@polycode-projects/seonix 0.2.1 → 0.4.0

package/src/extract.mjs

@@ -18,14 +18,15 @@
 //   mgx:subclassOf          Class  → Class    (inheritance; internal base resolved, else ext:)
 
 import { spawn } from "node:child_process";
-import { writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { writeFile, mkdir, readdir, stat } from "node:fs/promises";
+import { basename, dirname, join, parse, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as codegraph from "./codegraph.mjs"; // optional renderToolsCatalog (other agent owns this file)
 import { ingestRepo, LANG_EXTS } from "./extract_lang.mjs";
 import { loadIgnores } from "./walk.mjs";
 import { attachProseTokens, buildProseIndex } from "./prose.mjs";
 import { ingestSchemaDocs } from "./schema-docs.mjs";
+import { foldInSessions, readSessionRecords } from "./sessions.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const AST_SCRIPT = join(here, "extract_ast.py");
@@ -194,16 +195,36 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
   for (const m of modules) {
     for (const d of m.defines || []) {
       if (d.kind === "method" || d.kind === "attribute" || d.kind === "global") continue; // not standalone call targets
-      if (!nameToPaths.has(d.name)) nameToPaths.set(d.name, new Set());
-      nameToPaths.get(d.name).add(m.path);
-      if (!nameToSymbolIds.has(d.name)) nameToSymbolIds.set(d.name, new Set());
-      nameToSymbolIds.get(d.name).add(fnId(m.path, d.name));
-      if (d.kind === "class") {
-        if (!classToPaths.has(d.name)) classToPaths.set(d.name, new Set());
-        classToPaths.get(d.name).add(m.path);
+      const register = (name) => {
+        if (!nameToPaths.has(name)) nameToPaths.set(name, new Set());
+        nameToPaths.get(name).add(m.path);
+        if (!nameToSymbolIds.has(name)) nameToSymbolIds.set(name, new Set());
+        nameToSymbolIds.get(name).add(fnId(m.path, d.name));
+        if (d.kind === "class") {
+          if (!classToPaths.has(name)) classToPaths.set(name, new Set());
+          classToPaths.get(name).add(m.path);
+        }
+      };
+      register(d.name);
+      // Nested types (Java/C#) define dotted names like Outer.Inner — ALSO register the
+      // simple name so `new Inner()` / `extends Inner` still resolve. Same Set semantics:
+      // a second definition of the simple name makes it ambiguous → dropped, honest.
+      if (d.kind === "class" && d.name.includes(".")) {
+        const simple = lastIdent(d.name);
+        if (simple && simple !== d.name) register(simple);
       }
     }
   }
+  // Resolve a class SIMPLE name at a path to the id of its (possibly nested, dotted)
+  // define — nameToSymbolIds keeps full ids, so a unique in-path match wins; an exact
+  // plain define beats a nested one; else fall back to the literal id (pre-nesting shape).
+  const classIdAt = (path, ident) => {
+    const pre = `fn:${path}#`;
+    const exact = `${pre}${ident}`;
+    const ids = [...(nameToSymbolIds.get(ident) || [])].filter((i) => i.startsWith(pre));
+    if (ids.includes(exact) || ids.length !== 1) return exact;
+    return ids[0];
+  };
 
   // resolve a module's import candidates to internal module paths
   const internalImports = (m) => {
@@ -270,6 +291,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
         if (d.raises?.length) attrs.push({ prop: "seon:throwsException", key: "raises", value: list(d.raises) });
         if (d.catches?.length) attrs.push({ prop: "seon:catchesException", key: "catches", value: list(d.catches) });
         if (d.self_fields?.length) attrs.push({ prop: "seon:accessesField", key: "self_fields", value: list(d.self_fields) });
+        if (d.subkind) attrs.push({ prop: "seon:subKind", key: "subkind", value: String(d.subkind) });
         if (d.is_static) attrs.push({ prop: "seon:isStatic", key: "isStatic", value: "true" });
         if (d.is_abstract) attrs.push({ prop: "seon:isAbstract", key: "isAbstract", value: "true" });
         if (d.is_constant) attrs.push({ prop: "seon:isConstant", key: "isConstant", value: "true" });
@@ -305,10 +327,10 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
           const defs = classToPaths.get(ident);
           let object = `ext:${ident}`;
           if (defs && defs.has(m.path)) {
-            object = fnId(m.path, ident); // same-module base wins (local name scoping), even if the name is globally ambiguous
+            object = classIdAt(m.path, ident); // same-module base wins (local name scoping), even if the name is globally ambiguous
           } else if (defs && defs.size === 1) {
             const targetPath = [...defs][0];
-            if (imports.has(targetPath)) object = fnId(targetPath, ident);
+            if (imports.has(targetPath)) object = classIdAt(targetPath, ident);
           }
           const ikey = `${oid}>${object}`;
           if (seenInherits.has(ikey) || object === oid) continue;
@@ -376,7 +398,9 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       touchedBy.get(f).push(`git:${short}`);
       touchedAny = true;
     }
-    if (touchedAny) {
+    // !commitIds.has: a merged multi-repo commit list CAN repeat a sha (two clones of
+    // the same project indexed under different names) — one Commit individual per sha.
+    if (touchedAny && !commitIds.has(c.sha)) {
       commitIds.add(c.sha);
       commitIndividuals.push(commitInd(c.sha, short, c));
     }
@@ -514,6 +538,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       { prop: "seon:isStatic", note: "@staticmethod/@classmethod" },
       { prop: "seon:isAbstract", note: "@abstractmethod/@abstractproperty" },
       { prop: "seon:isConstant", note: "ALL_CAPS module global" },
+      { prop: "seon:subKind", note: "type flavour on a Class define when not a plain class (interface/enum/struct/record); kind stays class" },
       { prop: "seon:hasAccessModifier", note: "visibility from leading underscore (private/protected); public omitted" },
       { prop: "seon:hasDoc", note: "first docstring line (capped) — one-line purpose without the body" },
     ],
@@ -591,17 +616,13 @@ function localToolsCatalog(cliPath) {
   return lines.join("\n");
 }
 
-/**
- * Index a repository: parse (ast) + git log → entities → write <repo>/.seonix/graph.json
- * (+ a TOOLS.md catalog of the cold tools). Times the base extraction vs the added
- * symbol-history (line-range) pass so the latter can be kept within the ≤10% budget.
- * @returns {Promise<{graphFile, counts}>}
- */
-export async function indexRepository(repoPath, { python = process.env.SEONIX_PYTHON || process.env.SEON_PYTHON || "python3", generatedAt = "", ignores = true } = {}) {
+const DEFAULT_PYTHON = () => process.env.SEONIX_PYTHON || process.env.SEON_PYTHON || "python3";
+
+/** One repo's raw extraction — parsers + git, NO graph assembly. Both index modes
+ *  build on this; multi-repo runs it repo-by-repo so only one repo's raw source
+ *  (parser/git-log output) is in memory at a time. */
+async function extractRepo(repoPath, { python = DEFAULT_PYTHON(), ignores = true } = {}) {
   const t0 = Date.now();
-  // Second pass (PLAN_PROSE_INDEX.md): on by default; SEONIX_PROSE_INDEX=0 disables it
-  // (mirrors SEONIX_HISTORY_SYMBOL_DEPTH=0's disable convention above).
-  const proseEnabled = process.env.SEONIX_PROSE_INDEX !== "0";
   // `.seonixignore` (opt-out: `ignores:false`, the benchmark rig's flag). The matcher
   // prunes the in-process walkers (extract_lang) at parse time; the module filter below
   // is the AUTHORITATIVE cut — it also covers extractors that walk on their own
@@ -625,14 +646,24 @@ export async function indexRepository(repoPath, { python = process.env.SEONIX_PY
   const tHist = Date.now();
   const symbolHistory = await runGitLogHunks(repoPath, historySymbolDepth());
   const historyMs = Date.now() - tHist;
+  return { modules, perLang: langResult.perLang, commits, symbolHistory, baseMs, historyMs };
+}
 
+/** Assemble entities from (possibly merged) extractions and write the artifacts
+ *  (<rootDir>/.seonix/graph.json + TOOLS.md). Shared by both index modes. */
+async function assembleAndWrite(rootDir, { modules, commits, symbolHistory, generatedAt, proseEnabled, sessions = [] }) {
   const entities = buildEntities(modules, commits, { generatedAt, symbolHistory, prose: proseEnabled });
   // Schema self-documentation (schema-docs.mjs): static, repo-independent — merges in
   // SchemaClass/SchemaPredicate individuals + backfills entities.classes[].description
   // and entities.vocabulary[].note, so "what does cochange mean" is answerable by the
   // same graph traversal as any other question. Fixed-size, ~0ms marginal cost.
   ingestSchemaDocs(entities);
-  const graphFile = join(repoPath, ".seonix", "graph.json");
+  // Chat sessions (sessions.mjs): sessions are runtime observations, not source
+  // derivations — they are re-attached AFTER the source-derived build, each recorded
+  // entity id re-resolved against the fresh graph (unresolvable → edge dropped and
+  // counted on the Session node, never guessed). No sessions → byte-identical output.
+  if (sessions.length) foldInSessions(entities, sessions);
+  const graphFile = join(rootDir, ".seonix", "graph.json");
   await mkdir(dirname(graphFile), { recursive: true });
   await writeFile(graphFile, JSON.stringify(entities));
 
@@ -641,27 +672,177 @@ export async function indexRepository(repoPath, { python = process.env.SEONIX_PY
   const toolsMd = typeof codegraph.renderToolsCatalog === "function"
     ? codegraph.renderToolsCatalog(CLI_SCRIPT)
     : localToolsCatalog(CLI_SCRIPT);
-  await writeFile(join(repoPath, ".seonix", "TOOLS.md"), toolsMd);
+  await writeFile(join(rootDir, ".seonix", "TOOLS.md"), toolsMd);
+  return { entities, graphFile };
+}
 
+function buildCounts(entities, { modules, languages, commits, proseEnabled, baseMs, historyMs }) {
   const propCount = (prop) => entities.objectProperties.find((g) => g.prop === prop)?.count ?? 0;
   // history budget: the symbol pass should add ≤10% over base extraction time.
   const historyPct = baseMs > 0 ? Math.round((historyMs / baseMs) * 1000) / 10 : 0;
+  return {
+    modules,
+    languages,
+    functions: entities.classes.find((c) => c.name === "Function")?.count ?? 0,
+    commits,
+    edges: entities.objectProperties.reduce((n, g) => n + g.count, 0),
+    callsSymbol: propCount("mgx:callsSymbol"),
+    touchesSymbol: propCount("mgx:touchesSymbol"),
+    historySymbolDepth: historySymbolDepth(),
+    proseEnabled,
+    proseWords: Object.keys(entities.proseIndex || {}).length,
+    baseMs,
+    historyMs,
+    historyPct,
+  };
+}
+
+/**
+ * Index a repository: parse (ast) + git log → entities → write <repo>/.seonix/graph.json
+ * (+ a TOOLS.md catalog of the cold tools). Times the base extraction vs the added
+ * symbol-history (line-range) pass so the latter can be kept within the ≤10% budget.
+ * @returns {Promise<{graphFile, counts}>}
+ */
+export async function indexRepository(repoPath, { python = DEFAULT_PYTHON(), generatedAt = "", ignores = true } = {}) {
+  // Second pass (PLAN_PROSE_INDEX.md): on by default; SEONIX_PROSE_INDEX=0 disables it
+  // (mirrors SEONIX_HISTORY_SYMBOL_DEPTH=0's disable convention above).
+  const proseEnabled = process.env.SEONIX_PROSE_INDEX !== "0";
+  const { modules, perLang, commits, symbolHistory, baseMs, historyMs } = await extractRepo(repoPath, { python, ignores });
+  const sessions = await readSessionRecords(repoPath); // recorded chat sessions (.seonix/sessions/*.jsonl), [] when none
+  const { entities, graphFile } = await assembleAndWrite(repoPath, { modules, commits, symbolHistory, generatedAt, proseEnabled, sessions });
   return {
     graphFile,
-    counts: {
-      modules: modules.length,
-      languages: langResult.perLang,
-      functions: entities.classes.find((c) => c.name === "Function")?.count ?? 0,
-      commits: commits.length,
-      edges: entities.objectProperties.reduce((n, g) => n + g.count, 0),
-      callsSymbol: propCount("mgx:callsSymbol"),
-      touchesSymbol: propCount("mgx:touchesSymbol"),
-      historySymbolDepth: historySymbolDepth(),
-      proseEnabled,
-      proseWords: Object.keys(entities.proseIndex || {}).length,
-      baseMs,
-      historyMs,
-      historyPct,
-    },
+    counts: buildCounts(entities, { modules: modules.length, languages: perLang, commits: commits.length, proseEnabled, baseMs, historyMs }),
+  };
+}
+
+// ── multi-repository indexing ────────────────────────────────────────────────
+// n repos → ONE merged graph at <out_root>/.seonix/. Single-path mode above is
+// untouched (no prefix, artifacts in the repo — golden-compat guarded by
+// test/multi-repo.test.mjs). In multi mode every module id/label/dotted gets the
+// repo's directory basename as a leading component, so ids never collide and a
+// reader can tell repos apart. Cross-repo callsSymbol edges arise only where a
+// symbol name resolves uniquely across the whole merged registry (the existing
+// Set-semantics drop ambiguous names — nothing cross-repo-special is done).
+
+/** Deterministic repo-name prefixes for a set of (resolved, deduped) repo paths:
+ *  the directory basename; when two repos share a basename the FIRST in path sort
+ *  order keeps the bare name and later ones get `-2`, `-3`, … appended. */
+export function assignRepoPrefixes(repoPaths) {
+  const map = new Map();
+  const used = new Set();
+  for (const rp of [...repoPaths].sort()) {
+    const base = basename(rp) || rp;
+    let name = base;
+    for (let n = 2; used.has(name); n += 1) name = `${base}-${n}`;
+    used.add(name);
+    map.set(rp, name);
+  }
+  return map;
+}
+
+/** Prefix one repo's raw extraction in place: module path/dotted/imports, commit
+ *  file lists and symbol-history range keys all gain the repo name as a leading
+ *  component (`mod:<repoName>/<relpath>`, dotted `<repoName>.<dotted>`). Imports
+ *  are prefixed IDENTICALLY to dotted names so intra-repo import resolution is
+ *  unchanged and two repos' equal dotted names can never cross-resolve. Commit
+ *  ids (shas) stay as-is — history edges point at the prefixed module ids. */
+export function applyRepoPrefix({ modules, commits, symbolHistory }, prefix) {
+  for (const m of modules) {
+    m.path = `${prefix}/${m.path}`;
+    if (m.dotted) m.dotted = `${prefix}.${m.dotted}`;
+    if (m.imports?.length) m.imports = m.imports.map((i) => `${prefix}.${i}`);
+  }
+  for (const c of commits) c.files = (c.files || []).map((f) => `${prefix}/${f}`);
+  for (const c of symbolHistory) {
+    c.ranges = Object.fromEntries(Object.entries(c.ranges || {}).map(([p, r]) => [`${prefix}/${p}`, r]));
+  }
+}
+
+/** Default merged-artifact root: the deepest common ancestor DIRECTORY of the repo
+ *  paths (segment-wise, so /x/foo and /x/foobar meet at /x, not /x/foo). Falls back
+ *  to `cwd` when the ancestor is the filesystem root. */
+export function defaultOutRoot(repoPaths, cwd = process.cwd()) {
+  const segs = repoPaths.map((p) => resolve(p).split(sep));
+  const first = segs[0];
+  let depth = Math.min(...segs.map((s) => s.length));
+  let i = 0;
+  while (i < depth && segs.every((s) => s[i] === first[i])) i += 1;
+  const ancestor = first.slice(0, i).join(sep) || sep;
+  return ancestor === parse(ancestor).root ? cwd : ancestor;
+}
+
+/** Discovery for the estate case: every immediate child directory of `multiRoot`
+ *  that carries a `.git` (dir OR file — worktrees/submodules have .git files) is a
+ *  repo. Dot-dirs are ignored outright; plain child dirs without .git are returned
+ *  as `skipped` so the caller can log them. */
+export async function discoverRepos(multiRoot) {
+  const root = resolve(multiRoot);
+  const entries = await readdir(root, { withFileTypes: true });
+  entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  const repos = [];
+  const skipped = [];
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith(".")) continue;
+    try {
+      await stat(join(root, e.name, ".git"));
+      repos.push(join(root, e.name));
+    } catch {
+      skipped.push(e.name);
+    }
+  }
+  return { repos, skipped };
+}
+
+/**
+ * Index n repositories into ONE merged graph at <outRoot>/.seonix/. Repos are
+ * extracted sequentially (only one repo's raw parser/git output held at a time;
+ * the accumulated PARSED module list is small) and merged through a single
+ * buildEntities pass, so the unique-name registry spans all repos.
+ * `log` (optional) receives one progress line per repo.
+ * @returns {Promise<{graphFile, outRoot, repos, counts}>}
+ */
+export async function indexRepositories(repoPaths, { python = DEFAULT_PYTHON(), generatedAt = "", ignores = true, outRoot = "", log = () => {} } = {}) {
+  const paths = [...new Set((repoPaths || []).map((p) => resolve(p)))];
+  if (!paths.length) throw new Error("indexRepositories requires at least one repo path");
+  const proseEnabled = process.env.SEONIX_PROSE_INDEX !== "0";
+  const prefixes = assignRepoPrefixes(paths);
+  const root = outRoot ? resolve(outRoot) : defaultOutRoot(paths);
+
+  const allModules = [];
+  const allCommits = [];
+  const allSymbolHistory = [];
+  const languages = {};
+  const repos = [];
+  let baseMs = 0;
+  let historyMs = 0;
+  for (const rp of paths) {
+    const prefix = prefixes.get(rp);
+    const r = await extractRepo(rp, { python, ignores });
+    applyRepoPrefix(r, prefix);
+    allModules.push(...r.modules);
+    allCommits.push(...r.commits);
+    allSymbolHistory.push(...r.symbolHistory);
+    baseMs += r.baseMs;
+    historyMs += r.historyMs;
+    for (const [lang, s] of Object.entries(r.perLang)) {
+      const agg = languages[lang] || (languages[lang] = { lib: s.lib, files: 0, modules: 0, symbols: 0, failures: 0, ms: 0 });
+      agg.files += s.files; agg.modules += s.modules; agg.symbols += s.symbols; agg.failures += s.failures; agg.ms += s.ms;
+    }
+    repos.push({ path: rp, prefix, modules: r.modules.length, commits: r.commits.length });
+    log(`indexed ${prefix} (${rp}): ${r.modules.length} modules, ${r.commits.length} commits in ${r.baseMs + r.historyMs}ms`);
+  }
+
+  // TODO(sessions): multi-repo merges don't fold in the member repos' .seonix/sessions
+  // yet — their recorded ids would need the same repo-name prefixing as modules to
+  // re-resolve against the merged graph. Deferred; single-path fold-in is the contract.
+  const { entities, graphFile } = await assembleAndWrite(root, {
+    modules: allModules, commits: allCommits, symbolHistory: allSymbolHistory, generatedAt, proseEnabled,
+  });
+  return {
+    graphFile,
+    outRoot: root,
+    repos,
+    counts: buildCounts(entities, { modules: allModules.length, languages, commits: allCommits.length, proseEnabled, baseMs, historyMs }),
   };
 }

package/src/java_treesitter.mjs

@@ -36,10 +36,12 @@ const clip = (s, n) => (s.length <= n ? s : s.slice(0, n));
 const fieldText = (n, f) => n.childForFieldName(f)?.text || "";
 
 const TYPE_DECLS = new Set(["class_declaration", "interface_declaration", "enum_declaration", "record_declaration"]);
+const SUBKIND = { interface_declaration: "interface", enum_declaration: "enum", record_declaration: "record" };
 const BASE_WRAPPERS = new Set(["superclass", "super_interfaces", "extends_interfaces", "interfaces"]);
 const TYPE_NODES = new Set(["type_identifier", "generic_type", "scoped_type_identifier"]);
 
-/** Callee names within a node (syntax-level; unresolved). */
+/** Callee names within a node (syntax-level; unresolved). Object creations count as
+ *  call edges to the created type: `new X(...)` → bare "X" (generics/scope stripped). */
 function collectCalls(node) {
   const out = new Set();
   const stack = [node];
@@ -48,6 +50,10 @@ function collectCalls(node) {
     if (n.type === "method_invocation") {
       const nm = fieldText(n, "name");
       if (nm) out.add(clip(nm, 80));
+    } else if (n.type === "object_creation_expression") {
+      const t = n.childForFieldName("type");
+      const nm = t ? oneLine(t.text).replace(/<.*$/s, "").split(".").pop().trim() : "";
+      if (nm) out.add(clip(nm, 80));
     }
     for (let i = 0; i < n.namedChildCount; i++) stack.push(n.namedChild(i));
   }
@@ -104,6 +110,79 @@ function bodyContainer(typeNode) {
     || null;
 }
 
+/** Emit one type declaration (and, recursively, its nested types as Outer.Inner —
+ *  matching the JavaParser backend's qualified names). kind stays "class"; the
+ *  flavour (interface/enum/record) lands in `subkind`. */
+function emitType(n, prefix, defines, exports) {
+  const simple = fieldText(n, "name");
+  if (!simple) return;
+  const cname = prefix ? `${prefix}.${simple}` : simple;
+  const mods = modifiersNode(n);
+  defines.push({
+    name: cname, kind: "class", lineno: line(n), end_lineno: endLine(n),
+    bases: basesOf(n), decorators: decoratorsFrom(mods),
+    ...(SUBKIND[n.type] ? { subkind: SUBKIND[n.type] } : {}),
+    ...(visFrom(mods) ? { visibility: visFrom(mods) } : {}),
+  });
+  if (isPublic(mods)) exports.add(cname);
+
+  // record components (formal params) surface as attributes (match JavaParser)
+  if (n.type === "record_declaration") {
+    const fp = n.childForFieldName("parameters");
+    if (fp) for (let i = 0; i < fp.namedChildCount; i++) {
+      const fpc = fp.namedChild(i);
+      if (fpc.type !== "formal_parameter") continue;
+      const pn = fieldText(fpc, "name");
+      if (pn) defines.push({ name: `${cname}.${pn}`, kind: "attribute", lineno: line(fpc), end_lineno: endLine(fpc), decorators: [] });
+    }
+  }
+
+  const body = bodyContainer(n);
+  if (!body) return;
+  // enum bodies keep constants at the top and wrap the rest in enum_body_declarations
+  const members = [];
+  for (let i = 0; i < body.namedChildCount; i++) {
+    const mem = body.namedChild(i);
+    if (mem.type === "enum_body_declarations") {
+      for (let j = 0; j < mem.namedChildCount; j++) members.push(mem.namedChild(j));
+    } else {
+      members.push(mem);
+    }
+  }
+  for (const mem of members) {
+    if (TYPE_DECLS.has(mem.type)) {
+      emitType(mem, cname, defines, exports); // nested type → Outer.Inner
+    } else if (mem.type === "enum_constant") {
+      const en = fieldText(mem, "name");
+      if (en) defines.push({ name: `${cname}.${en}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem), decorators: [], is_constant: true });
+    } else if (mem.type === "method_declaration" || mem.type === "constructor_declaration") {
+      const mn = fieldText(mem, "name") || cname;
+      const mmods = modifiersNode(mem);
+      const returns = mem.type === "method_declaration"
+        ? clip(oneLine(mem.childForFieldName("type")?.text || ""), 80) : "";
+      defines.push({
+        name: `${cname}.${mn}`, kind: "method", lineno: line(mem), end_lineno: endLine(mem),
+        decorators: decoratorsFrom(mmods), params: paramsText(mem),
+        ...(returns ? { returns } : {}), calls: collectCalls(mem),
+        ...(isStatic(mmods) ? { is_static: true } : {}),
+        ...(visFrom(mmods) ? { visibility: visFrom(mmods) } : {}),
+      });
+    } else if (mem.type === "field_declaration") {
+      const fmods = modifiersNode(mem);
+      for (let j = 0; j < mem.namedChildCount; j++) {
+        const vd = mem.namedChild(j);
+        if (vd.type !== "variable_declarator") continue;
+        const fn = fieldText(vd, "name");
+        if (fn) defines.push({
+          name: `${cname}.${fn}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem),
+          decorators: decoratorsFrom(fmods),
+          ...(visFrom(fmods) ? { visibility: visFrom(fmods) } : {}),
+        });
+      }
+    }
+  }
+}
+
 export async function extractFile(absPath, root) {
   const text = await readFile(absPath, "utf8").catch(() => null);
   const path = relPath(root, absPath);
@@ -132,61 +211,9 @@ export async function extractFile(absPath, root) {
         if (nm) imports.add(oneLine(nm));
       }
     } else if (TYPE_DECLS.has(n.type)) {
-      const cname = fieldText(n, "name");
-      if (cname) {
-        const mods = modifiersNode(n);
-        defines.push({
-          name: cname, kind: "class", lineno: line(n), end_lineno: endLine(n),
-          bases: basesOf(n), decorators: decoratorsFrom(mods),
-          ...(visFrom(mods) ? { visibility: visFrom(mods) } : {}),
-        });
-        if (isPublic(mods)) exports.add(cname);
-
-        // record components (formal params) surface as attributes (match JavaParser)
-        if (n.type === "record_declaration") {
-          const fp = n.childForFieldName("parameters");
-          if (fp) for (let i = 0; i < fp.namedChildCount; i++) {
-            const fpc = fp.namedChild(i);
-            if (fpc.type !== "formal_parameter") continue;
-            const pn = fieldText(fpc, "name");
-            if (pn) defines.push({ name: `${cname}.${pn}`, kind: "attribute", lineno: line(fpc), end_lineno: endLine(fpc), decorators: [] });
-          }
-        }
-
-        const body = bodyContainer(n);
-        if (body) {
-          for (let i = 0; i < body.namedChildCount; i++) {
-            const mem = body.namedChild(i);
-            if (mem.type === "method_declaration" || mem.type === "constructor_declaration") {
-              const mn = fieldText(mem, "name") || cname;
-              const mmods = modifiersNode(mem);
-              const returns = mem.type === "method_declaration"
-                ? clip(oneLine(mem.childForFieldName("type")?.text || ""), 80) : "";
-              defines.push({
-                name: `${cname}.${mn}`, kind: "method", lineno: line(mem), end_lineno: endLine(mem),
-                decorators: decoratorsFrom(mmods), params: paramsText(mem),
-                ...(returns ? { returns } : {}), calls: collectCalls(mem),
-                ...(isStatic(mmods) ? { is_static: true } : {}),
-                ...(visFrom(mmods) ? { visibility: visFrom(mmods) } : {}),
-              });
-            } else if (mem.type === "field_declaration") {
-              const fmods = modifiersNode(mem);
-              for (let j = 0; j < mem.namedChildCount; j++) {
-                const vd = mem.namedChild(j);
-                if (vd.type !== "variable_declarator") continue;
-                const fn = fieldText(vd, "name");
-                if (fn) defines.push({
-                  name: `${cname}.${fn}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem),
-                  decorators: decoratorsFrom(fmods),
-                  ...(visFrom(fmods) ? { visibility: visFrom(fmods) } : {}),
-                });
-              }
-            }
-          }
-        }
-      }
+      emitType(n, "", defines, exports);
     }
-    // descend, but not back into a type body (members handled above)
+    // descend, but not back into a type body (emitType recurses for nested types)
     if (!TYPE_DECLS.has(n.type)) for (let i = 0; i < n.namedChildCount; i++) stack.push(n.namedChild(i));
   }
 

package/src/jsts_tsc.mjs

@@ -1,11 +1,17 @@
-// JS/TS extractor — TypeScript compiler API (via ts-morph's re-exported `ts`
-// namespace; no separate `typescript` dep). PICKED candidate for JS/TS.
+// JS/TS extractor — TypeScript compiler API (direct `typescript` dep; the
+// 2026-07-02 library review swapped ts-morph out — we only ever used its
+// re-exported `ts` namespace, so importing the compiler directly is byte-identical
+// output for −12.4 MB of install). PICKED candidate for JS/TS.
 //
 // Uses ts.createSourceFile per file (no Program / no type-checker) — the fast,
 // deterministic, offline structural pass. Covers .ts/.tsx/.js/.jsx (allowJs is
 // implicit: JS is just parsed with the JS script-kind). Emits the SAME
 // `{path,dotted,imports,defines,calls,exports}` contract extract_ast.py prints,
 // so extract.mjs/buildEntities + codegraph.mjs/digest consume it unchanged.
+// Both module systems are read: ESM import/export declarations AND a CommonJS
+// pass (top-level require() with literal specifiers → imports; module.exports /
+// exports.name assignments → exports) — express-style repos are CJS-only and
+// were producing edge-empty graphs before the 2026-07-02 pass.
 //
 // Fidelity note (honest): params/returns are ANNOTATION strings (Group-A
 // mechanical), exactly like the Python path's "returns = annotation only". A
@@ -13,7 +19,7 @@
 // promoting Group-B→A) is the documented ceiling, NOT run here.
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { ts } from "ts-morph";
+import ts from "typescript";
 import { walk, relPath } from "./walk.mjs";
 
 const EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
@@ -98,6 +104,27 @@ export async function extractFile(absPath, root) {
     imports.add(`${base}/index`); // dir-import fallback (./foo → ./foo/index)
   };
 
+  // ---- CommonJS pass (2026-07-02): express-style repos are require()/module.exports only,
+  // which left their graphs edge-empty (js-express: imports 0 — five of six ask families
+  // structurally impossible). Top-level statements only, same resolveSpecifier as the ESM
+  // specifiers (relative paths resolve to modules, bare ones stay as-is), and STRICTLY
+  // literal arguments — a require(expr) is skipped, never guessed (house "no wrong edge").
+  /** `require("x")` / require(`x`) with a single literal arg → its specifier, else null. */
+  const requireSpecifier = (node) =>
+    node && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" &&
+    node.arguments.length === 1 && ts.isStringLiteralLike(node.arguments[0])
+      ? node.arguments[0].text
+      : null;
+  /** Peel `require("x").member` / parens down to the require call (never enters functions). */
+  const requireIn = (expr) => {
+    let e = expr;
+    while (e && (ts.isPropertyAccessExpression(e) || ts.isParenthesizedExpression(e) || ts.isNonNullExpression?.(e))) e = e.expression;
+    return requireSpecifier(e);
+  };
+  const isModuleExports = (e) =>
+    ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression) && e.expression.text === "module" && e.name.text === "exports";
+  const isExportsRef = (e) => isModuleExports(e) || (ts.isIdentifier(e) && e.text === "exports");
+
   const addFn = (name, node, kind, extra = {}) => {
     defines.push({
       name, kind, lineno: lineOf(sf, node), end_lineno: endLineOf(sf, node),
@@ -155,6 +182,11 @@ export async function extractFile(absPath, root) {
     } else if (ts.isVariableStatement(stmt)) {
       const isConst = (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0;
       for (const d of stmt.declarationList.declarations) {
+        // CJS import: const X = require('spec') / const {a, b} = require('spec') /
+        // const Y = require('spec').member — BEFORE the identifier-only gate so a
+        // destructuring binding still records the import edge.
+        const reqSpec = requireIn(d.initializer);
+        if (reqSpec != null) resolveSpecifier(reqSpec);
         if (!ts.isIdentifier(d.name)) continue;
         const vn = d.name.text;
         const init = d.initializer;
@@ -173,6 +205,21 @@ export async function extractFile(absPath, root) {
       }
     } else if (ts.isExportAssignment?.(stmt)) {
       exports.add("default");
+    } else if (ts.isExpressionStatement(stmt)) {
+      // CJS exports + side-effect/re-export requires. Walk `=` chains so
+      // `exports = module.exports = X` records one default export, and
+      // `module.exports = require('./lib')` records both the export and the import.
+      let expr = stmt.expression;
+      while (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const lhs = expr.left;
+        if (isExportsRef(lhs)) exports.add("default");                       // module.exports = X / exports = X
+        else if (ts.isPropertyAccessExpression(lhs) && isExportsRef(lhs.expression)) {
+          exports.add(lhs.name.text);                                        // module.exports.name = / exports.name =
+        }
+        expr = expr.right;
+      }
+      const reqSpec = requireIn(expr); // covers bare `require('./side-effect')` too
+      if (reqSpec != null) resolveSpecifier(reqSpec);
     }
   }
 
@@ -208,4 +255,4 @@ export async function ingest(root, { ignore = null } = {}) {
   return { modules, failures, fileCount: files.length };
 }
 
-export const meta = { id: "tsc", language: "js/ts", lib: "typescript compiler API (via ts-morph)", exts: EXTS };
+export const meta = { id: "tsc", language: "js/ts", lib: "typescript compiler API", exts: EXTS };