@monoes/monograph 1.5.6 → 1.5.8

package/src/export/svg.ts

@@ -1,68 +0,0 @@
-import type { MonographNode, MonographEdge } from '../types.js';
-
-const W = 1200;
-const H = 800;
-
-export function toSvg(nodes: MonographNode[], edges: MonographEdge[]): string {
-  const positions = forceLayout(nodes.slice(0, 200));
-
-  const edgeSvg = edges
-    .filter(e => positions.has(e.sourceId) && positions.has(e.targetId))
-    .map(e => {
-      const s = positions.get(e.sourceId)!;
-      const t = positions.get(e.targetId)!;
-      return `<line x1="${s.x}" y1="${s.y}" x2="${t.x}" y2="${t.y}" stroke="#94a3b8" stroke-width="1" opacity="0.5"/>`;
-    })
-    .join('\n');
-
-  const COMMUNITY_COLORS = [
-    '#3b82f6','#ef4444','#22c55e','#f59e0b','#8b5cf6',
-    '#ec4899','#14b8a6','#f97316','#06b6d4','#84cc16',
-  ];
-  const degree = new Map<string, number>();
-  for (const e of edges) {
-    degree.set(e.sourceId, (degree.get(e.sourceId) ?? 0) + 1);
-    degree.set(e.targetId, (degree.get(e.targetId) ?? 0) + 1);
-  }
-
-  const nodeSvg = [...positions.entries()]
-    .map(([id, pos]) => {
-      const node = nodes.find(n => n.id === id);
-      const label = node?.name ?? id;
-      const deg = degree.get(id) ?? 0;
-      const r = Math.max(4, Math.min(16, 4 + deg));
-      const color = COMMUNITY_COLORS[(node?.communityId ?? 0) % COMMUNITY_COLORS.length];
-      return (
-        `<circle cx="${pos.x}" cy="${pos.y}" r="${r}" fill="${color}" stroke="#1e293b" stroke-width="0.5" opacity="0.85"/>` +
-        `<text x="${pos.x + r + 2}" y="${pos.y + 4}" font-size="10" fill="#1e293b">${sanitizeLabel(label)}</text>`
-      );
-    })
-    .join('\n');
-
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}">
-<defs>
-<style>
-  text { font-family: system-ui, -apple-system, sans-serif; user-select: none; }
-</style>
-</defs>
-<rect width="${W}" height="${H}" fill="#f8fafc"/>
-${edgeSvg}
-${nodeSvg}
-</svg>`;
-}
-
-function forceLayout(nodes: MonographNode[]): Map<string, { x: number; y: number }> {
-  const positions = new Map<string, { x: number; y: number }>();
-  nodes.forEach((n, i) => {
-    const angle = (i / Math.max(nodes.length, 1)) * 2 * Math.PI;
-    positions.set(n.id, {
-      x: W / 2 + Math.cos(angle) * (W * 0.35),
-      y: H / 2 + Math.sin(angle) * (H * 0.35),
-    });
-  });
-  return positions;
-}
-
-function sanitizeLabel(s: string): string {
-  return s.substring(0, 20).replace(/[&<>"']/g, '_');
-}

package/src/fix/deps.ts

@@ -1,70 +0,0 @@
-import { readFileSync, writeFileSync, renameSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-export interface DepFix {
-  packageJsonPath: string;
-  packageName: string;
-  section: 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
-}
-
-export interface DepFixResult {
-  packageJsonPath: string;
-  removed: string[];
-  dryRun: boolean;
-}
-
-export function fixUnusedDeps(
-  fixes: DepFix[],
-  options?: { dryRun?: boolean }
-): DepFixResult[] {
-  const dryRun = options?.dryRun ?? false;
-
-  // Group fixes by packageJsonPath
-  const byFile = new Map<string, DepFix[]>();
-  for (const fix of fixes) {
-    const existing = byFile.get(fix.packageJsonPath) ?? [];
-    existing.push(fix);
-    byFile.set(fix.packageJsonPath, existing);
-  }
-
-  const results: DepFixResult[] = [];
-
-  for (const [packageJsonPath, fileFixes] of byFile) {
-    let raw: string;
-    let pkg: Record<string, unknown>;
-
-    try {
-      raw = readFileSync(packageJsonPath, 'utf8');
-      pkg = JSON.parse(raw) as Record<string, unknown>;
-    } catch {
-      // Skip invalid or unreadable files
-      continue;
-    }
-
-    const removed: string[] = [];
-
-    for (const fix of fileFixes) {
-      const section = pkg[fix.section] as Record<string, unknown> | undefined;
-      if (section && typeof section === 'object' && fix.packageName in section) {
-        delete section[fix.packageName];
-        removed.push(fix.packageName);
-      }
-    }
-
-    if (!dryRun && removed.length > 0) {
-      const newContent = JSON.stringify(pkg, null, 2) + '\n';
-      const tmpFile = join(tmpdir(), `monograph-deps-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-      writeFileSync(tmpFile, newContent, 'utf8');
-      renameSync(tmpFile, packageJsonPath);
-    }
-
-    results.push({
-      packageJsonPath,
-      removed,
-      dryRun,
-    });
-  }
-
-  return results;
-}

