@monoes/monograph 1.5.6 → 1.5.8

package/src/graph/clone-families.ts

@@ -1,132 +0,0 @@
-export type RefactoringKind = 'ExtractFunction' | 'ExtractModule' | 'MergeDirectories';
-
-export const MODULE_EXTRACTION_THRESHOLD_LINES = 50;
-
-export interface RefactoringSuggestion {
-  kind: RefactoringKind;
-  description: string;
-  estimatedLines: number;
-  files: string[];
-}
-
-export interface CloneInstance {
-  filePath: string;
-  startLine: number;
-  endLine: number;
-  tokenCount?: number;
-}
-
-export interface CloneGroup {
-  id: number;
-  instances: CloneInstance[];
-  duplicatedLines: number;
-}
-
-export interface CloneFamily {
-  files: string[];        // sorted, deduplicated set of files
-  groups: CloneGroup[];
-  totalDuplicatedLines: number;
-  suggestions: RefactoringSuggestion[];
-}
-
-function fileSetKey(files: string[]): string {
-  // Avoid spread allocation: sort a copy directly
-  return files.slice().sort().join('|');
-}
-
-function generateSuggestions(family: Omit<CloneFamily, 'suggestions'>): RefactoringSuggestion[] {
-  const suggestions: RefactoringSuggestion[] = [];
-  const lines = family.totalDuplicatedLines;
-
-  if (lines < MODULE_EXTRACTION_THRESHOLD_LINES) {
-    suggestions.push({
-      kind: 'ExtractFunction',
-      description: `Extract ${lines} duplicated lines into a shared function`,
-      estimatedLines: lines,
-      files: family.files,
-    });
-  } else {
-    // Check if all files are in the same directory → MergeDirectories
-    // Use Set directly to avoid spread+map intermediate array
-    const dirSet = new Set<string>();
-    for (const f of family.files) {
-      const slash = f.replace(/\\/g, '/');
-      const lastSlash = slash.lastIndexOf('/');
-      dirSet.add(lastSlash >= 0 ? slash.slice(0, lastSlash) : '.');
-    }
-    const dirs = [...dirSet];
-    if (dirs.length > 1 && family.files.length >= 3) {
-      suggestions.push({
-        kind: 'MergeDirectories',
-        description: `Consider merging ${dirs.length} directories with ${lines} shared lines`,
-        estimatedLines: lines,
-        files: family.files,
-      });
-    } else {
-      suggestions.push({
-        kind: 'ExtractModule',
-        description: `Extract ${lines} duplicated lines into a shared module`,
-        estimatedLines: lines,
-        files: family.files,
-      });
-    }
-  }
-  return suggestions;
-}
-
-export function groupIntoFamilies(groups: CloneGroup[]): CloneFamily[] {
-  const familyMap = new Map<string, { files: Set<string>; groups: CloneGroup[] }>();
-
-  for (const group of groups) {
-    const files = group.instances.map(i => i.filePath);
-    const key = fileSetKey(files);
-    if (!familyMap.has(key)) {
-      familyMap.set(key, { files: new Set(files), groups: [] });
-    }
-    familyMap.get(key)!.groups.push(group);
-  }
-
-  // Build output array without intermediate spread + map allocation
-  const result: CloneFamily[] = [];
-  for (const { files, groups } of familyMap.values()) {
-    const fileList = [...files].sort();
-    let totalDuplicatedLines = 0;
-    for (const g of groups) totalDuplicatedLines += g.duplicatedLines;
-    const base = { files: fileList, groups, totalDuplicatedLines };
-    result.push({ ...base, suggestions: generateSuggestions(base) });
-  }
-  return result.sort((a, b) => b.totalDuplicatedLines - a.totalDuplicatedLines);
-}
-
-/** Format clone families as structured text for LLM consumption. */
-export function formatCloneFamilies(families: CloneFamily[]): string {
-  if (families.length === 0) return 'No clone families detected.';
-  const lines: string[] = [`Clone Families (${families.length} total):`];
-  for (const f of families.slice(0, 20)) {
-    lines.push(`\n  ${f.totalDuplicatedLines} duplicated lines across ${f.files.length} files:`);
-    for (const file of f.files) lines.push(`    ${file}`);
-    for (const s of f.suggestions) lines.push(`  -> [${s.kind}] ${s.description}`);
-  }
-  if (families.length > 20) lines.push(`\n  ... and ${families.length - 20} more families`);
-  return lines.join('\n');
-}
-
-export function cloneFamilySummary(families: CloneFamily[]): {
-  totalFamilies: number;
-  totalDuplicatedLines: number;
-  byKind: Record<RefactoringKind, number>;
-} {
-  const byKind: Record<RefactoringKind, number> = {
-    ExtractFunction: 0, ExtractModule: 0, MergeDirectories: 0,
-  };
-  let totalDuplicatedLines = 0;
-  for (const f of families) {
-    totalDuplicatedLines += f.totalDuplicatedLines;
-    for (const s of f.suggestions) byKind[s.kind]++;
-  }
-  return {
-    totalFamilies: families.length,
-    totalDuplicatedLines,
-    byKind,
-  };
-}

