@monoes/monograph 1.1.0 → 1.2.1

package/dist/src/graph/complexity.js

@@ -0,0 +1,150 @@
+/**
+ * Compute CRAP score for a function.
+ * Formula: CC² × (1 - coverage)³ + CC
+ * where coverage is a 0-1 fraction (0 = no tests, 1 = fully covered).
+ */
+export function computeCrapScore(cc, coverage) {
+    const cov = Math.max(0, Math.min(1, coverage));
+    return cc * cc * Math.pow(1 - cov, 3) + cc;
+}
+function percentile(arr, p) {
+    if (arr.length === 0)
+        return 0;
+    const idx = Math.floor((p / 100) * (arr.length - 1));
+    return arr[idx];
+}
+/**
+ * Compute cyclomatic and cognitive complexity for all Function/Method nodes
+ * in the knowledge graph. Uses graph degree as a proxy for decision points
+ * since AST is not available at this layer.
+ *
+ * - Cyclomatic complexity proxy: outgoing CALLS × 0.5 + outgoing ACCESSES × 0.2 + 1
+ * - Cognitive complexity proxy: (endLine - startLine) / 10, capped at 20
+ * - LOC: endLine - startLine + 1 (or 1 if missing)
+ * - CRAP: computed with coverage = 0 (worst-case, no test data available)
+ *
+ * Batches all SQL work to avoid N+1 queries (2 GROUP BY queries replace 2×N individual queries).
+ */
+export function computeComplexity(db) {
+    // Fetch all function/method nodes in one query
+    const rows = db.prepare(`
+    SELECT id, name, file_path, start_line, end_line, properties
+    FROM nodes
+    WHERE label IN ('Function', 'Method')
+  `).all();
+    if (rows.length === 0) {
+        return { functions: [], p50cc: 0, p90cc: 0, p95cc: 0, highComplexityCount: 0, criticalCount: 0 };
+    }
+    // ── Batch edge counts: 2 GROUP BY queries replace 2×N individual queries ─
+    const callsMap = new Map();
+    for (const { source_id, c } of db.prepare(`
+    SELECT source_id, COUNT(*) as c FROM edges WHERE relation = 'CALLS' GROUP BY source_id
+  `).all()) {
+        callsMap.set(source_id, c);
+    }
+    const accessesMap = new Map();
+    for (const { source_id, c } of db.prepare(`
+    SELECT source_id, COUNT(*) as c FROM edges WHERE relation = 'ACCESSES' GROUP BY source_id
+  `).all()) {
+        accessesMap.set(source_id, c);
+    }
+    // ── Compute metrics for each function ────────────────────────────────────
+    const functions = [];
+    const propUpdates = [];
+    for (const row of rows) {
+        const props = row.properties ? JSON.parse(row.properties) : {};
+        const callsCount = callsMap.get(row.id) ?? 0;
+        const accessesCount = accessesMap.get(row.id) ?? 0;
+        const cyclomaticComplexity = Math.round(callsCount * 0.5 + accessesCount * 0.2 + 1);
+        const lineSpan = (row.start_line != null && row.end_line != null)
+            ? row.end_line - row.start_line
+            : 0;
+        const cognitiveComplexity = Math.min(Math.round(lineSpan / 10), 20);
+        const linesOfCode = (row.start_line != null && row.end_line != null)
+            ? row.end_line - row.start_line + 1
+            : 1;
+        const paramCount = typeof props.paramCount === 'number' ? props.paramCount : 0;
+        const crapScore = computeCrapScore(cyclomaticComplexity, 0);
+        // Stage property update — batched in a single transaction below
+        propUpdates.push({
+            id: row.id,
+            props: JSON.stringify({ ...props, cyclomaticComplexity, cognitiveComplexity, crapScore }),
+        });
+        functions.push({
+            nodeId: row.id,
+            name: row.name,
+            filePath: row.file_path,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            cyclomaticComplexity,
+            cognitiveComplexity,
+            linesOfCode,
+            paramCount,
+            crapScore,
+        });
+    }
+    // ── Batch UPDATE all property writes in one transaction ───────────────────
+    const updateStmt = db.prepare('UPDATE nodes SET properties = ? WHERE id = ?');
+    db.transaction((updates) => {
+        for (const { id, props } of updates)
+            updateStmt.run(props, id);
+    })(propUpdates);
+    // ── Compute percentiles ───────────────────────────────────────────────────
+    const ccValues = functions.map(f => f.cyclomaticComplexity).sort((a, b) => a - b);
+    return {
+        functions,
+        p50cc: percentile(ccValues, 50),
+        p90cc: percentile(ccValues, 90),
+        p95cc: percentile(ccValues, 95),
+        highComplexityCount: functions.filter(f => f.cyclomaticComplexity > 10).length,
+        criticalCount: functions.filter(f => f.cyclomaticComplexity > 20).length,
+    };
+}
+/**
+ * Format a ComplexityReport as structured text with file:line hints for LLM navigation.
+ *
+ * @param report - ComplexityReport from computeComplexity()
+ * @param topN - number of worst offenders to list (default 10)
+ * @returns structured text suitable for LLM consumption
+ */
+export function formatComplexity(report, topN = 10) {
+    const { functions, p50cc, p90cc, p95cc, highComplexityCount, criticalCount } = report;
+    if (functions.length === 0) {
+        return 'complexity: no Function/Method nodes found in graph\n';
+    }
+    const lines = [
+        `complexity: ${functions.length} functions analysed`,
+        `  p50_cc: ${p50cc}  p90_cc: ${p90cc}  p95_cc: ${p95cc}`,
+        `  high(cc>10): ${highComplexityCount}  critical(cc>20): ${criticalCount}`,
+        '',
+    ];
+    // Sort by crapScore descending (worst first)
+    const worst = [...functions]
+        .sort((a, b) => b.crapScore - a.crapScore)
+        .slice(0, topN);
+    if (worst.length > 0) {
+        lines.push(`top_${topN}_worst_crap:`);
+        for (const fn of worst) {
+            const loc = fn.filePath
+                ? `${fn.filePath}:${fn.startLine ?? 1}`
+                : `<unknown>:1`;
+            lines.push(`  - ${fn.name}`);
+            lines.push(`    file: ${loc}`);
+            lines.push(`    cc: ${fn.cyclomaticComplexity}  crap: ${fn.crapScore.toFixed(1)}  loc: ${fn.linesOfCode}`);
+        }
+        lines.push('');
+    }
+    const critical = functions.filter(f => f.cyclomaticComplexity > 20);
+    if (critical.length > 0) {
+        lines.push(`critical_functions(cc>20): ${critical.length}`);
+        for (const fn of critical.slice(0, 5)) {
+            const loc = fn.filePath ? `${fn.filePath}:${fn.startLine ?? 1}` : `<unknown>:1`;
+            lines.push(`  - ${fn.name}  file: ${loc}  cc: ${fn.cyclomaticComplexity}`);
+        }
+        if (critical.length > 5)
+            lines.push(`  ... and ${critical.length - 5} more`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=complexity.js.map

package/dist/src/graph/complexity.js.map

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

package/dist/src/graph/cross-reference-findings.d.ts

@@ -0,0 +1,46 @@
+export type DeadCodeKind = {
+    type: 'unused-file';
+} | {
+    type: 'unused-export';
+    exportName: string;
+} | {
+    type: 'unused-type';
+    typeName: string;
+};
+export interface CloneInstanceRef {
+    file: string;
+    startLine: number;
+    endLine: number;
+    tokenCount?: number;
+}
+export interface CombinedFinding {
+    cloneInstance: CloneInstanceRef;
+    deadCodeKind: DeadCodeKind;
+    groupIndex: number;
+}
+export interface CrossReferenceResult {
+    combinedFindings: CombinedFinding[];
+    clonesInUnusedFiles: number;
+    clonesWithUnusedExports: number;
+}
+export interface CrossRefDeadCodeSummary {
+    unusedFiles: Set<string>;
+    unusedExports: Array<{
+        path: string;
+        exportName: string;
+        line: number;
+    }>;
+    unusedTypes: Array<{
+        path: string;
+        typeName: string;
+        line: number;
+    }>;
+}
+export interface CrossRefDuplicationReport {
+    cloneGroups: Array<{
+        instances: CloneInstanceRef[];
+    }>;
+}
+export declare function crossReference(duplication: CrossRefDuplicationReport, deadCode: CrossRefDeadCodeSummary): CrossReferenceResult;
+export declare function affectedGroupIndices(result: CrossReferenceResult): Set<number>;
+//# sourceMappingURL=cross-reference-findings.d.ts.map

package/dist/src/graph/cross-reference-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-reference-findings.d.ts","sourceRoot":"","sources":["../../../src/graph/cross-reference-findings.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,gBAAgB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzE,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,gBAAgB,EAAE,CAAA;KAAE,CAAC,CAAC;CACvD;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE,yBAAyB,EAAE,QAAQ,EAAE,uBAAuB,GAAG,oBAAoB,CA8C9H;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,GAAG,CAAC,MAAM,CAAC,CAE9E"}

package/dist/src/graph/cross-reference-findings.js

@@ -0,0 +1,46 @@
+export function crossReference(duplication, deadCode) {
+    const findings = [];
+    let clonesInUnusedFiles = 0, clonesWithUnusedExports = 0;
+    // Preindex unusedExports and unusedTypes by file path to avoid O(N) Array.find
+    // per clone instance. Each lookup becomes an O(1) Map get + a short in-range scan
+    // over the candidates for that specific file.
+    const exportsByPath = new Map();
+    for (const e of deadCode.unusedExports) {
+        const bucket = exportsByPath.get(e.path) ?? [];
+        bucket.push({ exportName: e.exportName, line: e.line });
+        exportsByPath.set(e.path, bucket);
+    }
+    const typesByPath = new Map();
+    for (const t of deadCode.unusedTypes) {
+        const bucket = typesByPath.get(t.path) ?? [];
+        bucket.push({ typeName: t.typeName, line: t.line });
+        typesByPath.set(t.path, bucket);
+    }
+    for (let gi = 0; gi < duplication.cloneGroups.length; gi++) {
+        for (const inst of duplication.cloneGroups[gi].instances) {
+            if (deadCode.unusedFiles.has(inst.file)) {
+                findings.push({ cloneInstance: inst, deadCodeKind: { type: 'unused-file' }, groupIndex: gi });
+                clonesInUnusedFiles++;
+                continue;
+            }
+            const exportsForFile = exportsByPath.get(inst.file);
+            const overlap = exportsForFile?.find(e => e.line >= inst.startLine && e.line <= inst.endLine);
+            if (overlap) {
+                findings.push({ cloneInstance: inst, deadCodeKind: { type: 'unused-export', exportName: overlap.exportName }, groupIndex: gi });
+                clonesWithUnusedExports++;
+                continue;
+            }
+            const typesForFile = typesByPath.get(inst.file);
+            const typeOverlap = typesForFile?.find(t => t.line >= inst.startLine && t.line <= inst.endLine);
+            if (typeOverlap) {
+                findings.push({ cloneInstance: inst, deadCodeKind: { type: 'unused-type', typeName: typeOverlap.typeName }, groupIndex: gi });
+                clonesWithUnusedExports++;
+            }
+        }
+    }
+    return { combinedFindings: findings, clonesInUnusedFiles, clonesWithUnusedExports };
+}
+export function affectedGroupIndices(result) {
+    return new Set(result.combinedFindings.map(f => f.groupIndex));
+}
+//# sourceMappingURL=cross-reference-findings.js.map

package/dist/src/graph/cross-reference-findings.js.map

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

package/dist/src/graph/cross-reference.d.ts

@@ -0,0 +1,26 @@
+import type { MonographDb } from '../storage/db.js';
+import type { AnnotatedFinding } from '../types.js';
+export interface CrossReferenceFinding extends AnnotatedFinding {
+    crossRefType: 'dead+duplicate';
+    nodeIds: string[];
+    description: string;
+}
+export interface CrossReferenceReport {
+    findings: CrossReferenceFinding[];
+    deadCount: number;
+    duplicateCount: number;
+    crossCount: number;
+}
+/**
+ * Cross-reference unreachable files with duplicated files.
+ * Files that are BOTH dead code AND structurally duplicated are
+ * the highest-confidence safe-delete candidates.
+ *
+ * @param db - monograph database
+ */
+export declare function crossReferenceDuplicatesAndDeadCode(db: MonographDb): CrossReferenceReport;
+/**
+ * Format a CrossReferenceReport as structured text for LLM consumption.
+ */
+export declare function formatCrossReferenceReport(report: CrossReferenceReport): string;
+//# sourceMappingURL=cross-reference.d.ts.map

package/dist/src/graph/cross-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-reference.d.ts","sourceRoot":"","sources":["../../../src/graph/cross-reference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,YAAY,EAAE,gBAAgB,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAAC,EAAE,EAAE,WAAW,GAAG,oBAAoB,CAyFzF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAqB/E"}

package/dist/src/graph/cross-reference.js

@@ -0,0 +1,115 @@
+/**
+ * Cross-reference unreachable files with duplicated files.
+ * Files that are BOTH dead code AND structurally duplicated are
+ * the highest-confidence safe-delete candidates.
+ *
+ * @param db - monograph database
+ */
+export function crossReferenceDuplicatesAndDeadCode(db) {
+    // ── Step 1: Find dead (unreachable) file nodes ────────────────────────────
+    const deadRows = db.prepare(`
+    SELECT id, name, file_path
+    FROM nodes
+    WHERE label = 'File'
+      AND json_extract(properties, '$.reachabilityRole') = 'unreachable'
+  `).all();
+    const deadIds = new Set(deadRows.map(r => r.id));
+    const deadById = new Map(deadRows.map(r => [r.id, r]));
+    // ── Step 2: Find duplicated file nodes ───────────────────────────────────
+    // Primary: nodes connected by STRUCTURALLY_SIMILAR edges
+    let duplicateIds = new Set();
+    try {
+        const simRows = db.prepare(`
+      SELECT source_id, target_id
+      FROM edges
+      WHERE relation = 'STRUCTURALLY_SIMILAR'
+    `).all();
+        for (const row of simRows) {
+            duplicateIds.add(row.source_id);
+            duplicateIds.add(row.target_id);
+        }
+    }
+    catch {
+        // relation may not exist in this graph
+    }
+    // Fallback: files with the same basename in multiple directories
+    if (duplicateIds.size === 0) {
+        const allFiles = db.prepare(`
+      SELECT id, file_path
+      FROM nodes
+      WHERE label = 'File' AND file_path IS NOT NULL
+    `).all();
+        const byBasename = new Map();
+        for (const { id, file_path } of allFiles) {
+            const lastSlash = Math.max(file_path.lastIndexOf('/'), file_path.lastIndexOf('\\'));
+            const base = lastSlash === -1 ? file_path : file_path.slice(lastSlash + 1);
+            if (!byBasename.has(base))
+                byBasename.set(base, []);
+            byBasename.get(base).push(id);
+        }
+        for (const ids of byBasename.values()) {
+            if (ids.length > 1) {
+                for (const id of ids)
+                    duplicateIds.add(id);
+            }
+        }
+    }
+    // ── Step 3: Cross-reference ──────────────────────────────────────────────
+    const crossIds = [];
+    for (const id of deadIds) {
+        if (duplicateIds.has(id))
+            crossIds.push(id);
+    }
+    // ── Step 4: Build findings ───────────────────────────────────────────────
+    const findings = crossIds.map(id => {
+        const node = deadById.get(id);
+        return {
+            crossRefType: 'dead+duplicate',
+            nodeIds: [id],
+            description: `File "${node.name}" is both unreachable (dead code) and structurally duplicated — highest-confidence safe-delete candidate.`,
+            title: 'Unreachable duplicate file',
+            severity: 'warning',
+            nodeId: id,
+            nodeName: node.name,
+            filePath: node.file_path,
+            actions: [
+                {
+                    type: 'delete',
+                    file: node.file_path ?? undefined,
+                    description: 'Safe to remove — file is both unreachable and duplicated',
+                    confidence: 'high',
+                },
+            ],
+        };
+    });
+    return {
+        findings,
+        deadCount: deadIds.size,
+        duplicateCount: duplicateIds.size,
+        crossCount: crossIds.length,
+    };
+}
+/**
+ * Format a CrossReferenceReport as structured text for LLM consumption.
+ */
+export function formatCrossReferenceReport(report) {
+    const lines = [
+        `Cross-reference analysis: dead code × structural duplicates`,
+        `  Dead (unreachable) file nodes : ${report.deadCount}`,
+        `  Duplicated file nodes         : ${report.duplicateCount}`,
+        `  Both dead AND duplicated      : ${report.crossCount}  (highest-confidence safe-delete candidates)`,
+    ];
+    if (report.crossCount === 0) {
+        lines.push('  No cross-referenced candidates found.');
+        return lines.join('\n');
+    }
+    lines.push('');
+    lines.push('Safe-delete candidates:');
+    for (const f of report.findings) {
+        const loc = f.filePath ? `  ${f.filePath}` : `  (no path) ${f.nodeName}`;
+        lines.push(loc);
+        lines.push(`    ${f.description}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=cross-reference.js.map

package/dist/src/graph/cross-reference.js.map

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

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

@@ -0,0 +1,8 @@
+export interface CycleGroup {
+    files: string[];
+    length: number;
+}
+export declare function findCycles(fileIds: number[], edges: Map<number, number[]>, idToPath: Map<number, string>, skipTypeOnly?: boolean, typeOnlyEdges?: Set<string>): CycleGroup[];
+/** Format cycle groups as structured text for LLM consumption. */
+export declare function formatCycleGroups(groups: CycleGroup[]): string;
+//# sourceMappingURL=cycle-detection.d.ts.map

package/dist/src/graph/cycle-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-detection.d.ts","sourceRoot":"","sources":["../../../src/graph/cycle-detection.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAwID,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,YAAY,UAAQ,EACpB,aAAa,GAAE,GAAG,CAAC,MAAM,CAAa,GACrC,UAAU,EAAE,CAyJd;AAED,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAS9D"}

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

@@ -0,0 +1,233 @@
+function canonicalCycle(cycle, idToPath) {
+    if (cycle.length === 0)
+        return [];
+    let minPos = 0;
+    let minPath = idToPath.get(cycle[0]) ?? '';
+    for (let i = 1; i < cycle.length; i++) {
+        const p = idToPath.get(cycle[i]) ?? '';
+        if (p < minPath) {
+            minPath = p;
+            minPos = i;
+        }
+    }
+    if (minPos === 0)
+        return cycle.slice(); // already canonical — single allocation
+    // Single-pass rotation without 3 intermediate arrays (2x slice + spread)
+    const n = cycle.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++)
+        result[i] = cycle[(minPos + i) % n];
+    return result;
+}
+function tryRecordCycle(path, idToPath, seen, cycles) {
+    const canonical = canonicalCycle(path, idToPath);
+    const key = canonical.join(',');
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    cycles.push(canonical);
+}
+function dfsFindCyclesFrom(start, depthLimit, sccSet, allSuccs, succRanges, maxCycles, seen, cycles, idToPath) {
+    const path = [start];
+    const pathSet = new Set([start]);
+    const range = succRanges.get(start) ?? [0, 0];
+    const dfs = [{ succPos: range[0], succEnd: range[1] }];
+    while (dfs.length > 0) {
+        if (cycles.length >= maxCycles)
+            return;
+        const frame = dfs[dfs.length - 1];
+        if (frame.succPos >= frame.succEnd) {
+            dfs.pop();
+            if (path.length > 1) {
+                const removed = path.pop();
+                pathSet.delete(removed);
+            }
+            continue;
+        }
+        const w = allSuccs[frame.succPos];
+        frame.succPos++;
+        if (!sccSet.has(w))
+            continue;
+        if (w === start && path.length >= 2 && path.length === depthLimit) {
+            tryRecordCycle(path, idToPath, seen, cycles);
+            continue;
+        }
+        if (pathSet.has(w) || path.length >= depthLimit)
+            continue;
+        path.push(w);
+        pathSet.add(w);
+        const wRange = succRanges.get(w) ?? [0, 0];
+        dfs.push({ succPos: wRange[0], succEnd: wRange[1] });
+    }
+}
+function enumerateElementaryCycles(sccNodes, allSuccs, succRanges, maxCycles, idToPath, skipTypeOnly, typeOnlyEdges) {
+    const sccSet = new Set(sccNodes);
+    const cycles = [];
+    const seen = new Set();
+    // Use slice() rather than spread to avoid the iterator allocation overhead
+    const sortedNodes = sccNodes.slice().sort((a, b) => {
+        const pa = idToPath.get(a) ?? '';
+        const pb = idToPath.get(b) ?? '';
+        return pa < pb ? -1 : pa > pb ? 1 : 0;
+    });
+    const maxDepth = Math.min(sccNodes.length, 12);
+    for (let depthLimit = 2; depthLimit <= maxDepth; depthLimit++) {
+        if (cycles.length >= maxCycles)
+            break;
+        for (const start of sortedNodes) {
+            if (cycles.length >= maxCycles)
+                break;
+            dfsFindCyclesFrom(start, depthLimit, sccSet, allSuccs, succRanges, maxCycles, seen, cycles, idToPath);
+        }
+    }
+    return cycles;
+}
+export function findCycles(fileIds, edges, idToPath, skipTypeOnly = false, typeOnlyEdges = new Set()) {
+    const n = fileIds.length;
+    if (n === 0)
+        return [];
+    const idIndex = new Map();
+    for (let i = 0; i < fileIds.length; i++) {
+        idIndex.set(fileIds[i], i);
+    }
+    const allSuccs = [];
+    const succRanges = new Map();
+    for (const id of fileIds) {
+        const start = allSuccs.length;
+        const seen = new Set();
+        const neighbors = edges.get(id) ?? [];
+        for (const neighbor of neighbors) {
+            if (skipTypeOnly && typeOnlyEdges.has(`${id}→${neighbor}`))
+                continue;
+            if (idIndex.has(neighbor) && !seen.has(neighbor)) {
+                seen.add(neighbor);
+                allSuccs.push(neighbor);
+            }
+        }
+        succRanges.set(id, [start, allSuccs.length]);
+    }
+    const UNDEF = 0xffffffff;
+    const indices = new Array(n).fill(UNDEF);
+    const lowlinks = new Array(n).fill(0);
+    const onStack = new Array(n).fill(false);
+    const stack = [];
+    const sccs = [];
+    let indexCounter = 0;
+    const dfsStack = [];
+    for (let startI = 0; startI < n; startI++) {
+        if (indices[startI] !== UNDEF)
+            continue;
+        const startId = fileIds[startI];
+        indices[startI] = indexCounter;
+        lowlinks[startI] = indexCounter;
+        indexCounter++;
+        onStack[startI] = true;
+        stack.push(startI);
+        const startRange = succRanges.get(startId) ?? [0, 0];
+        dfsStack.push({ node: startI, succPos: startRange[0], succEnd: startRange[1] });
+        while (dfsStack.length > 0) {
+            const frame = dfsStack[dfsStack.length - 1];
+            if (frame.succPos < frame.succEnd) {
+                const wId = allSuccs[frame.succPos];
+                frame.succPos++;
+                const wI = idIndex.get(wId);
+                if (wI === undefined)
+                    continue;
+                if (indices[wI] === UNDEF) {
+                    indices[wI] = indexCounter;
+                    lowlinks[wI] = indexCounter;
+                    indexCounter++;
+                    onStack[wI] = true;
+                    stack.push(wI);
+                    const wId2 = fileIds[wI];
+                    const wRange = succRanges.get(wId2) ?? [0, 0];
+                    dfsStack.push({ node: wI, succPos: wRange[0], succEnd: wRange[1] });
+                }
+                else if (onStack[wI]) {
+                    const v = frame.node;
+                    if (indices[wI] < lowlinks[v]) {
+                        lowlinks[v] = indices[wI];
+                    }
+                }
+            }
+            else {
+                const v = frame.node;
+                const vLowlink = lowlinks[v];
+                const vIndex = indices[v];
+                dfsStack.pop();
+                if (dfsStack.length > 0) {
+                    const parent = dfsStack[dfsStack.length - 1];
+                    if (vLowlink < lowlinks[parent.node]) {
+                        lowlinks[parent.node] = vLowlink;
+                    }
+                }
+                if (vLowlink === vIndex) {
+                    const scc = [];
+                    while (true) {
+                        const w = stack.pop();
+                        onStack[w] = false;
+                        scc.push(fileIds[w]);
+                        if (w === v)
+                            break;
+                    }
+                    if (scc.length >= 2) {
+                        sccs.push(scc);
+                    }
+                }
+            }
+        }
+    }
+    const MAX_CYCLES_PER_SCC = 20;
+    const result = [];
+    const seenCycles = new Set();
+    for (const scc of sccs) {
+        if (scc.length === 2) {
+            const pathA = idToPath.get(scc[0]) ?? '';
+            const pathB = idToPath.get(scc[1]) ?? '';
+            const cycle = pathA <= pathB ? [scc[0], scc[1]] : [scc[1], scc[0]];
+            const key = cycle.join(',');
+            if (!seenCycles.has(key)) {
+                seenCycles.add(key);
+                result.push(cycle);
+            }
+            continue;
+        }
+        const elementary = enumerateElementaryCycles(scc, allSuccs, succRanges, MAX_CYCLES_PER_SCC, idToPath, skipTypeOnly, typeOnlyEdges);
+        for (const cycle of elementary) {
+            const key = cycle.join(',');
+            if (!seenCycles.has(key)) {
+                seenCycles.add(key);
+                result.push(cycle);
+            }
+        }
+    }
+    result.sort((a, b) => {
+        if (a.length !== b.length)
+            return a.length - b.length;
+        const pa = idToPath.get(a[0]) ?? '';
+        const pb = idToPath.get(b[0]) ?? '';
+        return pa < pb ? -1 : pa > pb ? 1 : 0;
+    });
+    return result.map(cycle => ({
+        // slice() instead of spread to avoid iterator overhead
+        files: cycle.slice()
+            .sort((a, b) => (idToPath.get(a) ?? '').localeCompare(idToPath.get(b) ?? ''))
+            .map(id => idToPath.get(id) ?? String(id)),
+        length: cycle.length,
+    }));
+}
+/** Format cycle groups as structured text for LLM consumption. */
+export function formatCycleGroups(groups) {
+    if (groups.length === 0)
+        return 'No import cycles detected.';
+    const lines = [`Import Cycles (${groups.length} total):`];
+    for (const g of groups.slice(0, 30)) {
+        lines.push(`\n  Cycle (length ${g.length}):`);
+        for (const f of g.files)
+            lines.push(`    ${f}`);
+    }
+    if (groups.length > 30)
+        lines.push(`\n  ... and ${groups.length - 30} more cycles`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=cycle-detection.js.map