package/src/fix/enum-members.ts

@@ -1,103 +0,0 @@
-import { readFileSync, writeFileSync, renameSync } from 'fs';
-
-const EXPORTED_ENUM_RE = /^\s*(export\s+)?(declare\s+)?(const\s+)?enum\s+(\w+)/;
-
-export function declaresExportedEnum(line: string): { name: string } | null {
-  const m = line.match(EXPORTED_ENUM_RE);
-  if (!m) return null;
-  const name = m[4];
-  if (!name) return null;
-  // must have "export" somewhere in the prefix parts
-  if (!line.match(/\bexport\b/)) return null;
-  return { name };
-}
-
-export function findEnumDeclarationRange(lines: string[], enumName: string): [number, number] | null {
-  for (let i = 0; i < lines.length; i++) {
-    const d = declaresExportedEnum(lines[i]!);
-    if (d?.name !== enumName) continue;
-    let depth = 0;
-    for (let j = i; j < lines.length; j++) {
-      for (const ch of lines[j]!) {
-        if (ch === '{') depth++;
-        else if (ch === '}') {
-          depth--;
-          if (depth === 0) return [i, j];
-        }
-      }
-    }
-  }
-  return null;
-}
-
-export function isEnumBodyEmpty(lines: string[], range: [number, number]): boolean {
-  const body = lines.slice(range[0] + 1, range[1]).join('\n');
-  return body.replace(/[,\s]/g, '').length === 0;
-}
-
-export function removeEnumMember(source: string, memberName: string, enumName: string): string {
-  const lines = source.split('\n');
-  const range = findEnumDeclarationRange(lines, enumName);
-  if (!range) return source;
-
-  // Find the member line within the enum body
-  const memberRe = new RegExp(`^\\s*${escapeRegex(memberName)}\\s*[,=]?`);
-  let memberLine = -1;
-  for (let i = range[0] + 1; i < range[1]; i++) {
-    if (memberRe.test(lines[i]!)) { memberLine = i; break; }
-  }
-  if (memberLine === -1) return source;
-
-  const newLines = lines.filter((_, idx) => idx !== memberLine);
-  const newSource = newLines.join('\n');
-
-  // Check if the enum body is now empty → remove the whole declaration
-  const newRange = findEnumDeclarationRange(newLines, enumName);
-  if (newRange && isEnumBodyEmpty(newLines, newRange)) {
-    return newLines.filter((_, idx) => idx < newRange[0] || idx > newRange[1]).join('\n');
-  }
-  return newSource;
-}
-
-function escapeRegex(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export interface EnumMemberFix {
-  filePath: string;
-  enumName: string;
-  memberName: string;
-}
-
-export interface EnumMemberFixResult {
-  fixed: EnumMemberFix[];
-  errors: Array<{ fix: EnumMemberFix; error: string }>;
-}
-
-export function fixEnumMembers(fixes: EnumMemberFix[]): EnumMemberFixResult {
-  const result: EnumMemberFixResult = { fixed: [], errors: [] };
-  // Group by file, apply all member fixes to the same source
-  const byFile = new Map<string, EnumMemberFix[]>();
-  for (const fix of fixes) {
-    const arr = byFile.get(fix.filePath) ?? [];
-    arr.push(fix);
-    byFile.set(fix.filePath, arr);
-  }
-  for (const [filePath, fileFixes] of byFile) {
-    try {
-      let source = readFileSync(filePath, 'utf8');
-      for (const fix of fileFixes) {
-        source = removeEnumMember(source, fix.memberName, fix.enumName);
-      }
-      const tmp = filePath + '.tmp';
-      writeFileSync(tmp, source, 'utf8');
-      renameSync(tmp, filePath);
-      result.fixed.push(...fileFixes);
-    } catch (err) {
-      for (const fix of fileFixes) {
-        result.errors.push({ fix, error: String(err) });
-      }
-    }
-  }
-  return result;
-}

package/src/fix/export-surgery.ts

@@ -1,197 +0,0 @@
-export interface ExportSurgeryResult {
-  modified: boolean;
-  newContent: string;
-  linesRemoved: number;
-}
-
-const EXPORT_LIST_RE = /^(\s*)(export\s+)(type\s+)?\{([^}]*)\}(.*)$/;
-
-function findExportSpan(lines: string[], startIdx: number): { startIdx: number; endIdx: number; fullText: string } {
-  let text = lines[startIdx];
-  let endIdx = startIdx;
-
-  if (!text.includes('{')) {
-    return { startIdx, endIdx, fullText: text };
-  }
-
-  if (text.includes('}')) {
-    return { startIdx, endIdx, fullText: text };
-  }
-
-  for (let i = startIdx + 1; i < lines.length; i++) {
-    text += '\n' + lines[i];
-    endIdx = i;
-    if (lines[i].includes('}')) break;
-  }
-
-  return { startIdx, endIdx, fullText: text };
-}
-
-function removeSpecifierFromList(specifierList: string, exportName: string): string | null {
-  const specifiers = specifierList.split(',').map(s => s.trim()).filter(Boolean);
-
-  const filtered = specifiers.filter(spec => {
-    const baseName = spec.split(/\s+as\s+/)[0].trim();
-    return baseName !== exportName;
-  });
-
-  if (filtered.length === specifiers.length) return null;
-
-  return filtered.join(', ');
-}
-
-function applySurgery(
-  fileContent: string,
-  exportName: string,
-  line: number,
-  expectType: boolean | null,
-): ExportSurgeryResult {
-  const lines = fileContent.split('\n');
-  const idx = line - 1;
-
-  if (idx < 0 || idx >= lines.length) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const { startIdx, endIdx, fullText } = findExportSpan(lines, idx);
-
-  const singleLineMatch = fullText.replace(/\n/g, ' ').match(EXPORT_LIST_RE);
-  if (!singleLineMatch) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const indent = singleLineMatch[1];
-  const exportKw = singleLineMatch[2];
-  const typeKw = singleLineMatch[3] ?? '';
-  const specifierList = singleLineMatch[4];
-  const tail = singleLineMatch[5];
-
-  if (expectType === true && !typeKw) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-  if (expectType === false && typeKw) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const newList = removeSpecifierFromList(specifierList, exportName);
-
-  if (newList === null) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const spanSize = endIdx - startIdx + 1;
-  const newLines = [...lines];
-
-  if (newList.trim() === '') {
-    newLines.splice(startIdx, spanSize);
-    return {
-      modified: true,
-      newContent: newLines.join('\n'),
-      linesRemoved: spanSize,
-    };
-  }
-
-  const replacement = `${indent}${exportKw}${typeKw}{ ${newList} }${tail}`;
-  newLines.splice(startIdx, spanSize, replacement);
-  return {
-    modified: true,
-    newContent: newLines.join('\n'),
-    linesRemoved: spanSize - 1,
-  };
-}
-
-export function removeNameFromExportList(
-  fileContent: string,
-  exportName: string,
-  line: number,
-): ExportSurgeryResult {
-  return applySurgery(fileContent, exportName, line, false);
-}
-
-export function removeTypeFromExportList(
-  fileContent: string,
-  exportName: string,
-  line: number,
-): ExportSurgeryResult {
-  return applySurgery(fileContent, exportName, line, true);
-}
-
-export function promoteToTypeExport(
-  fileContent: string,
-  exportName: string,
-  line: number,
-): ExportSurgeryResult {
-  const lines = fileContent.split('\n');
-  const idx = line - 1;
-
-  if (idx < 0 || idx >= lines.length) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const { startIdx, endIdx, fullText } = findExportSpan(lines, idx);
-
-  const normalised = fullText.replace(/\n/g, ' ');
-  const match = normalised.match(EXPORT_LIST_RE);
-  if (!match || match[3]) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const indent = match[1];
-  const specifierList = match[4];
-  const tail = match[5];
-
-  const specifiers = specifierList.split(',').map(s => s.trim()).filter(Boolean);
-  const target = specifiers.find(spec => spec.split(/\s+as\s+/)[0].trim() === exportName);
-  if (!target) {
-    return { modified: false, newContent: fileContent, linesRemoved: 0 };
-  }
-
-  const remaining = specifiers.filter(spec => spec.split(/\s+as\s+/)[0].trim() !== exportName);
-  const spanSize = endIdx - startIdx + 1;
-  const newLines = [...lines];
-
-  const typeExportLine = `${indent}export type { ${target} }`;
-
-  if (remaining.length === 0) {
-    newLines.splice(startIdx, spanSize, typeExportLine);
-  } else {
-    const valueExportLine = `${indent}export { ${remaining.join(', ')} }${tail}`;
-    newLines.splice(startIdx, spanSize, valueExportLine, typeExportLine);
-  }
-
-  return {
-    modified: true,
-    newContent: newLines.join('\n'),
-    linesRemoved: spanSize - newLines.length + lines.length,
-  };
-}
-
-export function applyExportSurgeries(
-  fileContent: string,
-  surgeries: Array<{ exportName: string; line: number; action: 'remove' | 'remove-type' | 'promote-type' }>,
-): ExportSurgeryResult {
-  const sorted = [...surgeries].sort((a, b) => b.line - a.line);
-
-  let content = fileContent;
-  let totalLinesRemoved = 0;
-  let anyModified = false;
-
-  for (const surgery of sorted) {
-    let result: ExportSurgeryResult;
-    if (surgery.action === 'remove') {
-      result = removeNameFromExportList(content, surgery.exportName, surgery.line);
-    } else if (surgery.action === 'remove-type') {
-      result = removeTypeFromExportList(content, surgery.exportName, surgery.line);
-    } else {
-      result = promoteToTypeExport(content, surgery.exportName, surgery.line);
-    }
-
-    if (result.modified) {
-      content = result.newContent;
-      totalLinesRemoved += result.linesRemoved;
-      anyModified = true;
-    }
-  }
-
-  return { modified: anyModified, newContent: content, linesRemoved: totalLinesRemoved };
-}

