@monoes/monograph 1.5.6 → 1.5.8

package/src/audit.ts

@@ -1,234 +0,0 @@
-import { execSync, spawnSync } from 'child_process';
-import type { MonographDb } from './storage/db.js';
-
-export type AuditVerdict = 'Pass' | 'Warn' | 'Fail';
-export type AuditGate = 'new-only' | 'all';
-
-export interface AuditAttribution {
-  domain: string;            // 'dead-code' | 'complexity' | 'duplication' | 'cycles'
-  newCount: number;          // findings introduced by changed files
-  inheritedCount: number;    // pre-existing findings in changed files
-}
-
-export interface AuditSummary {
-  verdict: AuditVerdict;
-  changedFiles: number;
-  deadCodeIssues: number;
-  complexityFindings: number;
-  maxCyclomatic: number;
-  duplicationCloneGroups: number;
-  cycleCount: number;
-  attributions: AuditAttribution[];
-  gate: AuditGate;
-}
-
-interface NodeRow {
-  id: string;
-  file_path: string | null;
-  properties: string | null;
-}
-
-interface EdgeRow {
-  source_id: string;
-  target_id: string;
-}
-
-export function runAudit(
-  db: MonographDb,
-  repoPath: string,
-  options?: { changedSince?: string; gate?: AuditGate }
-): AuditSummary {
-  const gate: AuditGate = options?.gate ?? 'new-only';
-
-  // ── Step 1: Determine changed file set ──────────────────────────────────────
-  let changedFilePaths: Set<string> = new Set();
-  let useAllFiles = false;
-
-  if (options?.changedSince) {
-    try {
-      // Use spawnSync with argument array to prevent shell injection via changedSince
-      const result = spawnSync(
-        'git', ['diff', '--name-only', options.changedSince, 'HEAD'],
-        { cwd: repoPath, maxBuffer: 5 * 1024 * 1024, encoding: 'utf-8' },
-      );
-      if (result.status !== 0 || result.error) throw result.error ?? new Error(`git exited ${result.status}`);
-      const output = result.stdout;
-      for (const line of output.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed) changedFilePaths.add(trimmed);
-      }
-    } catch {
-      useAllFiles = true;
-    }
-  } else {
-    useAllFiles = true;
-  }
-
-  // ── Step 2: Get all File nodes from DB ──────────────────────────────────────
-  const fileNodes = db.prepare(`
-    SELECT id, file_path, properties
-    FROM nodes
-    WHERE label = 'File' AND file_path IS NOT NULL
-  `).all() as NodeRow[];
-
-  if (useAllFiles) {
-    for (const n of fileNodes) {
-      if (n.file_path) changedFilePaths.add(n.file_path);
-    }
-  }
-
-  // Build a map of file_path → node id for changed files
-  const changedNodeIds = new Set<string>();
-  const filePathToId = new Map<string, string>();
-  for (const n of fileNodes) {
-    if (!n.file_path) continue;
-    filePathToId.set(n.file_path, n.id);
-    // Match by full path or relative suffix
-    for (const cp of changedFilePaths) {
-      if (n.file_path === cp || n.file_path.endsWith('/' + cp) || n.file_path.endsWith('\\' + cp)) {
-        changedNodeIds.add(n.id);
-        break;
-      }
-    }
-  }
-
-  const changedFileCount = changedNodeIds.size;
-
-  // ── Step 3: Dead code issues (unreachable files in changed set) ─────────────
-  let deadCodeIssues = 0;
-  for (const n of fileNodes) {
-    if (!changedNodeIds.has(n.id)) continue;
-    let props: Record<string, unknown> = {};
-    try { props = n.properties ? JSON.parse(n.properties) : {}; } catch { /* skip malformed */ }
-    if (props['reachabilityRole'] === 'unreachable') deadCodeIssues++;
-  }
-
-  // ── Step 4: Complexity findings (Symbol nodes in changed files with CC > 10) ─
-  let complexityFindings = 0;
-  let maxCyclomatic = 0;
-
-  if (changedNodeIds.size > 0) {
-    // Get Symbol/Function/Method nodes belonging to changed files
-    const symbolRows = db.prepare(`
-      SELECT n.id, n.file_path, n.properties
-      FROM nodes n
-      WHERE n.label IN ('Function', 'Method', 'Symbol')
-        AND n.file_path IS NOT NULL
-    `).all() as NodeRow[];
-
-    for (const sym of symbolRows) {
-      if (!sym.file_path) continue;
-      // Check if this symbol belongs to a changed file
-      let inChangedFile = false;
-      for (const cp of changedFilePaths) {
-        if (sym.file_path === cp || sym.file_path.endsWith('/' + cp) || sym.file_path.endsWith('\\' + cp)) {
-          inChangedFile = true;
-          break;
-        }
-      }
-      if (!inChangedFile) continue;
-
-      let props: Record<string, unknown> = {};
-      try { props = sym.properties ? JSON.parse(sym.properties) : {}; } catch { continue; }
-      const cc: number = typeof props.cyclomaticComplexity === 'number' ? props.cyclomaticComplexity : 0;
-      if (cc > 10) complexityFindings++;
-      if (cc > maxCyclomatic) maxCyclomatic = cc;
-    }
-  }
-
-  // ── Step 5: Clone groups (STRUCTURALLY_SIMILAR edges between changed files) ──
-  let duplicationCloneGroups = 0;
-  if (changedNodeIds.size > 0) {
-    const cloneEdges = db.prepare(`
-      SELECT source_id, target_id
-      FROM edges
-      WHERE relation = 'STRUCTURALLY_SIMILAR'
-    `).all() as EdgeRow[];
-
-    for (const edge of cloneEdges) {
-      if (changedNodeIds.has(edge.source_id) && changedNodeIds.has(edge.target_id)) {
-        duplicationCloneGroups++;
-      }
-    }
-  }
-
-  // ── Step 6: Cycle detection (mutual imports among changed files) ─────────────
-  let cycleCount = 0;
-  if (changedNodeIds.size > 0) {
-    // Build adjacency for changed files
-    const importEdges = db.prepare(`
-      SELECT source_id, target_id
-      FROM edges
-      WHERE relation = 'IMPORTS'
-    `).all() as EdgeRow[];
-
-    // For a simplified cycle check: count changed files where there's a mutual import
-    const importMap = new Map<string, Set<string>>();
-    for (const edge of importEdges) {
-      if (!importMap.has(edge.source_id)) importMap.set(edge.source_id, new Set());
-      importMap.get(edge.source_id)!.add(edge.target_id);
-    }
-
-    const counted = new Set<string>();
-    for (const nodeId of changedNodeIds) {
-      const outgoing = importMap.get(nodeId);
-      if (!outgoing) continue;
-      for (const target of outgoing) {
-        if (counted.has(`${nodeId}:${target}`)) continue;
-        // Check if target imports back nodeId
-        const targetOutgoing = importMap.get(target);
-        if (targetOutgoing?.has(nodeId)) {
-          cycleCount++;
-          counted.add(`${nodeId}:${target}`);
-          counted.add(`${target}:${nodeId}`);
-        }
-      }
-    }
-  }
-
-  // ── Step 7: Attributions ─────────────────────────────────────────────────────
-  const attributions: AuditAttribution[] = [
-    {
-      domain: 'dead-code',
-      newCount: deadCodeIssues,
-      inheritedCount: deadCodeIssues > 0 ? 0 : 0, // heuristic: all new if changed
-    },
-    {
-      domain: 'complexity',
-      newCount: complexityFindings,
-      inheritedCount: 0,
-    },
-    {
-      domain: 'duplication',
-      newCount: duplicationCloneGroups,
-      inheritedCount: 0,
-    },
-    {
-      domain: 'cycles',
-      newCount: cycleCount,
-      inheritedCount: 0,
-    },
-  ];
-
-  // ── Step 8: Verdict ──────────────────────────────────────────────────────────
-  let verdict: AuditVerdict;
-  if (deadCodeIssues > 5 || cycleCount > 0) {
-    verdict = 'Fail';
-  } else if (deadCodeIssues > 0 || complexityFindings > 0 || duplicationCloneGroups > 0) {
-    verdict = 'Warn';
-  } else {
-    verdict = 'Pass';
-  }
-
-  return {
-    verdict,
-    changedFiles: changedFileCount,
-    deadCodeIssues,
-    complexityFindings,
-    maxCyclomatic,
-    duplicationCloneGroups,
-    cycleCount,
-    attributions,
-    gate,
-  };
-}

