fullstackgtm 0.11.1 → 0.13.0

package/src/connectors/hubspot.ts

@@ -542,6 +542,75 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Requir
     };
   }
 
+  /**
+   * Merge a duplicate group into the approved survivor via HubSpot's v3
+   * merge API (supported for contacts, companies, deals, and tickets).
+   * Merges are pairwise and IRREVERSIBLE; the survivor's values win on
+   * conflict and each loser is archived by HubSpot. A loser that is already
+   * gone (404 — e.g. a replayed plan) is treated as already merged.
+   */
+  async function mergeRecords(operation: PatchOperation): Promise<PatchOperationResult> {
+    const objectPath = OBJECT_PATHS[operation.objectType];
+    if (!objectPath || operation.objectType === "user" || operation.objectType === "activity") {
+      return {
+        operationId: operation.id,
+        status: "skipped",
+        detail: "merge_records is supported for accounts, contacts, and deals.",
+      };
+    }
+    const survivorId = String(operation.afterValue ?? "");
+    const groupIds = Array.isArray(operation.beforeValue)
+      ? operation.beforeValue.map((id) => String(id))
+      : [];
+    if (!survivorId || groupIds.length < 2) {
+      return {
+        operationId: operation.id,
+        status: "skipped",
+        detail: "merge_records needs a survivor id (afterValue) and the duplicate group ids (beforeValue).",
+      };
+    }
+    if (!groupIds.includes(survivorId)) {
+      return {
+        operationId: operation.id,
+        status: "skipped",
+        detail: `Survivor ${survivorId} is not in the duplicate group (${groupIds.join(", ")}); refusing to merge into an unrelated record.`,
+      };
+    }
+    const losers = groupIds.filter((id) => id !== survivorId);
+    const mergedIds: string[] = [];
+    const alreadyGoneIds: string[] = [];
+    for (const loser of losers) {
+      try {
+        await request(`/crm/v3/objects/${objectPath}/merge`, {
+          method: "POST",
+          body: JSON.stringify({ primaryObjectId: survivorId, objectIdToMerge: loser }),
+        });
+        mergedIds.push(loser);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes(" 404")) {
+          alreadyGoneIds.push(loser); // replayed plan: loser already merged/archived
+          continue;
+        }
+        return {
+          operationId: operation.id,
+          status: "failed",
+          detail: `Merged ${mergedIds.length} of ${losers.length} into ${survivorId}, then failed on ${loser}: ${message}`,
+          providerData: { survivorId, mergedIds, alreadyGoneIds },
+        };
+      }
+    }
+    return {
+      operationId: operation.id,
+      status: mergedIds.length === 0 && alreadyGoneIds.length === losers.length ? "skipped" : "applied",
+      detail:
+        mergedIds.length === 0 && alreadyGoneIds.length === losers.length
+          ? `All ${losers.length} duplicates were already merged into ${survivorId}; nothing to do.`
+          : `Merged ${mergedIds.length} duplicate ${objectPath} into ${survivorId}${alreadyGoneIds.length ? ` (${alreadyGoneIds.length} already gone)` : ""}. Irreversible.`,
+      providerData: { survivorId, mergedIds, alreadyGoneIds },
+    };
+  }
+
   async function applyOperation(operation: PatchOperation): Promise<PatchOperationResult> {
     try {
       switch (operation.operation) {
@@ -552,6 +621,8 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Requir
           return await linkRecord(operation);
         case "create_task":
           return await createTask(operation);
+        case "merge_records":
+          return await mergeRecords(operation);
         case "archive_record":
           return await archiveRecord(operation);
         default:

package/src/connectors/salesforce.ts

@@ -435,6 +435,16 @@ export function createSalesforceConnector(
         }
         case "create_task":
           return await createTask(operation);
+        case "merge_records":
+          // Salesforce merge exists only in the SOAP API and Apex (Lead,
+          // Contact, Account, Case; max 3 records) — there is no REST merge
+          // resource. Surface that honestly instead of half-merging.
+          return {
+            operationId: operation.id,
+            status: "skipped",
+            detail:
+              "Salesforce merge requires the SOAP API or Apex (Lead/Contact/Account/Case only) — this REST connector cannot merge. Merge in the Salesforce UI, or archive the duplicates explicitly.",
+          };
         case "archive_record":
           return await archiveRecord(operation);
         default:

package/src/index.ts

@@ -98,6 +98,19 @@ export {
   requiresHumanInput,
   staleDealRule,
 } from "./rules.ts";
+export {
+  extractCallInsights,
+  normalizeTranscript,
+  parseCall,
+  parseTranscript,
+  suggestCallDeal,
+  summarizeInsights,
+  type CallDealSuggestion,
+  type CallInsightType,
+  type ExtractedCallInsight,
+  type ParsedCall,
+  type ParsedTranscriptSegment,
+} from "./calls.ts";
 export { sampleSnapshot } from "./sampleData.ts";
 export { suggestValues, type SuggestionConfidence, type ValueSuggestion } from "./suggest.ts";
 export type {

package/src/mcp.ts

@@ -46,6 +46,7 @@ import type { FieldMappings } from "./mappings.ts";
 import { formatPatchPlanRun, patchPlanToMarkdown } from "./format.ts";
 import { builtinAuditRules } from "./rules.ts";
 import { sampleSnapshot } from "./sampleData.ts";
+import { parseCall } from "./calls.ts";
 import { suggestValues } from "./suggest.ts";
 import type { CanonicalGtmSnapshot, GtmConnector, PatchPlan } from "./types.ts";
 
@@ -188,6 +189,31 @@ export async function startMcpServer() {
     },
   );
 
+  server.registerTool(
+    "fullstackgtm_call_parse",
+    {
+      title: "Parse Call Transcript",
+      description:
+        "Deterministically parse a call transcript (Speaker:/[Speaker]: lines or Granola " +
+        "utterance JSON) into canonical segments, keyword-derived insights (next steps, " +
+        "objections, pricing, risks, competitor mentions...), and GtmEvidence records. " +
+        "Read-only and LLM-free; pair with fullstackgtm_audit/apply for governed writes.",
+      inputSchema: {
+        transcript: z.string().optional(),
+        transcriptPath: z.string().optional(),
+        title: z.string().optional(),
+        source: z.enum(["gong", "chorus", "fathom", "manual", "csv", "unknown"]).optional(),
+      },
+    },
+    async ({ transcript, transcriptPath, title, source }) => {
+      const raw =
+        transcript ??
+        (transcriptPath ? readFileSync(resolve(process.cwd(), transcriptPath), "utf8") : null);
+      if (!raw) throw new Error("Provide transcript (text) or transcriptPath (file).");
+      return content(parseCall(raw, { title, sourceSystem: source }));
+    },
+  );
+
   server.registerTool(
     "fullstackgtm_rules",
     {

package/src/rules.ts

@@ -350,13 +350,15 @@ export const duplicateAccountDomainRule: GtmAuditRule = {
         id: patchOperationId("duplicate-account-domain", anchor.id),
         objectType: "account" as const,
         objectId: anchor.id,
-        operation: "create_task" as const,
-        field: "merge_review_task",
-        beforeValue: null,
-        afterValue: `Review ${accounts.length} accounts sharing ${domain} and merge duplicates`,
-        reason: "Duplicate accounts split pipeline, attribution, and ownership.",
-        riskLevel: "medium" as const,
+        operation: "merge_records" as const,
+        field: "merge",
+        beforeValue: accounts.map((account) => account.id),
+        afterValue: "requires_human_survivor_selection",
+        reason: `Duplicate accounts split pipeline, attribution, and ownership. Merge the ${accounts.length} accounts sharing ${domain} into one survivor.`,
+        riskLevel: "high" as const,
         approvalRequired: true,
+        rollback:
+          "IRREVERSIBLE: provider merges cannot be unmerged. The pre-apply snapshot retains every record's field values; recreate a record manually from it if a merge was wrong.",
       });
     }
     return { findings, operations };
@@ -388,13 +390,15 @@ export const duplicateContactEmailRule: GtmAuditRule = {
         id: patchOperationId("duplicate-contact-email", anchor.id),
         objectType: "contact" as const,
         objectId: anchor.id,
-        operation: "create_task" as const,
-        field: "merge_review_task",
-        beforeValue: null,
-        afterValue: `Review ${contacts.length} contacts sharing ${email} and merge duplicates`,
-        reason: "Duplicate contacts fragment engagement history and double-route outreach.",
-        riskLevel: "low" as const,
+        operation: "merge_records" as const,
+        field: "merge",
+        beforeValue: contacts.map((contact) => contact.id),
+        afterValue: "requires_human_survivor_selection",
+        reason: `Duplicate contacts fragment engagement history and double-route outreach. Merge the ${contacts.length} contacts sharing ${email} into one survivor.`,
+        riskLevel: "high" as const,
         approvalRequired: true,
+        rollback:
+          "IRREVERSIBLE: provider merges cannot be unmerged. The pre-apply snapshot retains every record's field values; recreate a record manually from it if a merge was wrong.",
       });
     }
     return { findings, operations };
@@ -437,13 +441,15 @@ export const duplicateOpenDealRule: GtmAuditRule = {
         id: patchOperationId("duplicate-open-deal", anchor.id),
         objectType: "deal" as const,
         objectId: anchor.id,
-        operation: "create_task" as const,
-        field: "merge_review_task",
-        beforeValue: null,
-        afterValue: `Review ${deals.length} duplicate open deals named "${anchor.name}" — keep one, archive ${deals.length - 1}`,
-        reason: "Duplicate open deals inflate pipeline and forecast the same revenue more than once.",
-        riskLevel: "medium" as const,
+        operation: "merge_records" as const,
+        field: "merge",
+        beforeValue: deals.map((deal) => deal.id),
+        afterValue: "requires_human_survivor_selection",
+        reason: `Duplicate open deals inflate pipeline and forecast the same revenue more than once. Merge the ${deals.length} deals named "${anchor.name}" into one survivor.`,
+        riskLevel: "high" as const,
         approvalRequired: true,
+        rollback:
+          "IRREVERSIBLE: provider merges cannot be unmerged. The pre-apply snapshot retains every record's field values; recreate a record manually from it if a merge was wrong.",
       });
     }
     return { findings, operations };

