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

package/dist/package.json

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

package/dist/src/tui/import/spawn-v1-import.d.ts

@@ -16,6 +16,7 @@ interface PipelineResult {
 }
 export interface SpawnV1ImportOptions {
     project?: string;
+    tokens?: string;
     onProgress?: (line: string) => void;
 }
 export interface SpawnV1ImportResult {

package/dist/src/tui/import/steps/02-token-input/controls.d.ts

@@ -0,0 +1,11 @@
+export declare const TOKEN_INPUT_CONTROLS: readonly [{
+    readonly keys: "Enter";
+    readonly label: "Continue (skips if empty)";
+}, {
+    readonly keys: "s";
+    readonly label: "Skip";
+}, {
+    readonly keys: "Esc/q";
+    readonly label: "Back";
+}];
+export declare function useTokenInputControls(tokenPath: string, onSkip: () => void, onBack: () => void): void;

package/dist/src/tui/import/steps/02-token-input/logic.d.ts

@@ -0,0 +1,9 @@
+interface Key {
+    escape: boolean;
+    ctrl: boolean;
+    meta: boolean;
+}
+export declare function shouldGoBack(value: string, input: string, key: Key): boolean;
+export declare function shouldSkip(value: string, input: string, key: Key): boolean;
+export declare function toTokenPath(value: string): string | null;
+export {};

package/dist/src/tui/import/steps/02-token-input/screen.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface TokenInputScreenProps {
+    onConfirm: (tokensPath: string) => void;
+    onSkip: () => void;
+    onBack: () => void;
+}
+export declare function TokenInputScreen({ onConfirm, onSkip, onBack }: TokenInputScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/02-token-input/validate-path.d.ts

@@ -0,0 +1,12 @@
+export interface TokenPathFailure {
+    error: string;
+    resolvedPath: string;
+}
+type TokenPathCheck = {
+    ok: true;
+    path: string;
+} | ({
+    ok: false;
+} & TokenPathFailure);
+export declare function validateTokenPath(rawPath: string): TokenPathCheck;
+export {};

package/dist/src/tui/import/steps/index.d.ts

@@ -1 +1,2 @@
 export { WelcomeScreen } from './01-welcome/screen.js';
+export { TokenInputScreen } from './02-token-input/screen.js';

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/analyze/extract-command.d.ts

@@ -1,4 +1,7 @@
 import type { Command } from 'commander';
-export { resolveExtractNoCache } from './helpers/resolve-no-cache.js';
-export { collectSourceFiles } from './services/collect-source-files.js';
+export declare function resolveExtractNoCache(opts: {
+    cache?: boolean;
+    noCache?: boolean;
+}): boolean;
+export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;
 export declare function registerInternalExtractCommand(program: Command): void;

package/legacy/dist/src/apply/command.d.ts

@@ -1,5 +1,43 @@
 import type { Command } from 'commander';
-export { readTokensFromPath, toCDFTokens } from './helpers/read-token-files.js';
-export { detectSlotCycles, formatSlotCycleReport, assertNoSlotCycles, formatUnresolvedSlotReferences, assertNoUnresolvedSlotReferences, extractComponents, } from './helpers/slot-validation.js';
-export { hasBreakingChangesWithImpact } from './helpers/has-breaking-changes.js';
+import type { CDFComponentEntry, CDFTokenEntry, CDFValidationError, DTCGTokenEntry } from '@contentful/experience-design-system-types';
+import { findSlotCycles } from '../analyze/cycle-detection.js';
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
+/** Adapts flat DTCGTokenEntry[] (path alongside the leaf) into the
+ * {path, entry} pairs buildCDF/buildFilteredCDF expect. */
+export declare function toCDFTokens(tokens: DTCGTokenEntry[]): Array<{
+    path: string;
+    entry: CDFTokenEntry;
+}>;
+export declare function detectSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): ReturnType<typeof findSlotCycles>;
+export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
+export declare function assertNoSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+/**
+ * Client-side pre-flight for `$allowedComponents` references that are absent
+ * from this document, so a typo'd or renamed reference fails fast instead of
+ * waiting on the `previewImport`/`applyImport` round-trip. Only catches
+ * document-internal misses — a name that resolves against an *existing*
+ * target-environment Component still needs the network round-trip to
+ * confirm, so this cannot replace the server-side check.
+ *
+ * `validateSlotReferences` is the detection step (shared with
+ * `WizardApp.tsx` via `formatUnresolvedSlotReferences` below, mirroring how
+ * `detectSlotCycles`/`formatSlotCycleReport` split for the cycle check).
+ */
+export declare function formatUnresolvedSlotReferences(errors: CDFValidationError[]): string[];
+export declare function assertNoUnresolvedSlotReferences(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+export declare function extractComponents(cdf: Record<string, unknown> | null | undefined): Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>;
+export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;
 export declare function registerApplyCommand(program: Command): void;

package/legacy/dist/src/generate/command.d.ts

@@ -1,20 +1,2 @@
 import type { Command } from 'commander';
-export interface GenerateSubcommandOptions {
-    agent?: string;
-    model?: string;
-    bedrock?: boolean;
-    session?: string;
-    rawTokens?: string;
-    tokens?: string;
-    tokenMap?: string;
-    dryRun?: boolean;
-    verbose?: boolean;
-    cache?: boolean;
-    generatePromptPath?: string;
-    prompt?: string[];
-    existingEntitiesPath?: string;
-    cacheStatus?: boolean;
-    restoreCache?: boolean;
-    cachedComponents?: string;
-}
 export declare function registerInternalGenerateCommand(program: Command): void;

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[];