package/src/cache/augment-cache.ts

@@ -1,63 +0,0 @@
-export interface AugmentCacheOptions {
-  maxSize?: number;
-  ttlMs?: number;
-}
-
-interface CacheEntry {
-  value: string;
-  expiresAt: number;
-}
-
-export interface AugmentCache {
-  get(key: string): string | undefined;
-  set(key: string, value: string): void;
-  size(): number;
-  clear(): void;
-  makeKey(query: string, repoPath: string, topK: number, format: string): string;
-}
-
-export function createAugmentCache(options: AugmentCacheOptions = {}): AugmentCache {
-  const { maxSize = 100, ttlMs = 5 * 60 * 1000 } = options;
-  const store = new Map<string, CacheEntry>();
-
-  function evictExpired(): void {
-    const now = Date.now();
-    for (const [k, v] of store) {
-      if (v.expiresAt <= now) store.delete(k);
-    }
-  }
-
-  function evictOldest(): void {
-    const first = store.keys().next().value;
-    if (first !== undefined) store.delete(first);
-  }
-
-  return {
-    get(key) {
-      const entry = store.get(key);
-      if (!entry) return undefined;
-      if (entry.expiresAt <= Date.now()) {
-        store.delete(key);
-        return undefined;
-      }
-      return entry.value;
-    },
-    set(key, value) {
-      evictExpired();
-      if (store.size >= maxSize) evictOldest();
-      store.set(key, { value, expiresAt: Date.now() + ttlMs });
-    },
-    size() {
-      evictExpired();
-      return store.size;
-    },
-    clear() {
-      store.clear();
-    },
-    makeKey(query, repoPath, topK, format) {
-      return `${repoPath}\0${topK}\0${format}\0${query}`;
-    },
-  };
-}
-
-export const globalAugmentCache = createAugmentCache({ maxSize: 200, ttlMs: 5 * 60 * 1000 });