package/src/graph/codeowners-extended.ts

@@ -1,114 +0,0 @@
-export interface CodeOwnerRuleMatch {
-  ownerCount: number;
-  owners: string[];
-  sectionName: string | null;
-  matchedRule: string;
-}
-
-export interface SectionMatch {
-  sectionName: string | null;
-  sectionOwners: string[];
-  matchedRule: string;
-}
-
-export interface CodeOwnersLike {
-  ownerAndRuleOf?: (path: string) => CodeOwnerRuleMatch | null;
-  sectionAndOwnersOf?: (path: string) => SectionMatch | null;
-  hasSections?: boolean;
-  ownersOf: (path: string) => string[] | null;
-}
-
-export const UNOWNED_LABEL = '(unowned)';
-export const NO_SECTION_LABEL = '(no section)';
-
-export function ownerCountOf(co: CodeOwnersLike, relativePath: string): number | null {
-  if (co.ownerAndRuleOf) {
-    const match = co.ownerAndRuleOf(relativePath);
-    if (!match) return null;
-    return match.ownerCount;
-  }
-  const owners = co.ownersOf(relativePath);
-  if (owners === null) return null;
-  return owners.length;
-}
-
-export function sectionOf(co: CodeOwnersLike, relativePath: string): string | null | undefined {
-  if (!co.sectionAndOwnersOf) return undefined;
-  const match = co.sectionAndOwnersOf(relativePath);
-  if (!match) return undefined;
-  return match.sectionName;
-}
-
-export function sectionAndOwnersOf(co: CodeOwnersLike, relativePath: string): SectionMatch | null {
-  if (!co.sectionAndOwnersOf) return null;
-  return co.sectionAndOwnersOf(relativePath) ?? null;
-}
-
-export function hasGitLabSections(co: CodeOwnersLike): boolean {
-  return co.hasSections ?? false;
-}
-
-export function ownerLabel(co: CodeOwnersLike, relativePath: string): string {
-  const owners = co.ownersOf(relativePath);
-  if (owners === null) return UNOWNED_LABEL;
-  if (owners.length === 0) {
-    const section = sectionOf(co, relativePath);
-    if (section === null) return NO_SECTION_LABEL;
-    return UNOWNED_LABEL;
-  }
-  return owners[0];
-}
-
-export interface OwnershipAggregate {
-  /** Paths that have no owner. */
-  unowned: string[];
-  /** Map from owner handle → list of owned file paths. */
-  byOwner: Map<string, string[]>;
-  /** Total files analyzed. */
-  totalFiles: number;
-}
-
-/**
- * Aggregate ownership across a list of relative paths in a single pass.
- * Each file is attributed to its primary owner (first in the owners list).
- */
-export function aggregateOwnership(
-  co: CodeOwnersLike,
-  relativePaths: string[],
-): OwnershipAggregate {
-  const unowned: string[] = [];
-  const byOwner = new Map<string, string[]>();
-
-  for (const path of relativePaths) {
-    const owners = co.ownersOf(path);
-    if (!owners || owners.length === 0) {
-      unowned.push(path);
-    } else {
-      const primary = owners[0];
-      let bucket = byOwner.get(primary);
-      if (!bucket) { bucket = []; byOwner.set(primary, bucket); }
-      bucket.push(path);
-    }
-  }
-
-  return { unowned, byOwner, totalFiles: relativePaths.length };
-}
-
-/**
- * Format an OwnershipAggregate as structured text for LLM consumption.
- */
-export function formatOwnershipReport(agg: OwnershipAggregate): string {
-  const lines: string[] = [
-    `Ownership report: ${agg.totalFiles} files, ${agg.byOwner.size} owner(s), ${agg.unowned.length} unowned`,
-    '',
-  ];
-  // Sort owners by file count descending
-  const sorted = Array.from(agg.byOwner.entries()).sort((a, b) => b[1].length - a[1].length);
-  for (const [owner, files] of sorted) {
-    lines.push(`  ${owner}: ${files.length} file(s)`);
-  }
-  if (agg.unowned.length > 0) {
-    lines.push(`  ${UNOWNED_LABEL}: ${agg.unowned.length} file(s)`);
-  }
-  return lines.join('\n');
-}

