@monoes/monograph 1.5.5 → 1.5.7

package/src/pipeline/phases/middleware-extractor.ts

@@ -1,127 +0,0 @@
-// ── Middleware chain extractor ────────────────────────────────────────────────
-//
-// Pure regex-based extraction (no tree-sitter). Only scans the first 3000 chars
-// of source for performance. Handles four patterns:
-//
-//   1. nested:  withAuth(withRateLimit(handler))
-//   2. compose: compose(withAuth, withRateLimit)(handler)
-//   3. array:   app.get('/path', authMiddleware, handler)   (args before handler)
-//   4. none:    plain handler usage
-//
-// Next.js middleware.ts detection: if the source file itself exports a
-// `middleware` function with a `matcher` config, it is treated as a middleware
-// file rather than performing per-route handler scanning.
-
-export type WrapperPattern = 'compose' | 'nested' | 'array' | 'none';
-
-export interface MiddlewareInfo {
-  middlewareNames: string[];
-  wrapperPattern: WrapperPattern;
-}
-
-const SCAN_LIMIT = 3000;
-
-/**
- * Extracts the middleware chain wrapping a named handler in source code.
- *
- * @param source     Full source text of the handler file.
- * @param handlerName  The name of the handler function to look for.
- * @returns  MiddlewareInfo with names in outermost-first order.
- */
-export function extractMiddlewareChain(source: string, handlerName: string): MiddlewareInfo {
-  const snippet = source.slice(0, SCAN_LIMIT);
-
-  // ── Pattern 0: Next.js middleware.ts ──────────────────────────────────────
-  // If the file exports a `middleware` function and has a `matcher` config,
-  // treat it as a global middleware file — no per-route wrapping to extract.
-  const isNextMiddleware =
-    /export\s+(?:default\s+)?(?:async\s+)?function\s+middleware\b/.test(snippet) &&
-    /matcher/.test(snippet);
-  if (isNextMiddleware) {
-    return { middlewareNames: ['middleware.ts'], wrapperPattern: 'none' };
-  }
-
-  // ── Pattern 1: compose / pipe ─────────────────────────────────────────────
-  // Matches: compose(withAuth, withRateLimit)(handler)  or  pipe(...)(handler)
-  const composeRe = /(?:compose|pipe)\s*\(([\s\S]*?)\)\s*\(\s*HANDLER_NAME\s*\)/;
-  const composeSrc = composeRe.source.replace('HANDLER_NAME', escapeRe(handlerName));
-  const composeMatch = new RegExp(composeSrc, 'i').exec(snippet);
-  if (composeMatch) {
-    const names = composeMatch[1]
-      .split(',')
-      .map((s) => s.trim())
-      .filter((s) => /^[A-Za-z_$][\w$]*$/.test(s));
-    if (names.length > 0) {
-      return { middlewareNames: names, wrapperPattern: 'compose' };
-    }
-  }
-
-  // ── Pattern 2: nested wrappers ────────────────────────────────────────────
-  // Matches: withAuth(withRateLimit(handler)) — walks outward iteratively.
-  const nestedNames = extractNestedWrappers(snippet, handlerName);
-  if (nestedNames.length > 0) {
-    return { middlewareNames: nestedNames, wrapperPattern: 'nested' };
-  }
-
-  // ── Pattern 3: array / positional args (Express-style) ───────────────────
-  // Matches: app.METHOD('/path', mw1, mw2, handler)
-  // Extract identifiers that appear *before* the handler in the same call.
-  const arrayNames = extractArrayMiddleware(snippet, handlerName);
-  if (arrayNames.length > 0) {
-    return { middlewareNames: arrayNames, wrapperPattern: 'array' };
-  }
-
-  return { middlewareNames: [], wrapperPattern: 'none' };
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-/** Escape a string for use as a regex literal. */
-function escapeRe(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Walk outward from the innermost `wrapper(handler)` occurrence.
- * Returns names in outermost-first order, e.g. ['withAuth', 'withRateLimit']
- * for `withAuth(withRateLimit(handler))`.
- */
-function extractNestedWrappers(snippet: string, handlerName: string): string[] {
-  const wrappers: string[] = [];
-  let inner = escapeRe(handlerName);
-
-  // Each iteration tries to find `someIdent(inner)` in the snippet.
-  // Limit iterations to prevent pathological loops.
-  for (let i = 0; i < 10; i++) {
-    const re = new RegExp(`([A-Za-z_$][\\w$]*)\\s*\\(\\s*${inner}\\s*\\)`, 'i');
-    const m = re.exec(snippet);
-    if (!m) break;
-    wrappers.unshift(m[1]); // outermost first
-    inner = escapeRe(m[1]) + `\\s*\\(\\s*${inner}\\s*\\)`;
-  }
-
-  return wrappers;
-}
-
-/**
- * Detect Express-style middleware arrays:
- *   app.get('/path', mw1, mw2, handler)
- * Returns identifier args that appear before `handler` in the same call.
- */
-function extractArrayMiddleware(snippet: string, handlerName: string): string[] {
-  // Match: something.method('path', ...args, handler  — capture everything before handler
-  const re = new RegExp(
-    `\\.(?:get|post|put|delete|patch|use)\\s*\\(\\s*['"][^'"]*['"]\\s*,\\s*([^)]+?)\\s*\\b${escapeRe(handlerName)}\\b`,
-    'i',
-  );
-  const m = re.exec(snippet);
-  if (!m) return [];
-
-  const before = m[1];
-  const names = before
-    .split(',')
-    .map((s) => s.trim())
-    .filter((s) => /^[A-Za-z_$][\w$]*$/.test(s));
-
-  return names;
-}

package/src/pipeline/phases/module-resolution.ts

@@ -1,294 +0,0 @@
-// ── Module resolution for import specifiers ──────────────────────────────────
-
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join, extname, dirname, resolve as resolvePath } from 'path';
-import type { MonographNode } from '../../types.js';
-import { TS_JS_EXTS, CJS_MJS_EXTS } from './call-site-extractors.js';
-
-// ── Import regexes ───────────────────────────────────────────────────────────
-
-export const IMPORT_RE = /import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+)))?\s+from\s+['"]([^'"]+)['"]/g;
-export const REQUIRE_RE = /(?:const|let|var)\s+(?:\{([^}]+)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-const PY_FROM_IMPORT_RE = /from\s+([\w.]+)\s+import\s+(.+)/g;
-const PY_IMPORT_RE = /^import\s+([\w.]+)(?:\s+as\s+(\w+))?/gm;
-const GO_IMPORT_RE = /import\s+(?:"([^"]+)"|(?:\w+\s+)?"([^"]+)"|\(\s*([\s\S]*?)\s*\))/g;
-const JAVA_IMPORT_RE = /import\s+(?:static\s+)?([\w.]+)\s*;/g;
-const RUST_USE_RE = /use\s+((?:crate|super|self)(?:::\w+)+)(?:::\{([^}]+)\})?;/g;
-export const REEXPORT_RE = /export\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
-
-const RESOLVE_EXTS = ['.ts', '.tsx', '.js', '.jsx'];
-
-const PY_EXTS = new Set(['.py']);
-const GO_EXTS = new Set(['.go']);
-const JAVA_EXTS = new Set(['.java']);
-const RUST_EXTS = new Set(['.rs']);
-
-// ── Workspace package map ────────────────────────────────────────────────────
-
-const workspacePackageMapCache = new Map<string, Map<string, string>>();
-
-export function clearWorkspacePackageMapCache(repoPath: string): void {
-  workspacePackageMapCache.delete(repoPath);
-}
-
-export function buildWorkspacePackageMap(repoPath: string): Map<string, string> {
-  const cached = workspacePackageMapCache.get(repoPath);
-  if (cached) return cached;
-  const result = new Map<string, string>();
-  const packagesDir = join(repoPath, 'packages');
-  try {
-    const scanDirs = (base: string, depth: number) => {
-      if (depth > 2) return;
-      let entries: string[];
-      try { entries = readdirSync(base); } catch { return; }
-      for (const e of entries) {
-        const full = join(base, e);
-        const pkgJson = join(full, 'package.json');
-        try {
-          const pkg = JSON.parse(readFileSync(pkgJson, 'utf-8'));
-          if (pkg.name) {
-            const relDir = full.slice(repoPath.length + 1);
-            result.set(pkg.name, relDir);
-          }
-        } catch {
-          if (e.startsWith('@')) scanDirs(full, depth + 1);
-        }
-      }
-    };
-    scanDirs(packagesDir, 0);
-  } catch { /* no packages dir */ }
-  workspacePackageMapCache.set(repoPath, result);
-  return result;
-}
-
-// ── Specifier resolvers ──────────────────────────────────────────────────────
-
-export function resolveModuleSpecifier(
-  importerPath: string,
-  specifier: string,
-  repoPath: string,
-  knownFiles: Set<string>,
-  workspaceMap: Map<string, string>,
-): string | null {
-  if (specifier.startsWith('.')) {
-    const dir = dirname(importerPath);
-    const raw = resolvePath('/', dir, specifier).slice(1);
-    const base = raw.replace(/\.(js|jsx)$/, '');
-
-    for (const candidate of [
-      raw,
-      base,
-      ...RESOLVE_EXTS.map(e => base + e),
-      ...RESOLVE_EXTS.map(e => base + '/index' + e),
-    ]) {
-      if (knownFiles.has(candidate)) return candidate;
-    }
-
-    for (const ext of RESOLVE_EXTS) {
-      if (existsSync(join(repoPath, base + ext))) return base + ext;
-    }
-    return null;
-  }
-
-  for (const [pkgName, pkgDir] of workspaceMap) {
-    if (specifier === pkgName) {
-      for (const entry of RESOLVE_EXTS.map(e => pkgDir + '/src/index' + e)) {
-        if (knownFiles.has(entry)) return entry;
-      }
-      return null;
-    }
-    if (specifier.startsWith(pkgName + '/')) {
-      const subpath = specifier.slice(pkgName.length + 1);
-      const base = pkgDir + '/' + subpath;
-      for (const candidate of [
-        base,
-        ...RESOLVE_EXTS.map(e => base + e),
-        ...RESOLVE_EXTS.map(e => base + '/index' + e),
-      ]) {
-        if (knownFiles.has(candidate)) return candidate;
-      }
-      return null;
-    }
-  }
-
-  return null;
-}
-
-function resolvePythonModule(importerPath: string, modulePath: string, knownFiles: Set<string>): string | null {
-  const dir = dirname(importerPath);
-  for (const base of [dir + '/' + modulePath, modulePath]) {
-    for (const candidate of [base + '.py', base + '/__init__.py']) {
-      if (knownFiles.has(candidate)) return candidate;
-    }
-  }
-  return null;
-}
-
-function resolveGoPackage(_importerPath: string, goPath: string, knownFiles: Set<string>): string | null {
-  for (const f of knownFiles) {
-    if (f.startsWith(goPath + '/') && f.endsWith('.go')) return f;
-  }
-  return null;
-}
-
-function resolveJavaImport(qualifiedName: string, knownFiles: Set<string>): string | null {
-  const pathPart = qualifiedName.replace(/\./g, '/');
-  for (const candidate of [pathPart + '.java', 'src/main/java/' + pathPart + '.java', 'src/' + pathPart + '.java']) {
-    if (knownFiles.has(candidate)) return candidate;
-  }
-  if (pathPart.endsWith('/*')) {
-    const dir = pathPart.slice(0, -2);
-    for (const f of knownFiles) {
-      if (f.endsWith('.java') && (f.startsWith(dir + '/') || f.includes('/' + dir + '/'))) return f;
-    }
-  }
-  return null;
-}
-
-function resolveRustUse(usePath: string, importerPath: string, knownFiles: Set<string>): string | null {
-  const parts = usePath.split('::');
-  if (parts[0] === 'crate') parts[0] = 'src';
-  else if (parts[0] === 'super') {
-    const dir = dirname(importerPath);
-    parts[0] = dirname(dir);
-  } else if (parts[0] === 'self') {
-    parts[0] = dirname(importerPath);
-  }
-  for (let len = parts.length; len >= 2; len--) {
-    const base = parts.slice(0, len).join('/');
-    for (const candidate of [base + '.rs', base + '/mod.rs']) {
-      if (knownFiles.has(candidate)) return candidate;
-    }
-  }
-  return null;
-}
-
-// ── Import name extraction ───────────────────────────────────────────────────
-
-export function extractImportNames(clause: string): string[] {
-  return clause
-    .split(',')
-    .map(s => s.trim().split(/\s+as\s+/).pop()!.trim())
-    .filter(Boolean);
-}
-
-// ── Build import maps from source ────────────────────────────────────────────
-
-export function buildAllImportMapsFromSource(
-  repoPath: string,
-  fileNodesByPath: Map<string, MonographNode>,
-  fileContents?: Map<string, string>,
-): Map<string, Map<string, string>> {
-  const result = new Map<string, Map<string, string>>();
-  const knownFiles = new Set(fileNodesByPath.keys());
-  const workspaceMap = buildWorkspacePackageMap(repoPath);
-
-  for (const [filePath, fileNode] of fileNodesByPath) {
-    const ext = extname(filePath).toLowerCase();
-    const importMap = new Map<string, string>();
-
-    let source: string | undefined = fileContents?.get(filePath);
-    if (!source) {
-      try {
-        source = readFileSync(join(repoPath, filePath), 'utf-8');
-      } catch {
-        continue;
-      }
-    }
-
-    if (TS_JS_EXTS.has(ext) || ext === '.cjs' || ext === '.mjs') {
-      IMPORT_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = IMPORT_RE.exec(source)) !== null) {
-        const specifier = m[7];
-        const resolved = resolveModuleSpecifier(filePath, specifier, repoPath, knownFiles, workspaceMap);
-        if (!resolved) continue;
-        if (m[1]) for (const n of extractImportNames(m[1])) importMap.set(n, resolved);
-        if (m[4]) for (const n of extractImportNames(m[4])) importMap.set(n, resolved);
-        if (m[2]) importMap.set(m[2], resolved);
-        if (m[5]) importMap.set(m[5], resolved);
-        if (m[3]) importMap.set(m[3], resolved);
-        if (m[6]) importMap.set(m[6], resolved);
-        const baseName = resolved.split('/').pop()!.replace(/\.\w+$/, '');
-        importMap.set(baseName, resolved);
-      }
-
-      REQUIRE_RE.lastIndex = 0;
-      while ((m = REQUIRE_RE.exec(source)) !== null) {
-        const specifier = m[3];
-        const resolved = resolveModuleSpecifier(filePath, specifier, repoPath, knownFiles, workspaceMap);
-        if (!resolved) continue;
-        if (m[1]) for (const n of extractImportNames(m[1])) importMap.set(n, resolved);
-        if (m[2]) importMap.set(m[2], resolved);
-        const baseName = resolved.split('/').pop()!.replace(/\.\w+$/, '');
-        importMap.set(baseName, resolved);
-      }
-    } else if (PY_EXTS.has(ext)) {
-      PY_FROM_IMPORT_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = PY_FROM_IMPORT_RE.exec(source)) !== null) {
-        const modulePath = m[1].replace(/\./g, '/');
-        const resolved = resolvePythonModule(filePath, modulePath, knownFiles);
-        if (!resolved) continue;
-        for (const name of m[2].split(',').map(s => s.trim().split(/\s+as\s+/).pop()!.trim()).filter(Boolean)) {
-          importMap.set(name, resolved);
-        }
-        const baseName = resolved.split('/').pop()!.replace(/\.\w+$/, '');
-        importMap.set(baseName, resolved);
-      }
-      PY_IMPORT_RE.lastIndex = 0;
-      while ((m = PY_IMPORT_RE.exec(source)) !== null) {
-        const modulePath = m[1].replace(/\./g, '/');
-        const resolved = resolvePythonModule(filePath, modulePath, knownFiles);
-        if (!resolved) continue;
-        const alias = m[2] ?? m[1].split('.').pop()!;
-        importMap.set(alias, resolved);
-      }
-    } else if (GO_EXTS.has(ext)) {
-      GO_IMPORT_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = GO_IMPORT_RE.exec(source)) !== null) {
-        const paths = m[3]
-          ? m[3].match(/"([^"]+)"/g)?.map(s => s.slice(1, -1)) ?? []
-          : [m[1] ?? m[2]].filter(Boolean);
-        for (const goPath of paths) {
-          const resolved = resolveGoPackage(filePath, goPath, knownFiles);
-          if (!resolved) continue;
-          const pkgName = goPath.split('/').pop()!;
-          importMap.set(pkgName, resolved);
-        }
-      }
-    } else if (JAVA_EXTS.has(ext)) {
-      JAVA_IMPORT_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = JAVA_IMPORT_RE.exec(source)) !== null) {
-        const resolved = resolveJavaImport(m[1], knownFiles);
-        if (!resolved) continue;
-        const className = m[1].split('.').pop()!;
-        importMap.set(className, resolved);
-      }
-    } else if (RUST_EXTS.has(ext)) {
-      RUST_USE_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      while ((m = RUST_USE_RE.exec(source)) !== null) {
-        if (m[2]) {
-          for (const name of m[2].split(',').map(s => s.trim()).filter(Boolean)) {
-            const resolved = resolveRustUse(m[1] + '::' + name, filePath, knownFiles);
-            if (resolved) importMap.set(name.split('::').pop()!, resolved);
-          }
-        } else {
-          const resolved = resolveRustUse(m[1], filePath, knownFiles);
-          if (!resolved) continue;
-          const itemName = m[1].split('::').pop()!;
-          importMap.set(itemName, resolved);
-        }
-      }
-    }
-
-    if (importMap.size > 0) {
-      result.set(fileNode.id, importMap);
-    }
-  }
-
-  return result;
-}

