Skip to content

getaero-io/gtm-eng-skills / skills/deepline-gtm

deepline-gtm

Unverified

GTM leads, enrichment, outreach, Plays, developer signals/Reo.dev. Providers: adyntel,affinity,ai_ark,akta,allegrow,amplemarket,apify,attention,attio,aviato,bettercontact,bigquery,bluesky,bounceban,brave,browserbase,builtwith,buyercaddy,cbinsights,clay,clickhouse,close,cloudflare,contactout,contextdev,crunchbase,crustdata-v3,customer_db,databricks,dataforseo,datagma,dealroom,deepline_ip_to_company,deepline_native,deeplineagent,deepseek,discolike,dnb,edges,emailbison,emailguard,enformion,enigma,exa,findymail,firecrawl,fireflies,firmable,forager,fullenrich,fundable,generic_http,getleads,gong,google_ads_audiences,google_workspace,govfiles,grain,hackernews,harvestapi,heyreach,hubspot,hunter,icypeas,instantly,intercom,ipqs,kaspr,kernel,kickbox,leadmagic,lemlist,limadata,linkedin_ads_audiences,luma,lusha,meerapi,meta_audiences,millionverifier,nooks,notion,openmart,opensosdata,openwebninja,outreach,parallel,particle,peopledatalabs,pitchbook,podscan,polymarket,postgres,predictleads,prospeo,quickenrich,rapidapi,….

