@monoes/monograph 1.5.6 → 1.5.8

package/src/graph/complexity.ts

@@ -1,200 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface FunctionComplexity {
-  nodeId: string;
-  name: string;
-  filePath: string | null;
-  startLine: number | null;
-  endLine: number | null;
-  cyclomaticComplexity: number;   // decision points + 1
-  cognitiveComplexity: number;    // cognitive weight (nesting multiplier)
-  linesOfCode: number;
-  paramCount: number;
-  crapScore: number;              // CC² × (1 - coverage)³ + CC (coverage defaults to 0 when unknown)
-}
-
-export interface ComplexityReport {
-  functions: FunctionComplexity[];
-  p50cc: number;
-  p90cc: number;
-  p95cc: number;
-  highComplexityCount: number;   // CC > 10
-  criticalCount: number;          // CC > 20
-}
-
-/**
- * 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: number, coverage: number): number {
-  const cov = Math.max(0, Math.min(1, coverage));
-  return cc * cc * Math.pow(1 - cov, 3) + cc;
-}
-
-function percentile(arr: number[], p: number): number {
-  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: MonographDb): ComplexityReport {
-  // 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() as Array<{
-    id: string;
-    name: string;
-    file_path: string | null;
-    start_line: number | null;
-    end_line: number | null;
-    properties: string | null;
-  }>;
-
-  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<string, number>();
-  for (const { source_id, c } of db.prepare(`
-    SELECT source_id, COUNT(*) as c FROM edges WHERE relation = 'CALLS' GROUP BY source_id
-  `).all() as { source_id: string; c: number }[]) {
-    callsMap.set(source_id, c);
-  }
-
-  const accessesMap = new Map<string, number>();
-  for (const { source_id, c } of db.prepare(`
-    SELECT source_id, COUNT(*) as c FROM edges WHERE relation = 'ACCESSES' GROUP BY source_id
-  `).all() as { source_id: string; c: number }[]) {
-    accessesMap.set(source_id, c);
-  }
-
-  // ── Compute metrics for each function ────────────────────────────────────
-  const functions: FunctionComplexity[] = [];
-  const propUpdates: Array<{ id: string; props: string }> = [];
-
-  for (const row of rows) {
-    const props = row.properties ? JSON.parse(row.properties) as Record<string, unknown> : {};
-
-    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: typeof propUpdates) => {
-    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: ComplexityReport, topN = 10): string {
-  const { functions, p50cc, p90cc, p95cc, highComplexityCount, criticalCount } = report;
-
-  if (functions.length === 0) {
-    return 'complexity: no Function/Method nodes found in graph\n';
-  }
-
-  const lines: string[] = [
-    `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');
-}

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

@@ -1,85 +0,0 @@
-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 function crossReference(duplication: CrossRefDuplicationReport, deadCode: CrossRefDeadCodeSummary): CrossReferenceResult {
-  const findings: CombinedFinding[] = [];
-  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<string, Array<{ exportName: string; line: number }>>();
-  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<string, Array<{ typeName: string; line: number }>>();
-  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: CrossReferenceResult): Set<number> {
-  return new Set(result.combinedFindings.map(f => f.groupIndex));
-}

package/src/graph/cross-reference.ts

@@ -1,139 +0,0 @@
-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;   // nodes that are BOTH dead AND duplicated
-}
-
-/**
- * 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: MonographDb): CrossReferenceReport {
-  // ── 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() as { id: string; name: string; file_path: string | null }[];
-
-  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<string>();
-
-  try {
-    const simRows = db.prepare(`
-      SELECT source_id, target_id
-      FROM edges
-      WHERE relation = 'STRUCTURALLY_SIMILAR'
-    `).all() as { source_id: string; target_id: string }[];
-
-    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() as { id: string; file_path: string }[];
-
-    const byBasename = new Map<string, string[]>();
-    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: string[] = [];
-  for (const id of deadIds) {
-    if (duplicateIds.has(id)) crossIds.push(id);
-  }
-
-  // ── Step 4: Build findings ───────────────────────────────────────────────
-  const findings: CrossReferenceFinding[] = 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: CrossReferenceReport): string {
-  const lines: string[] = [
-    `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');
-}