package/src/graph/codeowners-gitlab.ts

@@ -1,150 +0,0 @@
-export const UNOWNED_LABEL = 'UNOWNED';
-export const NO_SECTION_LABEL = '(no section)';
-
-export const CODEOWNERS_PROBE_PATHS = [
-  'CODEOWNERS',
-  'docs/CODEOWNERS',
-  '.github/CODEOWNERS',
-  '.gitlab/CODEOWNERS',
-];
-
-export interface SectionHeader {
-  name: string;
-  optional: boolean;
-  minApprovals?: number;
-  defaultOwners: string[];
-}
-
-const SECTION_HEADER_RE = /^(\^)?\[([^\]]+)\](?:\[(\d+)\])?\s*(.*)?$/;
-
-export function parseSectionHeader(line: string): SectionHeader | null {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith('[') && !trimmed.startsWith('^[')) return null;
-  const m = trimmed.match(SECTION_HEADER_RE);
-  if (!m) return null;
-  const optional = m[1] === '^';
-  const name = m[2]!.trim();
-  const minApprovals = m[3] ? parseInt(m[3], 10) : undefined;
-  const defaultOwners = (m[4] ?? '').trim().split(/\s+/).filter(Boolean);
-  return { name, optional, minApprovals, defaultOwners };
-}
-
-export interface CodeownersEntry {
-  pattern: string;
-  owners: string[];
-  section?: string;
-  negated: boolean;
-}
-
-export function parseCodeownersWithSections(content: string): CodeownersEntry[] {
-  const entries: CodeownersEntry[] = [];
-  let currentSection: string | undefined;
-  let sectionDefaults: string[] = [];
-
-  for (const raw of content.split('\n')) {
-    const line = raw.trim();
-    if (!line || line.startsWith('#')) continue;
-    const sectionHeader = parseSectionHeader(line);
-    if (sectionHeader) {
-      currentSection = sectionHeader.name;
-      sectionDefaults = sectionHeader.defaultOwners;
-      if (sectionDefaults.length > 0) {
-        entries.push({ pattern: '**/*', owners: sectionDefaults, section: currentSection, negated: false });
-      }
-      continue;
-    }
-    const negated = line.startsWith('!');
-    const rest = negated ? line.slice(1).trim() : line;
-    const parts = rest.split(/\s+/);
-    const pattern = parts[0];
-    if (!pattern) continue;
-    const owners = negated ? [] : parts.slice(1);
-    entries.push({ pattern, owners, section: currentSection, negated });
-  }
-  return entries;
-}
-
-export function matchOwners(entries: CodeownersEntry[], filePath: string): { owners: string[]; section?: string } {
-  // Import minimatch dynamically to avoid circular deps — use simple suffix matching as fallback
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const entry = entries[i]!;
-    if (pathMatchesPattern(filePath, entry.pattern)) {
-      if (entry.negated) return { owners: [], section: entry.section };
-      return { owners: entry.owners, section: entry.section };
-    }
-  }
-  return { owners: [], section: undefined };
-}
-
-function pathMatchesPattern(filePath: string, pattern: string): boolean {
-  const norm = filePath.replace(/\\/g, '/');
-  const pat = pattern.replace(/\\/g, '/');
-  if (pat === '**/*') return true;
-  if (pat.startsWith('**')) return norm.endsWith(pat.slice(2));
-  if (pat.startsWith('/')) return norm === pat.slice(1) || norm.startsWith(pat.slice(1) + '/');
-  if (pat.endsWith('/')) return norm.startsWith(pat);
-  return norm === pat || norm.endsWith('/' + pat) || norm.startsWith(pat + '/');
-}
-
-/** Single-call helper — avoids triple matchOwners invocations when callers need all three fields. */
-export function singleFileOwnership(entries: CodeownersEntry[], filePath: string): { section: string; owners: string[]; ownerCount: number } {
-  const { owners, section } = matchOwners(entries, filePath);
-  return { section: section ?? NO_SECTION_LABEL, owners, ownerCount: owners.length };
-}
-
-export function ownerCountOf(entries: CodeownersEntry[], filePath: string): number {
-  return matchOwners(entries, filePath).owners.length;
-}
-
-export function sectionOf(entries: CodeownersEntry[], filePath: string): string {
-  return matchOwners(entries, filePath).section ?? NO_SECTION_LABEL;
-}
-
-export function sectionAndOwnersOf(entries: CodeownersEntry[], filePath: string): { section: string; owners: string[] } {
-  const { owners, section } = matchOwners(entries, filePath);
-  return { section: section ?? NO_SECTION_LABEL, owners };
-}
-
-export function hasSections(entries: CodeownersEntry[]): boolean {
-  return entries.some(e => e.section !== undefined);
-}
-
-export interface CodeownersGitlabReport {
-  totalEntries: number;
-  hasSections: boolean;
-  sectionNames: string[];
-  ownershipSummary: Array<{ file: string; section: string; owners: string[] }>;
-}
-
-/**
- * Format a batch file-ownership report for LLM consumption.
- * Uses singleFileOwnership() to avoid N*3 matchOwners scans.
- */
-export function formatCodeownersGitlab(entries: CodeownersEntry[], filePaths: string[]): string {
-  if (entries.length === 0) return 'No CODEOWNERS entries found.';
-
-  const sections = new Set<string>();
-  const rows: Array<{ file: string; section: string; owners: string[] }> = [];
-  for (const fp of filePaths) {
-    const { section, owners } = singleFileOwnership(entries, fp);
-    sections.add(section);
-    rows.push({ file: fp, section, owners });
-  }
-
-  const unowned = rows.filter(r => r.owners.length === 0);
-  const lines: string[] = [
-    `CODEOWNERS (GitLab) — ${entries.length} entries, ${sections.size} section(s)`,
-    `Sections: ${[...sections].join(', ') || '(none)'}`,
-    `Files scanned: ${filePaths.length}  Unowned: ${unowned.length}`,
-    '',
-  ];
-  for (const r of rows) {
-    const ownerStr = r.owners.length > 0 ? r.owners.join(' ') : UNOWNED_LABEL;
-    lines.push(`  ${r.file}  [${r.section}]  ${ownerStr}`);
-  }
-  if (unowned.length > 0) {
-    lines.push('', `Unowned files (${unowned.length}):`);
-    for (const r of unowned) lines.push(`  ${r.file}`);
-  }
-  return lines.join('\n');
-}

