fullstackgtm 0.10.0

package/dist/demo.js

@@ -0,0 +1,169 @@
+const FIRST_NAMES = [
+    "Ava", "Marcus", "Priya", "Diego", "Sofia", "Jordan",
+    "Mei", "Tomás", "Nia", "Ethan", "Lena", "Omar",
+];
+const LAST_NAMES = [
+    "Calloway", "Reyes", "Iyer", "Novak", "Bennett", "Okafor",
+    "Lindqvist", "Moreau", "Tanaka", "Whitfield", "Drummond", "Vargas",
+];
+const COMPANY_HEADS = [
+    "Halcyon", "Northwind", "Cobalt", "Ridgeline", "Lumen", "Vantage",
+    "Harbor", "Atlas", "Crestline", "Meridian", "Bluff", "Juniper",
+    "Granite", "Summit", "Beacon",
+];
+const COMPANY_TAILS = [
+    "Analytics", "Logistics", "Biotech", "Robotics", "Software",
+    "Manufacturing", "Health", "Financial", "Media", "Systems",
+    "Foods", "Energy", "Labs", "Dynamics",
+];
+const INDUSTRIES = [
+    "SaaS", "Logistics", "Healthcare", "Manufacturing", "Financial Services",
+    "Media", "Energy", "Retail",
+];
+const OPEN_STAGES = ["discovery", "qualification", "proposal", "negotiation"];
+const DEAL_LABELS = [
+    "Platform Subscription", "Enterprise Rollout", "Pilot Expansion",
+    "Renewal", "Multi-Year Agreement", "Team Upgrade", "Add-On Seats",
+];
+/** Deterministic PRNG (mulberry32) so demo data is stable across runs. */
+function mulberry32(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function shiftDate(today, days) {
+    const base = Date.parse(`${today}T00:00:00Z`);
+    return new Date(base + days * 86_400_000).toISOString().slice(0, 10);
+}
+/**
+ * Generate a realistic, deliberately messy mid-market CRM snapshot.
+ *
+ * The mess is injected at fixed indices so audits over a given seed produce
+ * stable, testable findings, while the PRNG varies names, amounts, and dates:
+ * - every 8th account is an orphan (no contacts, no deals)
+ * - every 9th deal references a departed owner that no longer exists
+ * - every 11th deal lost its account association
+ * - open deals carry a realistic spread of past close dates and stale activity
+ */
+export function generateDemoSnapshot(options = {}) {
+    const seed = options.seed ?? 7;
+    const today = options.today ?? "2026-06-09";
+    const accountCount = options.accounts ?? 56;
+    const dealCount = options.deals ?? 80;
+    const random = mulberry32(seed);
+    const pick = (items) => items[Math.floor(random() * items.length)];
+    const between = (min, max) => min + Math.floor(random() * (max - min + 1));
+    const users = FIRST_NAMES.map((firstName, index) => ({
+        id: `user_${String(index + 1).padStart(2, "0")}`,
+        provider: "mock",
+        crmId: `${9000 + index}`,
+        name: `${firstName} ${LAST_NAMES[index]}`,
+        email: `${firstName.toLowerCase()}.${LAST_NAMES[index].toLowerCase()}@example.com`,
+        title: index === 0 ? "VP Sales" : index === 1 ? "Sales Manager" : "Account Executive",
+        active: index < 10,
+    }));
+    const activeReps = users.slice(2, 10);
+    const accounts = [];
+    for (let index = 0; index < accountCount; index += 1) {
+        const name = `${COMPANY_HEADS[index % COMPANY_HEADS.length]} ${pick(COMPANY_TAILS)}`;
+        accounts.push({
+            id: `acct_${String(index + 1).padStart(3, "0")}`,
+            provider: "mock",
+            crmId: `${10_000 + index}`,
+            name,
+            domain: `${name.toLowerCase().replace(/[^a-z]/g, "")}.com`,
+            industry: pick(INDUSTRIES),
+            ownerId: random() < 0.85 ? pick(activeReps).id : undefined,
+            employeeCount: between(40, 4000),
+            annualRevenue: between(2, 400) * 1_000_000,
+            lastSyncAt: shiftDate(today, -between(0, 3)),
+        });
+    }
+    const orphanAccountIds = new Set(accounts.filter((_, index) => index % 8 === 0).map((account) => account.id));
+    const linkableAccounts = accounts.filter((account) => !orphanAccountIds.has(account.id));
+    const contacts = [];
+    for (const account of linkableAccounts) {
+        const count = between(1, 3);
+        for (let index = 0; index < count; index += 1) {
+            const firstName = pick(FIRST_NAMES);
+            const lastName = pick(LAST_NAMES);
+            contacts.push({
+                id: `contact_${String(contacts.length + 1).padStart(3, "0")}`,
+                provider: "mock",
+                crmId: `${20_000 + contacts.length}`,
+                accountId: account.id,
+                firstName,
+                lastName,
+                email: `${firstName.toLowerCase()}@${account.domain}`,
+                title: pick(["CTO", "VP Operations", "Head of RevOps", "Director of IT", "CFO"]),
+                ownerId: account.ownerId,
+                lastSyncAt: account.lastSyncAt,
+            });
+        }
+    }
+    const deals = [];
+    const activities = [];
+    for (let index = 0; index < dealCount; index += 1) {
+        const account = linkableAccounts[index % linkableAccounts.length];
+        const departedOwner = index % 9 === 0;
+        const unlinked = index % 11 === 0;
+        const stageRoll = random();
+        const stage = stageRoll < 0.7 ? pick(OPEN_STAGES) : stageRoll < 0.88 ? "closedwon" : "closedlost";
+        const isWon = stage === "closedwon";
+        const isClosed = isWon || stage === "closedlost";
+        const closeDate = isClosed
+            ? shiftDate(today, -between(5, 120))
+            : shiftDate(today, between(-60, 150));
+        const daysSinceActivity = isClosed ? between(5, 60) : between(0, 75);
+        const lastActivityAt = shiftDate(today, -daysSinceActivity);
+        const deal = {
+            id: `deal_${String(index + 1).padStart(3, "0")}`,
+            provider: "mock",
+            crmId: `${30_000 + index}`,
+            accountId: unlinked ? undefined : account.id,
+            ownerId: departedOwner ? `user_departed_${index % 2}` : (account.ownerId ?? pick(activeReps).id),
+            name: `${account.name} — ${pick(DEAL_LABELS)}`,
+            amount: between(8, 480) * 500,
+            currency: "USD",
+            stage,
+            closeDate,
+            forecastCategory: isWon ? "closed_won" : isClosed ? "closed_lost" : "pipeline",
+            probability: isClosed ? (isWon ? 1 : 0) : between(10, 80) / 100,
+            isClosed,
+            isWon,
+            lastActivityAt,
+            lastSyncAt: shiftDate(today, -between(0, 2)),
+        };
+        deals.push(deal);
+        const activityCount = Math.max(1, 3 - Math.floor(daysSinceActivity / 25));
+        for (let activityIndex = 0; activityIndex < activityCount; activityIndex += 1) {
+            activities.push({
+                id: `activity_${String(activities.length + 1).padStart(4, "0")}`,
+                provider: "mock",
+                dealId: deal.id,
+                accountId: deal.accountId,
+                ownerId: deal.ownerId,
+                type: pick(["call", "email", "meeting"]),
+                occurredAt: shiftDate(today, -(daysSinceActivity + activityIndex * between(3, 12))),
+                subject: pick([
+                    "Discovery call", "Pricing discussion", "Security review",
+                    "Champion sync", "Procurement follow-up", "Executive alignment",
+                ]),
+            });
+        }
+    }
+    return {
+        generatedAt: `${today}T00:00:00.000Z`,
+        provider: "mock",
+        users,
+        accounts,
+        contacts,
+        deals,
+        activities,
+    };
+}

package/dist/diff.d.ts

@@ -0,0 +1,46 @@
+import type { AuditFinding, CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+export type FieldChange = {
+    field: string;
+    before: unknown;
+    after: unknown;
+};
+export type RecordChange = {
+    id: string;
+    label: string;
+    changes: FieldChange[];
+};
+export type CollectionDiff = {
+    added: Array<{
+        id: string;
+        label: string;
+    }>;
+    removed: Array<{
+        id: string;
+        label: string;
+    }>;
+    changed: RecordChange[];
+};
+export type SnapshotDiff = {
+    before: {
+        provider: string;
+        generatedAt: string;
+    };
+    after: {
+        provider: string;
+        generatedAt: string;
+    };
+    users: CollectionDiff;
+    accounts: CollectionDiff;
+    contacts: CollectionDiff;
+    deals: CollectionDiff;
+    activities: CollectionDiff;
+};
+export declare function diffSnapshots(before: CanonicalGtmSnapshot, after: CanonicalGtmSnapshot): SnapshotDiff;
+export type FindingsDrift = {
+    newFindings: AuditFinding[];
+    resolvedFindings: AuditFinding[];
+    persistingCount: number;
+};
+/** Hygiene drift between two plans, keyed on stable finding ids. */
+export declare function diffFindings(before: PatchPlan, after: PatchPlan): FindingsDrift;
+export declare function diffToMarkdown(diff: SnapshotDiff, drift?: FindingsDrift): string;

package/dist/diff.js

@@ -0,0 +1,107 @@
+/**
+ * Snapshot and audit drift. Record ids and finding ids are stable across
+ * runs, so two snapshots (or two plans) can be compared directly: what
+ * appeared, what disappeared, what changed — and whether hygiene regressed.
+ */
+// Fields that change on every sync without semantic meaning.
+const IGNORED_FIELDS = new Set(["raw", "lastSyncAt", "identities"]);
+function labelOf(record) {
+    return record.name ?? record.email ?? record.id;
+}
+function diffCollection(before, after) {
+    const beforeById = new Map(before.map((record) => [record.id, record]));
+    const afterById = new Map(after.map((record) => [record.id, record]));
+    const added = after
+        .filter((record) => !beforeById.has(record.id))
+        .map((record) => ({ id: record.id, label: labelOf(record) }));
+    const removed = before
+        .filter((record) => !afterById.has(record.id))
+        .map((record) => ({ id: record.id, label: labelOf(record) }));
+    const changed = [];
+    for (const record of after) {
+        const previous = beforeById.get(record.id);
+        if (!previous)
+            continue;
+        const fields = new Set([...Object.keys(previous), ...Object.keys(record)]);
+        const changes = [];
+        for (const field of fields) {
+            if (IGNORED_FIELDS.has(field))
+                continue;
+            const beforeValue = previous[field];
+            const afterValue = record[field];
+            if (JSON.stringify(beforeValue) !== JSON.stringify(afterValue)) {
+                changes.push({ field, before: beforeValue ?? null, after: afterValue ?? null });
+            }
+        }
+        if (changes.length > 0) {
+            changed.push({ id: record.id, label: labelOf(record), changes });
+        }
+    }
+    return { added, removed, changed };
+}
+export function diffSnapshots(before, after) {
+    return {
+        before: { provider: before.provider, generatedAt: before.generatedAt },
+        after: { provider: after.provider, generatedAt: after.generatedAt },
+        users: diffCollection(before.users, after.users),
+        accounts: diffCollection(before.accounts, after.accounts),
+        contacts: diffCollection(before.contacts, after.contacts),
+        deals: diffCollection(before.deals, after.deals),
+        activities: diffCollection(before.activities, after.activities),
+    };
+}
+/** Hygiene drift between two plans, keyed on stable finding ids. */
+export function diffFindings(before, after) {
+    const beforeIds = new Set(before.findings.map((finding) => finding.id));
+    const afterIds = new Set(after.findings.map((finding) => finding.id));
+    return {
+        newFindings: after.findings.filter((finding) => !beforeIds.has(finding.id)),
+        resolvedFindings: before.findings.filter((finding) => !afterIds.has(finding.id)),
+        persistingCount: after.findings.filter((finding) => beforeIds.has(finding.id)).length,
+    };
+}
+export function diffToMarkdown(diff, drift) {
+    const lines = [
+        "# Snapshot diff",
+        "",
+        `Before: ${diff.before.provider} @ ${diff.before.generatedAt}`,
+        `After: ${diff.after.provider} @ ${diff.after.generatedAt}`,
+        "",
+        "| Collection | Added | Removed | Changed |",
+        "| --- | --- | --- | --- |",
+    ];
+    for (const collection of ["users", "accounts", "contacts", "deals", "activities"]) {
+        const entry = diff[collection];
+        lines.push(`| ${collection} | ${entry.added.length} | ${entry.removed.length} | ${entry.changed.length} |`);
+    }
+    for (const collection of ["users", "accounts", "contacts", "deals", "activities"]) {
+        const entry = diff[collection];
+        if (entry.added.length + entry.removed.length + entry.changed.length === 0)
+            continue;
+        lines.push("", `## ${collection}`, "");
+        for (const record of entry.added)
+            lines.push(`- added ${record.label} (${record.id})`);
+        for (const record of entry.removed)
+            lines.push(`- removed ${record.label} (${record.id})`);
+        for (const record of entry.changed) {
+            lines.push(`- changed ${record.label} (${record.id}): ${record.changes
+                .map((change) => `${change.field} ${formatValue(change.before)} → ${formatValue(change.after)}`)
+                .join("; ")}`);
+        }
+    }
+    if (drift) {
+        lines.push("", "## Hygiene drift", "", `New findings: ${drift.newFindings.length}`, `Resolved findings: ${drift.resolvedFindings.length}`, `Persisting findings: ${drift.persistingCount}`);
+        for (const finding of drift.newFindings) {
+            lines.push(`- NEW [${finding.ruleId}] ${finding.summary}`);
+        }
+        for (const finding of drift.resolvedFindings) {
+            lines.push(`- resolved [${finding.ruleId}] ${finding.summary}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function formatValue(value) {
+    if (value === undefined || value === null || value === "")
+        return "∅";
+    return typeof value === "string" ? value : JSON.stringify(value);
+}

package/dist/format.d.ts

@@ -0,0 +1,3 @@
+import type { PatchPlan, PatchPlanRun } from "./types.ts";
+export declare function patchPlanToMarkdown(plan: PatchPlan): string;
+export declare function formatPatchPlanRun(run: PatchPlanRun): string;

package/dist/format.js

@@ -0,0 +1,109 @@
+export function patchPlanToMarkdown(plan) {
+    const lines = [
+        `# ${plan.title}`,
+        "",
+        `Status: ${plan.status}`,
+        `Dry run: ${plan.dryRun ? "yes" : "no"}`,
+        `Summary: ${plan.summary}`,
+        "",
+    ];
+    if (plan.findings.length > 0) {
+        const byRule = new Map();
+        for (const finding of plan.findings) {
+            const entry = byRule.get(finding.ruleId) ?? { count: 0, severity: finding.severity };
+            entry.count += 1;
+            byRule.set(finding.ruleId, entry);
+        }
+        lines.push("## Findings by Rule", "", "| Rule | Findings | Severity |", "| --- | --- | --- |");
+        byRule.forEach((entry, ruleId) => {
+            lines.push(`| ${ruleId} | ${entry.count} | ${entry.severity} |`);
+        });
+        lines.push("");
+    }
+    lines.push("## Findings", "");
+    const findings = plan.pipelineFindings ?? [];
+    if (findings.length > 0) {
+        for (const finding of findings) {
+            lines.push(`- **${finding.title}** (${finding.severity}, ${finding.status})`, `  - Finding: ${finding.type}`, `  - Object: ${finding.objectType}/${finding.objectId}`, `  - Summary: ${finding.summary}`, `  - Recommendation: ${finding.recommendation}`, `  - Evidence refs: ${formatRefs(finding.evidenceIds)}`, `  - Current CRM value: ${formatValue(finding.currentCrmValue)}`, `  - Proposed value: ${formatValue(finding.proposedValue)}`, `  - Source freshness: ${formatFreshness(finding.freshness)}`, `  - Patch eligible: ${finding.patchEligibility.eligible ? "yes" : "no"} (${finding.patchEligibility.reason})`);
+        }
+        const pipelineFindingIds = new Set(findings.map((finding) => finding.id));
+        const otherFindings = plan.findings.filter((finding) => !pipelineFindingIds.has(finding.id));
+        if (otherFindings.length > 0) {
+            lines.push("", "### Other Findings", "");
+            for (const finding of otherFindings) {
+                lines.push(`- **${finding.title}** (${finding.severity})`, `  - Object: ${finding.objectType}/${finding.objectId}`, `  - Rule: ${finding.ruleId}`, `  - Summary: ${finding.summary}`, `  - Recommendation: ${finding.recommendation}`);
+            }
+        }
+    }
+    else if (plan.findings.length === 0) {
+        lines.push("No findings.");
+    }
+    else {
+        for (const finding of plan.findings) {
+            lines.push(`- **${finding.title}** (${finding.severity})`, `  - Object: ${finding.objectType}/${finding.objectId}`, `  - Rule: ${finding.ruleId}`, `  - Summary: ${finding.summary}`, `  - Recommendation: ${finding.recommendation}`);
+        }
+    }
+    if (plan.evidence && plan.evidence.length > 0) {
+        lines.push("", "## Evidence", "");
+        for (const evidence of plan.evidence) {
+            lines.push(`- **${evidence.id}** ${evidence.sourceSystem}:${evidence.sourceObjectType}/${evidence.sourceObjectId}`, `  - Object: ${evidence.objectType ?? "unknown"}/${evidence.objectId ?? "unknown"}`, `  - Text: ${evidence.text}`, `  - Freshness: ${evidence.freshness ? formatFreshness(evidence.freshness) : "unknown"}`);
+        }
+    }
+    lines.push("", "## Proposed Patch Operations", "");
+    if (plan.operations.length === 0) {
+        lines.push("No patch operations proposed.");
+    }
+    else {
+        for (const operation of plan.operations) {
+            lines.push(`- **${operation.operation}** ${operation.objectType}/${operation.objectId}`, `  - ID: ${operation.id}`, `  - Field/action: ${operation.field ?? operation.operation}`, `  - Findings: ${formatRefs(operation.findingIds)}`, `  - Evidence refs: ${formatRefs(operation.evidenceIds)}`, `  - Before: ${formatValue(operation.beforeValue)}`, `  - After: ${formatValue(operation.afterValue)}`, `  - Reason: ${operation.reason}`, `  - Source rule/policy: ${operation.sourceRuleOrPolicy ?? "unspecified"}`, `  - Risk: ${operation.riskLevel}`, `  - Approval required: ${operation.approvalRequired ? "yes" : "no"}`, `  - Rollback: ${operation.rollback ?? "restore prior value if apply is rejected or verification fails"}`, `  - Verification: ${formatVerification(operation.verification)}`);
+        }
+    }
+    lines.push("", "> This prototype is dry-run only. Real CRM writes must require explicit human approval before connector adapters apply any operation.");
+    return `${lines.join("\n")}\n`;
+}
+export function formatPatchPlanRun(run) {
+    const lines = [
+        `# Patch plan run`,
+        "",
+        `Plan: ${run.planId}`,
+        `Provider: ${run.provider}`,
+        `Status: ${run.status}`,
+        `Started: ${run.startedAt}`,
+        `Finished: ${run.finishedAt}`,
+        "",
+        "## Operation Results",
+        "",
+    ];
+    if (run.results.length === 0) {
+        lines.push("No operations were attempted.");
+    }
+    else {
+        for (const result of run.results) {
+            lines.push(`- **${result.status}** ${result.operationId}${result.detail ? ` — ${result.detail}` : ""}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function formatValue(value) {
+    if (value === undefined || value === null || value === "")
+        return "unset";
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function formatRefs(refs) {
+    return refs && refs.length > 0 ? refs.join(", ") : "none";
+}
+function formatFreshness(freshness) {
+    const age = freshness.ageDays === undefined ? "age unknown" : `${freshness.ageDays}d old`;
+    const source = freshness.sourceUpdatedAt ? `source ${freshness.sourceUpdatedAt}` : "source date unknown";
+    return `${freshness.state}, ${age}, ${source}, checked ${freshness.checkedAt}`;
+}
+function formatVerification(verification) {
+    if (!verification)
+        return "not started";
+    const observed = verification.observedValue === undefined
+        ? ""
+        : `, observed ${formatValue(verification.observedValue)}`;
+    return `${verification.status}${observed}${verification.auditText ? ` (${verification.auditText})` : ""}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { auditSnapshot, defaultPolicy } from "./audit.ts";
+export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, type FullstackgtmConfig, type LoadedConfig, } from "./config.ts";
+export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
+export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";
+export { DEFAULT_LOOPBACK_PORT, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, type HubspotTokenSet, type LoopbackLoginOptions, } from "./connectors/hubspotAuth.ts";
+export { createSalesforceConnector, type SalesforceConnection, type SalesforceConnectorOptions, } from "./connectors/salesforce.ts";
+export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, type SalesforceDeviceAuthorization, type SalesforceTokenSet, } from "./connectors/salesforceAuth.ts";
+export { createStripeConnector, type StripeConnectorOptions } from "./connectors/stripe.ts";
+export { credentialsDir, credentialsPath, deleteCredential, getCredential, resolveHubspotAccessToken, resolveHubspotConnection, storeCredential, type HubspotConnection, type StoredCredential, } from "./credentials.ts";
+export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
+export { diffFindings, diffSnapshots, diffToMarkdown, type CollectionDiff, type FieldChange, type FindingsDrift, type RecordChange, type SnapshotDiff, } from "./diff.ts";
+export { mergeSnapshots, type MergeConflict, type MergeMatch, type MergeReport, type MergeSuggestion, } from "./merge.ts";
+export { createFilePlanStore, type PlanStore, type StoredPlan } from "./planStore.ts";
+export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.ts";
+export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, type CrmObjectType, type FieldMappings, } from "./mappings.ts";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, requiresHumanInput, staleDealRule, } from "./rules.ts";
+export { sampleSnapshot } from "./sampleData.ts";
+export type { ApprovalStatus, AuditFinding, AuditFindingSeverity, CanonicalAccount, CanonicalActivity, CanonicalContact, CanonicalDeal, CanonicalGtmSnapshot, CanonicalUser, CrmProvider, GtmAuditRule, GtmConnector, GtmEvidence, GtmEvidenceSourceSystem, GtmObjectType, GtmPolicy, GtmRuleContext, GtmRuleResult, GtmSnapshotIndex, PatchOperation, PatchOperationResult, PatchOperationType, PatchPlan, PatchPlanRun, PatchPlanRunStatus, PatchVerification, PipelineFinding, PipelineFindingStatus, PipelineFindingType, ProviderIdentity, RiskLevel, SourceFreshness, } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,17 @@
+export { auditSnapshot, defaultPolicy } from "./audit.js";
+export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, } from "./config.js";
+export { applyPatchPlan } from "./connector.js";
+export { createHubspotConnector } from "./connectors/hubspot.js";
+export { DEFAULT_LOOPBACK_PORT, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, } from "./connectors/hubspotAuth.js";
+export { createSalesforceConnector, } from "./connectors/salesforce.js";
+export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, } from "./connectors/salesforceAuth.js";
+export { createStripeConnector } from "./connectors/stripe.js";
+export { credentialsDir, credentialsPath, deleteCredential, getCredential, resolveHubspotAccessToken, resolveHubspotConnection, storeCredential, } from "./credentials.js";
+export { generateDemoSnapshot } from "./demo.js";
+export { diffFindings, diffSnapshots, diffToMarkdown, } from "./diff.js";
+export { mergeSnapshots, } from "./merge.js";
+export { createFilePlanStore } from "./planStore.js";
+export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.js";
+export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, } from "./mappings.js";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, requiresHumanInput, staleDealRule, } from "./rules.js";
+export { sampleSnapshot } from "./sampleData.js";