package/src/suggest.ts

@@ -62,6 +62,11 @@ export function suggestValues(
       continue;
     }
 
+    if (placeholder === "requires_human_survivor_selection") {
+      suggestions.push(suggestSurvivor(operation, snapshot, dealsById));
+      continue;
+    }
+
     if (placeholder === "requires_human_owner_selection" && activeUsers.length === 1) {
       suggestions.push({
         operationId: operation.id,
@@ -194,6 +199,89 @@ function suggestDealAccount(
   };
 }
 
+/**
+ * Survivor selection for merge_records. Ranking is deterministic and
+ * evidence-based: most complete record first (count of populated canonical
+ * fields), most recent activity as the tiebreaker, group order last.
+ * Confidence is capped at "low" by design: merges are irreversible, so a
+ * survivor suggestion must never clear the default bulk-approval bar —
+ * accepting one requires --min-confidence low or an explicit --value.
+ */
+function suggestSurvivor(
+  operation: PatchOperation,
+  snapshot: CanonicalGtmSnapshot,
+  dealsById: Map<string, { name: string }>,
+): ValueSuggestion {
+  const base = {
+    operationId: operation.id,
+    objectType: operation.objectType,
+    objectId: operation.objectId,
+    objectName: dealsById.get(operation.objectId)?.name,
+    placeholder: "requires_human_survivor_selection",
+  };
+  const groupIds = Array.isArray(operation.beforeValue)
+    ? operation.beforeValue.map((id) => String(id))
+    : [];
+  if (groupIds.length < 2) {
+    return {
+      ...base,
+      suggestedValue: null,
+      confidence: "none",
+      reason: "Operation does not carry a duplicate group (expected ids in beforeValue).",
+    };
+  }
+  const collection =
+    operation.objectType === "account"
+      ? snapshot.accounts
+      : operation.objectType === "contact"
+        ? snapshot.contacts
+        : operation.objectType === "deal"
+          ? snapshot.deals
+          : [];
+  const records = groupIds
+    .map((id) => collection.find((row) => row.id === id))
+    .filter((row): row is NonNullable<typeof row> => row !== undefined);
+  if (records.length !== groupIds.length) {
+    return {
+      ...base,
+      suggestedValue: null,
+      confidence: "none",
+      reason: "Not every group member is present in the snapshot; re-run the audit before merging.",
+    };
+  }
+  const ranked = [...records].sort((a, b) => {
+    const completeness = populatedFields(b) - populatedFields(a);
+    if (completeness !== 0) return completeness;
+    return activityMs(b) - activityMs(a);
+  });
+  const winner = ranked[0];
+  const runnerUp = ranked[1];
+  const name = "name" in winner && typeof winner.name === "string" ? winner.name : winner.id;
+  return {
+    ...base,
+    suggestedValue: winner.id,
+    confidence: "low",
+    reason:
+      `"${name}" (${winner.id}) is the most complete record in the group ` +
+      `(${populatedFields(winner)} populated fields vs ${populatedFields(runnerUp)}` +
+      `${activityMs(winner) > activityMs(runnerUp) ? ", and more recent activity" : ""}). ` +
+      `Merging is IRREVERSIBLE — survivor suggestions never exceed low confidence; ` +
+      `approve with --min-confidence low or an explicit --value after review.`,
+  };
+}
+
+function populatedFields(record: object) {
+  return Object.values(record).filter(
+    (value) => value !== undefined && value !== null && value !== "",
+  ).length;
+}
+
+function activityMs(record: object) {
+  const value = (record as { lastActivityAt?: string }).lastActivityAt;
+  const parsed = value ? Date.parse(value) : NaN;
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
 function normalize(value: string) {
   return value
     .toLowerCase()

package/src/types.ts

@@ -41,7 +41,11 @@ export type PatchOperationType =
   | "clear_field"
   | "link_record"
   | "archive_record"
-  | "create_task";
+  | "create_task"
+  // Merge a duplicate group into a survivor. beforeValue is the group's
+  // record ids; afterValue is the survivor id (requires_human_survivor_selection
+  // until a human picks). IRREVERSIBLE on every provider that supports it.
+  | "merge_records";
 
 export type AuditFindingSeverity = "info" | "warning" | "critical";