package/src/graph/codeowners.ts

@@ -1,217 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { join, relative } from 'path';
-import type Database from 'better-sqlite3';
-
-export interface CodeownersEntry {
-  pattern: string;
-  owners: string[];
-}
-
-export interface OwnershipResult {
-  filePath: string;
-  declaredOwners: string[];
-  unowned: boolean;
-}
-
-// Convert a CODEOWNERS glob pattern to a RegExp
-function globToRegex(pattern: string): RegExp {
-  // Strip leading slash (anchors to root — handle separately)
-  const anchored = pattern.startsWith('/');
-  let p = pattern;
-  if (anchored) p = p.slice(1);
-
-  // Trailing slash: match directory and everything beneath it
-  const dirOnly = p.endsWith('/');
-  if (dirOnly) p = p.slice(0, -1);
-
-  // Escape special regex chars except * and ?
-  p = p.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-
-  // ** → match anything (including slashes)
-  p = p.replace(/\*\*/g, '§DOUBLESTAR§');
-  // * → match anything except slash
-  p = p.replace(/\*/g, '[^/]*');
-  // ? → match any single char except slash
-  p = p.replace(/\?/g, '[^/]');
-  // Restore **
-  p = p.replace(/§DOUBLESTAR§/g, '.*');
-
-  let regexStr: string;
-  if (anchored) {
-    // Anchored to repo root
-    if (dirOnly) {
-      regexStr = `^${p}(/|$)`;
-    } else if (p.includes('/')) {
-      // has slash → match full path from root
-      regexStr = `^${p}(/.*)?$`;
-    } else {
-      regexStr = `^${p}(/.*)?$`;
-    }
-  } else if (p.includes('/')) {
-    // Contains slash but not anchored → match from root
-    regexStr = `(^|/)${p}(/.*)?$`;
-  } else {
-    // No slash → match filename anywhere in tree
-    if (dirOnly) {
-      regexStr = `(^|/)${p}(/|$)`;
-    } else {
-      regexStr = `(^|/)${p}(/.*)?$`;
-    }
-  }
-
-  return new RegExp(regexStr);
-}
-
-// Parse CODEOWNERS from repoRoot/.github/CODEOWNERS, repoRoot/CODEOWNERS, or repoRoot/docs/CODEOWNERS
-// Last matching rule wins (GitHub semantics)
-export function parseCodeowners(repoRoot: string): CodeownersEntry[] {
-  const candidates = [
-    join(repoRoot, '.github', 'CODEOWNERS'),
-    join(repoRoot, 'CODEOWNERS'),
-    join(repoRoot, 'docs', 'CODEOWNERS'),
-  ];
-
-  let content: string | null = null;
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      content = readFileSync(candidate, 'utf-8');
-      break;
-    }
-  }
-
-  if (!content) return [];
-
-  const entries: CodeownersEntry[] = [];
-  for (const rawLine of content.split('\n')) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith('#')) continue;
-
-    const parts = line.split(/\s+/);
-    const pattern = parts[0];
-    const owners = parts.slice(1).filter(o => o.startsWith('@') || o.includes('@'));
-
-    if (pattern) {
-      entries.push({ pattern, owners });
-    }
-  }
-
-  return entries;
-}
-
-// ── Compiled entry (regex precompiled once) ────────────────────────────────────
-
-export interface CompiledEntry {
-  owners: string[];
-  re: RegExp;
-}
-
-/**
- * Compile an array of CodeownersEntry into CompiledEntry objects so that
- * globToRegex() runs exactly once per pattern instead of once per file lookup.
- */
-export function compileEntries(entries: CodeownersEntry[]): CompiledEntry[] {
-  return entries.map(e => ({ owners: e.owners, re: globToRegex(e.pattern) }));
-}
-
-// Resolve owner for a single file path using precompiled regexes.
-// Last matching entry wins (GitHub semantics).
-export function resolveOwnerCompiled(compiled: CompiledEntry[], filePath: string): string[] {
-  const normalised = filePath.replace(/\\/g, '/').replace(/^\.\//, '');
-  let lastMatch: CompiledEntry | null = null;
-  for (const entry of compiled) {
-    if (entry.re.test(normalised)) lastMatch = entry;
-  }
-  return lastMatch ? lastMatch.owners : [];
-}
-
-// Resolve owner for a single file path (relative to repoRoot)
-// Last matching entry wins
-export function resolveOwner(entries: CodeownersEntry[], filePath: string): string[] {
-  // Normalize path to use forward slashes, remove leading ./
-  const normalised = filePath.replace(/\\/g, '/').replace(/^\.\//, '');
-
-  let lastMatch: CodeownersEntry | null = null;
-  for (const entry of entries) {
-    const regex = globToRegex(entry.pattern);
-    if (regex.test(normalised)) {
-      lastMatch = entry;
-    }
-  }
-
-  return lastMatch ? lastMatch.owners : [];
-}
-
-// Annotate all File nodes in the DB with their owners (stored in properties.codeowners)
-export function annotateOwnership(
-  db: Database.Database,
-  repoRoot: string,
-): { annotated: number; unowned: number } {
-  const entries = parseCodeowners(repoRoot);
-  // Compile regexes once for all file nodes — avoids O(files * patterns) re-compilations.
-  const compiled = compileEntries(entries);
-
-  const fileNodes = db
-    .prepare(`SELECT id, file_path, properties FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`)
-    .all() as { id: string; file_path: string; properties: string | null }[];
-
-  let annotated = 0;
-  let unowned = 0;
-
-  const update = db.prepare(`UPDATE nodes SET properties = ? WHERE id = ?`);
-
-  const updateAll = db.transaction(() => {
-    for (const node of fileNodes) {
-      const relPath = relative(repoRoot, node.file_path).replace(/\\/g, '/');
-      const owners = resolveOwnerCompiled(compiled, relPath);
-      const existing = node.properties ? JSON.parse(node.properties) : {};
-      const updated = { ...existing, codeowners: owners };
-      update.run(JSON.stringify(updated), node.id);
-
-      if (owners.length > 0) {
-        annotated++;
-      } else {
-        unowned++;
-      }
-    }
-  });
-
-  updateAll();
-
-  return { annotated, unowned };
-}
-
-// Group a list of findings by owner
-// Findings with no filePath or no matching pattern bucket under 'unowned'
-// If a file has multiple owners, the finding appears under each owner key
-export function groupByOwner<T extends { filePath?: string | null }>(
-  findings: T[],
-  entries: CodeownersEntry[],
-): Map<string, T[]> {
-  // Compile patterns once for all findings to avoid O(findings * patterns) regex constructions.
-  const compiled = compileEntries(entries);
-  const result = new Map<string, T[]>();
-
-  for (const finding of findings) {
-    if (!finding.filePath) {
-      const bucket = result.get('unowned') ?? [];
-      bucket.push(finding);
-      result.set('unowned', bucket);
-      continue;
-    }
-
-    const owners = resolveOwnerCompiled(compiled, finding.filePath);
-    if (owners.length === 0) {
-      const bucket = result.get('unowned') ?? [];
-      bucket.push(finding);
-      result.set('unowned', bucket);
-    } else {
-      for (const owner of owners) {
-        const bucket = result.get(owner) ?? [];
-        bucket.push(finding);
-        result.set(owner, bucket);
-      }
-    }
-  }
-
-  return result;
-}