@monoes/monograph 1.5.5 → 1.5.7

package/src/pipeline/phases/contextual-proximity.ts

@@ -1,88 +0,0 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { MonographEdge } from '../../types.js';
-import { makeId, CONFIDENCE_SCORE } from '../../types.js';
-import { insertEdges } from '../../storage/edge-store.js';
-
-export interface ContextualProximityOutput {
-  coOccursEdges: number;
-  conceptsScored: number;
-}
-
-export const contextualProximityPhase: PipelinePhase<ContextualProximityOutput> = {
-  name: 'contextual-proximity',
-  deps: ['docs-parse', 'pdf-parse'],
-
-  async execute(ctx: PipelineContext) {
-    if (ctx.options.codeOnly) return { coOccursEdges: 0, conceptsScored: 0 };
-
-    // Fetch all Section → Concept links from TAGGED_AS edges
-    const rows = ctx.db
-      .prepare(`SELECT source_id, target_id FROM edges WHERE relation = 'TAGGED_AS'`)
-      .all() as { source_id: string; target_id: string }[];
-
-    if (rows.length === 0) return { coOccursEdges: 0, conceptsScored: 0 };
-
-    // Group concepts by section using ??= to avoid has+get pattern
-    const sectionConcepts = new Map<string, string[]>();
-    for (const { source_id, target_id } of rows) {
-      let list = sectionConcepts.get(source_id);
-      if (!list) { list = []; sectionConcepts.set(source_id, list); }
-      list.push(target_id);
-    }
-
-    // Count concept co-occurrences across all sections.
-    // Accumulate conceptDegree in the same pass to avoid a second loop over sectionConcepts.
-    // Use a ternary comparison instead of [a,b].sort() to avoid per-pair array allocation.
-    const coOccur = new Map<string, number>();
-    const conceptDegree = new Map<string, number>();
-    for (const concepts of sectionConcepts.values()) {
-      for (let i = 0; i < concepts.length; i++) {
-        conceptDegree.set(concepts[i], (conceptDegree.get(concepts[i]) ?? 0) + 1);
-        for (let j = i + 1; j < concepts.length; j++) {
-          // Avoid allocating a 2-element sort array — ternary comparison is equivalent
-          const a = concepts[i] <= concepts[j] ? concepts[i] : concepts[j];
-          const b = concepts[i] <= concepts[j] ? concepts[j] : concepts[i];
-          const key = `${a}::${b}`;
-          coOccur.set(key, (coOccur.get(key) ?? 0) + 1);
-        }
-      }
-    }
-
-    // Build CO_OCCURS edges (weight = number of sections where both concepts appear)
-    const edges: MonographEdge[] = [];
-    for (const [key, weight] of coOccur) {
-      const sep = key.indexOf('::');
-      const sourceId = key.slice(0, sep);
-      const targetId = key.slice(sep + 2);
-      edges.push({
-        id: makeId(sourceId, targetId, 'co_occurs'),
-        sourceId,
-        targetId,
-        relation: 'CO_OCCURS',
-        confidence: 'INFERRED',
-        confidenceScore: CONFIDENCE_SCORE.INFERRED,
-        weight,
-      });
-    }
-
-    if (conceptDegree.size > 0) {
-      // Compute maxDeg with a loop to avoid spread array allocation from [...values()]
-      let maxDeg = 0;
-      for (const deg of conceptDegree.values()) { if (deg > maxDeg) maxDeg = deg; }
-      const update = ctx.db.prepare(
-        `UPDATE nodes SET properties = json_set(COALESCE(properties, '{}'), '$.importance', ?) WHERE id = ?`,
-      );
-      ctx.db.transaction(() => {
-        for (const [cid, deg] of conceptDegree) {
-          const importance = Math.max(1, Math.ceil((deg / maxDeg) * 5));
-          update.run(importance, cid);
-        }
-      })();
-    }
-
-    if (edges.length > 0) insertEdges(ctx.db, edges);
-
-    ctx.onProgress?.({ phase: 'contextual-proximity', message: `${edges.length} CO_OCCURS edges, ${conceptDegree.size} concepts scored` });
-    return { coOccursEdges: edges.length, conceptsScored: conceptDegree.size };
-  },
-};