FileKindSize
SKILL.mdskill md15.9 KB
claude-deepline-statusline.mjsexecutablescript25.0 KB
prompts.jsonconfig297.9 KB
provider-playbooks/adyntel.mdmarkdown1.2 KB
provider-playbooks/affinity.mdmarkdown825 B
provider-playbooks/ai-ark.mdmarkdown10.6 KB
provider-playbooks/akta.mdmarkdown1.5 KB
provider-playbooks/allegrow.mdmarkdown4.6 KB
provider-playbooks/amplemarket.mdmarkdown2.8 KB
provider-playbooks/apify.mdmarkdown1.8 KB
provider-playbooks/attention.mdmarkdown449 B
provider-playbooks/attio.mdmarkdown5.6 KB
provider-playbooks/aviato.mdmarkdown756 B
provider-playbooks/bettercontact.mdmarkdown1.7 KB
provider-playbooks/bigquery.mdmarkdown1019 B
provider-playbooks/bloomberry.mdmarkdown935 B
provider-playbooks/bluesky.mdmarkdown139 B
provider-playbooks/bounceban.mdmarkdown1.6 KB
provider-playbooks/brave.mdmarkdown422 B
provider-playbooks/browserbase.mdmarkdown1.0 KB
provider-playbooks/builtwith.mdmarkdown1.0 KB
provider-playbooks/buyercaddy.mdmarkdown2.3 KB
provider-playbooks/cbinsights.mdmarkdown436 B
provider-playbooks/clay.mdmarkdown875 B
provider-playbooks/clickhouse.mdmarkdown1.1 KB
provider-playbooks/close.mdmarkdown2.6 KB
provider-playbooks/cloudflare.mdmarkdown2.3 KB
provider-playbooks/contactout.mdmarkdown8.3 KB
provider-playbooks/contextdev.mdmarkdown582 B
provider-playbooks/crunchbase.mdmarkdown742 B
provider-playbooks/crustdata-v2.mdmarkdown490 B
provider-playbooks/crustdata-v3.mdmarkdown8.4 KB
provider-playbooks/crustdata.mdmarkdown6.8 KB
provider-playbooks/databricks.mdmarkdown3.5 KB
provider-playbooks/dataforseo.mdmarkdown950 B
provider-playbooks/datagma.mdmarkdown6.0 KB
provider-playbooks/dealroom.mdmarkdown632 B
provider-playbooks/deepline-ip-to-company.mdmarkdown480 B
provider-playbooks/deepline-native-osint.mdmarkdown1.5 KB
provider-playbooks/deepline-native.mdmarkdown25.1 KB
provider-playbooks/deeplineagent.mdmarkdown2.7 KB
provider-playbooks/deepseek.mdmarkdown1.2 KB
provider-playbooks/discolike.mdmarkdown6.2 KB
provider-playbooks/dnb.mdmarkdown1.4 KB
provider-playbooks/dropleads.mdmarkdown10.2 KB
provider-playbooks/edges.mdmarkdown875 B
provider-playbooks/emailbison.mdmarkdown634 B
provider-playbooks/emailguard.mdmarkdown243 B
provider-playbooks/enformion.mdmarkdown9.3 KB
provider-playbooks/enigma.mdmarkdown1.7 KB
provider-playbooks/exa.mdmarkdown1.4 KB
provider-playbooks/file-transport.mdmarkdown739 B
provider-playbooks/findymail.mdmarkdown880 B
provider-playbooks/firecrawl.mdmarkdown2.4 KB
provider-playbooks/fireflies.mdmarkdown988 B
provider-playbooks/firmable.mdmarkdown1.3 KB
provider-playbooks/forager.mdmarkdown2.3 KB
provider-playbooks/fullenrich.mdmarkdown2.1 KB
provider-playbooks/fundable.mdmarkdown2.0 KB
provider-playbooks/generic-http.mdmarkdown348 B
provider-playbooks/getleads.mdmarkdown2.2 KB
provider-playbooks/gong.mdmarkdown488 B
provider-playbooks/google-ads-audiences.mdmarkdown2.0 KB
provider-playbooks/google-calendar-availability.mdmarkdown1.6 KB
provider-playbooks/google-calendar.mdmarkdown1.1 KB
provider-playbooks/google-sheets.mdmarkdown842 B
provider-playbooks/google-workspace.mdmarkdown2.1 KB
provider-playbooks/govfiles.mdmarkdown1.8 KB
provider-playbooks/grain.mdmarkdown1.0 KB
provider-playbooks/hackernews.mdmarkdown208 B
provider-playbooks/harvestapi.mdmarkdown3.5 KB
provider-playbooks/heyreach.mdmarkdown1.6 KB
provider-playbooks/hubspot.mdmarkdown3.3 KB
provider-playbooks/hunter.mdmarkdown849 B
provider-playbooks/icypeas.mdmarkdown1.8 KB
provider-playbooks/instantly.mdmarkdown1.6 KB
provider-playbooks/integration-operation.mdmarkdown704 B
provider-playbooks/intercom.mdmarkdown275 B
provider-playbooks/ipqs.mdmarkdown1.7 KB
provider-playbooks/kaspr.mdmarkdown822 B
provider-playbooks/kernel.mdmarkdown875 B
provider-playbooks/leadmagic.mdmarkdown5.3 KB
provider-playbooks/lemlist.mdmarkdown7.5 KB
provider-playbooks/limadata.mdmarkdown636 B
provider-playbooks/linkedin-ads-audiences.mdmarkdown629 B
provider-playbooks/luma.mdmarkdown3.2 KB
provider-playbooks/lusha.mdmarkdown3.5 KB
provider-playbooks/meerapi.mdmarkdown1.2 KB
provider-playbooks/meta-audiences.mdmarkdown4.8 KB
provider-playbooks/millionverifier.mdmarkdown618 B
provider-playbooks/nooks.mdmarkdown1.0 KB
provider-playbooks/notion.mdmarkdown724 B
provider-playbooks/openmart.mdmarkdown2.3 KB
provider-playbooks/opensosdata.mdmarkdown4.0 KB
provider-playbooks/openwebninja.mdmarkdown315 B
provider-playbooks/outreach.mdmarkdown2.6 KB
provider-playbooks/parallel.mdmarkdown4.4 KB
provider-playbooks/particle.mdmarkdown2.0 KB
provider-playbooks/peopledatalabs.mdmarkdown4.5 KB
provider-playbooks/pipedrive.mdmarkdown582 B
provider-playbooks/pitchbook.mdmarkdown606 B
provider-playbooks/podscan.mdmarkdown2.7 KB
provider-playbooks/polymarket.mdmarkdown2.2 KB
provider-playbooks/postgres.mdmarkdown553 B
provider-playbooks/predictleads.mdmarkdown622 B
provider-playbooks/prospeo.mdmarkdown2.4 KB
provider-playbooks/quickenrich.mdmarkdown595 B
provider-playbooks/rapidapi.mdmarkdown2.5 KB
provider-playbooks/rb2b.mdmarkdown247 B
provider-playbooks/redshift.mdmarkdown763 B
provider-playbooks/reo-write.mdmarkdown1.6 KB
provider-playbooks/reo.mdmarkdown2.0 KB
provider-playbooks/resend.mdmarkdown3.6 KB
provider-playbooks/salesforce.mdmarkdown3.6 KB
provider-playbooks/salesforge.mdmarkdown274 B
provider-playbooks/salesloft.mdmarkdown1.0 KB
provider-playbooks/scrapecreators.mdmarkdown3.4 KB
provider-playbooks/searchbug.mdmarkdown637 B
provider-playbooks/sec-edgar.mdmarkdown1.6 KB
provider-playbooks/sentrion.mdmarkdown737 B
provider-playbooks/serper.mdmarkdown1011 B
provider-playbooks/slack.mdmarkdown21.1 KB
provider-playbooks/smartleads.mdmarkdown11.8 KB
provider-playbooks/snitcher.mdmarkdown302 B
provider-playbooks/snowflake.mdmarkdown768 B
provider-playbooks/socrata.mdmarkdown3.2 KB
provider-playbooks/sumble.mdmarkdown1.3 KB
provider-playbooks/tamradar.mdmarkdown1.4 KB
provider-playbooks/test-unhinted.mdmarkdown505 B
provider-playbooks/test.mdmarkdown254 B
provider-playbooks/theirstack.mdmarkdown4.4 KB
provider-playbooks/theswarm.mdmarkdown1.4 KB
provider-playbooks/treg.mdmarkdown1.5 KB
provider-playbooks/trestle.mdmarkdown3.7 KB
provider-playbooks/trykitt.mdmarkdown862 B
provider-playbooks/twitterapi.mdmarkdown3.6 KB
provider-playbooks/unipile.mdmarkdown4.8 KB
provider-playbooks/upcell.mdmarkdown715 B
provider-playbooks/vector.mdmarkdown257 B
provider-playbooks/versium.mdmarkdown690 B
provider-playbooks/wiza.mdmarkdown2.0 KB
provider-playbooks/wizleads.mdmarkdown1.1 KB
provider-playbooks/zerobounce.mdmarkdown1.3 KB
provider-playbooks/zoho-crm.mdmarkdown630 B
provider-playbooks/zoominfo.mdmarkdown1.2 KB
recipes/account-orgchart.mdmarkdown35.6 KB
recipes/build-tam.mdmarkdown3.7 KB
recipes/clay-to-deepline.mdmarkdown26.8 KB
recipes/deepline-monitors.mdmarkdown32.5 KB
recipes/developer-signals.mdmarkdown14.7 KB
recipes/find-qualified-titles.mdmarkdown5.2 KB
recipes/portfolio-prospecting.mdmarkdown3.6 KB
recipes/small-business-prospecting.mdmarkdown3.0 KB
references/clay-action-mappings.mdmarkdown40.0 KB
references/clay-api-surface.mdmarkdown18.6 KB
references/clay-extraction.mdmarkdown16.2 KB
references/industry-radars.mdmarkdown3.3 KB
references/monitor-contract-reference.mdmarkdown25.9 KB
references/monitor-operations.mdmarkdown12.4 KB
references/monitor-sdk.mdmarkdown3.2 KB
references/run-events.mdmarkdown14.3 KB
scripts/clay-extract-bookmarklet.jsscript10.5 KB
scripts/clay-extract-bookmarklet.url.txtmarkdown8.2 KB
scripts/clay-extract.pyscript17.9 KB
scripts/clay-har-miner.pyscript5.8 KB
scripts/clay-to-deepline.mjsscript134.1 KB
scripts/contact-accuracy-audit.pyscript8.9 KB
scripts/fixtures_contact_accuracy_audit.jsonconfig5.5 KB
scripts/fixtures_current_role.jsonconfig10.3 KB
scripts/flatten-search-contact-persons.pyscript3.3 KB
scripts/select-current-role.pyscript12.2 KB
scripts/validate-emails.pyexecutablescript2.0 KB
skill-metadata.jsonconfig2.2 KB
writing-outreach.mdmarkdown14.1 KB