package/dist/mappings.d.ts

@@ -0,0 +1,8 @@
+export type CrmObjectType = "owners" | "accounts" | "contacts" | "deals";
+export type FieldMappings = Partial<Record<CrmObjectType | string, Record<string, string>>>;
+export declare const HUBSPOT_DEFAULT_FIELD_MAPPINGS: Record<Exclude<CrmObjectType, "owners">, Record<string, string>>;
+export declare const SALESFORCE_DEFAULT_FIELD_MAPPINGS: Record<CrmObjectType, Record<string, string>>;
+export declare function normalizeFieldMappings(value: unknown): FieldMappings;
+export declare function mappedField(mappings: FieldMappings | undefined, objectType: CrmObjectType, targetField: string, fallbackField: string): string;
+export declare function mappedFields(mappings: FieldMappings | undefined, objectType: CrmObjectType, defaults: Record<string, string>): string[];
+export declare function readMappedValue(source: Record<string, unknown>, mappings: FieldMappings | undefined, objectType: CrmObjectType, targetField: string, fallbackField: string): unknown;

package/dist/mappings.js

@@ -0,0 +1,123 @@
+export const HUBSPOT_DEFAULT_FIELD_MAPPINGS = {
+    accounts: {
+        name: "name",
+        domain: "domain",
+        industry: "industry",
+        employeeCount: "numberofemployees",
+        annualRevenue: "annualrevenue",
+        ownerId: "hubspot_owner_id",
+    },
+    contacts: {
+        firstName: "firstname",
+        lastName: "lastname",
+        email: "email",
+        phone: "phone",
+        title: "jobtitle",
+        ownerId: "hubspot_owner_id",
+    },
+    deals: {
+        name: "dealname",
+        amount: "amount",
+        closeDate: "closedate",
+        stage: "dealstage",
+        dealType: "dealtype",
+        ownerId: "hubspot_owner_id",
+        probability: "hs_deal_stage_probability",
+        lastActivityAt: "hs_last_sales_activity_timestamp",
+        nextStep: "hs_next_step",
+    },
+};
+export const SALESFORCE_DEFAULT_FIELD_MAPPINGS = {
+    owners: {
+        id: "Id",
+        name: "Name",
+        email: "Email",
+        title: "Title",
+        isActive: "IsActive",
+    },
+    accounts: {
+        id: "Id",
+        name: "Name",
+        domain: "Website",
+        industry: "Industry",
+        employeeCount: "NumberOfEmployees",
+        annualRevenue: "AnnualRevenue",
+        ownerId: "OwnerId",
+    },
+    contacts: {
+        id: "Id",
+        firstName: "FirstName",
+        lastName: "LastName",
+        email: "Email",
+        phone: "Phone",
+        title: "Title",
+        accountId: "AccountId",
+        ownerId: "OwnerId",
+    },
+    deals: {
+        id: "Id",
+        name: "Name",
+        amount: "Amount",
+        closeDate: "CloseDate",
+        stage: "StageName",
+        dealType: "Type",
+        probability: "Probability",
+        isClosed: "IsClosed",
+        isWon: "IsWon",
+        ownerId: "OwnerId",
+        accountId: "AccountId",
+        lastActivityAt: "LastActivityDate",
+        forecastCategoryName: "ForecastCategory",
+        nextStep: "NextStep",
+    },
+};
+const OBJECT_ALIASES = {
+    owners: ["owners", "users"],
+    accounts: ["accounts", "companies"],
+    contacts: ["contacts"],
+    deals: ["deals", "opportunities"],
+};
+export function normalizeFieldMappings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const normalized = {};
+    for (const [objectName, mapping] of Object.entries(value)) {
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping)) {
+            continue;
+        }
+        const clean = {};
+        for (const [targetField, providerField] of Object.entries(mapping)) {
+            if (typeof providerField === "string" && providerField.trim()) {
+                clean[targetField] = providerField.trim();
+            }
+        }
+        if (Object.keys(clean).length > 0)
+            normalized[objectName] = clean;
+    }
+    return normalized;
+}
+export function mappedField(mappings, objectType, targetField, fallbackField) {
+    const normalized = normalizeFieldMappings(mappings);
+    for (const alias of OBJECT_ALIASES[objectType]) {
+        const mapped = normalized[alias]?.[targetField];
+        if (mapped)
+            return mapped;
+    }
+    return fallbackField;
+}
+export function mappedFields(mappings, objectType, defaults) {
+    const fields = Object.entries(defaults).map(([targetField, fallbackField]) => mappedField(mappings, objectType, targetField, fallbackField));
+    return Array.from(new Set(fields)).filter(Boolean);
+}
+export function readMappedValue(source, mappings, objectType, targetField, fallbackField) {
+    return readPath(source, mappedField(mappings, objectType, targetField, fallbackField));
+}
+function readPath(source, path) {
+    if (Object.prototype.hasOwnProperty.call(source, path))
+        return source[path];
+    return path.split(".").reduce((value, segment) => {
+        if (!value || typeof value !== "object")
+            return undefined;
+        return value[segment];
+    }, source);
+}

package/dist/mcp-bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-bin.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// The MCP server needs the optional peer dependencies. Import dynamically so
+// a missing peer produces install guidance instead of a module-load stack
+// trace — `npx fullstackgtm-mcp` alone never installs optional peers.
+const MISSING_PEER_HELP = `The MCP server needs the optional peer dependencies @modelcontextprotocol/sdk and zod.
+
+In a project:
+  npm install fullstackgtm @modelcontextprotocol/sdk zod
+
+Zero-install:
+  npx -p fullstackgtm -p @modelcontextprotocol/sdk -p zod fullstackgtm-mcp`;
+function isMissingPeerError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    if (code !== "ERR_MODULE_NOT_FOUND" && code !== "MODULE_NOT_FOUND")
+        return false;
+    return error.message.includes("@modelcontextprotocol/sdk") || error.message.includes("zod");
+}
+try {
+    const { startMcpServer } = await import("./mcp.js");
+    await startMcpServer();
+}
+catch (error) {
+    if (isMissingPeerError(error)) {
+        console.error(MISSING_PEER_HELP);
+    }
+    else {
+        console.error(error instanceof Error ? error.message : String(error));
+    }
+    process.exitCode = 1;
+}
+export {};

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;