package/src/pipeline/phases/cross-file.ts

@@ -1,116 +0,0 @@
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import type { PipelinePhase } from '../types.js';
-import type { MonographEdge } from '../../types.js';
-import { makeId, CONFIDENCE_SCORE } from '../../types.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type { ParseOutput } from './parse.js';
-import type { StructureOutput } from './structure.js';
-import { resolveModuleSpecifier, buildWorkspacePackageMap } from './scope-resolution.js';
-
-export interface CrossFileOutput {
-  resolvedEdges: MonographEdge[];
-}
-
-// Mirrors parsers/extractor.ts's re-export detection regex — used here to recover
-// the ORIGINAL specifier string behind a RE_EXPORTS edge's mangled placeholder id
-// (makeId('import', specifier) is lossy: '/' and '.' are collapsed to '_', so the
-// placeholder can't be reversed directly — we re-derive it from source instead).
-const RE_EXPORT_RE = /export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g;
-
-// monolean: IMPORTS name-matching removed — it matched import names against a
-// global symbol index (e.g. `import fs` → random Variable named `fs` in wrong file).
-// scope-resolution.ts now handles cross-file CALLS via source-parsed import maps.
-export const crossFilePhase: PipelinePhase<CrossFileOutput> = {
-  name: 'cross-file',
-  deps: ['parse', 'structure'],
-  async execute(ctx, deps) {
-    const { allEdges } = deps.get('parse') as ParseOutput;
-    const { fileNodes } = deps.get('structure') as StructureOutput;
-
-    const reExportEdges = allEdges.filter((e) => e.relation === 'RE_EXPORTS');
-    const resolvedEdges: MonographEdge[] = [];
-
-    if (reExportEdges.length > 0) {
-      // fileId <-> filePath maps for resolving edge endpoints to real file nodes.
-      const fileIdToPath = new Map<string, string>();
-      const knownFiles = new Set<string>();
-      for (const fileNode of fileNodes) {
-        if (fileNode.filePath) {
-          fileIdToPath.set(fileNode.id, fileNode.filePath);
-          knownFiles.add(fileNode.filePath);
-        }
-      }
-      const filePathToId = new Map<string, string>();
-      for (const [id, path] of fileIdToPath) filePathToId.set(path, id);
-
-      const workspaceMap = buildWorkspacePackageMap(ctx.repoPath);
-
-      // Group by importing file so each source file is read at most once.
-      const edgesBySource = new Map<string, MonographEdge[]>();
-      for (const edge of reExportEdges) {
-        const arr = edgesBySource.get(edge.sourceId);
-        if (arr) arr.push(edge);
-        else edgesBySource.set(edge.sourceId, [edge]);
-      }
-
-      for (const [sourceId, edges] of edgesBySource) {
-        const filePath = fileIdToPath.get(sourceId);
-        if (!filePath) continue;
-
-        let source: string;
-        try {
-          source = readFileSync(join(ctx.repoPath, filePath), 'utf-8');
-        } catch {
-          continue;
-        }
-
-        // Recover each `export * / { ... } from '<specifier>'` string, keyed by the
-        // same mangled placeholder id the extractor used (makeId('import', specifier))
-        // so it can be matched back to the corresponding edge.
-        const specifierByPlaceholder = new Map<string, string>();
-        RE_EXPORT_RE.lastIndex = 0;
-        let m: RegExpExecArray | null;
-        while ((m = RE_EXPORT_RE.exec(source)) !== null) {
-          const specifier = m[1]!;
-          specifierByPlaceholder.set(makeId('import', specifier), specifier);
-        }
-
-        for (const edge of edges) {
-          const specifier = specifierByPlaceholder.get(edge.targetId);
-          if (!specifier) continue;
-
-          // Resolve relative to THIS importing file's own directory (reusing the
-          // same resolver scope-resolution.ts uses for IMPORTS) instead of an
-          // ambiguous global basename lookup that collides on repeated basenames
-          // like index.ts / utils.ts across the repo.
-          const resolvedPath = resolveModuleSpecifier(
-            filePath,
-            specifier,
-            ctx.repoPath,
-            knownFiles,
-            workspaceMap,
-          );
-          if (!resolvedPath) continue;
-
-          const resolvedId = filePathToId.get(resolvedPath);
-          if (!resolvedId || resolvedId === edge.targetId) continue;
-
-          resolvedEdges.push({
-            ...edge,
-            id: makeId(edge.sourceId, resolvedId, 'reexports_resolved'),
-            targetId: resolvedId,
-            confidence: 'INFERRED',
-            confidenceScore: CONFIDENCE_SCORE.INFERRED,
-          });
-        }
-      }
-    }
-
-    if (ctx.db && resolvedEdges.length > 0) {
-      insertEdges(ctx.db, resolvedEdges);
-    }
-
-    return { resolvedEdges };
-  },
-};