package/src/cache/extraction-cache.ts

@@ -1,141 +0,0 @@
-import { createHash } from 'crypto';
-import { readFileSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync, existsSync, statSync } from 'fs';
-import { join } from 'path';
-import type { MonographNode, MonographEdge } from '../types.js';
-
-/**
- * Bump this whenever the parser/extractor output format changes in a way that
- * would make previously-cached nodes/edges stale or wrong (e.g. a parser bugfix,
- * a change to what symbols get extracted, a change to node/edge shape). Any
- * cached entry written under an older version is treated as a miss on read, so
- * bumping this effectively invalidates the entire on-disk extraction cache.
- */
-export const EXTRACTION_CACHE_VERSION = 1;
-
-export interface CacheEntry {
-  fileHash: string;
-  mtimeMs?: number;
-  size?: number;
-  nodes: MonographNode[];
-  edges: MonographEdge[];
-  /** Extraction format version this entry was written under — see EXTRACTION_CACHE_VERSION. */
-  cacheVersion?: number;
-}
-
-export class ExtractionCache {
-  private pending: Array<{ path: string; data: string }> = [];
-
-  constructor(private readonly dir: string) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  hashFile(filePath: string): string {
-    const content = readFileSync(filePath);
-    return createHash('sha256').update(content).digest('hex');
-  }
-
-  hashContent(content: string): string {
-    return createHash('sha256').update(content).digest('hex');
-  }
-
-  private entryPath(filePath: string): string {
-    const key = createHash('sha256').update(filePath).digest('hex');
-    return join(this.dir, `${key}.json`);
-  }
-
-  /** tmp+rename write — cache corruption is low-stakes but a torn write from a
-   * killed process still shouldn't poison the next read. */
-  private writeAtomic(p: string, data: string): void {
-    const tmp = `${p}.${process.pid}.tmp`;
-    try {
-      writeFileSync(tmp, data);
-      renameSync(tmp, p);
-    } catch {
-      try { unlinkSync(tmp); } catch { /* ignore */ }
-    }
-  }
-
-  /**
-   * Delete cache entries whose mtime exceeds maxAgeMs (default 30 days).
-   * Covers files that were deleted/renamed (their cache entry is now orphaned
-   * and would otherwise sit on disk forever) as well as entries simply not
-   * touched in a long time. Single readdir + stat pass over the cache dir.
-   * Returns the number of entries removed.
-   */
-  prune(maxAgeMs = 30 * 24 * 60 * 60 * 1000): number {
-    let removed = 0;
-    let entries: string[];
-    try {
-      entries = readdirSync(this.dir).filter((f) => f.endsWith('.json') && !f.startsWith('._'));
-    } catch {
-      return 0;
-    }
-    const cutoff = Date.now() - maxAgeMs;
-    for (const f of entries) {
-      const p = join(this.dir, f);
-      try {
-        if (statSync(p).mtimeMs < cutoff) {
-          unlinkSync(p);
-          removed++;
-        }
-      } catch { /* ignore */ }
-    }
-    return removed;
-  }
-
-  /**
-   * Fast-path: check mtime+size before falling back to content hash.
-   * Returns cached entry if file hasn't changed, null on miss.
-   */
-  getWithStat(filePath: string): CacheEntry | null {
-    const p = this.entryPath(filePath);
-    if (!existsSync(p)) return null;
-    try {
-      const entry: CacheEntry = JSON.parse(readFileSync(p, 'utf-8'));
-      if (entry.cacheVersion !== EXTRACTION_CACHE_VERSION) return null;
-      const st = statSync(filePath);
-      if (entry.mtimeMs === st.mtimeMs && entry.size === st.size) return entry;
-      // mtime/size differ or missing — recheck content hash
-      const hash = this.hashFile(filePath);
-      if (entry.fileHash !== hash) return null;
-      // Hash matches — update entry with current mtime+size for next run
-      entry.mtimeMs = st.mtimeMs;
-      entry.size = st.size;
-      try { this.writeAtomic(p, JSON.stringify(entry)); } catch { /* non-fatal */ }
-      return entry;
-    } catch { return null; }
-  }
-
-  get(filePath: string, fileHash: string): CacheEntry | null {
-    const p = this.entryPath(filePath);
-    if (!existsSync(p)) return null;
-    try {
-      const entry: CacheEntry = JSON.parse(readFileSync(p, 'utf-8'));
-      if (entry.cacheVersion !== EXTRACTION_CACHE_VERSION) return null;
-      return entry.fileHash === fileHash ? entry : null;
-    } catch { return null; }
-  }
-
-  set(filePath: string, fileHash: string, nodes: MonographNode[], edges: MonographEdge[]): void {
-    let mtimeMs: number | undefined;
-    let size: number | undefined;
-    try { const st = statSync(filePath); mtimeMs = st.mtimeMs; size = st.size; } catch { /* ignore */ }
-    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges, cacheVersion: EXTRACTION_CACHE_VERSION };
-    this.writeAtomic(this.entryPath(filePath), JSON.stringify(entry));
-  }
-
-  setDeferred(filePath: string, fileHash: string, nodes: MonographNode[], edges: MonographEdge[]): void {
-    let mtimeMs: number | undefined;
-    let size: number | undefined;
-    try { const st = statSync(filePath); mtimeMs = st.mtimeMs; size = st.size; } catch { /* ignore */ }
-    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges, cacheVersion: EXTRACTION_CACHE_VERSION };
-    this.pending.push({ path: this.entryPath(filePath), data: JSON.stringify(entry) });
-  }
-
-  flush(): void {
-    for (const { path, data } of this.pending) {
-      try { this.writeAtomic(path, data); } catch { /* non-fatal */ }
-    }
-    this.pending = [];
-  }
-}