package/src/fix/exports.ts

@@ -1,93 +0,0 @@
-import { readFileSync, writeFileSync, renameSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-export interface ExportFix {
-  filePath: string;
-  exportName: string;
-  lineNumber: number;
-  fixType: 'remove-export-keyword' | 'remove-entire-declaration';
-}
-
-export interface FixResult {
-  filePath: string;
-  fixesApplied: number;
-  dryRun: boolean;
-  diff: string[];   // before/after lines for dry-run display
-}
-
-export function fixUnusedExports(
-  fixes: ExportFix[],
-  options?: { dryRun?: boolean }
-): FixResult[] {
-  const dryRun = options?.dryRun ?? false;
-
-  // Group fixes by filePath
-  const byFile = new Map<string, ExportFix[]>();
-  for (const fix of fixes) {
-    const existing = byFile.get(fix.filePath) ?? [];
-    existing.push(fix);
-    byFile.set(fix.filePath, existing);
-  }
-
-  const results: FixResult[] = [];
-
-  for (const [filePath, fileFixes] of byFile) {
-    let content: string;
-    try {
-      content = readFileSync(filePath, 'utf8');
-    } catch {
-      // Skip files we can't read
-      continue;
-    }
-
-    const lines = content.split('\n');
-    const diff: string[] = [];
-    let fixesApplied = 0;
-
-    // Sort by lineNumber descending to avoid line-shift bugs
-    const sortedFixes = [...fileFixes].sort((a, b) => b.lineNumber - a.lineNumber);
-
-    for (const fix of sortedFixes) {
-      const idx = fix.lineNumber - 1;
-      if (idx < 0 || idx >= lines.length) continue;
-
-      const originalLine = lines[idx];
-
-      if (fix.fixType === 'remove-export-keyword') {
-        // Remove the 'export ' prefix from the line
-        const newLine = originalLine.replace(
-          /^(\s*)export (default function|function|const|class|type|interface|default )/,
-          '$1$2'
-        );
-        if (newLine !== originalLine) {
-          diff.push(`- ${originalLine}`);
-          diff.push(`+ ${newLine}`);
-          lines[idx] = newLine;
-          fixesApplied++;
-        }
-      } else if (fix.fixType === 'remove-entire-declaration') {
-        diff.push(`- ${originalLine}`);
-        lines.splice(idx, 1);
-        fixesApplied++;
-      }
-    }
-
-    if (!dryRun && fixesApplied > 0) {
-      const newContent = lines.join('\n');
-      // Atomic write: temp file then rename
-      const tmpFile = join(tmpdir(), `monograph-fix-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-      writeFileSync(tmpFile, newContent, 'utf8');
-      renameSync(tmpFile, filePath);
-    }
-
-    results.push({
-      filePath,
-      fixesApplied,
-      dryRun,
-      diff,
-    });
-  }
-
-  return results;
-}

package/src/fix/orchestrator.ts

@@ -1,67 +0,0 @@
-export interface FixerAnalysisResults {
-  unusedExports: unknown[];
-  unusedDependencies: unknown[];
-  unusedEnumMembers: unknown[];
-}
-
-export interface FixOptions {
-  root: string;
-  output: 'human' | 'json';
-  dryRun: boolean;
-  yes: boolean;
-  quiet: boolean;
-}
-
-export interface FixRecord {
-  file: string;
-  kind: string;
-  name: string;
-  applied: boolean;
-  dryRun: boolean;
-}
-
-export type FixApplier = (root: string, results: FixerAnalysisResults, dryRun: boolean, out: FixRecord[]) => Promise<boolean>;
-
-export async function runFix(
-  results: FixerAnalysisResults,
-  opts: FixOptions,
-  appliers: {
-    exports?: FixApplier;
-    deps?: FixApplier;
-    enumMembers?: FixApplier;
-  } = {},
-): Promise<{ exitCode: number }> {
-  const isTTY = Boolean(process.stdin.isTTY);
-  if (!opts.dryRun && !opts.yes && !isTTY) {
-    const msg = 'fix requires --yes in non-interactive environments. Use --dry-run to preview first.';
-    if (opts.output === 'json') console.log(JSON.stringify({ error: msg }));
-    else console.error(`Error: ${msg}`);
-    return { exitCode: 2 };
-  }
-
-  const total = results.unusedExports.length + results.unusedDependencies.length + results.unusedEnumMembers.length;
-  if (total === 0) {
-    if (opts.output === 'json') console.log(JSON.stringify({ dryRun: opts.dryRun, fixes: [], total_fixed: 0 }));
-    else if (!opts.quiet) console.error('No issues to fix.');
-    return { exitCode: 0 };
-  }
-
-  const fixes: FixRecord[] = [];
-  let hadError = false;
-
-  if (appliers.exports && results.unusedExports.length > 0)
-    hadError ||= await appliers.exports(opts.root, results, opts.dryRun, fixes);
-  if (appliers.deps && results.unusedDependencies.length > 0)
-    hadError ||= await appliers.deps(opts.root, results, opts.dryRun, fixes);
-  if (appliers.enumMembers && results.unusedEnumMembers.length > 0)
-    hadError ||= await appliers.enumMembers(opts.root, results, opts.dryRun, fixes);
-
-  if (opts.output === 'json') {
-    const applied = fixes.filter(f => f.applied).length;
-    console.log(JSON.stringify({ dryRun: opts.dryRun, fixes, total_fixed: applied }, null, 2));
-  } else if (!opts.quiet) {
-    if (opts.dryRun) console.error('Dry run complete. No files were modified.');
-    else console.error(`Fixed ${fixes.filter(f => f.applied).length} issue(s).`);
-  }
-  return { exitCode: hadError ? 2 : 0 };
-}

package/src/graph/analyzer.ts

@@ -1,69 +0,0 @@
-import { bidirectional } from 'graphology-shortest-path';
-import betweennessCentrality from 'graphology-metrics/centrality/betweenness.js';
-import type Graph from 'graphology';
-import type { MonographDb } from '../storage/db.js';
-import { loadGraphFromDb } from './loader.js';
-
-// ── TTL graph cache ───────────────────────────────────────────────────────────
-// Avoids loading the full graph from the DB multiple times in the same request
-// window (e.g. when getShortestPath and getBetweennessCentrality are called
-// back-to-back on the same DB instance).
-
-const GRAPH_CACHE_TTL_MS = 30_000;
-
-interface CachedGraph {
-  graph: Graph;
-  expiresAt: number;
-}
-
-const graphCache = new WeakMap<object, CachedGraph>();
-
-function getOrLoadGraph(db: MonographDb): Graph {
-  const cached = graphCache.get(db);
-  if (cached && Date.now() < cached.expiresAt) return cached.graph;
-  const graph = loadGraphFromDb(db);
-  graphCache.set(db, { graph, expiresAt: Date.now() + GRAPH_CACHE_TTL_MS });
-  return graph;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-
-export function getShortestPath(
-  db: MonographDb,
-  sourceId: string,
-  targetId: string,
-  maxDepth = 6,
-): string[] | null {
-  const graph = getOrLoadGraph(db);
-  if (!graph.hasNode(sourceId) || !graph.hasNode(targetId)) return null;
-  try {
-    const path = bidirectional(graph, sourceId, targetId);
-    if (path && path.length <= maxDepth + 1) return path;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Computes betweenness centrality for all nodes in the graph.
- * Returns a Map from node id to centrality score (0–1 normalized).
- *
- * Betweenness centrality measures how often a node appears on the
- * shortest path between other node pairs. High-centrality nodes are
- * structural bridges — refactoring them has wide blast radius.
- */
-export function getBetweennessCentrality(db: MonographDb): Map<string, number> {
-  const graph = getOrLoadGraph(db);
-  if (graph.order === 0) return new Map();
-  const scores = betweennessCentrality(graph, { normalized: true });
-  return new Map(Object.entries(scores));
-}
-
-export function getNodeDegrees(graph: Graph, nodeId: string): { in: number; out: number } {
-  if (!graph.hasNode(nodeId)) return { in: 0, out: 0 };
-  return {
-    in: graph.inDegree ? graph.inDegree(nodeId) : 0,
-    out: graph.outDegree ? graph.outDegree(nodeId) : 0,
-  };
-}