package/src/pipeline/phases/mro.ts

@@ -1,56 +0,0 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { MonographEdge } from '../../types.js';
-import { makeId, CONFIDENCE_SCORE } from '../../types.js';
-import type { ParseOutput } from './parse.js';
-
-export interface MroOutput {
-  mroEdges: MonographEdge[];
-}
-
-export const mroPhase: PipelinePhase<MroOutput> = {
-  name: 'mro',
-  deps: ['parse'],
-  async execute(_ctx, deps) {
-    const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
-
-    // Method nodes — used to filter CONTAINS edges (the relation actually emitted by the extractor)
-    const methodIds = new Set(symbolNodes.filter(n => n.label === 'Method').map(n => n.id));
-
-    const classMethodsIndex = new Map<string, string[]>();
-    for (const edge of allEdges) {
-      // Extractor emits CONTAINS for method-in-class; HAS_METHOD is never produced
-      if (edge.relation === 'CONTAINS' && methodIds.has(edge.targetId)) {
-        const methods = classMethodsIndex.get(edge.sourceId) ?? [];
-        methods.push(edge.targetId);
-        classMethodsIndex.set(edge.sourceId, methods);
-      }
-    }
-
-    const nameIndex = new Map(symbolNodes.map(n => [n.id, n.name]));
-    const mroEdges: MonographEdge[] = [];
-
-    for (const edge of allEdges) {
-      if (edge.relation !== 'EXTENDS' && edge.relation !== 'IMPLEMENTS') continue;
-
-      const parentMethods = classMethodsIndex.get(edge.targetId) ?? [];
-      const childMethods = classMethodsIndex.get(edge.sourceId) ?? [];
-      const parentMethodNames = new Map(parentMethods.map(id => [nameIndex.get(id) ?? id, id]));
-
-      for (const childMethodId of childMethods) {
-        const childName = nameIndex.get(childMethodId);
-        if (!childName) continue;
-        const parentMethodId = parentMethodNames.get(childName);
-        if (!parentMethodId) continue;
-
-        const relation = edge.relation === 'IMPLEMENTS' ? 'METHOD_IMPLEMENTS' : 'METHOD_OVERRIDES';
-        mroEdges.push({
-          id: makeId(childMethodId, parentMethodId, relation.toLowerCase()),
-          sourceId: childMethodId, targetId: parentMethodId,
-          relation, confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-        });
-      }
-    }
-
-    return { mroEdges };
-  },
-};