@monoes/monograph 1.5.6 → 1.5.8

package/src/analysis/list.ts

@@ -1,74 +0,0 @@
-export interface BoundaryRule {
-  fromZone: string;
-  toZone: string;
-  allowed: boolean;
-}
-
-export interface PluginInfo {
-  name: string;
-  version: string;
-  hooks: string[];
-}
-
-export interface ListOptions {
-  format?: 'human' | 'json';
-}
-
-export function listBoundaries(config: {
-  zones?: Array<{ name: string; allowedDeps?: string[]; deniedDeps?: string[] }>;
-}): BoundaryRule[] {
-  const rules: BoundaryRule[] = [];
-  for (const zone of config.zones ?? []) {
-    for (const dep of zone.allowedDeps ?? []) {
-      rules.push({ fromZone: zone.name, toZone: dep, allowed: true });
-    }
-    for (const dep of zone.deniedDeps ?? []) {
-      rules.push({ fromZone: zone.name, toZone: dep, allowed: false });
-    }
-  }
-  return rules;
-}
-
-export function listPlugins(config: {
-  plugins?: Array<{ name: string; version?: string; hooks?: string[] }>;
-}): PluginInfo[] {
-  return (config.plugins ?? []).map((p) => ({
-    name: p.name,
-    version: p.version ?? '0.0.0',
-    hooks: p.hooks ?? [],
-  }));
-}
-
-export function listEntryPoints(config: { entryPoints?: string[] }): string[] {
-  return config.entryPoints ?? [];
-}
-
-export function formatListHuman(
-  items: Array<Record<string, unknown>>,
-  columns: string[]
-): string {
-  if (items.length === 0) return '';
-
-  // Calculate column widths from header and values
-  const widths = columns.map((col) => {
-    const headerLen = col.length;
-    const maxValueLen = items.reduce((max, item) => {
-      const val = item[col] !== undefined && item[col] !== null ? String(item[col]) : '';
-      return Math.max(max, val.length);
-    }, 0);
-    return Math.max(headerLen, maxValueLen);
-  });
-
-  const pad = (str: string, width: number): string => str.padEnd(width);
-
-  const header = columns.map((col, i) => pad(col, widths[i]!)).join('  ');
-  const separator = widths.map((w) => '-'.repeat(w)).join('  ');
-  const rows = items.map((item) =>
-    columns.map((col, i) => {
-      const val = item[col] !== undefined && item[col] !== null ? String(item[col]) : '';
-      return pad(val, widths[i]!);
-    }).join('  ')
-  );
-
-  return [header, separator, ...rows].join('\n');
-}

package/src/analysis/node-similarity.ts

