@contentful/experience-design-system-cli 2.12.4-dev-build-ff57340.0 → 2.13.1-dev-build-847dead.0

package/dist/src/session/db.js

@@ -138,15 +138,6 @@ CREATE TABLE IF NOT EXISTS scanned_files (
   PRIMARY KEY (session_id, path)
 );
 
-CREATE TABLE IF NOT EXISTS slot_cycles (
-  session_id             TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  cycle_index            INTEGER NOT NULL,
-  path_json              TEXT NOT NULL,
-  edges_json             TEXT NOT NULL,
-  suggested_break_json   TEXT,
-  PRIMARY KEY (session_id, cycle_index)
-);
-
 CREATE INDEX IF NOT EXISTS idx_steps_session            ON steps(session_id);
 CREATE INDEX IF NOT EXISTS idx_steps_command            ON steps(session_id, command);
 CREATE INDEX IF NOT EXISTS idx_raw_components_session   ON raw_components(session_id);
@@ -1397,43 +1388,6 @@ export function loadScannedFiles(db, sessionId) {
     const rows = db.prepare('SELECT path FROM scanned_files WHERE session_id = ? ORDER BY path').all(sessionId);
     return rows.map((r) => r.path);
 }
-// --- Slot-dependency cycle persistence (INTEG-4401) ---
-//
-// The `slot_cycles` table caches the result of running the cycle detector
-// over the extractor's slot output so the TUI can render sidebar badges,
-// a banner, and an expandable detail panel without re-running the analysis
-// on every render. Rows are session-scoped and rewritten wholesale on each
-// re-extract via `storeSlotCycles`.
-export function storeSlotCycles(db, sessionId, cycles) {
-    db.exec('BEGIN');
-    try {
-        db.prepare('DELETE FROM slot_cycles WHERE session_id = ?').run(sessionId);
-        const insert = db.prepare(`INSERT INTO slot_cycles (session_id, cycle_index, path_json, edges_json, suggested_break_json)
-       VALUES (?, ?, ?, ?, ?)`);
-        for (let i = 0; i < cycles.length; i += 1) {
-            const cycle = cycles[i];
-            insert.run(sessionId, i, JSON.stringify(cycle.path), JSON.stringify(cycle.edges), cycle.suggestedBreak ? JSON.stringify(cycle.suggestedBreak) : null);
-        }
-        db.exec('COMMIT');
-    }
-    catch (e) {
-        db.exec('ROLLBACK');
-        throw e;
-    }
-}
-export function loadSlotCycles(db, sessionId) {
-    const rows = db
-        .prepare('SELECT cycle_index, path_json, edges_json, suggested_break_json FROM slot_cycles WHERE session_id = ? ORDER BY cycle_index')
-        .all(sessionId);
-    return rows.map((r) => ({
-        path: JSON.parse(r.path_json),
-        edges: JSON.parse(r.edges_json),
-        suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null,
-    }));
-}
-export function clearSlotCycles(db, sessionId) {
-    db.prepare('DELETE FROM slot_cycles WHERE session_id = ?').run(sessionId);
-}
 export function markCacheHumanEdited(db, entityType, entityId) {
     const now = new Date().toISOString();
     db.prepare(`UPDATE generation_cache SET human_edited = 1, updated_at = ? WHERE entity_type = ? AND entity_id = ?`).run(now, entityType, entityId);

package/dist/src/types.d.ts

@@ -1,11 +1,6 @@
 import type { DesignTokenType } from '@contentful/experience-design-system-types';
-export type ExtractionValidationIssueCode = 'EMPTY_COMPONENT_NAME' | 'EMPTY_PROP_NAME' | 'EMPTY_SLOT_NAME' | 'PROP_SLOT_NAME_COLLISION' | 'DUPLICATE_COMPONENT_NAME' | 'EMPTY_COMPONENT' | 'SERVER_VALIDATION_FAILED';
-export type ExtractionValidationIssue = {
-    severity: 'error' | 'warning';
-    code: ExtractionValidationIssueCode;
-    message: string;
-    field?: string;
-};
+export type { ExtractionValidationIssueCode, ExtractionValidationIssue, RawPropDefinition, RawSlotDefinition, RawComponentDefinition, ComponentExtractionResult, ExtractorProgress, ExtractorOptions, ComponentExtractor, } from '@contentful/experience-design-system-extraction';
+export { stripScoringFields } from '@contentful/experience-design-system-extraction';
 export interface RawTokenDefinition {
     name: string;
     value: string;
@@ -13,76 +8,7 @@ export interface RawTokenDefinition {
     inferredKind: DesignTokenType | string;
     ambiguous: boolean;
 }
-export interface RawPropDefinition {
-    name: string;
-    type: string;
-    required: boolean;
-    category?: 'content' | 'design' | 'state';
-    defaultValue?: string;
-    allowedValues?: string[];
-    description?: string;
-    tokenReference?: string;
-    /** 1-indexed source line where this prop's declaration begins; relative to RawComponentDefinition.source. */
-    sourceStartLine?: number;
-    /** 1-indexed inclusive source line where this prop's declaration ends; relative to RawComponentDefinition.source. */
-    sourceEndLine?: number;
-}
-export interface RawSlotDefinition {
-    name: string;
-    isDefault: boolean;
-    description?: string;
-    allowedComponents?: string[];
-}
-export interface RawComponentDefinition {
-    name: string;
-    source: string;
-    framework: 'react' | 'next' | 'vue' | 'astro' | 'web-component' | 'stencil' | 'svelte';
-    props: RawPropDefinition[];
-    slots: RawSlotDefinition[];
-    /**
-     * True when the source file declaring this component calls
-     * React.createContext / createContext. Used downstream to filter
-     * non-authorable context-provider components.
-     */
-    usesCreateContext?: boolean;
-    extractionConfidence?: number | null;
-    reviewReasons?: string[];
-    needsReview?: boolean;
-    validationIssues?: ExtractionValidationIssue[];
-    /** Absolute path to the source file this component was extracted from. Null for synthesized / multi-file. */
-    sourcePath?: string;
-}
-export interface ComponentExtractionResult {
-    components: RawComponentDefinition[];
-    warnings: string[];
-}
-export type ExtractorProgress = {
-    filesProcessed: number;
-    componentsFound: number;
-};
-/**
- * Optional extraction-time settings forwarded from the CLI through the
- * pipeline to each extractor. Only the Svelte extractor currently consumes
- * any of these; other extractors ignore the value.
- */
-export interface ExtractorOptions {
-    /**
-     * Whether the Svelte extractor should run a retry pass for components whose
-     * declared Props type couldn't be resolved on the first pass (cross-package
-     * extends, path-alias-only types, etc.). See svelte.ts for the policy.
-     */
-    resolveUnreachable?: 'auto' | 'always' | 'never';
-    /** Absolute project root — used by the retry pass to locate tsconfig.json and node_modules. */
-    projectRoot?: string;
-}
-export interface ComponentExtractor {
-    name: string;
-    fileFilter: (filePath: string) => boolean;
-    extract(filePaths: string[], onProgress?: (p: ExtractorProgress) => void, opts?: ExtractorOptions): Promise<ComponentExtractionResult>;
-}
 export interface TokenExtractor {
     name: string;
     extract(projectRoot: string): Promise<RawTokenDefinition[]>;
 }
-/** Strip internal scoring fields before serialising a RawComponentDefinition for display or editing. */
-export declare function stripScoringFields({ extractionConfidence: _c, reviewReasons: _r, needsReview: _n, ...rest }: RawComponentDefinition): Omit<RawComponentDefinition, 'extractionConfidence' | 'reviewReasons' | 'needsReview'>;

package/dist/src/types.js

@@ -1,4 +1 @@
-/** Strip internal scoring fields before serialising a RawComponentDefinition for display or editing. */
-export function stripScoringFields({ extractionConfidence: _c, reviewReasons: _r, needsReview: _n, ...rest }) {
-    return rest;
-}
+export { stripScoringFields } from '@contentful/experience-design-system-extraction';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.12.4-dev-build-ff57340.0",
+  "version": "2.13.1-dev-build-847dead.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -28,16 +28,13 @@
     "skills/"
   ],
   "dependencies": {
-    "@vue/compiler-sfc": "^3.5.31",
     "commander": "^13.1.0",
     "ink": "^4.4.1",
     "react": "^18.3.1",
     "react-devtools-core": "^4.19.1",
     "react-dom": "^18.3.1",
-    "svelte": "^5.56.4",
-    "ts-morph": "^27.0.2",
-    "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.12.4-dev-build-ff57340.0"
+    "@contentful/experience-design-system-extraction": "2.13.1-dev-build-847dead.0",
+    "@contentful/experience-design-system-types": "2.13.1-dev-build-847dead.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",

package/dist/src/analyze/cycle-detection.d.ts

@@ -1,93 +0,0 @@
-/**
- * Slot-dependency cycle detection.
- *
- * The Contentful Experience Design System backend rejects component manifests
- * that contain slot-dependency cycles at apply time — a topo-sort in the
- * apply worker refuses to create component types whose slot's
- * `$allowedComponents` transitively point back at themselves. Reference:
- * `experience-design-system-integrations` / services/design-system-sources-apply-worker/src/topo-sort.ts.
- *
- * We surface the same check locally so the wizard can:
- *   1. warn the operator at extract time (soft) with sidebar badges + banner,
- *   2. hard-block the push at manifest-finalization time before any API call.
- *
- * The algorithm is Johnson's — an O((V + E)(C + 1)) enumeration of all
- * elementary (simple) cycles in a directed graph. We need *elementary*
- * cycles rather than just cycle-existence because an operator can have
- * multiple independent cycles they need to address separately, and each
- * gets its own suggested fix.
- *
- * Johnson's algorithm reference: Donald B. Johnson, "Finding all the
- * elementary circuits of a directed graph." SIAM J. Comput., 4(1):77-84, 1975.
- */
-/** A directed edge in the slot-dependency graph. */
-export interface SlotEdge {
-    fromComponent: string;
-    slotName: string;
-    toComponent: string;
-}
-/** A single elementary cycle, with `path[0] === path[path.length - 1]`. */
-export interface SlotCycle {
-    /** Component names visited, with the first repeated at the end. */
-    path: string[];
-    /** Ordered edges forming the cycle. `edges.length === path.length - 1`. */
-    edges: SlotEdge[];
-}
-/** Input shape mirroring the slot definition on CDFComponentEntry. */
-export interface ComponentSlotInfo {
-    name: string;
-    slots: Array<{
-        name: string;
-        allowedComponents?: string[];
-    }>;
-}
-/**
- * Johnson's algorithm — enumerates all elementary (simple) cycles in the
- * slot-dependency graph. Self-loops are handled as a degenerate first pass
- * because Tarjan's SCC decomposition assigns a self-looping node to its own
- * single-node SCC, which Johnson's inner loop otherwise skips.
- */
-export declare function findSlotCycles(components: ComponentSlotInfo[]): SlotCycle[];
-/**
- * Pick which edge is the best candidate to remove to break a cycle.
- * Heuristic: prefer removing the edge whose `toComponent` appears most often
- * as a destination across all cycles — that "hub" node is the biggest
- * contributor and removing an inbound edge to it likely breaks multiple
- * cycles at once. Falls back to the first edge in the cycle for
- * deterministic output when all candidates are tied.
- */
-export declare function suggestCycleBreakEdge(cycle: SlotCycle, allCycles: SlotCycle[]): SlotEdge;
-/**
- * Format a cycle for the compact banner:
- *   `CardA → header → CardB → footer → CardA`
- *
- * Truncates at `maxHops` edges (default 8), inserting `…` mid-path so the
- * beginning and end remain visible. A hop is one edge; the returned string
- * for an n-edge cycle contains n+1 component names.
- *
- * Kept for backend/log/error use where a single string is required (see
- * `assertNoSlotCycles` in `apply/command.ts`). The TUI banner + detail panel
- * use `formatCyclePathSegments` instead so slot names can be visually
- * distinguished from component names.
- */
-export declare function formatCyclePath(cycle: SlotCycle, maxHops?: number): string;
-/**
- * A single token in the rendered cycle path — either a component name, a
- * slot name (wrapped in brackets for monochrome legibility), or the arrow
- * separator between them. The TUI colorizes each kind independently.
- *
- * Slots are rendered as `[slotName]` so the visual distinction survives when
- * ANSI colors are stripped (log files, redirection, dumb terminals).
- */
-export interface CyclePathSegment {
-    kind: 'component' | 'slot' | 'arrow';
-    text: string;
-}
-/**
- * Segment-oriented counterpart to `formatCyclePath`. Preserves the same
- * 8-hop truncation semantics but returns each token classified so the
- * renderer can color slots (cyan) and components (default) independently.
- * The truncation marker `…` is emitted as a bare component segment because
- * it stands in for one or more component nodes.
- */
-export declare function formatCyclePathSegments(cycle: SlotCycle, maxHops?: number): CyclePathSegment[];

package/dist/src/analyze/cycle-detection.js

@@ -1,326 +0,0 @@
-/**
- * Slot-dependency cycle detection.
- *
- * The Contentful Experience Design System backend rejects component manifests
- * that contain slot-dependency cycles at apply time — a topo-sort in the
- * apply worker refuses to create component types whose slot's
- * `$allowedComponents` transitively point back at themselves. Reference:
- * `experience-design-system-integrations` / services/design-system-sources-apply-worker/src/topo-sort.ts.
- *
- * We surface the same check locally so the wizard can:
- *   1. warn the operator at extract time (soft) with sidebar badges + banner,
- *   2. hard-block the push at manifest-finalization time before any API call.
- *
- * The algorithm is Johnson's — an O((V + E)(C + 1)) enumeration of all
- * elementary (simple) cycles in a directed graph. We need *elementary*
- * cycles rather than just cycle-existence because an operator can have
- * multiple independent cycles they need to address separately, and each
- * gets its own suggested fix.
- *
- * Johnson's algorithm reference: Donald B. Johnson, "Finding all the
- * elementary circuits of a directed graph." SIAM J. Comput., 4(1):77-84, 1975.
- */
-function buildGraph(components) {
-    const nodes = [];
-    const seen = new Set();
-    for (const c of components) {
-        if (seen.has(c.name))
-            continue;
-        seen.add(c.name);
-        nodes.push(c.name);
-    }
-    const adjacency = new Map();
-    for (const node of nodes)
-        adjacency.set(node, []);
-    for (const comp of components) {
-        const outgoing = adjacency.get(comp.name);
-        if (!outgoing)
-            continue;
-        for (const slot of comp.slots) {
-            const allowed = slot.allowedComponents ?? [];
-            for (const target of allowed) {
-                if (!seen.has(target))
-                    continue; // unknown / external — ignore
-                outgoing.push({ target, slotName: slot.name });
-            }
-        }
-    }
-    return { nodes, adjacency };
-}
-/**
- * Tarjan's strongly-connected-components algorithm — used by Johnson's
- * algorithm to constrain cycle search to one SCC at a time. Returns SCCs in
- * reverse-topological order.
- */
-function stronglyConnectedComponents(nodes, adjacency) {
-    const index = new Map();
-    const lowlink = new Map();
-    const onStack = new Set();
-    const stack = [];
-    const sccs = [];
-    let counter = 0;
-    const nodeSet = new Set(nodes);
-    function strongconnect(v) {
-        index.set(v, counter);
-        lowlink.set(v, counter);
-        counter += 1;
-        stack.push(v);
-        onStack.add(v);
-        const neighbours = adjacency.get(v) ?? [];
-        for (const { target } of neighbours) {
-            if (!nodeSet.has(target))
-                continue;
-            if (!index.has(target)) {
-                strongconnect(target);
-                lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(target)));
-            }
-            else if (onStack.has(target)) {
-                lowlink.set(v, Math.min(lowlink.get(v), index.get(target)));
-            }
-        }
-        if (lowlink.get(v) === index.get(v)) {
-            const scc = [];
-            let w;
-            do {
-                w = stack.pop();
-                onStack.delete(w);
-                scc.push(w);
-            } while (w !== v);
-            sccs.push(scc);
-        }
-    }
-    for (const node of nodes) {
-        if (!index.has(node))
-            strongconnect(node);
-    }
-    return sccs;
-}
-/**
- * Given a specific traversal `path` (component names) and the edge multiset
- * we walked to build it, materialize a `SlotCycle`. Because multiple parallel
- * edges may exist between the same two components (different slot names), we
- * carry the exact edges along the search rather than reconstructing them from
- * the node path.
- */
-function makeCycle(path, edges) {
-    return { path: [...path, path[0]], edges: [...edges] };
-}
-/**
- * Johnson's algorithm — enumerates all elementary (simple) cycles in the
- * slot-dependency graph. Self-loops are handled as a degenerate first pass
- * because Tarjan's SCC decomposition assigns a self-looping node to its own
- * single-node SCC, which Johnson's inner loop otherwise skips.
- */
-export function findSlotCycles(components) {
-    if (components.length === 0)
-        return [];
-    const { nodes, adjacency } = buildGraph(components);
-    if (nodes.length === 0)
-        return [];
-    const cycles = [];
-    // Degenerate case: self-loops. For any component whose slot allows itself,
-    // emit a length-1 cycle before invoking Johnson's inner loop — Tarjan's
-    // trivial single-node SCC test in Johnson's original paper only counts as
-    // an SCC if the node participates in an edge, which we replicate here.
-    for (const node of nodes) {
-        const outgoing = adjacency.get(node) ?? [];
-        for (const edge of outgoing) {
-            if (edge.target === node) {
-                cycles.push({
-                    path: [node, node],
-                    edges: [{ fromComponent: node, slotName: edge.slotName, toComponent: node }],
-                });
-            }
-        }
-    }
-    // Johnson's main algorithm — iterate over remaining nodes in a fixed order,
-    // decomposing the subgraph induced by `{node, ...higherOrder}` into SCCs,
-    // and running the blocked-list circuit search rooted at the least node of
-    // each non-trivial SCC. This is the classic formulation from the paper.
-    const nodeOrder = [...nodes].sort();
-    let remaining = [...nodeOrder];
-    while (remaining.length > 0) {
-        const subgraphNodes = remaining;
-        const sccs = stronglyConnectedComponents(subgraphNodes, adjacency).filter((scc) => {
-            if (scc.length > 1)
-                return true;
-            // Non-trivial single-node SCC iff the node has a self-loop within the
-            // subgraph. We already emitted those above, so exclude here.
-            return false;
-        });
-        if (sccs.length === 0)
-            break;
-        // Pick the SCC containing the lexicographically-smallest node — mirrors
-        // the "least vertex" root selection in Johnson's paper.
-        let startNode = null;
-        let startScc = null;
-        for (const scc of sccs) {
-            const min = [...scc].sort()[0];
-            if (startNode === null || min < startNode) {
-                startNode = min;
-                startScc = scc;
-            }
-        }
-        if (startNode === null || startScc === null)
-            break;
-        const sccSet = new Set(startScc);
-        const blocked = new Set();
-        const blockedMap = new Map();
-        const pathStack = [];
-        const edgeStack = [];
-        function unblock(u) {
-            blocked.delete(u);
-            const dependents = blockedMap.get(u);
-            if (!dependents)
-                return;
-            for (const w of dependents) {
-                if (blocked.has(w))
-                    unblock(w);
-            }
-            dependents.clear();
-        }
-        function circuit(v, root) {
-            let foundCycle = false;
-            pathStack.push(v);
-            blocked.add(v);
-            const outgoing = adjacency.get(v) ?? [];
-            for (const { target: w, slotName } of outgoing) {
-                if (!sccSet.has(w))
-                    continue;
-                edgeStack.push({ fromComponent: v, slotName, toComponent: w });
-                if (w === root) {
-                    cycles.push(makeCycle(pathStack, edgeStack));
-                    foundCycle = true;
-                }
-                else if (!blocked.has(w)) {
-                    if (circuit(w, root))
-                        foundCycle = true;
-                }
-                edgeStack.pop();
-            }
-            if (foundCycle) {
-                unblock(v);
-            }
-            else {
-                for (const { target: w } of outgoing) {
-                    if (!sccSet.has(w))
-                        continue;
-                    let deps = blockedMap.get(w);
-                    if (!deps) {
-                        deps = new Set();
-                        blockedMap.set(w, deps);
-                    }
-                    deps.add(v);
-                }
-            }
-            pathStack.pop();
-            return foundCycle;
-        }
-        circuit(startNode, startNode);
-        // Remove `startNode` from consideration and repeat with the reduced
-        // subgraph. In classic Johnson's this is done by re-running SCC on the
-        // subgraph induced by the remaining nodes.
-        remaining = remaining.filter((n) => n !== startNode);
-    }
-    return cycles;
-}
-/**
- * Pick which edge is the best candidate to remove to break a cycle.
- * Heuristic: prefer removing the edge whose `toComponent` appears most often
- * as a destination across all cycles — that "hub" node is the biggest
- * contributor and removing an inbound edge to it likely breaks multiple
- * cycles at once. Falls back to the first edge in the cycle for
- * deterministic output when all candidates are tied.
- */
-export function suggestCycleBreakEdge(cycle, allCycles) {
-    if (cycle.edges.length === 0) {
-        throw new Error('suggestCycleBreakEdge: cycle has no edges');
-    }
-    const indegree = new Map();
-    for (const c of allCycles) {
-        for (const edge of c.edges) {
-            indegree.set(edge.toComponent, (indegree.get(edge.toComponent) ?? 0) + 1);
-        }
-    }
-    let best = cycle.edges[0];
-    let bestScore = indegree.get(best.toComponent) ?? 0;
-    for (const edge of cycle.edges) {
-        const score = indegree.get(edge.toComponent) ?? 0;
-        if (score > bestScore) {
-            best = edge;
-            bestScore = score;
-        }
-    }
-    return best;
-}
-/**
- * Format a cycle for the compact banner:
- *   `CardA → header → CardB → footer → CardA`
- *
- * Truncates at `maxHops` edges (default 8), inserting `…` mid-path so the
- * beginning and end remain visible. A hop is one edge; the returned string
- * for an n-edge cycle contains n+1 component names.
- *
- * Kept for backend/log/error use where a single string is required (see
- * `assertNoSlotCycles` in `apply/command.ts`). The TUI banner + detail panel
- * use `formatCyclePathSegments` instead so slot names can be visually
- * distinguished from component names.
- */
-export function formatCyclePath(cycle, maxHops = 8) {
-    const arrow = ' → ';
-    const parts = [];
-    // Interleave: component, slot, component, slot, ..., final component
-    // path.length === edges.length + 1.
-    for (let i = 0; i < cycle.edges.length; i += 1) {
-        parts.push(cycle.path[i]);
-        parts.push(cycle.edges[i].slotName);
-    }
-    parts.push(cycle.path[cycle.path.length - 1]);
-    if (cycle.edges.length <= maxHops) {
-        return parts.join(arrow);
-    }
-    // Truncated: keep the first `keep` edges' worth of tokens and the final
-    // component. Two "tokens per hop" (component + slot) plus the trailing
-    // component name.
-    const keepHops = Math.max(1, maxHops - 1);
-    const keepTokens = keepHops * 2;
-    const head = parts.slice(0, keepTokens).join(arrow);
-    const tail = parts[parts.length - 1];
-    return `${head}${arrow}…${arrow}${tail}`;
-}
-/**
- * Segment-oriented counterpart to `formatCyclePath`. Preserves the same
- * 8-hop truncation semantics but returns each token classified so the
- * renderer can color slots (cyan) and components (default) independently.
- * The truncation marker `…` is emitted as a bare component segment because
- * it stands in for one or more component nodes.
- */
-export function formatCyclePathSegments(cycle, maxHops = 8) {
-    // Interleaved [component, slot, component, slot, ..., component] token list
-    // matching `formatCyclePath`'s parts array, but classified.
-    const raw = [];
-    for (let i = 0; i < cycle.edges.length; i += 1) {
-        raw.push({ kind: 'component', text: cycle.path[i] });
-        raw.push({ kind: 'slot', text: `[${cycle.edges[i].slotName}]` });
-    }
-    raw.push({ kind: 'component', text: cycle.path[cycle.path.length - 1] });
-    const withArrows = (segs) => {
-        const out = [];
-        for (let i = 0; i < segs.length; i += 1) {
-            if (i > 0)
-                out.push({ kind: 'arrow', text: ' → ' });
-            out.push(segs[i]);
-        }
-        return out;
-    };
-    if (cycle.edges.length <= maxHops) {
-        return withArrows(raw);
-    }
-    // Match `formatCyclePath` truncation: keep the first (maxHops-1)*2 tokens
-    // plus a "…" placeholder plus the trailing component.
-    const keepHops = Math.max(1, maxHops - 1);
-    const keepTokens = keepHops * 2;
-    const head = raw.slice(0, keepTokens);
-    const tail = raw[raw.length - 1];
-    return withArrows([...head, { kind: 'component', text: '…' }, tail]);
-}

package/dist/src/analyze/extract/astro.d.ts

@@ -1,5 +0,0 @@
-import type { ComponentExtractionResult } from '../../types.js';
-export declare function extractAstroComponents(filePaths: string[], onProgress?: (p: {
-    filesProcessed: number;
-    componentsFound: number;
-}) => void): Promise<ComponentExtractionResult>;