claude-deepline-statusline.mjs

View on GitHub
#!/usr/bin/env node
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { execSync } from 'node:child_process';

const MAX_TRANSCRIPT_BYTES = 1024 * 1024;
const MAX_RUNNING_SHOWN = 2;
const BACKEND_STATUS_TTL_MS = 15000;
const ACTIVE_PERSIST_MS = 45_000;
const STATE_PATH = path.join(
  os.homedir(),
  '.claude',
  'deepline-statusline-state.json',
);
const USER_CMD_PATH = path.join(
  os.homedir(),
  '.claude',
  'statusline-user-command.txt',
);

const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
const BACKEND_PULSE = ['●', '◉'];

const C = {
  reset: '\x1b[0m',
  bold: '\x1b[1m',
  white: '\x1b[97m',
  dim: '\x1b[37m',
  cyan: '\x1b[96m',
  green: '\x1b[92m',
  red: '\x1b[91m',
  yellow: '\x1b[93m',
};

const PROVIDER_LABELS = {
  apify: 'Apify',
  crustdata: 'CrustData',
  deepline_native: 'Deepline Native',
  dropleads: 'DropLeads',
  exa: 'Exa',
  leadmagic: 'LeadMagic',
  hunter: 'Hunter',
  parallel: 'Parallel',
  peopledatalabs: 'People Data Labs',
  adyntel: 'Adyntel',
  google_search: 'Google Search',
  instantly: 'Instantly',
  lemlist: 'Lemlist',
  heyreach: 'HeyReach',
};

function ansi(text, color, useBold = false) {
  return `${useBold ? C.bold : ''}${color}${text}${C.reset}`;
}

