fullstackgtm 0.45.0 → 0.47.0

package/dist/cli.js

@@ -1,22 +1,14 @@
 import { activeProfile, listProfiles, setActiveProfile } from "./credentials.js";
-import { audit, healthCommand, reportCommand, rulesCommand, snapshotCommand } from "./cli/audit.js";
-import { doctorCommand, login, logout } from "./cli/auth.js";
 import { capabilitiesCommand, printCommandHelpJson, robotDocsCommand, unknownCommandEnvelope } from "./cli/capabilities.js";
-import { callCommand } from "./cli/call.js";
-import { draftCommand } from "./cli/draft.js";
-import { enrichCommand } from "./cli/enrich.js";
-import { bulkUpdateCommand, dedupeCommand, fixCommand, reassignCommand, resolveCommand, suggest } from "./cli/fix.js";
 import { BESPOKE_HELP, commandHelp, HELP, shortUsage, stylizeShortUsage, usage } from "./cli/help.js";
-import { icpCommand } from "./cli/icp.js";
-import { initCommand } from "./cli/init.js";
-import { marketCommand } from "./cli/market.js";
-import { apply, auditLogCommand, diffCommand, mergeCommand, plansCommand } from "./cli/plans.js";
-import { scheduleCommand } from "./cli/schedule.js";
 import { readPackageInfo } from "./cli/shared.js";
 import { correctedCommand, detectFlagTypo, suggestCommand, unknownFlagEnvelope } from "./cli/suggest.js";
 import { colorEnabled, paint } from "./cli/ui.js";
