@codeyam/codeyam-cli 0.1.0-staging.2a88920 → 0.1.0-staging.2ea44f6

package/codeyam-cli/src/utils/editorPreloadHelpers.js

@@ -0,0 +1,135 @@
+/**
+ * Pure redirect and mock-matching functions for the Node.js preload module.
+ *
+ * Extracted so they can be unit-tested without loading the actual preload
+ * (which patches global fetch and http).
+ */
+/**
+ * If `url` points to the dev server, return a redirected URL going through the proxy.
+ * Otherwise return the original URL unchanged.
+ */
+export function redirectUrl(url, devServerUrl, proxyUrl) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        // Relative URL or invalid — pass through
+        return url;
+    }
+    const dev = new URL(devServerUrl);
+    const proxy = new URL(proxyUrl);
+    if (parsed.hostname === dev.hostname && parsed.port === dev.port) {
+        parsed.hostname = proxy.hostname;
+        parsed.port = proxy.port;
+        parsed.protocol = proxy.protocol;
+        return parsed.toString();
+    }
+    return url;
+}
+/**
+ * If http.request options target the dev server, patch them to go through the proxy.
+ * Returns the original options object if no redirect is needed.
+ */
+export function redirectOptions(options, devServerUrl, proxyUrl) {
+    const dev = new URL(devServerUrl);
+    const proxy = new URL(proxyUrl);
+    const devPort = parseInt(dev.port, 10);
+    const proxyPort = parseInt(proxy.port, 10);
+    // Match on hostname + port
+    if (options.hostname &&
+        parseInt(String(options.port), 10) === devPort &&
+        options.hostname === dev.hostname) {
+        return {
+            ...options,
+            hostname: proxy.hostname,
+            port: proxyPort,
+            headers: options.headers
+                ? { ...options.headers, host: `${proxy.hostname}:${proxyPort}` }
+                : options.headers,
+        };
+    }
+    // Match on host field (hostname:port combined)
+    if (options.host) {
+        const expectedHost = `${dev.hostname}:${devPort}`;
+        if (options.host === expectedHost) {
+            return {
+                ...options,
+                host: `${proxy.hostname}:${proxyPort}`,
+            };
+        }
+    }
+    return options;
+}
+/**
+ * Match a request URL against scenario mock data routes.
+ *
+ * Supports:
+ * - Path-only routes:    "/api/drinks" matches fetch("http://localhost:3000/api/drinks")
+ * - Full URL routes:     "https://api.stripe.com/v1/charges" matches external API calls
+ * - Method-prefixed:     "POST /api/drinks" matches POST requests only
+ *
+ * Returns the mock response if matched, or null if no match.
+ */
+export function matchScenarioRoute(requestUrl, method, scenarioData) {
+    const routes = scenarioData.routes;
+    if (!routes || typeof routes !== 'object')
+        return null;
+    // Extract pathname from the request URL
+    let pathname;
+    try {
+        const parsed = new URL(requestUrl);
+        pathname = parsed.pathname;
+    }
+    catch {
+        // Relative URL — use as-is
+        pathname = requestUrl.split('?')[0];
+    }
+    const upperMethod = method.toUpperCase();
+    for (const [routeKey, routeValue] of Object.entries(routes)) {
+        if (!routeValue || typeof routeValue !== 'object')
+            continue;
+        const entry = routeValue;
+        // Check for method-prefixed route: "POST /api/drinks"
+        const spaceIdx = routeKey.indexOf(' ');
+        if (spaceIdx !== -1) {
+            const routeMethod = routeKey.slice(0, spaceIdx).toUpperCase();
+            const routePath = routeKey.slice(spaceIdx + 1);
+            if (routeMethod === upperMethod && routePath === pathname) {
+                return {
+                    body: entry.body ?? routeValue,
+                    status: typeof entry.status === 'number' ? entry.status : 200,
+                };
+            }
+            continue;
+        }
+        // Full URL route: "https://api.stripe.com/v1/charges"
+        if (routeKey.startsWith('http://') || routeKey.startsWith('https://')) {
+            try {
+                const routeParsed = new URL(routeKey);
+                const reqParsed = new URL(requestUrl);
+                if (routeParsed.hostname === reqParsed.hostname &&
+                    routeParsed.port === reqParsed.port &&
+                    routeParsed.pathname === reqParsed.pathname) {
+                    return {
+                        body: entry.body ?? routeValue,
+                        status: typeof entry.status === 'number' ? entry.status : 200,
+                    };
+                }
+            }
+            catch {
+                // Invalid URL in route key — skip
+            }
+            continue;
+        }
+        // Path-only route: "/api/drinks"
+        if (routeKey === pathname) {
+            return {
+                body: entry.body ?? routeValue,
+                status: typeof entry.status === 'number' ? entry.status : 200,
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=editorPreloadHelpers.js.map

package/codeyam-cli/src/utils/editorPreloadHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorPreloadHelpers.js","sourceRoot":"","sources":["../../../../src/utils/editorPreloadHelpers.ts"],"names":[],"mappings":"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"}

package/codeyam-cli/src/utils/editorPreview.js

@@ -0,0 +1,96 @@
+/**
+ * Preview URL construction and viewport scaling for the editor.
+ *
+ * Extracted from inline logic in editor.tsx (previewUrl useMemo and previewScale useMemo).
+ */
+import { generateScenarioSlug } from "./editorScenarios.js";
+/**
+ * Resolve the preview URL based on current editor state.
+ *
+ * Priority:
+ * 1. Analyzed scenario with interactive server URL
+ * 2. Active scenario with path-based URL → combine with proxy/dev server
+ * 3. Active scenario with full URL → use directly
+ * 4. Zoom component with scenario → __codeyam__ isolation URL
+ * 5. Base proxy/dev server URL
+ */
+export function buildPreviewUrl(params) {
+    const { activeAnalyzedScenario, analyzedPreviewUrl, activeScenarioId, scenarios, proxyUrl, devServerUrl, zoomComponent, } = params;
+    // When viewing an analyzed scenario, use the interactive server URL
+    if (activeAnalyzedScenario && analyzedPreviewUrl) {
+        return analyzedPreviewUrl;
+    }
+    // If analyzed scenario is active but no URL, fall through to check other sources
+    // but if nothing else matches either, return null
+    if (activeAnalyzedScenario && !analyzedPreviewUrl) {
+        return null;
+    }
+    // Component isolation scenarios store a path (e.g. /codeyam-isolate/DrinkCard?s=Default)
+    if (activeScenarioId) {
+        const scenario = scenarios.find((s) => s.id === activeScenarioId);
+        if (scenario?.url) {
+            const base = proxyUrl || devServerUrl;
+            if (!base)
+                return null;
+            if (scenario.url.startsWith('/')) {
+                return `${base}${scenario.url}`;
+            }
+            return scenario.url;
+        }
+    }
+    const baseUrl = proxyUrl || devServerUrl;
+    if (!baseUrl)
+        return null;
+    if (zoomComponent && activeScenarioId) {
+        const scenario = scenarios.find((s) => s.id === activeScenarioId);
+        const scenarioSlug = scenario
+            ? generateScenarioSlug(scenario.name)
+            : 'Default';
+        return `${baseUrl}/__codeyam__/${zoomComponent}/${scenarioSlug}`;
+    }
+    return baseUrl;
+}
+/**
+ * Apply a navigation path override to a preview URL.
+ *
+ * Correctly handles paths with query strings (e.g. `/codeyam-isolate/DrinkCard?s=Default`)
+ * by parsing the path into pathname + search components instead of naively assigning
+ * to `URL.pathname` (which would URL-encode the `?`).
+ */
+export function applyNavigatePath(previewUrl, navigatePath) {
+    if (!previewUrl)
+        return previewUrl;
+    if (!navigatePath)
+        return previewUrl;
+    try {
+        const base = new URL(previewUrl);
+        // Parse navigatePath to separate pathname from query string
+        const qIndex = navigatePath.indexOf('?');
+        if (qIndex >= 0) {
+            base.pathname = navigatePath.slice(0, qIndex);
+            base.search = navigatePath.slice(qIndex);
+        }
+        else {
+            base.pathname = navigatePath;
+            base.search = '';
+        }
+        return base.href;
+    }
+    catch {
+        return previewUrl;
+    }
+}
+/**
+ * Compute CSS scale factor to fit a viewport in a container.
+ * Returns 1 if the target fits, otherwise the smallest scale that fits both dimensions.
+ */
+export function calculatePreviewScale(containerSize, targetSize) {
+    const targetW = targetSize.width;
+    const targetH = targetSize.height ?? 900;
+    const availW = containerSize.width;
+    const availH = containerSize.height;
+    if (targetW <= availW && targetH <= availH)
+        return 1;
+    return Math.min(availW / targetW, availH / targetH);
+}
+//# sourceMappingURL=editorPreview.js.map

package/codeyam-cli/src/utils/editorPreview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorPreview.js","sourceRoot":"","sources":["../../../../src/utils/editorPreview.ts"],"names":[],"mappings":"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"}

package/codeyam-cli/src/utils/editorScenarios.js

@@ -0,0 +1,96 @@
+/**
+ * Shared scenario utilities used across editor routes and components.
+ *
+ * Extracted from inline logic in editor.tsx, api.editor-journal-entry.ts,
+ * and api.editor-register-scenario.ts.
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * Generic Map-based deduplication that keeps the last item for each key.
+ * Items are iterated in order, so later entries overwrite earlier ones.
+ * Map preserves insertion order of first appearance.
+ */
+export function deduplicateByName(items, keyFn) {
+    const byKey = new Map();
+    for (const item of items) {
+        byKey.set(keyFn(item), item);
+    }
+    return [...byKey.values()];
+}
+/**
+ * Convert a scenario name to a URL-safe slug.
+ * Replaces any run of non-alphanumeric, non-underscore characters with a single underscore.
+ */
+export function generateScenarioSlug(name) {
+    return name.replace(/[^a-zA-Z0-9_]+/g, '_');
+}
+/**
+ * Convert an ISO 8601 timestamp (e.g. "2026-02-28T19:00:00.000Z") to
+ * SQLite-compatible format (e.g. "2026-02-28 19:00:00").
+ *
+ * SQLite's CURRENT_TIMESTAMP uses space-separated "YYYY-MM-DD HH:MM:SS" format,
+ * so we need this conversion for date comparisons.
+ */
+export function convertIsoToSqliteTimestamp(iso) {
+    return iso.replace('T', ' ').replace(/\.\d{3}Z$/, '');
+}
+/**
+ * Resolve which URL to use for Playwright screenshot capture.
+ *
+ * Priority:
+ * 1. Path-based URL + proxy → combine (component isolation with API interception)
+ * 2. Full URL → use directly (legacy)
+ * 3. No URL → proxy root or dev server root (page scenarios)
+ */
+/**
+ * Resolve the navigation path for preview refresh.
+ * Priority: explicit path > scenario URL from DB > undefined (plain refresh).
+ */
+export function resolvePreviewNavPath(explicitPath, scenarioUrl) {
+    if (explicitPath)
+        return explicitPath;
+    if (scenarioUrl)
+        return scenarioUrl;
+    return undefined;
+}
+/**
+ * Clear the editor step state file (for starting a new feature).
+ * This should NOT touch the user prompt file — the prompt is captured
+ * by the hook before step 1 runs, so deleting it here would lose it.
+ */
+export function clearEditorState(root) {
+    const statePath = path.join(root, '.codeyam', 'editor-step.json');
+    try {
+        fs.unlinkSync(statePath);
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+}
+/**
+ * Clear the user prompt file so the hook can capture the next feature request.
+ * Call this after a feature is committed, not during step 1.
+ */
+export function clearEditorUserPrompt(root) {
+    const promptPath = path.join(root, '.codeyam', 'editor-user-prompt.txt');
+    try {
+        fs.unlinkSync(promptPath);
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+}
+export function determineCaptureUrl(url, proxyUrl, devServerUrl) {
+    const isPath = url && url.startsWith('/');
+    if (isPath && proxyUrl) {
+        return `${proxyUrl}${url}`;
+    }
+    else if (url && !isPath) {
+        return url;
+    }
+    else {
+        return proxyUrl || devServerUrl || null;
+    }
+}
+//# sourceMappingURL=editorScenarios.js.map

package/codeyam-cli/src/utils/editorScenarios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorScenarios.js","sourceRoot":"","sources":["../../../../src/utils/editorScenarios.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAU,EACV,KAA0B;IAE1B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAa,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,GAAW;IACrD,OAAO,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;GAOG;AACH;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAAuC,EACvC,WAAsC;IAEtC,IAAI,YAAY;QAAE,OAAO,YAAY,CAAC;IACtC,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC;IACpC,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,kBAAkB,CAAC,CAAC;IAClE,IAAI,CAAC;QACH,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC3B,CAAC;IAAC,MAAM,CAAC;QACP,kCAAkC;IACpC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,wBAAwB,CAAC,CAAC;IACzE,IAAI,CAAC;QACH,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,kCAAkC;IACpC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,GAA8B,EAC9B,QAAuB,EACvB,YAA2B;IAE3B,MAAM,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAI,MAAM,IAAI,QAAQ,EAAE,CAAC;QACvB,OAAO,GAAG,QAAQ,GAAG,GAAG,EAAE,CAAC;IAC7B,CAAC;SAAM,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC1B,OAAO,GAAG,CAAC;IACb,CAAC;SAAM,CAAC;QACN,OAAO,QAAQ,IAAI,YAAY,IAAI,IAAI,CAAC;IAC1C,CAAC;AACH,CAAC"}

package/codeyam-cli/src/utils/entityChangeStatus.js

@@ -0,0 +1,326 @@
+/**
+ * Pure, deterministic computation of entity change status (new / edited / impacted).
+ *
+ * Uses pre-computed `importedBy` metadata from the entity DB table to trace
+ * transitive dependencies, showing which root-cause dependency triggered each impact.
+ *
+ * Shared by both the editor.tsx loader and the journal entry API.
+ */
+/**
+ * Build the changedFiles map from git status entries.
+ *
+ * - `added` / `untracked` → 'new'
+ * - `modified` → 'edited'
+ * - `deleted` / `renamed` → ignored (not relevant for entity change status)
+ * - When `isFirstFeature` is true, ALL non-deleted files are treated as 'new'
+ *   (scaffold commit is boilerplate, so everything the user built is new).
+ */
+export function buildChangedFilesMap(gitFiles, isFirstFeature) {
+    const changedFiles = new Map();
+    for (const gf of gitFiles) {
+        if (gf.status === 'deleted')
+            continue;
+        if (isFirstFeature || gf.status === 'added' || gf.status === 'untracked') {
+            changedFiles.set(gf.path, 'new');
+        }
+        else if (gf.status === 'modified') {
+            changedFiles.set(gf.path, 'edited');
+        }
+    }
+    return changedFiles;
+}
+/**
+ * Derive a page entity name from a scenario URL.
+ * Returns 'Home' for root/null URLs, capitalized first segment otherwise.
+ *
+ * This is the canonical implementation — previously duplicated in 3+ components.
+ */
+export function pageNameFromUrl(url) {
+    if (!url || url === '/')
+        return 'Home';
+    const path = url.split('?')[0].replace(/^\//, '');
+    const segment = path.split('/')[0];
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+/**
+ * Build EntityInfo[] from editor scenarios + page file paths + entity metadata.
+ *
+ * This converts the heterogeneous scenario data (component scenarios with
+ * componentName/Path, page scenarios with URL) into a uniform EntityInfo[]
+ * that computeEntityChangeStatus can consume.
+ *
+ * - Component scenarios: use componentName + componentPath directly
+ * - Page scenarios: derive page name from URL, look up file path from pageFilePaths
+ * - Deduplicates by entity name (first occurrence wins)
+ * - Enriches each entity with importedBy metadata from the entity DB
+ */
+export function buildEntityInfosFromScenarios(scenarios, pageFilePaths, entitiesWithMetadata) {
+    const entityInfos = [];
+    const seenNames = new Set();
+    for (const s of scenarios) {
+        let entityName = null;
+        let filePath = null;
+        if (s.componentName && s.componentPath) {
+            entityName = s.componentName;
+            filePath = s.componentPath;
+        }
+        else if (!s.componentName && s.url !== undefined) {
+            const pageName = pageNameFromUrl(s.url);
+            if (pageFilePaths[pageName]) {
+                entityName = pageName;
+                filePath = pageFilePaths[pageName];
+            }
+        }
+        if (entityName && filePath && !seenNames.has(entityName)) {
+            seenNames.add(entityName);
+            const metadataEntity = entitiesWithMetadata.find((e) => e.name === entityName);
+            entityInfos.push({
+                name: entityName,
+                filePath,
+                importedBy: metadataEntity?.metadata?.importedBy,
+            });
+        }
+    }
+    return entityInfos;
+}
+/**
+ * Build EntityInfo[] from glossary function entries.
+ *
+ * Glossary functions (library utilities with tests) need to participate in
+ * the change status graph so that the results panel and journal entries can
+ * filter them to only show new/edited/impacted functions.
+ *
+ * - Deduplicates by name (first occurrence wins)
+ * - Skips entries whose name is already in `existingNames` (e.g., from scenarios)
+ */
+export function buildEntityInfosFromGlossary(glossaryEntries, existingNames) {
+    const entityInfos = [];
+    const seenNames = new Set(existingNames);
+    for (const entry of glossaryEntries) {
+        if (seenNames.has(entry.name))
+            continue;
+        seenNames.add(entry.name);
+        entityInfos.push({
+            name: entry.name,
+            filePath: entry.filePath,
+        });
+    }
+    return entityInfos;
+}
+// ── Filtering ────────────────────────────────────────────────────────────
+/**
+ * Filter grouped entries to only show those with a change status.
+ * When entityChangeStatus is empty/undefined, returns all entries (safe fallback).
+ */
+export function filterGroupsByChangeStatus(groups, entityChangeStatus) {
+    if (!entityChangeStatus || Object.keys(entityChangeStatus).length === 0) {
+        return groups;
+    }
+    return groups.filter(([name]) => entityChangeStatus[name]);
+}
+/**
+ * Filter glossary function entries to only show those with a change status.
+ * When entityChangeStatus is empty/undefined, returns all entries (safe fallback
+ * for first feature builds where everything is new).
+ */
+export function filterGlossaryByChangeStatus(functions, entityChangeStatus) {
+    if (!entityChangeStatus || Object.keys(entityChangeStatus).length === 0) {
+        return functions;
+    }
+    return functions.filter((fn) => entityChangeStatus[fn.name]);
+}
+/**
+ * Filter scenario screenshots to only include those belonging to entities
+ * with a change status (new/edited/impacted).
+ *
+ * Screenshot names follow the pattern "ComponentName - Scenario" or just "Scenario"
+ * (app-level, no component prefix).
+ *
+ * `pageEntityNames` lists the entity names that represent pages (e.g., "Home", "Drinks").
+ * App-level screenshots (no component prefix) match if any page entity has a status.
+ *
+ * When entityChangeStatus is empty/undefined, returns all screenshots (safe fallback).
+ */
+export function filterScenarioScreenshotsByChangeStatus(screenshots, entityChangeStatus, pageEntityNames) {
+    if (!entityChangeStatus || Object.keys(entityChangeStatus).length === 0) {
+        return screenshots;
+    }
+    // Check if any page entity has a change status
+    const anyPageChanged = pageEntityNames
+        ? [...pageEntityNames].some((name) => entityChangeStatus[name])
+        : false;
+    return screenshots.filter((ss) => {
+        const dashIdx = ss.name.indexOf(' - ');
+        if (dashIdx !== -1) {
+            const prefix = ss.name.slice(0, dashIdx);
+            // "App - Scenario" is a legacy page-level screenshot (backward compat)
+            if (prefix === 'App')
+                return anyPageChanged;
+            // Component screenshot: "ComponentName - Scenario"
+            return !!entityChangeStatus[prefix];
+        }
+        else {
+            // No prefix: app-level screenshot
+            return anyPageChanged;
+        }
+    });
+}
+// ── Graph Helpers ────────────────────────────────────────────────────────
+/**
+ * Build a reverse dependency graph: entityName → Set of entity names that import it.
+ * Extracted from entity metadata.importedBy which has the shape:
+ *   { [filePath]: { [importerName]: { shas: string[] } } }
+ */
+export function buildReverseDependencyGraph(entities) {
+    const graph = new Map();
+    for (const entity of entities) {
+        const importedBy = entity.importedBy;
+        if (!importedBy || typeof importedBy !== 'object')
+            continue;
+        const importers = new Set();
+        for (const filePath of Object.keys(importedBy)) {
+            for (const importerName of Object.keys(importedBy[filePath])) {
+                importers.add(importerName);
+            }
+        }
+        if (importers.size > 0) {
+            graph.set(entity.name, importers);
+        }
+    }
+    return graph;
+}
+/**
+ * Classify entities as directly changed ('new' or 'edited') by matching
+ * entity file paths against the set of changed files.
+ */
+export function classifyDirectChanges(changedFiles, entities) {
+    const result = new Map();
+    for (const entity of entities) {
+        const status = changedFiles.get(entity.filePath);
+        if (status) {
+            result.set(entity.name, status);
+        }
+    }
+    return result;
+}
+// ── Core ─────────────────────────────────────────────────────────────────
+const DEFAULT_MAX_DEPTH = 20;
+/**
+ * Compute change status for all entities.
+ *
+ * Algorithm (BFS with root-cause tracking):
+ * 1. Build reverseDepGraph from importedBy metadata
+ * 2. Classify direct changes by matching entity file paths to changedFiles
+ * 3. BFS from directly-changed entities through the reverse graph:
+ *    - Root causes are tracked in a canonical map; the BFS reads from
+ *      this map (not stale queue snapshots) for correct diamond propagation
+ *    - Directly-changed entities act as pass-through: upstream root causes
+ *      merge through them to downstream importers, but their own status stays
+ *    - Nodes are re-enqueued when their root cause set grows (handles
+ *      converging paths at different depths)
+ *    - Phantom importers (not in entities list) are skipped
+ *    - Termination: root cause sets only grow, bounded by |directChanges|;
+ *      maxDepth provides additional safety
+ * 4. Return map with only new/edited/impacted entries (unchanged entities omitted)
+ */
+export function computeEntityChangeStatus(changedFiles, entities, maxDepth = DEFAULT_MAX_DEPTH) {
+    const result = {};
+    if (entities.length === 0 || changedFiles.size === 0) {
+        return result;
+    }
+    // Build entity name → EntityInfo lookup
+    const entityByName = new Map();
+    for (const entity of entities) {
+        entityByName.set(entity.name, entity);
+    }
+    // Step 1: Build reverse dependency graph
+    const reverseDepGraph = buildReverseDependencyGraph(entities);
+    // Step 2: Classify direct changes
+    const directChanges = classifyDirectChanges(changedFiles, entities);
+    // Record direct changes in result
+    for (const [entityName, changeType] of directChanges) {
+        result[entityName] = { status: changeType };
+    }
+    // Step 3: BFS from directly-changed entities
+    // Track root causes for each impacted entity in a canonical map.
+    // The BFS reads from this map (not stale queue snapshots) so that
+    // root causes from multiple converging paths are fully propagated.
+    const rootCauses = new Map(); // entityName → Set<rootCauseEntityName>
+    // Seed: directly-changed entities carry themselves as root causes
+    for (const [entityName] of directChanges) {
+        rootCauses.set(entityName, new Set([entityName]));
+    }
+    const queue = [];
+    // Seed BFS with directly-changed entities at depth 0
+    for (const [entityName] of directChanges) {
+        queue.push({ name: entityName, depth: 0 });
+    }
+    while (queue.length > 0) {
+        const { name, depth } = queue.shift();
+        if (depth >= maxDepth)
+            continue;
+        // Read canonical root causes from the map — NOT a stale queue snapshot.
+        // For seeds this is {self}; for impacted nodes it's the fully-merged set
+        // from all paths that have been processed so far. BFS guarantees that
+        // all shorter paths are processed before longer ones, so the set is
+        // complete for same-depth convergence (the common case: diamond deps).
+        const currentRootCauses = rootCauses.get(name) || new Set();
+        // Find all entities that import this one
+        const importers = reverseDepGraph.get(name);
+        if (!importers)
+            continue;
+        for (const importerName of importers) {
+            // Skip phantom importers (referenced in importedBy but not in entities list)
+            if (!entityByName.has(importerName))
+                continue;
+            // Merge root causes into canonical map — even for directly-changed
+            // entities, so they can act as pass-through for downstream propagation.
+            // (Their status won't be overridden — step 4 skips directly-changed.)
+            if (!rootCauses.has(importerName)) {
+                rootCauses.set(importerName, new Set());
+            }
+            const existing = rootCauses.get(importerName);
+            let grew = false;
+            for (const rc of currentRootCauses) {
+                if (!existing.has(rc)) {
+                    existing.add(rc);
+                    grew = true;
+                }
+            }
+            // Enqueue if new root causes were added. This handles:
+            // - First visit: always enqueue
+            // - Later visit from a different path: re-enqueue so downstream
+            //   importers receive the newly-merged root causes
+            if (grew) {
+                queue.push({ name: importerName, depth: depth + 1 });
+            }
+        }
+    }
+    // Step 4: Build impacted entries from root causes
+    // Skip directly-changed entities — they already have their status set and
+    // are only in rootCauses to serve as propagation seeds.
+    for (const [entityName, causes] of rootCauses) {
+        if (directChanges.has(entityName))
+            continue;
+        const impactedBy = [];
+        for (const causeName of causes) {
+            const causeEntity = entityByName.get(causeName);
+            const changeType = directChanges.get(causeName);
+            if (causeEntity && changeType) {
+                impactedBy.push({
+                    name: causeName,
+                    filePath: causeEntity.filePath,
+                    changeType,
+                });
+            }
+        }
+        // Sort by name for deterministic output
+        impactedBy.sort((a, b) => a.name.localeCompare(b.name));
+        result[entityName] = {
+            status: 'impacted',
+            impactedBy: impactedBy.length > 0 ? impactedBy : undefined,
+        };
+    }
+    return result;
+}
+//# sourceMappingURL=entityChangeStatus.js.map