package/src/check/filtering.ts

@@ -1,78 +0,0 @@
-import * as path from 'node:path';
-
-export interface WorkspaceFilterOptions {
-  root: string;
-  patterns: string[];
-}
-
-export function filterToWorkspaces<T extends { filePath: string }>(
-  results: T[],
-  wsRoots: string[],
-): T[] {
-  if (wsRoots.length === 0) return results;
-  return results.filter(r =>
-    wsRoots.some(root => r.filePath === root || r.filePath.startsWith(root + path.sep))
-  );
-}
-
-export function resolveWorkspaceFilters(
-  root: string,
-  patterns: string[],
-  allWorkspaceRoots: string[],
-): string[] {
-  const positive: string[] = [];
-  const negative: string[] = [];
-  for (const p of patterns) {
-    if (p.startsWith('!')) negative.push(p.slice(1));
-    else positive.push(p);
-  }
-
-  let matches = positive.length > 0
-    ? allWorkspaceRoots.filter(ws => positive.some(p => matchWorkspacePattern(ws, p, root)))
-    : allWorkspaceRoots;
-
-  if (negative.length > 0) {
-    matches = matches.filter(ws => !negative.some(p => matchWorkspacePattern(ws, p, root)));
-  }
-
-  return matches;
-}
-
-export function resolveWorkspaceScope(
-  root: string,
-  workspacePatterns: string[] | undefined,
-  changedWorkspaces: string | undefined,
-  allWorkspaceRoots: string[],
-): string[] {
-  if (!workspacePatterns && !changedWorkspaces) return [];
-
-  let scope = workspacePatterns
-    ? resolveWorkspaceFilters(root, workspacePatterns, allWorkspaceRoots)
-    : allWorkspaceRoots;
-
-  if (changedWorkspaces) {
-    const changedSet = new Set(
-      changedWorkspaces.split(',').map(s => path.resolve(root, s.trim()))
-    );
-    scope = scope.filter(ws => changedSet.has(ws));
-  }
-
-  return scope;
-}
-
-export function getChangedFiles(
-  root: string,
-  since?: string,
-  workspaces?: string[],
-): string[] {
-  return [];
-}
-
-function matchWorkspacePattern(wsRoot: string, pattern: string, root: string): boolean {
-  const rel = path.relative(root, wsRoot).replace(/\\/g, '/');
-  if (pattern.includes('*')) {
-    const re = new RegExp('^' + pattern.replace(/\*/g, '[^/]+') + '$');
-    return re.test(rel);
-  }
-  return rel === pattern || wsRoot === pattern || wsRoot.endsWith(path.sep + pattern);
-}