-import { signalsCommand } from "./cli/signals.js";
-import { tamCommand } from "./cli/tam.js";
+// Verb modules load lazily inside their dispatch branch below. The dispatcher
+// used to import all of them eagerly, so `--version` compiled the full
+// 78-module graph (audit, market, enrich, signals, schedule, …) before
+// printing one line. Each branch now `await import()`s only its own module;
+// help/typo/error paths and the exports above stay eager and byte-identical.
 /**
  * Pull the global `--profile <name>` flag out of argv (it may appear before
  * or after the command) and activate it. Stripping it keeps positional
@@ -126,95 +118,99 @@ export async function runCli(argv) {
         return;
     }
     if (command === "login") {
-        await login(args);
+        await (await import("./cli/auth.js")).login(args);
         return;
     }
     if (command === "logout") {
-        logout(args);
+        (await import("./cli/auth.js")).logout(args);
         return;
     }
     if (command === "snapshot") {
-        await snapshotCommand(args);
+        await (await import("./cli/audit.js")).snapshotCommand(args);
         return;
     }
     if (command === "audit") {
-        await audit(args);
+        await (await import("./cli/audit.js")).audit(args);
         return;
     }
     if (command === "report") {
-        await reportCommand(args);
+        await (await import("./cli/audit.js")).reportCommand(args);
         return;
     }
     if (command === "rules") {
-        await rulesCommand(args);
+        await (await import("./cli/audit.js")).rulesCommand(args);
         return;
     }
     if (command === "doctor") {
-        await doctorCommand(args);
+        await (await import("./cli/auth.js")).doctorCommand(args);
         return;
     }
     if (command === "health") {
-        healthCommand(args);
+        (await import("./cli/audit.js")).healthCommand(args);
         return;
     }
     if (command === "suggest") {
-        await suggest(args);
+        await (await import("./cli/fix.js")).suggest(args);
         return;
     }
     if (command === "call") {
-        await callCommand(args);
+        await (await import("./cli/call.js")).callCommand(args);
         return;
     }
     if (command === "resolve") {
-        await resolveCommand(args);
+        await (await import("./cli/fix.js")).resolveCommand(args);
         return;
     }
     if (command === "bulk-update") {
-        await bulkUpdateCommand(args);
+        await (await import("./cli/fix.js")).bulkUpdateCommand(args);
         return;
     }
     if (command === "dedupe") {
-        await dedupeCommand(args);
+        await (await import("./cli/fix.js")).dedupeCommand(args);
         return;
     }
     if (command === "reassign") {
-        await reassignCommand(args);
+        await (await import("./cli/fix.js")).reassignCommand(args);
         return;
     }
     if (command === "fix") {
-        await fixCommand(args);
+        await (await import("./cli/fix.js")).fixCommand(args);
         return;
     }
     if (command === "market") {
-        await marketCommand(args);
+        await (await import("./cli/market.js")).marketCommand(args);
         return;
     }
     if (command === "enrich") {
-        await enrichCommand(args);
+        await (await import("./cli/enrich.js")).enrichCommand(args);
+        return;
+    }
+    if (command === "backfill") {
+        await (await import("./cli/backfill.js")).backfillCommand(args);
         return;
     }
     if (command === "init") {
-        initCommand(args);
+        (await import("./cli/init.js")).initCommand(args);
         return;
     }
     if (command === "tam") {
-        await tamCommand(args);
+        await (await import("./cli/tam.js")).tamCommand(args);
         return;
     }
     if (command === "icp") {
-        await icpCommand(args);
+        await (await import("./cli/icp.js")).icpCommand(args);
         return;
     }
     if (command === "signals") {
-        await signalsCommand(args);
+        await (await import("./cli/signals.js")).signalsCommand(args);
         return;
     }
     if (command === "draft") {
-        await draftCommand(args);
+        await (await import("./cli/draft.js")).draftCommand(args);
         return;
     }
     if (command === "schedule") {
-        await scheduleCommand(args);
+        await (await import("./cli/schedule.js")).scheduleCommand(args);
         return;
     }
     if (command === "profiles") {
@@ -222,23 +218,23 @@ export async function runCli(argv) {
         return;
     }
     if (command === "diff") {
-        await diffCommand(args);
+        await (await import("./cli/plans.js")).diffCommand(args);
         return;
     }
     if (command === "merge") {
-        await mergeCommand(args);
+        await (await import("./cli/plans.js")).mergeCommand(args);
         return;
     }
     if (command === "plans") {
-        await plansCommand(args);
+        await (await import("./cli/plans.js")).plansCommand(args);
         return;
     }
     if (command === "audit-log") {
-        await auditLogCommand(args);
+        await (await import("./cli/plans.js")).auditLogCommand(args);
         return;
     }
     if (command === "apply") {
-        await apply(args);
+        await (await import("./cli/plans.js")).apply(args);
         return;
     }
     // Machine callers get a structured envelope with a did-you-mean hint

package/dist/connector.d.ts

@@ -1,3 +1,4 @@
+import { type ProgressEmitter } from "./progress.ts";
 import type { GtmConnector, PatchPlan, PatchPlanRun } from "./types.ts";
 export type ApplyPatchPlanOptions = {
     /**
@@ -31,6 +32,13 @@ export type ApplyPatchPlanOptions = {
      * full operation count.
      */
     onOperation?: (progress: ApplyProgress) => void;