function stripAnsi(text) {
  return text.replace(/\x1b\[[0-9;]*m/g, '');
}

function width() {
  const w = Number(process.stdout.columns || process.env.COLUMNS || 120);
  return Number.isFinite(w) && w > 20 ? w : 120;
}

function truncateText(text, maxLen) {
  if (maxLen <= 0) return '';
  if (text.length <= maxLen) return text;
  if (maxLen <= 3) return '.'.repeat(maxLen);
  return `${text.slice(0, maxLen - 3)}...`;
}

function joinInline(left, right) {
  const w = width();
  const leftRaw = stripAnsi(left);
  const sepRaw = ' | ';
  const leftLen = leftRaw.length;
  const sepLen = sepRaw.length;
  const availableRight = Math.max(16, w - leftLen - sepLen);
  const trimmedRight = truncateText(stripAnsi(right), availableRight);
  return `${left}${ansi(sepRaw, C.dim)}${ansi(trimmedRight, C.white, true)}`;
}

async function readStdin() {
  if (process.stdin.isTTY) return null;
  const chunks = [];
  process.stdin.setEncoding('utf8');
  try {
    for await (const chunk of process.stdin) {
      chunks.push(chunk);
    }
    const text = chunks.join('').trim();
    return text.length ? text : null;
  } catch {
    return null;
  }
}

function parseJsonLine(line) {
  try {
    return JSON.parse(line);
  } catch {
    return null;
  }
}

function readTranscriptTail(transcriptPath, maxBytes = MAX_TRANSCRIPT_BYTES) {
  if (!transcriptPath) return [];
  try {
    const resolved = path.resolve(transcriptPath);
    const stat = fs.statSync(resolved);
    if (!stat.isFile()) return [];

    const start = Math.max(0, stat.size - maxBytes);
    const len = stat.size - start;
    const fd = fs.openSync(resolved, 'r');
    const buffer = Buffer.alloc(len);
    fs.readSync(fd, buffer, 0, len, start);
    fs.closeSync(fd);

    let text = buffer.toString('utf8');
    if (start > 0) {
      const firstNl = text.indexOf('\n');
      if (firstNl >= 0) text = text.slice(firstNl + 1);
    }

    return text
      .split('\n')
      .map((line) => line.trim())
      .filter(Boolean)
      .map(parseJsonLine)
      .filter(Boolean);
  } catch {
    return [];
  }
}

function getToolUsesFromMessage(message) {
  const content = Array.isArray(message?.content) ? message.content : [];
  return content.filter((b) => b?.type === 'tool_use');
}

function getToolResultsFromMessage(message) {
  const content = Array.isArray(message?.content) ? message.content : [];
  return content.filter((b) => b?.type === 'tool_result');
}

function extractToolUseCommand(toolUse) {
  const input = toolUse?.input;
  if (!input || typeof input !== 'object') return '';
  if (typeof input.command === 'string') return input.command;
  if (typeof input.cmd === 'string') return input.cmd;
  return '';
}

function extractToolUseName(toolUse) {
  const name = toolUse?.name;
  return typeof name === 'string' ? name : '';
}

function extractThinkingText(lines) {
  for (let i = lines.length - 1; i >= 0; i -= 1) {
    const message = lines[i]?.message;
    const content = Array.isArray(message?.content) ? message.content : [];
    for (let j = content.length - 1; j >= 0; j -= 1) {
      const block = content[j];
      if (block?.type === 'text' && typeof block?.text === 'string') {
        const text = block.text.trim();
        if (text) return text;
      }
    }
  }
  return '';
}

function isDeeplineCommand(command) {
  return /(^|\s)(deepline|dl)(\s|$)/.test(command);
}

function isDeeplineToolUse(toolUse) {
  const name = String(toolUse?.name || '').toLowerCase();
  if (name.includes('deepline')) return true;
  const cmd = extractToolUseCommand(toolUse);
  return Boolean(cmd && isDeeplineCommand(cmd));
}

function classifyCommand(command) {
  if (!command) return 'running';
  if (/\b(deepline|dl)\s+enrich\b/.test(command)) return 'enrich';
  if (/\b(deepline|dl)\s+(tools\s+)?describe\b/.test(command))
    return 'tools_describe';
  if (/\b(deepline|dl)\s+(tools\s+execute|plays\s+run|run)\s/.test(command))
    return 'tools_execute';
  if (/\b(deepline|dl)\s+tools\s+(search|list)\b/.test(command))
    return 'tools_search';
  if (/\b(deepline|dl)\s+csv\s+(show|render)\b/.test(command)) return 'csv';
  return 'running';
}

function isTrackableMode(mode) {
  return (
    mode === 'enrich' ||
    mode === 'tools_describe' ||
    mode === 'tools_execute' ||
    mode === 'tools_search' ||
    mode === 'csv' ||
    mode === 'running'
  );
}

function shouldUseCachedBackendOnly(command) {
  if (!command) return false;
  return (
    /\b(deepline|dl)\s+csv\s+render\b/.test(command) ||
    /\b(deepline|dl)\s+enrich\b/.test(command)
  );
}

function parseRowCount(command) {
  const rows = command.match(/--rows\s+(\d+)\s*:\s*(\d+)/);
  if (rows) {
    const start = Number(rows[1]);
    const end = Number(rows[2]);
    if (Number.isFinite(start) && Number.isFinite(end) && end >= start) {
      return end - start + 1;
    }
  }
  const limit = command.match(/--limit\s+(\d+)/);
  if (limit) {
    const n = Number(limit[1]);
    if (Number.isFinite(n) && n > 0) return n;
  }
  return null;
}

function extractCsvPath(command) {
  // `deepline run <play> --input '{"csv":"leads.csv"}'` names the CSV inside its JSON.
  const runCsv = command.match(
    /--input\s+\S*?\{[^}]*?\\?"csv\\?"\s*:\s*\\?"([^"\\]+)/,
  );
  if (runCsv) return runCsv[1];
  const patterns = [
    /--input\s+(?![\s'"]*\{)("([^"]+)"|'([^']+)'|(\S+))/,
    /--csv\s+("([^"]+)"|'([^']+)'|(\S+))/,
    /--output\s+("([^"]+)"|'([^']+)'|(\S+))/,
  ];
  for (const p of patterns) {
    const m = command.match(p);
    if (m) return m[2] || m[3] || m[4] || '';
  }
  return '';
}