package/src/check/index.ts

@@ -1,99 +0,0 @@
-import type { RulesConfig, AnalysisIssue } from './rules.js';
-import { applyRules, hasErrorSeverityIssues, DEFAULT_RULES_CONFIG } from './rules.js';
-import type { OutputFormat, TraceOptions } from './output.js';
-import { filterToWorkspaces, resolveWorkspaceScope } from './filtering.js';
-
-export * from './rules.js';
-export * from './filtering.js';
-export * from './output.js';
-
-export interface IssueFilters {
-  unusedFiles: boolean;
-  unusedExports: boolean;
-  unusedDeps: boolean;
-  unusedTypes: boolean;
-  privateTypeLeaks: boolean;
-  unusedEnumMembers: boolean;
-  unusedClassMembers: boolean;
-  unresolvedImports: boolean;
-  unlistedDeps: boolean;
-  duplicateExports: boolean;
-  circularDeps: boolean;
-  boundaryViolations: boolean;
-  staleSuppressions: boolean;
-}
-
-export interface CheckOptions {
-  root: string;
-  configPath?: string;
-  output: OutputFormat;
-  noCache: boolean;
-  threads: number;
-  quiet: boolean;
-  failOnIssues: boolean;
-  filters: IssueFilters;
-  changedSince?: string;
-  baseline?: string;
-  saveBaseline?: string;
-  sarifFile?: string;
-  production: boolean;
-  productionOverride?: boolean;
-  workspace?: string[];
-  changedWorkspaces?: string;
-  trace?: TraceOptions;
-}
-
-export const DEFAULT_ISSUE_FILTERS: IssueFilters = {
-  unusedFiles: true,
-  unusedExports: true,
-  unusedDeps: true,
-  unusedTypes: true,
-  privateTypeLeaks: true,
-  unusedEnumMembers: true,
-  unusedClassMembers: true,
-  unresolvedImports: true,
-  unlistedDeps: true,
-  duplicateExports: true,
-  circularDeps: true,
-  boundaryViolations: true,
-  staleSuppressions: true,
-};
-
-export interface CheckResult {
-  issues: AnalysisIssue[];
-  hasErrors: boolean;
-  filteredByWorkspace: boolean;
-}
-
-export function runCheckFilter(
-  issues: AnalysisIssue[],
-  opts: Pick<CheckOptions, 'filters' | 'workspace' | 'changedWorkspaces' | 'root'>,
-  rules: RulesConfig = DEFAULT_RULES_CONFIG,
-  allWorkspaceRoots: string[] = [],
-): CheckResult {
-  let filtered = applyRules(issues, rules);
-
-  const activeFilters = opts.filters;
-  filtered = filtered.filter(issue => {
-    const key = issue.kind as keyof IssueFilters;
-    return activeFilters[key] !== false;
-  });
-
-  const wsRoots = resolveWorkspaceScope(
-    opts.root,
-    opts.workspace,
-    opts.changedWorkspaces,
-    allWorkspaceRoots,
-  );
-
-  const filteredByWorkspace = wsRoots.length > 0;
-  if (filteredByWorkspace) {
-    filtered = filterToWorkspaces(filtered, wsRoots);
-  }
-
-  return {
-    issues: filtered,
-    hasErrors: hasErrorSeverityIssues(filtered, rules),
-    filteredByWorkspace,
-  };
-}