+    /**
+     * Shared progress vocabulary (src/progress.ts): the run emits the
+     * APPLY_STAGES (preflight → operations → results), one `opResult` per
+     * resolved operation (id + status only — no values), and `items` over the
+     * plan's operations. Additive alongside `onOperation`; presentation only.
+     */
+    progress?: ProgressEmitter;
 };
 export type ApplyProgress = {
     completed: number;

package/dist/connector.js

@@ -1,4 +1,5 @@
 import { dedupeKey } from "./dedupe.js";
+import { APPLY_STAGES } from "./progress.js";
 import { requiresHumanInput } from "./rules.js";
 const IRREVERSIBLE_OPERATIONS = new Set(["merge_records", "archive_record"]);
 const IDENTITY_KEY_BY_TYPE = {
@@ -70,6 +71,13 @@ function normalizeForComparison(value) {
         return null;
     return String(value);
 }
+function isApplyBatchCandidate(operation) {
+    return (((operation.operation === "set_field" || operation.operation === "clear_field") && Boolean(operation.field)) ||
+        operation.operation === "archive_record");
+}
+function sameApplyBatchKind(a, b) {
+    return a.operation === b.operation && a.objectType === b.objectType;
+}
 /**
  * Apply an approved subset of a patch plan through a connector.
  *
@@ -83,6 +91,8 @@ export async function applyPatchPlan(connector, plan, options) {
         throw new Error(`The ${connector.provider} connector is read-only.`);
     }
     const startedAt = new Date().toISOString();
+    const emitStage = (stage) => options.progress?.stage(stage, APPLY_STAGES.indexOf(stage), APPLY_STAGES.length);
+    emitStage("preflight");
     const approved = new Set(options.approvedOperationIds);
     const checkConflicts = options.checkConflicts ?? typeof connector.readField === "function";
     const results = [];
@@ -157,6 +167,7 @@ export async function applyPatchPlan(connector, plan, options) {
                     : "Operation was not approved.",
             });
         }
+        emitStage("results");
         return {
             planId: plan.id,
             provider: connector.provider,
@@ -190,6 +201,11 @@ export async function applyPatchPlan(connector, plan, options) {
         for (const operation of plan.operations) {
             if (!approved.has(operation.id) || conflicts.has(operation.id))
                 continue;
+            // Generic batch connectors (Salesforce) do their own batched CAS read for
+            // eligible field writes, so don't pre-read those one-by-one here.
+            if (connector.applyBatch && isApplyBatchCandidate(operation) && !operation.groupId && !operation.preconditions?.length) {
+                continue;
+            }
             let conflict = null;
             if (operation.field && FIELD_WRITE_OPERATIONS.has(operation.operation)) {
                 const current = await connector.readField(operation.objectType, operation.objectId, operation.field);
@@ -260,30 +276,40 @@ export async function applyPatchPlan(connector, plan, options) {
     const resultsBefore = results.length;
     let lastNotified = results.length;
     const notifyProgress = () => {
-        if (!options.onOperation || results.length === lastNotified)
+        if ((!options.onOperation && !options.progress) || results.length === lastNotified)
             return;
-        lastNotified = results.length;
-        const last = results[results.length - 1];
-        if (last.status === "applied")
-            progressCounts.applied += 1;
-        else if (last.status === "failed")
-            progressCounts.failed += 1;
-        else if (last.status === "conflict")
-            progressCounts.conflicts += 1;
-        else
-            progressCounts.skipped += 1;
-        try {
-            options.onOperation({
-                completed: results.length - resultsBefore,
-                total: plan.operations.length,
-                ...progressCounts,
-            });
-        }
-        catch {
-            // progress is presentation-only
+        while (lastNotified < results.length) {
+            const last = results[lastNotified];
+            lastNotified += 1;
+            if (last.status === "applied")
+                progressCounts.applied += 1;
+            else if (last.status === "failed")
+                progressCounts.failed += 1;
+            else if (last.status === "conflict")
+                progressCounts.conflicts += 1;
+            else
+                progressCounts.skipped += 1;
+            // Shared vocabulary: operation id + status only — a conflict/failure
+            // detail can echo field values, which never leave the machine.
+            options.progress?.opResult(last.operationId, last.status);
+            options.progress?.items(results.length - resultsBefore, plan.operations.length);
+            if (options.onOperation) {
+                try {
+                    options.onOperation({
+                        completed: lastNotified - resultsBefore,
+                        total: plan.operations.length,
+                        ...progressCounts,
+                    });
+                }
+                catch {
+                    // progress is presentation-only
+                }
+            }
         }
     };
-    for (const operation of plan.operations) {
+    emitStage("operations");
+    for (let opIndex = 0; opIndex < plan.operations.length; opIndex++) {
+        const operation = plan.operations[opIndex];
         // Report the previous iteration's result (guarded: no-op if it pushed
         // nothing). One-iteration lag keeps this a two-line hook instead of a
         // notify after all ten push sites; the loop-exit call below flushes the last.
@@ -351,6 +377,62 @@ export async function applyPatchPlan(connector, plan, options) {
             });
             continue;
         }
+        if (connector.applyBatch && isApplyBatchCandidate(operation) && (checkConflicts || operation.operation === "archive_record") && !operation.groupId && !operation.preconditions?.length) {
+            const chunk = [];
+            const applyBatchLimit = Math.max(1, connector.applyBatchLimit ?? 200);
+            for (let scan = opIndex; scan < plan.operations.length && chunk.length < applyBatchLimit; scan++) {
+                const candidate = plan.operations[scan];
+                if (!sameApplyBatchKind(operation, candidate) || !isApplyBatchCandidate(candidate))
+                    break;
+                const candidateOverride = options.valueOverrides?.[candidate.id];
+                if (!approved.has(candidate.id) ||
+                    (requiresHumanInput(candidate.afterValue) && candidateOverride === undefined) ||
+                    conflicts.has(candidate.id) ||
+                    Boolean(candidate.groupId) ||
+                    Boolean(candidate.preconditions?.length) ||
+                    (staleByFilter && staleByFilter.has(candidate.objectId)) ||
+                    irreversibleStale.has(candidate.id)) {
+                    break;
+                }
+                chunk.push(candidateOverride === undefined ? candidate : { ...candidate, afterValue: candidateOverride });
+            }
+            if (chunk.length > 1) {
+                try {
+                    const batchResults = await connector.applyBatch(chunk);
+                    const byOperationId = new Map(batchResults.map((result) => [result.operationId, result]));
+                    for (const batchOperation of chunk) {
+                        const result = byOperationId.get(batchOperation.id) ?? {
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: "Batch connector did not return a result for this operation.",
+                        };
+                        results.push(result);
+                        if (result.status === "applied" || result.status === "failed")
+                            attempted += 1;
+                        if (result.status === "applied")
+                            applied += 1;
+                    }
+                    const appliedInBatch = batchResults.filter((result) => result.status === "applied").length;
+                    appliedSinceRecheck += appliedInBatch;
+                    if (appliedInBatch > 0 && (applied === appliedInBatch || appliedSinceRecheck >= recheckEvery)) {
+                        appliedSinceRecheck = 0;
+                        await refreshSnapshotChecks();
+                    }
+                }
+                catch (error) {
+                    for (const batchOperation of chunk) {
+                        results.push({
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: error instanceof Error ? error.message : String(error),
+                        });
+                        attempted += 1;
+                    }
+                }
+                opIndex += chunk.length - 1;
+                continue;
+            }
+        }
         const resolved = override === undefined ? operation : { ...operation, afterValue: override };
         attempted += 1;
         try {
@@ -377,6 +459,7 @@ export async function applyPatchPlan(connector, plan, options) {
         }
     }
     notifyProgress();
+    emitStage("results");
     return {
         planId: plan.id,
         provider: connector.provider,

package/dist/connectors/hubspot.d.ts

@@ -1,5 +1,6 @@
 import { type FieldMappings } from "../mappings.ts";
 import type { GtmConnector, SnapshotProgress } from "../types.ts";
+import { type ProgressEmitter } from "../progress.ts";
 export type HubspotConnectorOptions = {
     /** Returns a HubSpot access token (private app token or OAuth access token). */
     getAccessToken: () => string | Promise<string>;
@@ -10,6 +11,12 @@ export type HubspotConnectorOptions = {
     fetchImpl?: typeof fetch;
     /** Per-page snapshot-pull progress (presentation only — errors are swallowed). */
     onProgress?: (progress: SnapshotProgress) => void;
+    /**
+     * Shared progress vocabulary (src/progress.ts): the snapshot pull emits a
+     * `stage` per object type and an `items` heartbeat per page. Additive
+     * alongside the legacy `onProgress` callback; both are presentation-only.
+     */
+    progress?: ProgressEmitter;
 };
 /**
  * Reference connector for HubSpot.
@@ -19,4 +26,4 @@ export type HubspotConnectorOptions = {
  * amountless deals — so audit rules can surface the gaps instead of hiding
  * them.
  */
-export declare function createHubspotConnector(options: HubspotConnectorOptions): Required<GtmConnector>;
+export declare function createHubspotConnector(options: HubspotConnectorOptions): GtmConnector;