@@ -1,115 +0,0 @@
-/**
- * Graph node similarity using Jaccard coefficient.
- *
- * Jaccard(A, B) = |A ∩ B| / |A ∪ B|
- *
- * Two nodes are similar if they share many common neighbors.
- * This is useful for finding structurally equivalent nodes or
- * recommending related modules in a codebase graph.
- */
-
-export type SimilarityEdge = { sourceId: string; targetId: string };
-
-export interface SimilarNode {
-  nodeId: string;
-  score: number;
-}
-
-/**
- * Build an undirected neighbor map from an edge list.
- * Callers that invoke findSimilarNodes for multiple nodes on the same edge set
- * should build once and pass the map directly to findSimilarNodesFromMap.
- */
-export function buildNeighborMap(
-  edges: SimilarityEdge[],
-): Map<string, Set<string>> {
-  const neighbors = new Map<string, Set<string>>();
-  for (const { sourceId, targetId } of edges) {
-    if (!neighbors.has(sourceId)) neighbors.set(sourceId, new Set());
-    if (!neighbors.has(targetId)) neighbors.set(targetId, new Set());
-    neighbors.get(sourceId)!.add(targetId);
-    neighbors.get(targetId)!.add(sourceId);
-  }
-  return neighbors;
-}
-
-/**
- * Compute the Jaccard similarity between two sets.
- * Returns 0 when both sets are empty.
- */
-export function jaccardSimilarity(a: Set<string>, b: Set<string>): number {
-  if (a.size === 0 && b.size === 0) return 0;
-  let intersection = 0;
-  for (const item of a) {
-    if (b.has(item)) intersection++;
-  }
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-/**
- * Find the k most similar nodes to `nodeId` using a pre-built neighbor map.
- *
- * Use this variant when querying multiple nodes against the same edge set —
- * build the map once with `buildNeighborMap` and reuse it across calls.
- *
- * Only nodes with score > 0 are returned (no shared neighbors → excluded).
- * Results are sorted descending by score.
- */
-export function findSimilarNodesFromMap(
-  nodeId: string,
-  neighborMap: Map<string, Set<string>>,
-  k: number,
-): SimilarNode[] {
-  const targetNeighbors = neighborMap.get(nodeId);
-  if (!targetNeighbors || targetNeighbors.size === 0) return [];
-
-  const results: SimilarNode[] = [];
-  for (const [candidate, candidateNeighbors] of neighborMap) {
-    if (candidate === nodeId) continue;
-    const score = jaccardSimilarity(targetNeighbors, candidateNeighbors);
-    if (score > 0) {
-      results.push({ nodeId: candidate, score });
-    }
-  }
-
-  results.sort((a, b) => b.score - a.score);
-  return results.slice(0, k);
-}
-
-/**
- * Find the k most similar nodes to `nodeId` by Jaccard neighbor overlap.
- *
- * Builds the neighbor map from `edges` on each call. For repeated queries
- * over the same edge set, prefer `buildNeighborMap` + `findSimilarNodesFromMap`.
- *
- * Only nodes with score > 0 are returned (no shared neighbors → excluded).
- * Results are sorted descending by score.
- */
-export function findSimilarNodes(
-  nodeId: string,
-  edges: SimilarityEdge[],
-  k: number,
-): SimilarNode[] {
-  return findSimilarNodesFromMap(nodeId, buildNeighborMap(edges), k);
-}
-
-/**
- * Format similar-node results as structured text for LLM consumption.
- */
-export function formatSimilarNodes(
-  nodeId: string,
-  results: SimilarNode[],
-  nodeLabels?: Map<string, string>,
-): string {
-  if (results.length === 0) {
-    return `No structurally similar nodes found for: ${nodeId}`;
-  }
-  const lines: string[] = [`Similar nodes to ${nodeId} (Jaccard neighbor overlap):`];
-  for (const { nodeId: id, score } of results) {
-    const label = nodeLabels?.get(id);
-    const suffix = label ? ` [${label}]` : '';
-    lines.push(`  ${(score * 100).toFixed(1)}%  ${id}${suffix}`);
-  }
-  return lines.join('\n');
-}

package/src/analysis/private-type-leaks.ts

@@ -1,119 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface PrivateTypeLeak {
-  exportNodeId: string;
-  exportName: string;
-  exportFilePath: string | null;
-  exportStartLine: number | null;
-  leakedTypeNodeId: string;
-  leakedTypeName: string;
-  leakedTypeFilePath: string | null;
-  leakedTypeStartLine: number | null;
-  reason: string;
-}
-
-export interface PrivateTypeLeaksResult {
-  leaks: PrivateTypeLeak[];
-  totalLeaks: number;
-  affectedExports: number;
-}
-
-interface LeakRow {
-  source_id: string;
-  target_id: string;
-  src_name: string;
-  src_path: string | null;
-  src_line: number | null;
-  tgt_name: string;
-  tgt_path: string | null;
-  tgt_line: number | null;
-}
-
-export function detectPrivateTypeLeaks(db: MonographDb): PrivateTypeLeaksResult {
-  const rows = db.prepare(`
-    SELECT e.source_id, e.target_id,
-           n1.name as src_name, n1.file_path as src_path, n1.start_line as src_line,
-           n2.name as tgt_name, n2.file_path as tgt_path, n2.start_line as tgt_line
-    FROM edges e
-    JOIN nodes n1 ON n1.id = e.source_id
-    JOIN nodes n2 ON n2.id = e.target_id
-    WHERE e.relation IN ('IMPORTS', 'REFERENCES')
-      AND n1.is_exported = 1
-      AND n2.is_exported = 0
-      AND n1.community_id != n2.community_id
-      AND n1.community_id IS NOT NULL
-      AND n2.community_id IS NOT NULL
-    LIMIT 200
-  `).all() as LeakRow[];
-
-  // Deduplicate by (source_id, target_id) pair
-  const seen = new Set<string>();
-  const leaks: PrivateTypeLeak[] = [];
-  const affectedExportIds = new Set<string>();
-
-  for (const row of rows) {
-    const key = `${row.source_id}:${row.target_id}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-
-    affectedExportIds.add(row.source_id);
-
-    leaks.push({
-      exportNodeId: row.source_id,
-      exportName: row.src_name,
-      exportFilePath: row.src_path,
-      exportStartLine: row.src_line ?? null,
-      leakedTypeNodeId: row.target_id,
-      leakedTypeName: row.tgt_name,
-      leakedTypeFilePath: row.tgt_path,
-      leakedTypeStartLine: row.tgt_line ?? null,
-      reason: `Exported symbol ${row.src_name} references non-exported ${row.tgt_name} from another community`,
-    });
-  }
-
-  return {
-    leaks,
-    totalLeaks: leaks.length,
-    affectedExports: affectedExportIds.size,
-  };
-}
-
-/** Format PrivateTypeLeaksResult as structured text with file:line hints for LLM navigation. */
-export function formatPrivateTypeLeaks(result: PrivateTypeLeaksResult): string {
-  if (result.totalLeaks === 0) {
-    return 'Private type leaks: none detected.';
-  }
-
-  const lines: string[] = [
-    `Private type leaks: ${result.totalLeaks} leak(s) across ${result.affectedExports} exported symbol(s).`,
-    '',
-  ];
-
-  // Group leaks by exporting file for compact display
-  const byFile = new Map<string, PrivateTypeLeak[]>();
-  for (const leak of result.leaks) {
-    const key = leak.exportFilePath ?? '(unknown)';
-    let group = byFile.get(key);
-    if (!group) { group = []; byFile.set(key, group); }
-    group.push(leak);
-  }
-
-  for (const [filePath, fileLeaks] of byFile) {
-    lines.push(`File: ${filePath}`);
-    for (const leak of fileLeaks) {
-      const exportRef = leak.exportStartLine != null
-        ? `${filePath}:${leak.exportStartLine}`
-        : filePath;
-      const leakRef = leak.leakedTypeFilePath
-        ? leak.leakedTypeStartLine != null
-          ? `${leak.leakedTypeFilePath}:${leak.leakedTypeStartLine}`
-          : leak.leakedTypeFilePath
-        : '(unknown)';
-      lines.push(`  ${leak.exportName} (${exportRef}) → leaks ${leak.leakedTypeName} (${leakRef})`);
-    }
-    lines.push('');
-  }
-
-  lines.push(`Fix: make leaked types public, move them to a shared module, or restructure community boundaries.`);
-  return lines.join('\n').trimEnd();
-}

package/src/analysis/progress.ts

@@ -1,43 +0,0 @@
-const TICK_CHARS = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏',' '];
-
-export interface Spinner {
-  stop(finalMessage?: string): void;
-}
-
-export class AnalysisProgress {
-  private readonly enabled: boolean;
-  private spinners: Array<ReturnType<typeof setInterval>> = [];
-
-  constructor(enabled: boolean) {
-    this.enabled = enabled && Boolean(process.stderr.isTTY);
-  }
-
-  stageSpinner(message: string): Spinner {
-    if (!this.enabled) return { stop: () => {} };
-    let tick = 0;
-    const interval = setInterval(() => {
-      const char = TICK_CHARS[tick % TICK_CHARS.length];
-      process.stderr.write(`\r\x1b[36m${char}\x1b[0m ${message}`);
-      tick++;
-    }, 80);
-    this.spinners.push(interval);
-    return {
-      stop: (finalMessage?: string) => {
-        clearInterval(interval);
-        const idx = this.spinners.indexOf(interval);
-        if (idx !== -1) this.spinners.splice(idx, 1);
-        if (finalMessage) process.stderr.write(`\r${finalMessage}\n`);
-        else process.stderr.write('\r\x1b[K');
-      },
-    };
-  }
-
-  finish(): void {
-    for (const s of this.spinners) clearInterval(s);
-    this.spinners = [];
-  }
-}
-
-export function createAnalysisProgress(quiet: boolean): AnalysisProgress {
-  return new AnalysisProgress(!quiet);
-}

package/src/analysis/project-state.ts

@@ -1,95 +0,0 @@
-export interface ProjectFile {
-  fileId: number;
-  path: string;
-  canonicalPath?: string;
-  sizeBytes?: number;
-}
-
-export interface WorkspaceEntry {
-  root: string;
-  name?: string;
-  packageJson?: Record<string, unknown>;
-}
-
-export interface ProjectState {
-  files: ProjectFile[];
-  pathToId: Map<string, number>;
-  /** O(1) lookup by numeric fileId */
-  idToFile: Map<number, ProjectFile>;
-  workspaces: WorkspaceEntry[];
-}
-
-export function makeProjectState(files: ProjectFile[], workspaces: WorkspaceEntry[]): ProjectState {
-  // Build both lookup maps in a single pass to avoid intermediate arrays
-  const pathToId = new Map<string, number>();
-  const idToFile = new Map<number, ProjectFile>();
-  for (const f of files) {
-    pathToId.set(f.path, f.fileId);
-    idToFile.set(f.fileId, f);
-  }
-  return { files, pathToId, idToFile, workspaces };
-}
-
-export function fileById(state: ProjectState, fileId: number): ProjectFile | undefined {
-  // O(1) lookup via idToFile map instead of O(N) linear scan
-  return state.idToFile.get(fileId);
-}
-
-export function idForPath(state: ProjectState, filePath: string): number | undefined {
-  return state.pathToId.get(filePath);
-}
-
-export function workspaceForFile(state: ProjectState, fileId: number): WorkspaceEntry | undefined {
-  const file = fileById(state, fileId);
-  if (!file) return undefined;
-  const normalized = file.path.replace(/\\/g, '/');
-  let bestMatch: WorkspaceEntry | undefined;
-  let bestLen = 0;
-  for (const ws of state.workspaces) {
-    const wsPath = ws.root.replace(/\\/g, '/');
-    if (normalized.startsWith(wsPath + '/') || normalized === wsPath) {
-      if (wsPath.length > bestLen) {
-        bestLen = wsPath.length;
-        bestMatch = ws;
-      }
-    }
-  }
-  return bestMatch;
-}
-
-export function filesInWorkspace(state: ProjectState, workspace: WorkspaceEntry): ProjectFile[] {
-  const wsPath = workspace.root.replace(/\\/g, '/');
-  return state.files.filter(f => {
-    const fp = f.path.replace(/\\/g, '/');
-    return fp.startsWith(wsPath + '/') || fp === wsPath;
-  });
-}
-
-export class PackageResolver {
-  private entries: Array<{ root: string; name: string }>;
-
-  constructor(workspaces: WorkspaceEntry[]) {
-    // Combine filter + map into a single for-of loop to avoid 2 intermediate arrays
-    const named: Array<{ root: string; name: string }> = [];
-    for (const w of workspaces) {
-      if (w.name) named.push({ root: w.root, name: w.name });
-    }
-    named.sort((a, b) => b.root.length - a.root.length);
-    this.entries = named;
-  }
-
-  resolvePackage(filePath: string): string | undefined {
-    const normalized = filePath.replace(/\\/g, '/');
-    for (const entry of this.entries) {
-      const rootNorm = entry.root.replace(/\\/g, '/');
-      if (normalized.startsWith(rootNorm + '/') || normalized === rootNorm) {
-        return entry.name;
-      }
-    }
-    return undefined;
-  }
-
-  resolveRoot(packageName: string): string | undefined {
-    return this.entries.find(e => e.name === packageName)?.root;
-  }
-}

package/src/analysis/regression-config.ts

@@ -1,36 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-
-export interface Tolerance {
-  type: 'absolute' | 'percentage';
-  value: number;
-}
-
-export function parseTolerance(s: string): Tolerance {
-  const pct = s.match(/^(\d+(?:\.\d+)?)%$/);
-  if (pct) return { type: 'percentage', value: parseFloat(pct[1]!) };
-  const abs = s.match(/^(\d+)$/);
-  if (abs) return { type: 'absolute', value: parseInt(abs[1]!, 10) };
-  return { type: 'absolute', value: 0 };
-}
-
-export function toleranceExceeded(tol: Tolerance, baseline: number, current: number): boolean {
-  const delta = current - baseline;
-  if (delta <= 0) return false;
-  if (tol.type === 'absolute') return delta > tol.value;
-  return delta / Math.max(1, baseline) * 100 > tol.value;
-}
-
-export function saveBaselineToConfig(configPath: string, counts: Record<string, number>): void {
-  let content: string;
-  try { content = readFileSync(configPath, 'utf8'); }
-  catch { content = '{}'; }
-  let parsed: Record<string, unknown>;
-  try { parsed = JSON.parse(stripJsonComments(content)); }
-  catch { parsed = {}; }
-  parsed['regression'] = { ...((parsed['regression'] as Record<string, unknown>) ?? {}), baseline: counts };
-  writeFileSync(configPath, JSON.stringify(parsed, null, 2));
-}
-
-function stripJsonComments(text: string): string {
-  return text.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
-}

package/src/analysis/rule-overrides.ts

@@ -1,81 +0,0 @@
-export interface RuleSet {
-  allow: string[];
-  deny: string[];
-}
-
-export interface RuleOverride {
-  pattern: string;
-  rules: RuleSet;
-}
-
-export function matchesGlob(filePath: string, pattern: string): boolean {
-  // Escape dots
-  let regexStr = pattern.replace(/\./g, '\\.');
-  // Replace **/ with a group that matches any path segments (including none)
-  regexStr = regexStr.replace(/\*\*\//g, '(?:.+/)?');
-  // Replace remaining * with [^/]* to match within a segment only
-  regexStr = regexStr.replace(/\*/g, '[^/]*');
-  // Anchor at end
-  regexStr = regexStr + '$';
-
-  const regex = new RegExp(regexStr);
-  return regex.test(filePath);
-}
-
-export function resolveRulesForFile(filePath: string, overrides: RuleOverride[]): RuleSet | null {
-  for (const override of overrides) {
-    if (matchesGlob(filePath, override.pattern)) {
-      return override.rules;
-    }
-  }
-  return null;
-}
-
-export function applyRules<T extends { filePath?: string | null; ruleCode?: string }>(
-  issues: T[],
-  globalRules: RuleSet,
-  overrides: RuleOverride[],
-): T[] {
-  return issues.filter((issue) => {
-    const filePath = issue.filePath ?? '';
-    const effectiveRules = resolveRulesForFile(filePath, overrides) ?? globalRules;
-
-    const ruleCode = issue.ruleCode;
-    if (ruleCode == null) {
-      // No ruleCode — keep by default
-      return true;
-    }
-
-    // Keep if ruleCode is NOT in allow list
-    return !effectiveRules.allow.includes(ruleCode);
-  });
-}
-
-// ── Round 8: severity helpers ──────────────────────────────────────────────
-
-export type IssueSeverity = 'error' | 'warn' | 'off';
-
-export interface RuleWithSeverity {
-  name: string;
-  severity: IssueSeverity;
-}
-
-/** Returns true if any rule currently set to 'error' has findings in results. */
-export function hasErrorSeverityIssues(
-  rules: RuleWithSeverity[],
-  resultCounts: Record<string, number>,
-): boolean {
-  return rules
-    .filter(r => r.severity === 'error')
-    .some(r => (resultCounts[r.name] ?? 0) > 0);
-}
-
-/** Bulk-upgrade all 'warn' severity rules to 'error' for strict CI gates. */
-export function promoteWarnsToErrors(rules: RuleWithSeverity[]): RuleWithSeverity[] {
-  return rules.map(r => r.severity === 'warn' ? { ...r, severity: 'error' as IssueSeverity } : r);
-}
-
-/** Downgrade all 'error' severity rules to 'warn'. */
-export function demoteErrorsToWarns(rules: RuleWithSeverity[]): RuleWithSeverity[] {
-  return rules.map(r => r.severity === 'error' ? { ...r, severity: 'warn' as IssueSeverity } : r);
-}

package/src/analysis/scripts.ts

@@ -1,95 +0,0 @@
-// Analyzes npm scripts fields and CI config files to derive additional
-// entry points for dead-code analysis.
-
-export interface ScriptCommand {
-  binary: string;
-  args: string[];
-  sourceScript: string;
-}
-
-export interface ScriptAnalysis {
-  entryPatterns: string[];
-  commands: ScriptCommand[];
-  binToPackage: Map<string, string>;
-}
-
-export interface CiAnalysis {
-  entryPatterns: string[];
-  detectedRunners: string[];
-}
-
-const PACKAGE_MANAGER_PREFIXES = ['npx', 'pnpm', 'yarn', 'bunx', 'nx', 'turbo'];
-const SHELL_OPERATORS = /&&|\|\||;|\|/;
-
-export function splitShellOperators(script: string): string[] {
-  return script.split(SHELL_OPERATORS).map(s => s.trim()).filter(Boolean);
-}
-
-export function skipInitialWrappers(parts: string[]): string[] {
-  const skip = new Set(['env', 'cross-env', 'dotenv', 'run-s', 'run-p', 'concurrently']);
-  let i = 0;
-  while (i < parts.length && (skip.has(parts[i]) || parts[i].includes('='))) i++;
-  return parts.slice(i);
-}
-
-export function parseScriptCommand(raw: string): ScriptCommand | null {
-  const segments = splitShellOperators(raw);
-  const first = segments[0];
-  if (!first) return null;
-
-  const tokens = first.split(/\s+/).filter(Boolean);
-  const adjusted = skipInitialWrappers(tokens);
-  if (!adjusted.length) return null;
-
-  let binary = adjusted[0];
-  let args = adjusted.slice(1);
-
-  if (PACKAGE_MANAGER_PREFIXES.includes(binary) && args.length) {
-    binary = args[0];
-    args = args.slice(1);
-  }
-
-  return { binary, args, sourceScript: raw };
-}
-
-export function filterProductionScripts(scripts: Record<string, string>): Record<string, string> {
-  const devKeys = /^(dev|test|lint|type-check|watch|storybook|e2e)/;
-  const result: Record<string, string> = {};
-  for (const [k, v] of Object.entries(scripts)) {
-    if (!devKeys.test(k)) result[k] = v;
-  }
-  return result;
-}
-
-export function analyzeScripts(
-  scripts: Record<string, string>,
-  _root?: string,
-): ScriptAnalysis {
-  const production = filterProductionScripts(scripts);
-  const commands: ScriptCommand[] = [];
-  const entryPatterns: string[] = [];
-
-  for (const raw of Object.values(production)) {
-    const cmd = parseScriptCommand(raw);
-    if (cmd) commands.push(cmd);
-  }
-
-  return { entryPatterns, commands, binToPackage: new Map() };
-}
-
-export function buildBinToPackageMap(packageJson: Record<string, unknown>): Map<string, string> {
-  const map = new Map<string, string>();
-  const name = packageJson['name'] as string | undefined;
-  if (!name) return map;
-  const bin = packageJson['bin'];
-  if (typeof bin === 'string') {
-    map.set(name, name);
-  } else if (typeof bin === 'object' && bin !== null) {
-    for (const k of Object.keys(bin as object)) map.set(k, name);
-  }
-  return map;
-}
-
-export function analyzeCiFiles(_root: string): CiAnalysis {
-  return { entryPatterns: [], detectedRunners: [] };
-}