package/src/check/output.ts

@@ -1,79 +0,0 @@
-import type { IssueSeverity, AnalysisIssue } from './rules.js';
-
-export type OutputFormat = 'text' | 'json' | 'compact';
-
-export interface TraceOptions {
-  traceExport?: string;
-  traceFile?: string;
-  traceDependency?: string;
-  performance: boolean;
-}
-
-export interface SarifOutput {
-  version: '2.1.0';
-  $schema: string;
-  runs: SarifRun[];
-}
-
-export interface SarifRun {
-  tool: { driver: { name: string; version: string; rules: SarifRule[] } };
-  results: SarifResult[];
-}
-
-export interface SarifRule {
-  id: string;
-  shortDescription: { text: string };
-  defaultConfiguration: { level: 'error' | 'warning' | 'note' };
-}
-
-export interface SarifResult {
-  ruleId: string;
-  level: 'error' | 'warning' | 'note';
-  message: { text: string };
-  locations: Array<{ physicalLocation: { artifactLocation: { uri: string }; region?: { startLine: number } } }>;
-}
-
-export function parseTraceSpec(spec: string): [string, string] | null {
-  const idx = spec.lastIndexOf(':');
-  if (idx <= 0) return null;
-  return [spec.slice(0, idx), spec.slice(idx + 1)];
-}
-
-export function buildSarifOutput(
-  issues: AnalysisIssue[],
-  toolVersion: string,
-): SarifOutput {
-  const ruleIds = [...new Set(issues.map(i => i.kind))];
-  const rules: SarifRule[] = ruleIds.map(id => ({
-    id,
-    shortDescription: { text: id },
-    defaultConfiguration: { level: 'warning' },
-  }));
-
-  const results: SarifResult[] = issues.map(issue => ({
-    ruleId: issue.kind,
-    level: issue.severity === 'error' ? 'error' : issue.severity === 'warn' ? 'warning' : 'note',
-    message: { text: issue.message },
-    locations: [{
-      physicalLocation: {
-        artifactLocation: { uri: issue.filePath.replace(/\\/g, '/') },
-      },
-    }],
-  }));
-
-  return {
-    version: '2.1.0',
-    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
-    runs: [{ tool: { driver: { name: 'monograph', version: toolVersion, rules } }, results }],
-  };
-}
-
-export function formatIssuesAsText(issues: AnalysisIssue[], quiet: boolean): string {
-  if (quiet && issues.length === 0) return '';
-  const lines = issues.map(i => `[${(i.severity ?? 'error').toUpperCase()}] ${i.filePath}: ${i.message}`);
-  return lines.join('\n');
-}
-
-export function formatIssuesAsJson(issues: AnalysisIssue[]): string {
-  return JSON.stringify({ issues }, null, 2);
-}