@contentful/experience-design-system-cli 2.35.1-dev-build-fa950e44.0 → 2.35.1-dev-build-b8da2525.0

package/bin/cli.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-await import("../dist/index.js");
+await import('../dist/index.js');

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.35.1-dev-build-fa950e44.0",
+  "version": "2.35.1-dev-build-b8da2525.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/legacy/bin/cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 // Suppress the SQLite ExperimentalWarning before any modules load.
 // Must use dynamic import so this handler registers before sqlite is imported.
-process.removeAllListeners("warning");
-process.on("warning", (w) => {
-  if (w.name === "ExperimentalWarning" && w.message.includes("SQLite")) return;
+process.removeAllListeners('warning');
+process.on('warning', (w) => {
+  if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite')) return;
   process.stderr.write(`${w.name}: ${w.message}\n`);
 });
 
 // Auto-rebuild when running from source (dev mode only).
 // Skipped when src/ doesn't exist (e.g. npm-installed users).
-import { existsSync, statSync, readdirSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { dirname, resolve, join } from "node:path";
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve, join } from 'node:path';
 
 function newestMtime(dir, depth = 0) {
   if (depth > 10) return 0;
@@ -22,7 +22,7 @@ function newestMtime(dir, depth = 0) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       max = Math.max(max, newestMtime(full, depth + 1));
-    } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+    } else if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
       max = Math.max(max, statSync(full).mtimeMs);
     }
   }
@@ -30,29 +30,25 @@ function newestMtime(dir, depth = 0) {
 }
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = resolve(__dirname, "..");
-const srcDir = join(pkgRoot, "src");
-const distEntry = join(pkgRoot, "dist", "src", "index.js");
+const pkgRoot = resolve(__dirname, '..');
+const srcDir = join(pkgRoot, 'src');
+const distEntry = join(pkgRoot, 'dist', 'src', 'index.js');
 