function extractExecutedTools(command) {
  const out = [];
  const execRe =
    /(?:deepline|dl)\s+(?:tools\s+execute|plays\s+run|run)\s+([a-zA-Z0-9_.:/@-]+)/g;
  let m = execRe.exec(command);
  while (m) {
    out.push(m[1]);
    m = execRe.exec(command);
  }
  const withRe = /=[\s"']*([a-zA-Z0-9_]+):\{/g;
  m = withRe.exec(command);
  while (m) {
    out.push(m[1]);
    m = withRe.exec(command);
  }
  return [...new Set(out)];
}

function extractToolsDescribeTarget(command) {
  const m = command.match(
    /(?:deepline|dl)\s+(?:tools\s+)?describe\s+([a-zA-Z0-9_.:/@-]+)/,
  );
  return m ? m[1] : '';
}

// The value after `--input`, `--input-file` (`deepline run`) or `--payload` (older forms).
function extractInputValue(command) {
  const flag = command.match(/--(?:input-file|input|payload)(?=[\s=])[\s=]*/);
  if (!flag) return '';
  let raw = command.slice(flag.index + flag[0].length).trim();
  if (!raw) return '';
  const nextFlag = raw.search(/\s--[a-zA-Z0-9_-]+/);
  if (nextFlag > 0) raw = raw.slice(0, nextFlag).trim();
  if (
    (raw.startsWith('"') && raw.endsWith('"')) ||
    (raw.startsWith("'") && raw.endsWith("'"))
  ) {
    raw = raw.slice(1, -1).trim();
  }
  return raw;
}

function extractPayloadPreview(command) {
  const raw = extractInputValue(command);
  if (!raw) return '';
  return truncateText(raw.replace(/\s+/g, ' '), 18);
}

function extractPayloadQuery(command) {
  const raw = extractInputValue(command);
  if (!raw) return '';
  try {
    const parsed = JSON.parse(raw);
    if (
      parsed &&
      typeof parsed === 'object' &&
      typeof parsed.query === 'string'
    ) {
      return truncateText(parsed.query.replace(/\s+/g, ' ').trim(), 48);
    }
  } catch {
    // fall through to regex extraction
  }

  const m = raw.match(/"query"\s*:\s*"([^"]+)"/);
  if (m && m[1]) {
    return truncateText(m[1].replace(/\s+/g, ' ').trim(), 48);
  }
  return '';
}

function getProviderLabel(toolId) {
  const prefixes = Object.keys(PROVIDER_LABELS).sort(
    (a, b) => b.length - a.length,
  );
  for (const prefix of prefixes) {
    if (
      toolId === prefix ||
      toolId.startsWith(`${prefix}_`) ||
      toolId.startsWith(`${prefix}.`)
    )
      return PROVIDER_LABELS[prefix];
  }
  return null;
}

function titleCaseWords(text) {
  return text
    .split(/[_\-\s]+/)
    .filter(Boolean)
    .map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase())
    .join(' ');
}

function labelAction(actionRaw) {
  const action = actionRaw.toLowerCase();
  if (action.includes('linkedin') && action.includes('post'))
    return 'LinkedIn Posts';
  if (action.includes('job') || action.includes('hiring'))
    return 'Job Listings';
  if (action.includes('comment') && action.includes('filter'))
    return 'Comment Filtering';
  if (action.includes('comment') && action.includes('search'))
    return 'Comment Search';
  if (action.includes('tam')) return 'TAM Analysis';
  if (action.includes('people') && action.includes('search'))
    return 'People Search';
  if (action.includes('company') && action.includes('search'))
    return 'Company Search';
  if (
    action.includes('email') &&
    (action.includes('finder') || action.includes('find'))
  )
    return 'Email Finder';
  if (action.includes('verify') || action.includes('validation'))
    return 'Verification';
  return null;
}

function formatToolName(toolId) {
  const provider = getProviderLabel(toolId);
  const prefixes = Object.keys(PROVIDER_LABELS).sort(
    (a, b) => b.length - a.length,
  );
  if (provider) {
    const prefix = prefixes.find(
      (p) => toolId === p || toolId.startsWith(`${p}_`),
    );
    const actionRaw = prefix
      ? toolId.slice(prefix.length).replace(/^_+/, '')
      : toolId;
    if (!actionRaw) return provider;
    const clean = actionRaw
      .replace(/_search$/, ' search')
      .replace(/_finder$/, ' finder')
      .replace(/_enrichment$/, ' enrichment')
      .replace(/_verify|_validation$/, ' verify');
    return `${provider}: ${labelAction(clean) || titleCaseWords(clean)}`;
  }
  return labelAction(toolId) || titleCaseWords(toolId);
}

function shortToolTarget(toolId) {
  if (!toolId) return 'tool';
  const provider = getProviderLabel(toolId);
  if (provider) {
    return provider.toLowerCase();
  }
  return toolId.split('_')[0].toLowerCase();
}

