fullstackgtm 0.11.1 → 0.13.0

package/src/calls.ts

@@ -0,0 +1,434 @@
+export type CallInsightType =
+  | "pain_point"
+  | "objection"
+  | "competitor_mention"
+  | "next_step"
+  | "feature_request"
+  | "pricing"
+  | "decision_criteria"
+  | "risk"
+  | "coaching_moment";
+
+export type ParsedTranscriptSegment = {
+  index: number;
+  speaker?: string;
+  speakerRole: "rep" | "customer" | "unknown";
+  text: string;
+  startChar: number;
+  endChar: number;
+};
+
+export type ExtractedCallInsight = {
+  type: CallInsightType;
+  title: string;
+  text: string;
+  evidence: string;
+  speaker?: string;
+  confidence: number;
+  importance: number;
+  segmentIndex?: number;
+  startChar?: number;
+  endChar?: number;
+};
+
+const DEFAULT_REP_SPEAKERS = [
+  "rep",
+  "sales",
+  "seller",
+  "ae",
+  "sdr",
+  "bdr",
+  "account executive",
+  "host",
+];
+
+const CUSTOMER_HINTS = [
+  "customer",
+  "prospect",
+  "buyer",
+  "client",
+  "champion",
+  "participant",
+];
+
+const insightPatterns: Array<{
+  type: CallInsightType;
+  title: string;
+  confidence: number;
+  importance: number;
+  patterns: RegExp[];
+}> = [
+  {
+    type: "pain_point",
+    title: "Customer pain point",
+    confidence: 0.78,
+    importance: 4,
+    patterns: [
+      /\b(struggling|struggle|pain|problem|challenge|frustrat(?:ed|ing)|manual|messy|broken|hard to|difficult|too much time|takes too long)\b/i,
+    ],
+  },
+  {
+    type: "objection",
+    title: "Sales objection",
+    confidence: 0.76,
+    importance: 4,
+    patterns: [
+      /\b(concern|worried|not sure|too expensive|budget|price|pricing|timing|procurement|security review|legal review|need to think|another vendor)\b/i,
+    ],
+  },
+  {
+    type: "competitor_mention",
+    title: "Competitor or alternative mentioned",
+    confidence: 0.72,
+    importance: 3,
+    patterns: [
+      /\b(competitor|alternative|evaluating|looked at|using|salesforce|hubspot|gong|chorus|clari|outreach|salesloft|6sense|demandbase|clay|zapier|workato)\b/i,
+    ],
+  },
+  {
+    type: "next_step",
+    title: "Next step",
+    confidence: 0.82,
+    importance: 5,
+    patterns: [
+      /\b(next step|follow up|send over|circle back|schedule|book|meet again|by (monday|tuesday|wednesday|thursday|friday)|action item|I'll send|we'll send)\b/i,
+    ],
+  },
+  {
+    type: "feature_request",
+    title: "Feature request",
+    confidence: 0.74,
+    importance: 3,
+    patterns: [
+      /\b(wish|would love|need it to|feature|capability|does it support|can it|integration|custom field|dashboard|report|export|import)\b/i,
+    ],
+  },
+  {
+    type: "pricing",
+    title: "Pricing or budget signal",
+    confidence: 0.76,
+    importance: 4,
+    patterns: [
+      /\b(price|pricing|budget|cost|discount|contract|renewal|procurement|purchase order|PO|invoice|annual|monthly|ARR|MRR|\$\d+)\b/i,
+    ],
+  },
+  {
+    type: "decision_criteria",
+    title: "Decision criteria",
+    confidence: 0.73,
+    importance: 4,
+    patterns: [
+      /\b(criteria|decision|evaluate|evaluation|success looks like|requirements|must have|need to see|stakeholder|committee|approve|approval)\b/i,
+    ],
+  },
+  {
+    type: "risk",
+    title: "Deal risk",
+    confidence: 0.75,
+    importance: 5,
+    patterns: [
+      /\b(delay|blocked|risk|concern|not a priority|no budget|push|slip|stalled|ghost|unresponsive|champion left|reorg)\b/i,
+    ],
+  },
+  {
+    type: "coaching_moment",
+    title: "Coaching moment",
+    confidence: 0.68,
+    importance: 2,
+    patterns: [
+      /\b(let me tell you|obviously|basically|trust me|to be honest|just checking in|does that make sense\?)\b/i,
+    ],
+  },
+];
+
+export function parseTranscript(transcript: string): ParsedTranscriptSegment[] {
+  const normalized = transcript.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return [];
+
+  const lines = normalized.split(/\n+/);
+  const segments: ParsedTranscriptSegment[] = [];
+  let cursor = 0;
+  let current: ParsedTranscriptSegment | null = null;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      cursor += rawLine.length + 1;
+      continue;
+    }
+
+    const startChar = normalized.indexOf(line, cursor);
+    const lineStart = startChar >= 0 ? startChar : cursor;
+    const lineEnd = lineStart + line.length;
+    const match = line.match(/^([^:\[\]]{1,60}|\[[^\]]{1,60}\])\s*:\s*(.+)$/);
+
+    if (match) {
+      const speaker = match[1].replace(/^\[|\]$/g, "").trim();
+      const text = match[2].trim();
+      current = {
+        index: segments.length,
+        speaker,
+        speakerRole: inferSpeakerRole(speaker),
+        text,
+        startChar: lineStart + line.indexOf(text),
+        endChar: lineEnd,
+      };
+      segments.push(current);
+    } else if (current) {
+      current.text = `${current.text}\n${line}`;
+      current.endChar = lineEnd;
+    } else {
+      current = {
+        index: segments.length,
+        speakerRole: "unknown",
+        text: line,
+        startChar: lineStart,
+        endChar: lineEnd,
+      };
+      segments.push(current);
+    }
+
+    cursor = lineEnd;
+  }
+
+  return segments;
+}
+
+export function extractCallInsights(
+  transcript: string,
+  segments = parseTranscript(transcript),
+): ExtractedCallInsight[] {
+  const seen = new Set<string>();
+  const insights: ExtractedCallInsight[] = [];
+
+  for (const segment of segments) {
+    const text = segment.text.trim();
+    if (!text || text.length < 12) continue;
+
+    for (const pattern of insightPatterns) {
+      if (!pattern.patterns.some((candidate) => candidate.test(text))) continue;
+      const key = `${pattern.type}:${text.slice(0, 180).toLowerCase()}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      insights.push({
+        type: pattern.type,
+        title: pattern.title,
+        text: text.length > 500 ? `${text.slice(0, 497)}...` : text,
+        evidence: text,
+        speaker: segment.speaker,
+        confidence: pattern.confidence,
+        importance: pattern.importance,
+        segmentIndex: segment.index,
+        startChar: segment.startChar,
+        endChar: segment.endChar,
+      });
+    }
+  }
+
+  return insights.sort((a, b) => b.importance - a.importance || b.confidence - a.confidence);
+}
+
+export function summarizeInsights(insights: ExtractedCallInsight[]) {
+  const byType: Record<string, number> = {};
+  let highImportance = 0;
+  for (const insight of insights) {
+    byType[insight.type] = (byType[insight.type] ?? 0) + 1;
+    if (insight.importance >= 4) highImportance += 1;
+  }
+  return {
+    total: insights.length,
+    highImportance,
+    byType,
+    topTypes: Object.entries(byType)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([type, count]) => ({ type, count })),
+  };
+}
+
+function inferSpeakerRole(speaker: string): ParsedTranscriptSegment["speakerRole"] {
+  const normalized = speaker.toLowerCase();
+  if (DEFAULT_REP_SPEAKERS.some((hint) => normalized.includes(hint))) return "rep";
+  if (CUSTOMER_HINTS.some((hint) => normalized.includes(hint))) return "customer";
+  return "unknown";
+}
+
+// ── Canonical call parsing (dialect normalization + evidence) ─────────────
+//
+// Three transcript dialects exist in the wild that this package normalizes:
+//   1. "Speaker: text" lines (Fathom, Gong exports, the app's provider sync)
+//   2. "[Speaker]: text" lines (manually labeled transcripts)
+//   3. Granola raw utterance JSON: [{ text, source: "microphone"|"system", ... }]
+//      — no speaker names; microphone = the note-taker ("Me"), system = the
+//      other side ("Them").
+
+import type { CanonicalGtmSnapshot, GtmEvidence, GtmEvidenceSourceSystem } from "./types.ts";
+
+export type ParsedCall = {
+  /** Stable hash of the normalized transcript — same input, same id. */
+  id: string;
+  title?: string;
+  sourceSystem: GtmEvidenceSourceSystem;
+  segments: ParsedTranscriptSegment[];
+  insights: ExtractedCallInsight[];
+  evidence: GtmEvidence[];
+  summary: ReturnType<typeof summarizeInsights>;
+};
+
+type GranolaUtterance = { text?: string; source?: string };
+
+/** Detect and normalize a raw transcript payload into "Speaker: text" lines. */
+export function normalizeTranscript(raw: string): string {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      const utterances = Array.isArray(parsed)
+        ? (parsed as GranolaUtterance[])
+        : Array.isArray((parsed as { transcript?: unknown }).transcript)
+          ? ((parsed as { transcript: GranolaUtterance[] }).transcript)
+          : null;
+      if (utterances && utterances.every((u) => typeof u === "object" && u !== null && "text" in u)) {
+        return utterances
+          .filter((u) => typeof u.text === "string" && u.text.trim())
+          .map((u) => `${u.source === "microphone" ? "[Me]" : "[Them]"}: ${String(u.text).trim()}`)
+          .join("\n");
+      }
+    } catch {
+      // not JSON — fall through and treat as plain text
+    }
+  }
+  return raw;
+}
+
+/**
+ * Parse any supported transcript dialect into a canonical call: segments,
+ * deterministic insights, and GtmEvidence records ready for findings and
+ * patch plans. Pure and deterministic — same transcript, same ids.
+ */
+export function parseCall(
+  raw: string,
+  options: { title?: string; sourceSystem?: GtmEvidenceSourceSystem; capturedAt?: string } = {},
+): ParsedCall {
+  const normalized = normalizeTranscript(raw);
+  const segments = parseTranscript(normalized);
+  const insights = extractCallInsights(normalized, segments);
+  const sourceSystem = options.sourceSystem ?? "manual";
+  const id = `call_${callHash(normalized)}`;
+  const evidence: GtmEvidence[] = insights.map((insight, index) => ({
+    id: `ev_${callHash(`${id}:${insight.type}:${index}:${insight.text.slice(0, 80)}`)}`,
+    sourceSystem,
+    sourceObjectType: "call",
+    sourceObjectId: id,
+    title: insight.title,
+    text: insight.evidence,
+    capturedAt: options.capturedAt,
+    metadata: {
+      insightType: insight.type,
+      speaker: insight.speaker,
+      confidence: insight.confidence,
+      importance: insight.importance,
+      segmentIndex: insight.segmentIndex,
+    },
+  }));
+  return {
+    id,
+    title: options.title,
+    sourceSystem,
+    segments,
+    insights,
+    evidence,
+    summary: summarizeInsights(insights),
+  };
+}
+
+export type CallDealSuggestion = {
+  dealId: string | null;
+  dealName?: string;
+  accountId?: string;
+  accountName?: string;
+  confidence: "high" | "low" | "none";
+  reason: string;
+};
+
+/**
+ * Suggest which deal a call belongs to: attendee email domains → account
+ * (contact emails or account domain) → open deals, most recent activity
+ * first. Deterministic; mirrors the heuristic every call pipeline hand-rolls.
+ */
+export function suggestCallDeal(
+  snapshot: CanonicalGtmSnapshot,
+  options: { attendeeEmails?: string[]; domain?: string },
+): CallDealSuggestion {
+  const domains = new Set<string>();
+  if (options.domain) domains.add(options.domain.trim().toLowerCase());
+  for (const email of options.attendeeEmails ?? []) {
+    const at = email.indexOf("@");
+    if (at > 0) domains.add(email.slice(at + 1).trim().toLowerCase());
+  }
+  if (domains.size === 0) {
+    return { dealId: null, confidence: "none", reason: "No attendee emails or domain supplied to match on." };
+  }
+
+  const accountIds = new Set<string>();
+  for (const account of snapshot.accounts) {
+    const domain = account.domain?.trim().toLowerCase().replace(/^www\./, "");
+    if (domain && domains.has(domain)) accountIds.add(account.id);
+  }
+  for (const contact of snapshot.contacts) {
+    const email = contact.email?.trim().toLowerCase();
+    const at = email ? email.indexOf("@") : -1;
+    if (email && at > 0 && domains.has(email.slice(at + 1)) && contact.accountId) {
+      accountIds.add(contact.accountId);
+    }
+  }
+  if (accountIds.size === 0) {
+    return {
+      dealId: null,
+      confidence: "none",
+      reason: `No account matches the attendee domain(s) ${[...domains].join(", ")} by account domain or contact email.`,
+    };
+  }
+  const accountsById = new Map(snapshot.accounts.map((a) => [a.id, a]));
+  const openDeals = snapshot.deals
+    .filter((deal) => deal.accountId && accountIds.has(deal.accountId))
+    .filter((deal) => deal.isClosed !== true && deal.isWon !== true)
+    .sort((a, b) => Date.parse(b.lastActivityAt ?? "1970") - Date.parse(a.lastActivityAt ?? "1970"));
+  if (openDeals.length === 0) {
+    const names = [...accountIds].map((id) => accountsById.get(id)?.name ?? id).join(", ");
+    return {
+      dealId: null,
+      confidence: "none",
+      reason: `Matched account(s) ${names} but found no open deals on them.`,
+    };
+  }
+  const top = openDeals[0];
+  const account = top.accountId ? accountsById.get(top.accountId) : undefined;
+  if (openDeals.length === 1) {
+    return {
+      dealId: top.id,
+      dealName: top.name,
+      accountId: top.accountId,
+      accountName: account?.name,
+      confidence: "high",
+      reason: `"${top.name}" is the only open deal on matched account "${account?.name ?? top.accountId}".`,
+    };
+  }
+  return {
+    dealId: top.id,
+    dealName: top.name,
+    accountId: top.accountId,
+    accountName: account?.name,
+    confidence: "low",
+    reason: `${openDeals.length} open deals on matched account(s); "${top.name}" has the most recent activity. Confirm before writing.`,
+  };
+}
+
+function callHash(value: string) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+  }
+  return hash.toString(36);
+}

package/src/cli.ts

@@ -38,6 +38,7 @@ import { createFilePlanStore } from "./planStore.ts";
 import { auditReportToHtml, auditReportToMarkdown, type ReportOptions } from "./report.ts";
 import { builtinAuditRules } from "./rules.ts";
 import { sampleSnapshot } from "./sampleData.ts";
+import { parseCall, suggestCallDeal, type ExtractedCallInsight, type ParsedCall } from "./calls.ts";
 import { suggestValues, type ValueSuggestion } from "./suggest.ts";
 import type { FieldMappings } from "./mappings.ts";
 import type {
@@ -69,6 +70,11 @@ Usage:
   fullstackgtm report [source options] [audit options] [report options]
   fullstackgtm diff --before <a.json> --after <b.json> [--json] [--fail-on-new-findings]
   fullstackgtm merge --input <a.json> --input <b.json> [...] --out <merged.json> [--json]
+  fullstackgtm call parse --transcript <file> [--title t] [--source fathom|granola|...] [--json|--ndjson] [--out <path>]
+  fullstackgtm call link --attendees <a@x.com,...> | --domain <x.com>  [source options] [--json]
+  fullstackgtm call plan --transcript <file>|--call <parsed.json> --deal <id> [source options] [--save|--json]
+                                               calls become evidence: parse dialects (Speaker:/[Me]/Granola JSON),
+                                               link to the right deal, and propose governed next-step writes
   fullstackgtm suggest --plan-id <id> | --plan <path>  [source options] [--json] [--out <path>]
                                                derive values for requires_human_* placeholders
                                                from snapshot evidence, with confidence + reasons
@@ -465,6 +471,189 @@ function parseValueOverrides(args: string[]) {
   return valueOverrides;
 }
 
+async function callCommand(args: string[]) {
+  const [subcommand, ...rest] = args;
+
+  const loadParsedCall = (): ParsedCall => {
+    const callPath = option(rest, "--call");
+    if (callPath) {
+      return JSON.parse(readFileSync(resolve(process.cwd(), callPath), "utf8")) as ParsedCall;
+    }
+    const transcriptPath = option(rest, "--transcript");
+    if (!transcriptPath) throw new Error(`call ${subcommand} requires --transcript <file> or --call <parsed.json>`);
+    const raw = readFileSync(resolve(process.cwd(), transcriptPath), "utf8");
+    const source = option(rest, "--source") as ParsedCall["sourceSystem"] | undefined;
+    return parseCall(raw, {
+      title: option(rest, "--title") ?? undefined,
+      sourceSystem: source,
+      capturedAt: new Date().toISOString(),
+    });
+  };
+
+  if (subcommand === "parse") {
+    const parsed = loadParsedCall();
+    const outPath = option(rest, "--out");
+    if (outPath) writeFileSync(resolve(process.cwd(), outPath), `${JSON.stringify(parsed, null, 2)}\n`);
+    if (rest.includes("--ndjson")) {
+      // One flat row per insight — warehouse-friendly (e.g. Snowflake COPY).
+      for (const insight of parsed.insights) {
+        console.log(
+          JSON.stringify({
+            call_id: parsed.id,
+            call_title: parsed.title ?? null,
+            source_system: parsed.sourceSystem,
+            type: insight.type,
+            title: insight.title,
+            text: insight.text,
+            evidence: insight.evidence,
+            speaker: insight.speaker ?? null,
+            confidence: insight.confidence,
+            importance: insight.importance,
+          }),
+        );
+      }
+      return;
+    }
+    if (rest.includes("--json") || outPath) {
+      if (!outPath) console.log(JSON.stringify(parsed, null, 2));
+      return;
+    }
+    console.log(`Call ${parsed.id}${parsed.title ? ` — ${parsed.title}` : ""} (${parsed.sourceSystem})`);
+    console.log(`${parsed.segments.length} segments · ${parsed.insights.length} insights (${parsed.summary.highImportance} high-importance)\n`);
+    for (const insight of parsed.insights) {
+      console.log(`[${insight.type}] (importance ${insight.importance}) ${insight.text}`);
+    }
+    return;
+  }
+
+  if (subcommand === "link") {
+    const attendees = option(rest, "--attendees");
+    const domain = option(rest, "--domain");
+    if (!attendees && !domain) throw new Error("call link requires --attendees <emails,comma-separated> and/or --domain <example.com>");
+    const snapshot = await readSnapshot(rest);
+    const suggestion = suggestCallDeal(snapshot, {
+      attendeeEmails: attendees?.split(",").map((e) => e.trim()).filter(Boolean),
+      domain: domain ?? undefined,
+    });
+    if (rest.includes("--json")) {
+      console.log(JSON.stringify(suggestion, null, 2));
+    } else {
+      const marker = suggestion.confidence === "high" ? "✓" : suggestion.confidence === "low" ? "~" : "✗";
+      console.log(`${marker} [${suggestion.confidence}] ${suggestion.dealId ?? "no match"}${suggestion.dealName ? ` — ${suggestion.dealName}` : ""}`);
+      console.log(`    ${suggestion.reason}`);
+    }
+    if (suggestion.confidence === "none") process.exitCode = 1;
+    return;
+  }
+
+  if (subcommand === "plan") {
+    const dealId = option(rest, "--deal");
+    if (!dealId) throw new Error("call plan requires --deal <dealId> (use `call link` to find it)");
+    const parsed = loadParsedCall();
+    const snapshot = await readSnapshot(rest);
+    const deal = snapshot.deals.find((row) => row.id === dealId);
+    if (!deal) throw new Error(`Deal ${dealId} is not in the snapshot — check the id or the snapshot source.`);
+
+    const nextSteps = parsed.insights.filter((insight) => insight.type === "next_step");
+    if (nextSteps.length === 0) {
+      console.log("No next-step insights in this call — nothing to plan. (Other insight types are evidence, not writes.)");
+      return;
+    }
+    const [top, ...others] = nextSteps;
+    const proposed = top.text.trim().slice(0, 255);
+    const current = deal.nextStep?.trim() ?? "";
+    const plan = buildCallPlan(parsed, deal, proposed, current, others.slice(0, 3));
+
+    if (rest.includes("--save")) {
+      await createFilePlanStore().save(plan);
+      console.log(
+        `Saved plan ${plan.id}. Review with \`fullstackgtm plans show ${plan.id}\`, approve with \`fullstackgtm plans approve ${plan.id} --operations <ids|all>\`, then \`fullstackgtm apply --plan-id ${plan.id} --provider <name>\`.`,
+      );
+      return;
+    }
+    console.log(rest.includes("--json") ? JSON.stringify(plan, null, 2) : patchPlanToMarkdown(plan));
+    return;
+  }
+
+  throw new Error(`call supports: parse, link, plan (got ${subcommand ?? "nothing"})`);
+}
+
+function buildCallPlan(
+  parsed: ParsedCall,
+  deal: { id: string; name: string; nextStep?: string },
+  proposed: string,
+  current: string,
+  extraNextSteps: ExtractedCallInsight[],
+): PatchPlan {
+  const findings: PatchPlan["findings"] = [];
+  const operations: PatchPlan["operations"] = [];
+  const nextStepEvidence = parsed.evidence.filter(
+    (item) => (item.metadata as { insightType?: string } | undefined)?.insightType === "next_step",
+  );
+  const evidenceIds = nextStepEvidence.map((item) => item.id);
+
+  if (current.toLowerCase() !== proposed.toLowerCase()) {
+    findings.push({
+      id: `finding_${parsed.id.replace(/^call_/, "")}_${deal.id}`,
+      objectType: "deal",
+      objectId: deal.id,
+      ruleId: "call-next-step-not-reflected-in-crm",
+      type: "call_next_step_not_reflected_in_crm",
+      title: "Call agreed a next step the CRM does not reflect",
+      severity: "warning",
+      summary: current
+        ? `The call produced "${proposed}" but ${deal.name}'s next step still reads "${current}".`
+        : `The call produced "${proposed}" but ${deal.name} has no next step set.`,
+      recommendation: "Review the evidence and approve the next-step update.",
+      evidenceIds,
+      currentCrmValue: current || null,
+      proposedValue: proposed,
+    });
+    operations.push({
+      id: `op_${parsed.id.replace(/^call_/, "")}_next`,
+      objectType: "deal",
+      objectId: deal.id,
+      operation: "set_field",
+      field: "nextStep",
+      beforeValue: current || null,
+      afterValue: proposed,
+      reason: `Call evidence: ${nextStepEvidence[0]?.text.slice(0, 200) ?? proposed}`,
+      sourceRuleOrPolicy: "call_intelligence.next_step",
+      riskLevel: "high",
+      approvalRequired: true,
+      rollback: "Restore the previous deal next step (the before value) if the update is wrong.",
+      evidenceIds,
+    });
+  }
+  for (const [index, extra] of extraNextSteps.entries()) {
+    operations.push({
+      id: `op_${parsed.id.replace(/^call_/, "")}_task${index}`,
+      objectType: "deal",
+      objectId: deal.id,
+      operation: "create_task",
+      field: "follow_up_task",
+      beforeValue: null,
+      afterValue: extra.text.trim().slice(0, 255),
+      reason: `Additional commitment from the call: ${extra.evidence.slice(0, 160)}`,
+      sourceRuleOrPolicy: "call_intelligence.follow_up",
+      riskLevel: "low",
+      approvalRequired: true,
+      rollback: "Close or delete the created task.",
+    });
+  }
+  return {
+    id: `patch_plan_${parsed.id.replace(/^call_/, "")}${deal.id.slice(-4)}`,
+    title: `Call evidence plan${parsed.title ? ` — ${parsed.title}` : ""} → ${deal.name}`,
+    createdAt: new Date().toISOString(),
+    status: "needs_approval",
+    dryRun: true,
+    summary: `${findings.length} finding(s) and ${operations.length} proposed operation(s) from call ${parsed.id}.`,
+    findings,
+    evidence: parsed.evidence,
+    operations,
+  };
+}
+
 async function suggest(args: string[]) {
   const planId = option(args, "--plan-id");
   const planPath = option(args, "--plan");
@@ -1271,6 +1460,10 @@ export async function runCli(argv: string[]) {
     await suggest(args);
     return;
   }
+  if (command === "call") {
+    await callCommand(args);
+    return;
+  }
   if (command === "profiles") {
     profilesCommand(args);
     return;