-if (
-  existsSync(srcDir) &&
-  existsSync(distEntry) &&
-  process.env.NODE_ENV !== "test"
-) {
+if (existsSync(srcDir) && existsSync(distEntry) && process.env.NODE_ENV !== 'test') {
   const distMtime = statSync(distEntry).mtimeMs;
   if (newestMtime(srcDir) > distMtime) {
-    process.stderr.write("⚙ Source changed — rebuilding...\n");
-    const tsc = join(pkgRoot, "node_modules", ".bin", "tsc");
+    process.stderr.write('⚙ Source changed — rebuilding...\n');
+    const tsc = join(pkgRoot, 'node_modules', '.bin', 'tsc');
     try {
-      execFileSync(tsc, ["-p", join(pkgRoot, "tsconfig.build.json")], {
-        stdio: ["ignore", "ignore", "inherit"],
+      execFileSync(tsc, ['-p', join(pkgRoot, 'tsconfig.build.json')], {
+        stdio: ['ignore', 'ignore', 'inherit'],
         cwd: pkgRoot,
       });
-      process.stderr.write("✓ Build complete\n");
+      process.stderr.write('✓ Build complete\n');
     } catch {
-      process.stderr.write("✗ Build failed — running with existing dist\n");
+      process.stderr.write('✗ Build failed — running with existing dist\n');
     }
   }
 }
 
-await import("../dist/src/index.js");
+await import('../dist/src/index.js');

package/legacy/dist/src/analyze/composition/interchange-schema.d.ts

@@ -5,7 +5,7 @@
  * parent→child relationship, carrying optional `slot` (T7), `confidence`,
  * and `provenance`. It is easier to merge and dedupe across sources (T2).
  */
-export type EdgeProvenance = 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
+export type EdgeProvenance = 'typed-slot' | 'structural' | 'call-site' | 'manifest' | 'doc' | `adapter:${string}`;
 export type CompositionEdge = {
     parent: string;
     child: string;
@@ -13,5 +13,11 @@ export type CompositionEdge = {
     slot?: string;
     /** 1–5 scale, same as select/reject agent tools. */
     confidence?: number;
+    citation?: CompositionCitation;
     provenance: EdgeProvenance;
 };
+export type CompositionCitation = {
+    sourcePath: string;
+    startLine: number;
+    endLine: number;
+};

package/legacy/dist/src/analyze/composition/resolve-mapping.d.ts

@@ -1,59 +1,36 @@
 import type { RawComponentDefinition } from '../../types.js';
 import type { CompositionEdge } from './interchange-schema.js';
 import { type EdgeConflict } from './merge-edges.js';
+import type { SourceCallSiteEvidence, SourceCallSiteRejection } from './source-call-site-evidence.js';
 export type ResolveMappingResult = {
     components: RawComponentDefinition[];
     edges: CompositionEdge[];
     conflicts: EdgeConflict[];
     warnings: string[];
+    sourceCallSiteEvidence: SourceCallSiteEvidence[];
+    sourceCallSiteRejections: SourceCallSiteRejection[];
 };
 /**
  * Orchestrate composition-edge acquisition and enrichment.
  *
- * Sources by rank: typed-slot / "code slots" (2) > structural usage evidence
- * (3) > manifest (4) > doc (5) > adapter-resolved / extraEdges (6) >
- * edge-emitting agent (7). Manifest/doc edges are computed deterministically outside
+ * Sources by rank: typed-slot / "code slots" (1) > structural usage evidence
+ * (2) > cited source call sites (3) > manifest (4) > doc (5) > adapter-resolved
+ * / extraEdges (6). Manifest/doc edges are computed deterministically outside
  * this function (see manifest-doc-evidence.ts) and joined via `extraEdges`.
  * ALL sources — including the code slots already on the incoming components —
  * are fed into one ranked merge and unioned; non-conflicting edges from every
  * source survive, and on a conflict (same parent+child, different slot) the
- * higher-rank source wins and the loser is recorded. The edge-emitting agent runs only when
- * `forceAgent` is set OR there is residue a higher-rank source
- * didn't cover (routing/cost optimization) — `forceAgent` bypasses that
- * suppression but never changes rank.
- *
- * `runAgentFn` is injected (returns the agent's raw stdout) so this is
- * testable without spawning a subprocess.
+ * higher-rank source wins and the loser is recorded. No agent contributes
+ * edges: every edge is backed by code, a manifest or documentation.
  */
 export declare function resolveMapping(input: {
     components: RawComponentDefinition[];
-    forceAgent?: boolean;
-    files: Array<{
-        path: string;
-        content: string;
-    }>;
-    runAgentFn: (opts: {
-        prompt: string;
-        files: Array<{
-            path: string;
-            content: string;
-        }>;
-    }) => Promise<string>;
-    buildPrompt?: (files: Array<{
-        path: string;
-        content: string;
-    }>, componentNames: string[]) => string;
-    /**
-     * Custom instruction preamble (from `--prompt composition=...`). Replaces the
-     * default guidance line ONLY; the machine-readable output contract + the
-     * component-name allowlist + candidate files are always appended so the
-     * JSONL parser keeps working regardless of the override.
-     */
-    promptOverride?: string;
     /**
      * Pre-resolved edges from an external source (e.g. manifest or documentation)
      * path). They join the ranked merge at their own provenance rank alongside
      * code slots and other automatic mapping sources.
      */
     extraEdges?: CompositionEdge[];
-}): Promise<ResolveMappingResult>;
+    sourceCallSiteEvidence?: SourceCallSiteEvidence[];
+    sourceCallSiteRejections?: SourceCallSiteRejection[];
+}): ResolveMappingResult;

package/legacy/dist/src/analyze/composition/source-call-site-evidence.d.ts

@@ -0,0 +1,30 @@
+import type { RawComponentDefinition } from '../../types.js';
+export type SourceCallSiteEvidence = {
+    parent: string;
+    child: string;
+    slot?: string;
+    sourcePath: string;
+    startLine: number;
+    endLine: number;
+    excerpt: string;
+    kind: 'jsx-render';
+};
+export type SourceCallSiteRejection = {
+    parent: string;
+    candidate: string;
+    sourcePath: string;
+    startLine?: number;
+    endLine?: number;
+    excerpt?: string;
+    reason: 'unknown-component' | 'unbound-component' | 'text-only-child' | 'no-call-site';
+};
+export type SourceCallSiteEvidenceResult = {
+    accepted: SourceCallSiteEvidence[];
+    rejected: SourceCallSiteRejection[];
+};
+type SourceFileInput = {
+    path: string;
+    content: string;
+};
+export declare function collectSourceCallSiteEvidence(files: readonly SourceFileInput[], components: readonly RawComponentDefinition[]): SourceCallSiteEvidenceResult;
+export {};

package/legacy/dist/src/import/tui/ai-flag.d.ts

@@ -1,6 +1,5 @@
 export type AiFlaggable = {
     aiDecision?: 'accepted' | 'rejected' | 'failed' | null;
-    needsReview?: boolean;
 };
 export declare function isAiFlagged(row: AiFlaggable): boolean;
 export declare function isDefaultIncluded(row: AiFlaggable): boolean;

package/legacy/dist/src/import/tui/steps/ScopeGateStep.d.ts

@@ -4,7 +4,6 @@ export type ScopeComponent = {
     componentId: string;
     aiDecision?: 'accepted' | 'rejected' | 'failed' | null;
     aiReason?: string | null;
-    needsReview?: boolean;
     slots?: Array<{
         name: string;
         allowedComponents: string[];