function summarizeProviders(toolIds) {
  const names = [
    ...new Set(toolIds.map((id) => getProviderLabel(id)).filter(Boolean)),
  ];
  return names.join(', ');
}

function basenameSafe(filePath) {
  return filePath ? path.basename(filePath) : '';
}

function explainCommand(command) {
  const mode = classifyCommand(command);
  const toolIds = extractExecutedTools(command);
  const primaryTool = toolIds[0] || '';
  const target = shortToolTarget(primaryTool);
  const primaryLabel = primaryTool ? formatToolName(primaryTool) : '';
  const rows = parseRowCount(command);
  const csv = basenameSafe(extractCsvPath(command));
  const payload = extractPayloadPreview(command);
  const payloadQuery = extractPayloadQuery(command);

  if (mode === 'enrich') {
    if (rows && csv)
      return {
        detail: `Enriching ${rows} rows (${csv})`,
        current: '',
        providers: '',
      };
    if (rows)
      return { detail: `Enriching ${rows} rows`, current: '', providers: '' };
    return { detail: 'Enriching rows', current: '', providers: '' };
  }

  if (mode === 'tools_describe') {
    const target = extractToolsDescribeTarget(command);
    return {
      detail: `Learning ${shortToolTarget(target)}`,
      current: '',
      providers: '',
    };
  }

  if (mode === 'tools_execute') {
    if (payloadQuery && primaryLabel)
      return {
        detail: `${primaryLabel}: ${payloadQuery}`,
        current: '',
        providers: '',
      };
    if (primaryLabel && payload)
      return {
        detail: `${primaryLabel}: ${payload}`,
        current: '',
        providers: '',
      };
    if (primaryLabel)
      return { detail: `Running ${primaryLabel}`, current: '', providers: '' };
    if (payload)
      return {
        detail: `Calling ${target} with ${payload}`,
        current: '',
        providers: '',
      };
    return { detail: `Calling ${target}`, current: '', providers: '' };
  }

  if (mode === 'tools_search') {
    return { detail: 'Searching tools', current: '', providers: '' };
  }

  if (mode === 'csv') {
    return {
      detail: rows ? `Running CSV (${rows} rows)` : 'Running CSV',
      current: '',
      providers: '',
    };
  }

  return { detail: '', current: '', providers: '' };
}

function loadState() {
  try {
    const raw = fs.readFileSync(STATE_PATH, 'utf8');
    const parsed = JSON.parse(raw);
    if (!parsed || typeof parsed !== 'object')
      return { sessions: {}, backend: {} };
    return {
      sessions:
        parsed.sessions && typeof parsed.sessions === 'object'
          ? parsed.sessions
          : {},
      backend:
        parsed.backend && typeof parsed.backend === 'object'
          ? parsed.backend
          : {},
    };
  } catch {
    return { sessions: {}, backend: {} };
  }
}

function saveState(state) {
  try {
    fs.mkdirSync(path.dirname(STATE_PATH), { recursive: true });
    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
  } catch {
    // Keep status line resilient.
  }
}

function nextSpinnerFrame(sessionState) {
  const index = Number.isFinite(sessionState?.spinner_index)
    ? sessionState.spinner_index
    : 0;
  const next = (index + 1) % SPINNER_FRAMES.length;
  sessionState.spinner_index = next;
  return SPINNER_FRAMES[next];
}

function parseBackendUpFromText(text) {
  if (!text) return { up: null, renderUrl: '' };
  const lines = text.split('\n');
  let section = '';
  let backendStatus = null;
  let renderStatus = null;
  let renderUrl = '';
  let backendApiUrl = '';

  for (const rawLine of lines) {
    const line = rawLine.trim();
    if (!line) continue;

    if (/^backend:/i.test(line)) {
      section = 'backend';
      continue;
    }
    if (/^render:/i.test(line)) {
      section = 'render';
      continue;
    }
    if (
      /^[a-z][a-z0-9 _-]*:/i.test(line) &&
      !/^status:/i.test(line) &&
      !/^api url:/i.test(line) &&
      !/^url:/i.test(line)
    ) {
      section = '';
    }

    const statusMatch = line.match(/^status:\s*([a-z_ -]+)/i);
    if (statusMatch) {
      const val = statusMatch[1].trim().toLowerCase();
      if (section === 'backend') backendStatus = val;
      if (section === 'render') renderStatus = val;
    }

    const apiUrlMatch = line.match(/^api url:\s*(https?:\/\/\S+)/i);
    if (apiUrlMatch && section === 'backend') {
      backendApiUrl = apiUrlMatch[1];
    }

    const renderUrlMatch = line.match(/^url:\s*(https?:\/\/\S+)/i);
    if (renderUrlMatch && section === 'render') {
      renderUrl = renderUrlMatch[1];
    }
  }

  const lower = text.toLowerCase();
  if (!backendStatus) {
    if (
      lower.includes('"backend":{"running":true') ||
      lower.includes('"backend":{"status":"running"')
    ) {
      backendStatus = 'running';
    } else if (
      lower.includes('"backend":{"running":false') ||
      lower.includes('"backend":{"status":"stopped"')
    ) {
      backendStatus = 'stopped';
    }
  }

  let up = null;
  if (backendStatus) {
    up = backendStatus.includes('running') || backendStatus.includes('healthy');
  } else if (lower.includes('backend') && lower.includes('running')) {
    up = true;
  } else if (
    lower.includes('backend') &&
    (lower.includes('stopped') ||
      lower.includes('not running') ||
      lower.includes('down'))
  ) {
    up = false;
  }

  if (
    !renderUrl &&
    renderStatus &&
    renderStatus.includes('running') &&
    backendApiUrl
  ) {
    renderUrl = backendApiUrl;
  }

  return { up, renderUrl };
}