package/src/pipeline/phases/docs-parse.ts

@@ -1,307 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { extname, basename, join } from 'path';
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-import { makeId, toNormLabel, CONFIDENCE_SCORE } from '../../types.js';
-import { insertNodes } from '../../storage/node-store.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type { StructureOutput } from './structure.js';
-
-const DOC_EXTENSIONS = new Set(['.md', '.mdx', '.txt', '.rst']);
-
-interface HeadingEntry {
-  level: number;
-  title: string;
-  startLine: number;
-  endLine: number;
-  content: string;
-}
-
-interface LinkRef {
-  target: string;
-  isWiki: boolean;
-}
-
-export interface DocsParseOutput {
-  sectionNodes: MonographNode[];
-  docFiles: number;
-}
-
-// ── Frontmatter ───────────────────────────────────────────────────────────────
-
-function parseFrontmatter(text: string): { meta: Record<string, unknown>; body: string; lineOffset: number } {
-  const fmMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
-  if (!fmMatch) return { meta: {}, body: text, lineOffset: 0 };
-
-  const yaml = fmMatch[1];
-  const meta: Record<string, unknown> = {};
-  let currentKey: string | null = null;
-
-  for (const line of yaml.split('\n')) {
-    const keyOnlyMatch = line.match(/^(\w[\w-]*)\s*:\s*$/);
-    if (keyOnlyMatch) {
-      currentKey = keyOnlyMatch[1];
-      meta[currentKey] = [];
-      continue;
-    }
-    const itemMatch = line.match(/^\s+-\s+(.+)$/);
-    if (itemMatch && currentKey && Array.isArray(meta[currentKey])) {
-      (meta[currentKey] as string[]).push(itemMatch[1].trim().replace(/^["']|["']$/g, ''));
-      continue;
-    }
-    if (line && !line.match(/^\s/)) currentKey = null;
-    const kvMatch = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
-    if (!kvMatch) continue;
-    const key = kvMatch[1];
-    const val = kvMatch[2].trim();
-    if (val.startsWith('[')) {
-      meta[key] = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
-    } else {
-      meta[key] = val.replace(/^["']|["']$/g, '');
-    }
-  }
-
-  const lineOffset = fmMatch[0].split('\n').length - 1;
-  return { meta, body: text.slice(fmMatch[0].length), lineOffset };
-}
-
-// ── Heading extraction ────────────────────────────────────────────────────────
-
-function extractHeadings(body: string, lineOffset: number): HeadingEntry[] {
-  const lines = body.split('\n');
-  const positions: Array<{ level: number; title: string; idx: number }> = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const m = lines[i].match(/^(#{1,6})\s+(.+?)(?:\s+#+)?$/);
-    if (m) positions.push({ level: m[1].length, title: m[2].trim(), idx: i });
-  }
-
-  return positions.map((h, i) => {
-    const nextIdx = positions[i + 1]?.idx ?? lines.length;
-    return {
-      level: h.level,
-      title: h.title,
-      startLine: lineOffset + h.idx + 1,
-      endLine: lineOffset + nextIdx,
-      content: lines.slice(h.idx + 1, nextIdx).join('\n').trim(),
-    };
-  });
-}
-
-// ── Link extraction ───────────────────────────────────────────────────────────
-
-function extractLinks(text: string): LinkRef[] {
-  const links: LinkRef[] = [];
-  for (const m of text.matchAll(/\[\[([^\]|#]+)(?:[|#][^\]]+)?\]\]/g)) {
-    links.push({ target: m[1].trim(), isWiki: true });
-  }
-  for (const m of text.matchAll(/\[[^\]]+\]\(([^)]+\.mdx?(?:#[^)]*)?)\)/g)) {
-    const href = m[1].split('#')[0].trim();
-    if (!href.startsWith('http')) links.push({ target: href, isWiki: false });
-  }
-  return links;
-}
-
-// ── Tag extraction ────────────────────────────────────────────────────────────
-
-function extractTags(text: string, meta: Record<string, unknown>): string[] {
-  const tags = new Set<string>();
-  for (const key of ['tags', 'tag', 'categories', 'category']) {
-    const v = meta[key];
-    if (Array.isArray(v)) v.forEach(t => typeof t === 'string' && tags.add(t.toLowerCase()));
-    else if (typeof v === 'string') tags.add(v.toLowerCase());
-  }
-  for (const m of text.matchAll(/(?<![a-z0-9])#([a-z][a-z0-9_-]+)/gi)) {
-    tags.add(m[1].toLowerCase());
-  }
-  return [...tags];
-}
-
-// ── Phase ─────────────────────────────────────────────────────────────────────
-
-export const docsParsePhase: PipelinePhase<DocsParseOutput> = {
-  name: 'docs-parse',
-  deps: ['structure'],
-
-  async execute(ctx, deps) {
-    // Respect codeOnly flag
-    if (ctx.options.codeOnly) return { sectionNodes: [], docFiles: 0 };
-
-    const { fileNodes } = deps.get('structure') as StructureOutput;
-    const docFiles = fileNodes.filter(n => n.filePath && DOC_EXTENSIONS.has(extname(n.filePath).toLowerCase()));
-    if (docFiles.length === 0) return { sectionNodes: [], docFiles: 0 };
-
-    const fileByRel = new Map<string, MonographNode>(docFiles.map(n => [n.filePath!, n]));
-    const fileByName = new Map<string, MonographNode>(
-      docFiles.map(n => [basename(n.filePath!).replace(/\.mdx?$/, '').toLowerCase(), n])
-    );
-
-    const sectionNodes: MonographNode[] = [];
-    // Key: `${fileId}::${normTitle}` to avoid cross-file title collisions
-    const sectionByKey = new Map<string, MonographNode>();
-    const conceptNodes = new Map<string, MonographNode>();
-    const allEdges: MonographEdge[] = [];
-    const deferredRefs: Array<{ sourceId: string; fileId: string; target: string; isWiki: boolean }> = [];
-
-    for (const fileNode of docFiles) {
-      const absPath = join(ctx.repoPath, fileNode.filePath!);
-      let text: string;
-      try {
-        const st = statSync(absPath);
-        if (st.size > ctx.options.maxFileSizeBytes) continue;
-        text = readFileSync(absPath, 'utf-8');
-      } catch { continue; }
-
-      const { meta, body, lineOffset } = parseFrontmatter(text);
-      const headings = extractHeadings(body, lineOffset);
-      const fileTags = extractTags('', meta);
-
-      // No headings → single Section node for the whole file
-      if (headings.length === 0) {
-        const title = (meta['title'] as string | undefined) ?? basename(fileNode.filePath!).replace(/\.[^.]+$/, '');
-        const sectionId = makeId('section', fileNode.id, 'root');
-        const node: MonographNode = {
-          id: sectionId, label: 'Section',
-          name: title, normLabel: toNormLabel(title),
-          filePath: fileNode.filePath, startLine: 1, endLine: text.split('\n').length,
-          isExported: false,
-          properties: { ...meta, level: 0, content: body.slice(0, 2000) },
-        };
-        sectionNodes.push(node);
-        sectionByKey.set(`${fileNode.id}::${toNormLabel(title)}`, node);
-
-        allEdges.push({
-          id: makeId(fileNode.id, sectionId, 'defines'),
-          sourceId: fileNode.id, targetId: sectionId,
-          relation: 'DEFINES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-        });
-
-        wireTagEdges(sectionId, fileTags, conceptNodes, allEdges);
-        for (const lnk of extractLinks(body)) deferredRefs.push({ sourceId: sectionId, fileId: fileNode.id, ...lnk });
-        continue;
-      }
-
-      // Preamble content: text before the first heading
-      const firstHeadingStart = headings[0].startLine - lineOffset - 1;
-      const preamble = body.split('\n').slice(0, firstHeadingStart).join('\n').trim();
-
-      // Build section nodes with parent hierarchy
-      const stack: Array<{ level: number; id: string }> = [];
-      let firstSectionId: string | null = null;
-
-      for (const h of headings) {
-        const sectionId = makeId('section', fileNode.id, toNormLabel(h.title), String(h.startLine));
-        if (!firstSectionId) firstSectionId = sectionId;
-
-        const node: MonographNode = {
-          id: sectionId, label: 'Section',
-          name: h.title, normLabel: toNormLabel(h.title),
-          filePath: fileNode.filePath, startLine: h.startLine, endLine: h.endLine,
-          isExported: false,
-          properties: { ...meta, level: h.level, content: h.content.slice(0, 2000) },
-        };
-        sectionNodes.push(node);
-        // Scoped key: fileId::normTitle — prevents cross-file title collisions
-        sectionByKey.set(`${fileNode.id}::${toNormLabel(h.title)}`, node);
-
-        // File → Section (DEFINES)
-        allEdges.push({
-          id: makeId(fileNode.id, sectionId, 'defines'),
-          sourceId: fileNode.id, targetId: sectionId,
-          relation: 'DEFINES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-        });
-
-        // Parent section → this section (PARENT_SECTION)
-        while (stack.length > 0 && stack[stack.length - 1].level >= h.level) stack.pop();
-        if (stack.length > 0) {
-          const parentId = stack[stack.length - 1].id;
-          allEdges.push({
-            id: makeId(parentId, sectionId, 'parent_section'),
-            sourceId: parentId, targetId: sectionId,
-            relation: 'PARENT_SECTION', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-        stack.push({ level: h.level, id: sectionId });
-
-        wireTagEdges(sectionId, extractTags(h.content, {}), conceptNodes, allEdges);
-        for (const lnk of extractLinks(h.content)) deferredRefs.push({ sourceId: sectionId, fileId: fileNode.id, ...lnk });
-      }
-
-      // Preamble links/tags → attach to first section
-      if (preamble && firstSectionId) {
-        wireTagEdges(firstSectionId, extractTags(preamble, {}), conceptNodes, allEdges);
-        for (const lnk of extractLinks(preamble)) deferredRefs.push({ sourceId: firstSectionId, fileId: fileNode.id, ...lnk });
-      }
-
-      // Frontmatter tags → first section
-      if (fileTags.length > 0 && firstSectionId) {
-        wireTagEdges(firstSectionId, fileTags, conceptNodes, allEdges);
-      }
-    }
-
-    // Resolve deferred REFERENCES edges
-    // Wiki links resolve within the same file first, then fall back to cross-file
-    const seenRefs = new Set<string>();
-    for (const ref of deferredRefs as Array<{ sourceId: string; fileId: string; target: string; isWiki: boolean }>) {
-      let target: MonographNode | undefined;
-
-      if (ref.isWiki) {
-        // Same-file resolution first (avoids cross-file title collisions)
-        const normTarget = toNormLabel(ref.target);
-        target = sectionByKey.get(`${ref.fileId}::${normTarget}`);
-        if (!target) {
-          // Cross-file: search all files for matching title
-          for (const [key, node] of sectionByKey) {
-            if (key.endsWith(`::${normTarget}`)) { target = node; break; }
-          }
-        }
-        if (!target) target = fileByName.get(normTarget);
-      } else {
-        target = fileByRel.get(ref.target.replace(/^\.\//, ''))
-          ?? fileByName.get(basename(ref.target).replace(/\.mdx?$/, '').toLowerCase());
-      }
-
-      if (target) {
-        const edgeId = makeId(ref.sourceId, target.id, 'references');
-        if (!seenRefs.has(edgeId)) {
-          seenRefs.add(edgeId);
-          allEdges.push({
-            id: edgeId, sourceId: ref.sourceId, targetId: target.id,
-            relation: 'REFERENCES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-      }
-    }
-
-    // File nodes are never persisted by structure/parse phases — insert them here
-    // so DEFINES/REFERENCES edges can satisfy FK constraints.
-    insertNodes(ctx.db, docFiles);
-    if (sectionNodes.length > 0) insertNodes(ctx.db, sectionNodes);
-    if (conceptNodes.size > 0) insertNodes(ctx.db, [...conceptNodes.values()]);
-    if (allEdges.length > 0) insertEdges(ctx.db, allEdges);
-
-    ctx.onProgress?.({ phase: 'docs-parse', message: `Parsed ${docFiles.length} doc files → ${sectionNodes.length} sections` });
-    return { sectionNodes, docFiles: docFiles.length };
-  },
-};
-
-function wireTagEdges(
-  sourceId: string,
-  tags: string[],
-  conceptNodes: Map<string, MonographNode>,
-  edges: MonographEdge[],
-): void {
-  for (const tag of tags) {
-    const conceptId = makeId('concept', tag.replace(/[^a-z0-9]/g, '_'));
-    if (!conceptNodes.has(conceptId)) {
-      conceptNodes.set(conceptId, {
-        id: conceptId, label: 'Concept', name: tag, normLabel: toNormLabel(tag), isExported: false,
-      });
-    }
-    edges.push({
-      id: makeId(sourceId, conceptId, 'tagged_as'),
-      sourceId, targetId: conceptId,
-      relation: 'TAGGED_AS', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-    });
-  }
-}

package/src/pipeline/phases/evidence.ts

@@ -1,9 +0,0 @@
-import type { EvidenceEntry } from '../../types.js';
-
-export function makeEvidence(kind: string, weight: number, note?: string): EvidenceEntry {
-  return { kind, weight: Math.max(0, Math.min(1, weight)), note };
-}
-
-export function mergeEvidence(existing: EvidenceEntry[] | undefined, entry: EvidenceEntry): EvidenceEntry[] {
-  return [...(existing ?? []), entry];
-}

package/src/pipeline/phases/field-access.ts

@@ -1,49 +0,0 @@
-export type AccessReason = 'read' | 'write';
-
-export interface FieldAccess {
-  varName: string;
-  field: string;
-  reason: AccessReason;
-  line: number;
-}
-
-function escapeRegexChars(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export function extractFieldAccesses(source: string, varName: string, filePath: string): FieldAccess[] {
-  const results: FieldAccess[] = [];
-  const lines = source.split('\n');
-  const escapedName = escapeRegexChars(varName);
-
-  // Hoist regex construction outside the loop — both patterns are fixed for the
-  // entire call, so creating them once avoids O(lines) RegExp allocations.
-  // Write: varName.field = or varName.field +=/-=/*=
-  const writeRe = new RegExp(`\\b${escapedName}\\.(\\w+)\\s*(?:\\+|-|\\*|\\/|%)?=(?!=)`, 'g');
-  // Read: varName.field NOT followed by assignment operator
-  const readRe = new RegExp(`\\b${escapedName}\\.(\\w+)`, 'g');
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    // Reset stateful lastIndex before each line (required for reused /g regexes).
-    writeRe.lastIndex = 0;
-    readRe.lastIndex = 0;
-
-    const writeFields = new Set<string>();
-    let m: RegExpExecArray | null;
-
-    while ((m = writeRe.exec(line)) !== null) {
-      writeFields.add(m[1]);
-      results.push({ varName, field: m[1], reason: 'write', line: i + 1 });
-    }
-
-    while ((m = readRe.exec(line)) !== null) {
-      if (!writeFields.has(m[1])) {
-        results.push({ varName, field: m[1], reason: 'read', line: i + 1 });
-      }
-    }
-  }
-
-  return results;
-}

package/src/pipeline/phases/framework-detect.ts

@@ -1,109 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import type { PipelinePhase, PipelineContext } from '../types.js';
-
-export type SupportedFramework =
-  | 'react' | 'vue' | 'angular' | 'svelte'
-  | 'express' | 'fastify' | 'nestjs' | 'koa'
-  | 'django' | 'flask' | 'fastapi'
-  | 'spring' | 'rails' | 'laravel';
-
-export type PrimaryLanguage = 'javascript' | 'python' | 'java' | 'ruby' | 'php' | null;
-
-export interface FrameworkDetectOutput {
-  frameworks: SupportedFramework[];
-  primaryLanguage: PrimaryLanguage;
-  confidence: Record<SupportedFramework, number>;
-}
-
-const NPM_FRAMEWORK_MAP: Record<string, SupportedFramework> = {
-  'react': 'react', 'react-dom': 'react',
-  'vue': 'vue', '@vue/core': 'vue',
-  '@angular/core': 'angular',
-  'svelte': 'svelte',
-  'express': 'express',
-  'fastify': 'fastify',
-  '@nestjs/core': 'nestjs',
-  'koa': 'koa',
-};
-
-const PYTHON_FRAMEWORK_MAP: Record<string, SupportedFramework> = {
-  'Django': 'django', 'django': 'django',
-  'Flask': 'flask', 'flask': 'flask',
-  'fastapi': 'fastapi', 'FastAPI': 'fastapi',
-};
-
-export function detectFrameworks(repoPath: string): FrameworkDetectOutput {
-  const detected = new Map<SupportedFramework, number>();
-  let primaryLanguage: PrimaryLanguage = null;
-
-  const pkgPath = join(repoPath, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
-      for (const dep of Object.keys(allDeps)) {
-        const fw = NPM_FRAMEWORK_MAP[dep];
-        if (fw) {
-          detected.set(fw, Math.max(detected.get(fw) ?? 0, 0.9));
-          primaryLanguage = 'javascript';
-        }
-      }
-    } catch { /* malformed JSON */ }
-  }
-
-  const reqPath = join(repoPath, 'requirements.txt');
-  if (existsSync(reqPath)) {
-    const lines = readFileSync(reqPath, 'utf8').split('\n');
-    for (const line of lines) {
-      const pkg = line.split(/[=><!]/)[0]?.trim() ?? '';
-      const fw = PYTHON_FRAMEWORK_MAP[pkg];
-      if (fw) {
-        detected.set(fw, Math.max(detected.get(fw) ?? 0, 0.9));
-        primaryLanguage = 'python';
-      }
-    }
-  }
-
-  const pomPath = join(repoPath, 'pom.xml');
-  if (existsSync(pomPath)) {
-    const pom = readFileSync(pomPath, 'utf8');
-    if (pom.includes('spring-boot') || pom.includes('spring-web')) {
-      detected.set('spring', Math.max(detected.get('spring') ?? 0, 0.85));
-      primaryLanguage = 'java';
-    }
-  }
-
-  const gemfilePath = join(repoPath, 'Gemfile');
-  if (existsSync(gemfilePath)) {
-    const gemfile = readFileSync(gemfilePath, 'utf8');
-    if (gemfile.includes("gem 'rails'") || gemfile.includes('gem "rails"')) {
-      detected.set('rails', Math.max(detected.get('rails') ?? 0, 0.9));
-      primaryLanguage = 'ruby';
-    }
-  }
-
-  const composerPath = join(repoPath, 'composer.json');
-  if (existsSync(composerPath)) {
-    try {
-      const composer = JSON.parse(readFileSync(composerPath, 'utf8'));
-      const reqs = { ...composer.require, ...composer['require-dev'] };
-      if (reqs['laravel/framework']) {
-        detected.set('laravel', Math.max(detected.get('laravel') ?? 0, 0.9));
-        primaryLanguage = 'php';
-      }
-    } catch { /* malformed JSON */ }
-  }
-
-  const frameworks = [...detected.keys()];
-  const confidence = Object.fromEntries(detected) as Record<SupportedFramework, number>;
-  return { frameworks, primaryLanguage, confidence };
-}
-
-export const frameworkDetectPhase: PipelinePhase<FrameworkDetectOutput> = {
-  name: 'framework-detect',
-  deps: ['scan'],
-  async execute(ctx: PipelineContext): Promise<FrameworkDetectOutput> {
-    return detectFrameworks(ctx.repoPath);
-  },
-};