function parseBackendUpFromJson(output) {
  try {
    const parsed = JSON.parse(output);
    let up = null;
    if (typeof parsed?.backend?.running === 'boolean') {
      up = parsed.backend.running;
    } else if (typeof parsed?.backend?.healthy === 'boolean') {
      up = parsed.backend.healthy;
    } else if (typeof parsed?.running === 'boolean') {
      up = parsed.running;
    } else if (typeof parsed?.healthy === 'boolean') {
      up = parsed.healthy;
    } else if (typeof parsed?.status === 'string') {
      const s = parsed.status.toLowerCase();
      up = s === 'ok' || s.includes('running') || s.includes('healthy');
    } else if (typeof parsed?.backend?.status === 'string') {
      const s = parsed.backend.status.toLowerCase();
      up = s.includes('running') || s.includes('healthy');
    }

    const renderStatus = String(
      parsed?.render?.status || parsed?.render_status || '',
    ).toLowerCase();
    let renderUrl = String(
      parsed?.render?.url || parsed?.render_url || parsed?.csv_render_url || '',
    ).trim();
    if (!renderUrl && renderStatus.includes('running')) {
      renderUrl = String(
        parsed?.backend?.api_url || parsed?.api_url || '',
      ).trim();
    }

    return { up, renderUrl };
  } catch {
    return parseBackendUpFromText(output);
  }
}

function getBackendStatus(state, opts = {}) {
  const { allowProbe = true } = opts;
  const now = Date.now();
  const cached = state.backend || {};
  if (
    Number.isFinite(cached.checked_at_ms) &&
    now - cached.checked_at_ms < BACKEND_STATUS_TTL_MS &&
    typeof cached.up === 'boolean'
  ) {
    return {
      up: cached.up,
      renderUrl: cached.renderUrl || '',
      checked_at_ms: cached.checked_at_ms,
    };
  }

  if (!allowProbe) {
    return {
      up: typeof cached.up === 'boolean' ? cached.up : null,
      renderUrl: cached.renderUrl || '',
      checked_at_ms: Number.isFinite(cached.checked_at_ms)
        ? cached.checked_at_ms
        : 0,
    };
  }

  let up = null;
  let renderUrl = '';
  try {
    const out = execSync('deepline health --json', {
      encoding: 'utf8',
      stdio: ['ignore', 'pipe', 'pipe'],
      timeout: 1200,
    });
    const parsed = parseBackendUpFromJson(String(out || ''));
    up = parsed.up;
    renderUrl = parsed.renderUrl || '';
  } catch (err) {
    const stdout = String(err?.stdout || '');
    const stderr = String(err?.stderr || '');
    const parsed = parseBackendUpFromText(`${stdout}\n${stderr}`);
    up = typeof parsed.up === 'boolean' ? parsed.up : false;
    renderUrl = parsed.renderUrl || '';
  }

  const status = { up, renderUrl, checked_at_ms: now };
  state.backend = status;
  return status;
}

function buildActiveFromTranscript(lines, fallbackCommand) {
  const pending = new Map();
  const deeplineHistory = [];

  for (const entry of lines) {
    if (entry?.type === 'assistant') {
      for (const toolUse of getToolUsesFromMessage(entry.message)) {
        pending.set(toolUse.id, toolUse);
        if (isDeeplineToolUse(toolUse)) deeplineHistory.push(toolUse);
      }
      continue;
    }

    if (entry?.type === 'user') {
      for (const result of getToolResultsFromMessage(entry.message)) {
        if (typeof result?.tool_use_id === 'string')
          pending.delete(result.tool_use_id);
      }
    }
  }

  const active = [...pending.values()].filter((toolUse) =>
    isDeeplineToolUse(toolUse),
  );
  if (active.length > 0) {
    const latestCmd =
      extractToolUseCommand(active[active.length - 1]) || fallbackCommand || '';
    if (!isTrackableMode(classifyCommand(latestCmd))) return null;
    const explained = explainCommand(latestCmd);
    const runningIds = [
      ...new Set(
        active.flatMap((toolUse) =>
          extractExecutedTools(extractToolUseCommand(toolUse)),
        ),
      ),
    ];
    const currentFallback = runningIds
      .slice(0, MAX_RUNNING_SHOWN)
      .map((id) => formatToolName(id))
      .join(', ');
    return {
      detail: explained.detail,
      current: explained.current || currentFallback,
      providers: explained.providers || summarizeProviders(runningIds),
      summary:
        explained.current || explained.detail || currentFallback || 'workflow',
    };
  }

  const fallback =
    fallbackCommand ||
    extractToolUseCommand(deeplineHistory[deeplineHistory.length - 1]) ||
    '';
  if (!fallback || !isDeeplineCommand(fallback)) return null;
  if (!isTrackableMode(classifyCommand(fallback))) return null;

  if (deeplineHistory.length === 0) {
    const explained = explainCommand(fallback);
    return {
      detail: explained.detail,
      current: explained.current,
      providers: explained.providers,
      summary:
        explained.current ||
        explained.detail ||
        explained.providers ||
        'workflow',
    };
  }

  return null;
}

function backendBadge(backend, frameIndex) {
  if (typeof backend?.up !== 'boolean') {
    return '';
  }
  void frameIndex;
  if (backend.up) {
    return ansi('✅ Deepline reachable', C.green, true);
  }
  return ansi('⏸️ Deepline unreachable', C.red, true);
}

function renderActiveLine(frame, status, backend, frameIndex, thinking) {
  const detail = status.detail || 'Running task';
  const thinkingSuffix = thinking ? ` | ${thinking}` : '';
  const rightRaw = `${frame} ${detail}${thinkingSuffix}`;
  const right = ansi(rightRaw, C.white, true);
  const left = backendBadge(backend, frameIndex);
  if (!left) return right;
  return joinInline(left, right);
}

function runUserStatusline(input) {
  try {
    const cmd = fs.readFileSync(USER_CMD_PATH, 'utf8').trim();
    if (!cmd) return '';
    const out = execSync(cmd, {
      input,
      encoding: 'utf8',
      stdio: ['pipe', 'pipe', 'pipe'],
      timeout: 2000,
    });
    return (out || '').trim();
  } catch {
    return '';
  }
}

async function main() {
  const input = await readStdin();
  if (!input) return;

  let data;
  try {
    data = JSON.parse(input);
  } catch {
    return;
  }

  const fallbackCommand = typeof data?.command === 'string' ? data.command : '';
  const transcriptPath =
    typeof data?.transcript_path === 'string' ? data.transcript_path : '';
  const sessionId =
    typeof data?.session_id === 'string' ? data.session_id : 'default';

  const state = loadState();
  const sessionState = state.sessions[sessionId] || {
    spinner_index: 0,
    was_active: false,
    active_summary: '',
    last_ran: '',
  };

  const frame = nextSpinnerFrame(sessionState);
  const frameIndex = sessionState.spinner_index || 0;

  const lines = readTranscriptTail(transcriptPath);
  const activeStatus = buildActiveFromTranscript(lines, fallbackCommand);
  const latestThinking = extractThinkingText(lines);
  const backendStatus = getBackendStatus(state, {
    allowProbe: !activeStatus && !shouldUseCachedBackendOnly(fallbackCommand),
  });

  // Compute deepline-specific output
  let dlOutput = '';

  if (activeStatus) {
    sessionState.was_active = true;
    sessionState.active_summary = activeStatus.summary || activeStatus.detail;
    sessionState.active_started_ms = Date.now();
    state.sessions[sessionId] = sessionState;
    saveState(state);
    const activeThinking = latestThinking
      ? `Thinking: ${truncateText(latestThinking, 56)}`
      : '';
    dlOutput = renderActiveLine(
      frame,
      activeStatus,
      backendStatus,
      frameIndex,
      activeThinking,
    );
  } else {
    const now = Date.now();
    const lastActiveMs = Number.isFinite(sessionState.active_started_ms)
      ? sessionState.active_started_ms
      : 0;
    if (
      sessionState.was_active &&
      lastActiveMs &&
      now - lastActiveMs < ACTIVE_PERSIST_MS &&
      sessionState.active_summary
    ) {
      sessionState.was_active = true;
      state.sessions[sessionId] = sessionState;
      saveState(state);
      const persisted = {
        detail: sessionState.active_summary,
        current: sessionState.active_summary,
        providers: '',
        summary: sessionState.active_summary,
      };
      const activeThinking = latestThinking
        ? `Thinking: ${truncateText(latestThinking, 56)}`
        : '';
      dlOutput = renderActiveLine(
        frame,
        persisted,
        backendStatus,
        frameIndex,
        activeThinking,
      );
    } else {
      if (sessionState.was_active && sessionState.active_summary) {
        sessionState.last_ran = sessionState.active_summary;
      }
      sessionState.was_active = false;
      sessionState.active_summary = '';
      state.sessions[sessionId] = sessionState;
      saveState(state);
    }
  }

  // Chain user's own statusline (preserved during install)
  const userOutput = runUserStatusline(input);

  // Line 1: user's personal statusline
  if (userOutput) console.log(userOutput);
  // Line 2: deepline status (only when active)
  if (dlOutput) console.log(dlOutput);
}

main();
deprecation-and-migrationaddyosmani/agent-skillsManages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
performance-optimizationaddyosmani/agent-skillsOptimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall