@event4u/agent-config 17.3.0 → 17.4.0

package/src/scripts/code_graph/estate_manifests.ts

@@ -0,0 +1,223 @@
+/**
+ * What a project's manifests declare and publish, for the estate index
+ * (ADR-299, step 4.2). Read from the same manifest set the providers detect a
+ * stack by (`readProjectProbe`), plus `Cargo.toml`. Line-level parsing on
+ * purpose: the index needs package names, not a resolver, and a malformed
+ * manifest costs its own rows rather than the refresh.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { hardenedSpawnEnv } from '../_lib/spawn_env.js';
+import { MANIFEST_NAME, readProjectProbe, walkedPath } from './build.js';
+
+export type Ecosystem = 'npm' | 'composer' | 'pypi' | 'go' | 'cargo' | 'rubygems';
+
+export interface Declared {
+    ecosystem: Ecosystem;
+    package: string;
+    manifest: string;
+}
+
+export interface Published {
+    ecosystem: Ecosystem;
+    package: string;
+}
+
+export interface ManifestFacts {
+    declares: Declared[];
+    publishes: Published[];
+}
+
+const PY_NAME = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/;
+
+/** PEP 503 normalisation, so `Foo_Bar` and `foo-bar` are one package. */
+function pyName(n: string): string {
+    return n.toLowerCase().replace(/[-_.]+/g, '-');
+}
+
+function json(text: string): Record<string, unknown> | null {
+    try {
+        const v = JSON.parse(text) as unknown;
+        return v && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
+    } catch {
+        return null;
+    }
+}
+
+function keys(v: unknown): string[] {
+    return v && typeof v === 'object' && !Array.isArray(v) ? Object.keys(v) : [];
+}
+
+/** `[section]` → its lines, for the flat TOML tables manifests use. */
+function tomlSections(text: string): Map<string, string[]> {
+    const out = new Map<string, string[]>();
+    let cur = '';
+    out.set(cur, []);
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/#.*$/, '').trimEnd();
+        const head = /^\s*\[\s*([^\]]+?)\s*\]\s*$/.exec(line);
+        if (head) {
+            cur = head[1] as string;
+            if (!out.has(cur)) out.set(cur, []);
+            continue;
+        }
+        out.get(cur)?.push(line);
+    }
+    return out;
+}
+
+function tomlKeys(lines: readonly string[] | undefined): string[] {
+    const out: string[] = [];
+    for (const l of lines ?? []) {
+        const m = /^\s*([A-Za-z0-9_.-]+|"[^"]+")\s*=/.exec(l);
+        if (m) out.push((m[1] as string).replace(/^"|"$/g, ''));
+    }
+    return out;
+}
+
+function tomlString(lines: readonly string[] | undefined, key: string): string | null {
+    for (const l of lines ?? []) {
+        const m = new RegExp(`^\\s*${key}\\s*=\\s*["']([^"']+)["']`).exec(l);
+        if (m) return m[1] as string;
+    }
+    return null;
+}
+
+/** The quoted entries of a TOML array that may span lines (`dependencies = [ … ]`). */
+function tomlArray(lines: readonly string[] | undefined, key: string): string[] {
+    const body = (lines ?? []).join('\n');
+    const m = new RegExp(`^\\s*${key}\\s*=\\s*\\[([\\s\\S]*?)\\]`, 'm').exec(body);
+    if (!m) return [];
+    return [...(m[1] as string).matchAll(/["']([^"']+)["']/g)].map((x) => x[1] as string);
+}
+
+function parse(rel: string, text: string, facts: ManifestFacts): void {
+    const name = path.posix.basename(rel);
+    const dec = (ecosystem: Ecosystem, pkg: string): void => {
+        if (pkg) facts.declares.push({ ecosystem, package: pkg, manifest: rel });
+    };
+    const pub = (ecosystem: Ecosystem, pkg: unknown): void => {
+        if (typeof pkg === 'string' && pkg) facts.publishes.push({ ecosystem, package: pkg });
+    };
+    if (name === 'package.json') {
+        const j = json(text);
+        if (!j) return;
+        pub('npm', j['name']);
+        for (const f of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) for (const k of keys(j[f])) dec('npm', k);
+    } else if (name === 'composer.json') {
+        const j = json(text);
+        if (!j) return;
+        pub('composer', typeof j['name'] === 'string' ? j['name'].toLowerCase() : null);
+        for (const f of ['require', 'require-dev']) {
+            for (const k of keys(j[f])) if (k !== 'php' && !k.startsWith('ext-') && !k.startsWith('lib-')) dec('composer', k.toLowerCase());
+        }
+    } else if (name === 'pyproject.toml') {
+        const s = tomlSections(text);
+        const own = tomlString(s.get('project'), 'name') ?? tomlString(s.get('tool.poetry'), 'name');
+        if (own) pub('pypi', pyName(own));
+        for (const d of tomlArray(s.get('project'), 'dependencies')) {
+            const m = PY_NAME.exec(d);
+            if (m) dec('pypi', pyName(m[1] as string));
+        }
+        for (const sec of ['tool.poetry.dependencies', 'tool.poetry.dev-dependencies', 'tool.poetry.group.dev.dependencies']) {
+            for (const k of tomlKeys(s.get(sec))) if (k !== 'python') dec('pypi', pyName(k));
+        }
+    } else if (/^requirements[\w.-]*\.txt$/.test(name)) {
+        for (const line of text.split(/\r?\n/)) {
+            const l = line.replace(/#.*$/, '').trim();
+            if (!l || l.startsWith('-')) continue;
+            const m = PY_NAME.exec(l);
+            if (m) dec('pypi', pyName(m[1] as string));
+        }
+    } else if (name === 'go.mod') {
+        let block = false;
+        for (const raw of text.split(/\r?\n/)) {
+            const l = raw.replace(/\/\/.*$/, '').trim();
+            const mod = /^module\s+(\S+)/.exec(l);
+            if (mod) pub('go', mod[1]);
+            if (/^require\s*\($/.test(l)) {
+                block = true;
+                continue;
+            }
+            if (block && l === ')') {
+                block = false;
+                continue;
+            }
+            const req = block ? /^(\S+)\s+\S+/.exec(l) : /^require\s+(\S+)\s+\S+/.exec(l);
+            if (req) dec('go', req[1] as string);
+        }
+    } else if (name === 'Cargo.toml') {
+        const s = tomlSections(text);
+        pub('cargo', tomlString(s.get('package'), 'name'));
+        for (const sec of ['dependencies', 'dev-dependencies', 'build-dependencies']) for (const k of tomlKeys(s.get(sec))) dec('cargo', k);
+    } else if (name === 'Gemfile') {
+        for (const m of text.matchAll(/^\s*gem\s+["']([^"']+)["']/gm)) dec('rubygems', m[1] as string);
+    }
+}
+
+function dedupe<T>(rows: T[]): T[] {
+    const seen = new Set<string>();
+    return rows.filter((r) => {
+        const k = JSON.stringify(r);
+        if (seen.has(k)) return false;
+        seen.add(k);
+        return true;
+    });
+}
+
+const isManifest = (name: string): boolean => name === 'Cargo.toml' || MANIFEST_NAME.test(name);
+const ROOT_MANIFESTS = ['package.json', 'composer.json', 'pyproject.toml', 'requirements.txt', 'go.mod', 'Cargo.toml', 'Gemfile'];
+
+/**
+ * Manifest paths from git's index, plus an untracked one at the root, then the
+ * discovery walk's own directory filter. A refresh already walked the tree
+ * once; this keeps the index from walking it a second time (6.4 measured the
+ * walk, and then git's untracked scan, as most of the index's cost). `null`
+ * outside a repository.
+ */
+function manifestPathsFromGit(root: string): string[] | null {
+    let out: string;
+    try {
+        out = execFileSync('git', ['-C', root, 'ls-files', '-z', '--cached'], {
+            env: hardenedSpawnEnv(),
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    } catch {
+        return null;
+    }
+    const rels = new Set(out.split('\0').filter((rel) => rel && isManifest(path.posix.basename(rel)) && walkedPath(rel)));
+    for (const name of ROOT_MANIFESTS) if (fs.existsSync(path.join(root, name))) rels.add(name);
+    return [...rels];
+}
+
+export function manifestFacts(root: string): ManifestFacts {
+    const facts: ManifestFacts = { declares: [], publishes: [] };
+    const texts = new Map<string, string>();
+    const fromGit = manifestPathsFromGit(root);
+    if (fromGit !== null) {
+        for (const rel of fromGit) {
+            try {
+                texts.set(rel, fs.readFileSync(path.join(root, rel), 'utf-8'));
+            } catch {
+                /* deleted in the working tree: no rows */
+            }
+        }
+    } else {
+        const probe = readProjectProbe(root);
+        for (const [rel, text] of probe.manifests) texts.set(rel, text);
+        for (const rel of probe.paths) {
+            if (path.posix.basename(rel) !== 'Cargo.toml') continue;
+            try {
+                texts.set(rel, fs.readFileSync(path.join(root, rel), 'utf-8'));
+            } catch {
+                /* unreadable: no rows */
+            }
+        }
+    }
+    for (const [rel, text] of [...texts.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) parse(rel, text, facts);
+    return { declares: dedupe(facts.declares), publishes: dedupe(facts.publishes) };
+}

package/src/scripts/code_graph/estate_map.ts

@@ -0,0 +1,141 @@
+/**
+ * `code-graph map --estate` — one offline page of the registered projects and
+ * the edges the estate index derived between them (ADR-299, step 5.4).
+ *
+ * Projects are nodes; a `package` edge (a declared dependency on a package
+ * another project publishes) is drawn solid, the two guesses (`unique-name`,
+ * `mention`) dashed. The page names client projects, so it is written under
+ * the user-global home and refused anywhere inside a git work tree.
+ *
+ * The page exposes `window.__mapLabelBoxes` and a `#panel .plist` list in the
+ * shape `map_verify` reads, so the same three-width render check applies.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { enclosingWorkTree } from '../_lib/git_common_dir.js';
+import { write_atomic } from '../_lib/fs_atomic.js';
+import { event4u_root } from '../_lib/user_global_paths.js';
+import { openEstate, type XEdge } from './estate_index.js';
+import { verifyMap } from './map_verify.js';
+
+export interface EstateMapData {
+    projects: Array<{ id: string; name: string; indexed_at: string }>;
+    edges: XEdge[];
+}
+
+export function estateMapDir(): string {
+    return path.join(event4u_root(), 'runtime', 'estate', 'map');
+}
+
+/** JSON safe inside a `<script>` element: no `</script>`, no `<!--`. */
+function scriptJson(v: unknown): string {
+    return JSON.stringify(v).replace(/</g, '\\u003c').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+}
+
+const CSS = `
+:root{--bg:#fbfbf9;--fg:#1d1d1b;--muted:#6b6b66;--line:#3c6e8f;--guess:#b0703a;--node:#ffffff;--ring:#3c6e8f;--hl:#d9e8f2}
+@media (prefers-color-scheme:dark){:root{--bg:#161615;--fg:#ecece8;--muted:#a3a39c;--line:#7fb2d4;--guess:#e0a46b;--node:#22221f;--ring:#7fb2d4;--hl:#25343e}}
+*{box-sizing:border-box}html,body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.45 system-ui,-apple-system,"Segoe UI",sans-serif}
+header{padding:16px 16px 4px}h1{font-size:18px;margin:0 0 4px}p{margin:0;color:var(--muted);max-width:60ch}
+main{display:flex;flex-wrap:wrap;gap:16px;padding:8px 16px 16px}.stage{flex:1 1 320px;min-width:0}svg{display:block;width:100%;height:auto}
+#panel{flex:0 1 260px;min-width:0}.plist{list-style:none;margin:0;padding:0}.plist button{display:flex;align-items:center;gap:8px;width:100%;
+border:0;background:none;color:inherit;font:inherit;text-align:left;padding:6px 4px;cursor:pointer;border-radius:6px}
+.plist button[aria-pressed=true]{background:var(--hl)}.swatch{flex:0 0 10px;height:10px;border-radius:50%;background:var(--ring)}
+.fname{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}.legend{display:flex;flex-wrap:wrap;gap:12px;margin-top:8px;color:var(--muted);font-size:12px}
+.k{display:inline-block;width:24px;border-top:2px solid var(--line);vertical-align:middle;margin-right:4px}.k.g{border-top:2px dashed var(--guess)}
+line.package{stroke:var(--line);stroke-width:2}line.guess{stroke:var(--guess);stroke-width:1.5;stroke-dasharray:5 4}
+line.dim{opacity:.15}circle{fill:var(--node);stroke:var(--ring);stroke-width:2}text{fill:var(--fg);font-size:12px}
+`;
+
+const JS = `
+(function(){
+var data=JSON.parse(document.getElementById('estate-data').textContent);
+var svg=document.getElementById('stage');var NS='http://www.w3.org/2000/svg';
+var list=document.getElementById('plist');var selected=null;
+function short(s){return s.length>18?s.slice(0,17)+'\\u2026':s}
+function draw(){
+  while(svg.firstChild)svg.removeChild(svg.firstChild);
+  var w=Math.max(240,svg.parentNode.clientWidth),h=Math.min(w,520);
+  svg.setAttribute('viewBox','0 0 '+w+' '+h);svg.setAttribute('width',w);svg.setAttribute('height',h);
+  var n=data.projects.length,texts=[],maxw=0;
+  var gl=document.createElementNS(NS,'g'),gn=document.createElementNS(NS,'g');svg.appendChild(gl);svg.appendChild(gn);
+  data.projects.forEach(function(p){var t=document.createElementNS(NS,'text');t.textContent=short(p.name);t.setAttribute('text-anchor','middle');gn.appendChild(t);texts.push(t);maxw=Math.max(maxw,t.getComputedTextLength())});
+  var r=n<2?0:Math.max(24,Math.min(w/2-maxw/2-12,h/2-40));var cx=w/2,cy=h/2-8,pos={};
+  data.projects.forEach(function(p,i){var a=-Math.PI/2+2*Math.PI*i/Math.max(1,n);pos[p.id]={x:cx+r*Math.cos(a),y:cy+r*Math.sin(a)}});
+  data.edges.forEach(function(e){var s=pos[e.source],t=pos[e.target];if(!s||!t)return;var l=document.createElementNS(NS,'line');
+    l.setAttribute('x1',s.x);l.setAttribute('y1',s.y);l.setAttribute('x2',t.x);l.setAttribute('y2',t.y);
+    var cls=e.via==='package'?'package':'guess';if(selected&&e.source!==selected&&e.target!==selected)cls+=' dim';l.setAttribute('class',cls);
+    var tt=document.createElementNS(NS,'title');tt.textContent=e.via+': '+e.detail;l.appendChild(tt);gl.appendChild(l)});
+  var boxes=[];
+  data.projects.forEach(function(p,i){var c=document.createElementNS(NS,'circle');var q=pos[p.id];c.setAttribute('cx',q.x);c.setAttribute('cy',q.y);c.setAttribute('r',p.id===selected?9:7);
+    gn.insertBefore(c,texts[0]);var t=texts[i];t.setAttribute('x',q.x);t.setAttribute('y',q.y+22);var b=t.getBBox();boxes.push({x:b.x,y:b.y,w:b.width,h:b.height})});
+  window.__mapLabelBoxes={boxes:boxes,width:w,height:h};
+}
+data.projects.forEach(function(p){var li=document.createElement('li');var b=document.createElement('button');b.type='button';b.setAttribute('aria-pressed','false');
+  var s=document.createElement('span');s.className='swatch';var f=document.createElement('span');f.className='fname';f.textContent=p.name;f.title=p.id;
+  b.appendChild(s);b.appendChild(f);b.addEventListener('click',function(){selected=selected===p.id?null:p.id;
+    Array.prototype.forEach.call(list.querySelectorAll('button'),function(x){x.setAttribute('aria-pressed','false')});if(selected)b.setAttribute('aria-pressed','true');draw()});
+  li.appendChild(b);list.appendChild(li)});
+draw();window.addEventListener('resize',draw);
+})();
+`;
+
+export function renderEstateHtml(data: EstateMapData): string {
+    const packages = data.edges.filter((e) => e.via === 'package').length;
+    const guesses = data.edges.length - packages;
+    return [
+        '<!doctype html>',
+        '<html lang="en">',
+        '<head>',
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        '<title>Project estate</title>',
+        `<style>${CSS}</style>`,
+        '</head>',
+        '<body>',
+        '<header>',
+        '<h1>Project estate</h1>',
+        `<p>${data.projects.length} registered projects · ${packages} package links · ${guesses} guessed links. Local to this machine; never committed.</p>`,
+        '<div class="legend"><span><span class="k"></span>declared dependency</span><span><span class="k g"></span>guess (unique name or mention)</span></div>',
+        '</header>',
+        '<main>',
+        '<div class="stage"><svg id="stage" role="img" aria-label="Projects and the links between them"></svg></div>',
+        '<aside id="panel"><ul class="plist" id="plist"></ul></aside>',
+        '</main>',
+        `<script type="application/json" id="estate-data">${scriptJson(data)}</script>`,
+        `<script>${JS}</script>`,
+        '</body>',
+        '</html>',
+        '',
+    ].join('\n');
+}
+
+export async function estateMapMain(argv: string[]): Promise<number> {
+    const i = argv.indexOf('--out');
+    const outDir = i >= 0 && i + 1 < argv.length ? path.resolve(argv[i + 1] as string) : estateMapDir();
+    const tree = enclosingWorkTree(outDir);
+    if (tree !== null) {
+        process.stderr.write(`code-graph: refusing to write the estate map inside a git work tree (${tree}): it names client projects\n`);
+        return 1;
+    }
+    const db = openEstate();
+    if (!db) {
+        process.stderr.write('code-graph: no estate index — `code-graph projects index on`, then build or refresh each project\n');
+        return 1;
+    }
+    let data: EstateMapData;
+    try {
+        data = { projects: db.projects().map(({ id, name, indexed_at }) => ({ id, name, indexed_at })), edges: db.xedges() };
+    } finally {
+        db.close();
+    }
+    const page = path.join(outDir, 'index.html');
+    fs.mkdirSync(outDir, { recursive: true });
+    write_atomic(page, renderEstateHtml(data));
+    process.stdout.write(`✅  estate map — ${data.projects.length} projects · ${data.edges.length} links\n    wrote ${page}\n`);
+    if (argv.includes('--no-verify')) return 0;
+    const check = await verifyMap(page);
+    process.stdout.write(`    render check: ${check.verification}${check.reason ? ` — ${check.reason}` : ''}\n`);
+    return check.verification === 'failed' ? 1 : 0;
+}

package/src/scripts/code_graph/extract.ts

@@ -20,7 +20,7 @@ import {
     MAX_FILE_BYTES,
     type Relation,
 } from './types.js';
-import { extractCSharp, extractGo, extractJava, extractPython } from './extract_more.js';
+import { extractCSharp, extractGo, extractJava, extractPython, extractRuby } from './extract_more.js';
 import { getParser, nodeHasError, type TsNode } from './loader.js';
 
 export type CallStyle = 'new' | 'free' | 'this' | 'self' | 'static' | 'parent' | 'scoped' | 'dynamic';
@@ -90,6 +90,8 @@ export interface FileExtract {
     parseError: boolean;
     /** C#: the namespaces the file declares, for `using` resolution in the build pass. */
     namespaces?: string[];
+    /** C#: the namespace each declared type sits in, by node id, for namespace-scope resolution. */
+    typeNamespaces?: Record<string, string>;
 }
 
 export function loc(n: TsNode): number[] {
@@ -703,6 +705,7 @@ export async function extractFile(relPath: string, source: string, lang: Lang):
         else if (lang === 'java') extractJava(tree.rootNode, relPath, out);
         else if (lang === 'go') extractGo(tree.rootNode, relPath, out);
         else if (lang === 'csharp') extractCSharp(tree.rootNode, relPath, out);
+        else if (lang === 'ruby') extractRuby(tree.rootNode, relPath, out);
         else extractTsJs(tree.rootNode, relPath, out);
     } finally {
         tree.delete(); // delete the tree, never the cached parser (loader.ts)

package/src/scripts/code_graph/extract_more.ts

@@ -1,5 +1,5 @@
 /**
- * Python, Go, Java and C# extraction — the same shape `extract.ts` emits for
+ * Python, Go, Java, C# and Ruby extraction — the same shape `extract.ts` emits for
  * PHP / TS / JS, so the build pass resolves them with no language branch
  * beyond module lookup.
  *
@@ -113,11 +113,18 @@ export function extractPython(root: TsNode, file: string, out: FileExtract): voi
             case 'call': {
                 const fn = n.childForFieldName('function');
                 if (fn?.type === 'identifier') {
-                    out.rawEdges.push({ sourceId: scopeId, relation: 'calls', targetName: fn.text, confidenceHint: 'EXTRACTED', callStyle: 'free' });
+                    // `Order(...)` instantiates: a CapWords name is a class by Python convention.
+                    const isNew = /^[A-Z]/.test(fn.text);
+                    out.rawEdges.push({ sourceId: scopeId, relation: 'calls', targetName: fn.text, confidenceHint: 'EXTRACTED', callStyle: isNew ? 'new' : 'free' });
                 } else if (fn?.type === 'attribute') {
                     const obj = fn.childForFieldName('object');
                     const attr = text(fn.childForFieldName('attribute'));
                     const isSelf = obj?.type === 'identifier' && (obj.text === 'self' || obj.text === 'cls');
+                    let base = obj;
+                    while (base?.type === 'attribute') base = base.childForFieldName('object');
+                    // `Post.objects.count()` / `Service.run()` name a class at the root of the chain.
+                    const classRoot = base?.type === 'identifier' && /^[A-Z]/.test(base.text) ? base.text : null;
+                    if (classRoot) out.rawEdges.push({ sourceId: scopeId, relation: 'uses', targetName: classRoot, confidenceHint: 'EXTRACTED' });
                     out.rawEdges.push({
                         sourceId: scopeId,
                         relation: 'calls',
@@ -125,6 +132,7 @@ export function extractPython(root: TsNode, file: string, out: FileExtract): voi
                         confidenceHint: isSelf && classId ? 'INFERRED' : 'AMBIGUOUS',
                         callStyle: isSelf ? 'this' : 'dynamic',
                         ...(classId ? { enclosingClassId: classId } : {}),
+                        ...(classRoot && obj === base ? { scopeName: classRoot } : {}),
                     });
                 }
                 break;
@@ -330,12 +338,25 @@ export function extractCSharp(root: TsNode, file: string, out: FileExtract): voi
         enum_declaration: 'enum',
     };
     const namespaces: string[] = [];
+    const typeNamespaces: Record<string, string> = {};
+    /** Every project-type name a type expression mentions: `List<Order>` names `List` and `Order`; `int` names none. */
+    const typeNames = (t: TsNode | null, acc: string[] = []): string[] => {
+        if (!t || t.type === 'predefined_type') return acc;
+        if (t.type === 'identifier' || t.type === 'qualified_name') return [...acc, csType(t)];
+        if (t.type === 'generic_name') acc.push(csType(t));
+        for (const c of namedChildren(t)) if (t.type !== 'generic_name' || c.type === 'type_argument_list') acc = typeNames(c, acc);
+        return acc;
+    };
+    const usesTypes = (sourceId: string, t: TsNode | null): void => {
+        for (const nm of new Set(typeNames(t))) out.rawEdges.push({ sourceId, relation: 'uses', targetName: nm, confidenceHint: 'EXTRACTED' });
+    };
     const walk = (n: TsNode, classId: string | null, scopeId: string, ns = ''): void => {
         const kind = TYPES[n.type];
         if (kind) {
             const nm = nameField(n) ?? '<anon>';
             const id = uniq(out, classId ? `${classId}::${nm}` : `${file}#${nm}`);
             out.nodes.push({ id, label: nm, kind, source_file: file, source_location: loc(n) });
+            if (!classId && ns) typeNamespaces[id] = ns;
             out.rawEdges.push({ sourceId: classId ?? file, relation: 'member', targetName: nm, confidenceHint: 'EXTRACTED' });
             for (const c of namedChildren(n)) {
                 if (c.type !== 'base_list') continue;
@@ -376,12 +397,21 @@ export function extractCSharp(root: TsNode, file: string, out: FileExtract): voi
                 }
                 return;
             }
+            case 'field_declaration':
+            case 'property_declaration': {
+                const decl = n.type === 'field_declaration' ? namedChildren(n).find((c) => c.type === 'variable_declaration') : n;
+                if (classId) usesTypes(classId, decl?.childForFieldName('type') ?? null);
+                break;
+            }
             case 'method_declaration':
             case 'constructor_declaration': {
                 const nm = nameField(n) ?? '<anon>';
                 const id = uniq(out, classId ? `${classId}::${nm}` : `${file}#${nm}`);
                 out.nodes.push({ id, label: nm, kind: 'method', source_file: file, source_location: loc(n) });
                 out.rawEdges.push({ sourceId: classId ?? file, relation: 'member', targetName: nm, confidenceHint: 'EXTRACTED' });
+                usesTypes(id, n.childForFieldName('returns') ?? n.childForFieldName('type'));
+                for (const c of namedChildren(n))
+                    if (c.type === 'parameter_list') for (const p of namedChildren(c)) if (p.type === 'parameter') usesTypes(id, p.childForFieldName('type'));
                 for (const c of namedChildren(n)) if (c.type === 'block' || c.type === 'arrow_expression_clause') walk(c, classId, id, ns);
                 return;
             }
@@ -415,4 +445,109 @@ export function extractCSharp(root: TsNode, file: string, out: FileExtract): voi
     };
     walk(root, null, file);
     out.namespaces = namespaces;
+    out.typeNamespaces = typeNamespaces;
+}
+
+/** The last segment of a Ruby constant path: `Admin::User` → `User`. */
+function rbConst(n: TsNode | null): string {
+    return n ? (n.text.split('::').pop() ?? n.text).trim() : '';
+}
+
+/**
+ * Ruby: classes, modules (as `trait` — a mixin is what PHP calls a trait),
+ * instance and singleton methods, `require` / `require_relative`, the
+ * superclass and every `include` / `extend` / `prepend` as `inherits`, and
+ * calls: implicit-self and `self.` calls on the enclosing class, `Foo.new`,
+ * `Foo.bar` scoped calls (plus a `uses` of `Foo`), and dynamic receivers.
+ */
+export function extractRuby(root: TsNode, file: string, out: FileExtract): void {
+    out.nodes.push({ id: file, label: file, kind: 'file', source_file: file, source_location: [] });
+    const MIXINS = new Set(['include', 'extend', 'prepend']);
+    const walk = (n: TsNode, classId: string | null, scopeId: string): void => {
+        switch (n.type) {
+            case 'class':
+            case 'module': {
+                const nm = rbConst(n.childForFieldName('name')) || '<anon>';
+                const id = uniq(out, classId ? `${classId}::${nm}` : `${file}#${nm}`);
+                out.nodes.push({ id, label: nm, kind: n.type === 'class' ? 'class' : 'trait', source_file: file, source_location: loc(n) });
+                out.rawEdges.push({ sourceId: classId ?? file, relation: 'member', targetName: nm, confidenceHint: 'EXTRACTED' });
+                const sup = n.childForFieldName('superclass');
+                const parent = sup ? namedChildren(sup)[0] : undefined;
+                if (parent && (parent.type === 'constant' || parent.type === 'scope_resolution')) out.inherits.push({ classId: id, parentName: rbConst(parent) });
+                const body = n.childForFieldName('body');
+                if (body) for (const c of namedChildren(body)) walk(c, id, id);
+                return;
+            }
+            case 'method':
+            case 'singleton_method': {
+                const nm = nameField(n) ?? '<anon>';
+                const id = uniq(out, classId ? `${classId}::${nm}` : `${file}#${nm}`);
+                out.nodes.push({ id, label: nm, kind: classId ? 'method' : 'function', source_file: file, source_location: loc(n) });
+                out.rawEdges.push({ sourceId: classId ?? file, relation: 'member', targetName: nm, confidenceHint: 'EXTRACTED' });
+                const body = n.childForFieldName('body');
+                for (const c of body ? namedChildren(body) : []) {
+                    // A bare identifier statement is an argument-less implicit-self
+                    // call (`audit`); a local read looks the same and resolves to
+                    // nothing, which is what an unresolved call records.
+                    if (c.type === 'identifier' && classId)
+                        out.rawEdges.push({ sourceId: id, relation: 'calls', targetName: c.text, confidenceHint: 'INFERRED', callStyle: 'this', enclosingClassId: classId });
+                    else walk(c, classId, id);
+                }
+                return;
+            }
+            case 'call': {
+                const recv = n.childForFieldName('receiver');
+                const nm = text(n.childForFieldName('method'));
+                const args = n.childForFieldName('arguments');
+                const first = args ? namedChildren(args)[0] : undefined;
+                if (!recv && (nm === 'require' || nm === 'require_relative') && first?.type === 'string') {
+                    const raw = text(namedChildren(first).find((c) => c.type === 'string_content'));
+                    if (raw) {
+                        const spec = nm === 'require_relative' && !raw.startsWith('.') ? `./${raw}` : raw;
+                        out.rawEdges.push({
+                            sourceId: file,
+                            relation: 'imports',
+                            targetName: lastSegment(raw),
+                            confidenceHint: 'EXTRACTED',
+                            moduleSpecifier: spec,
+                            importKind: 'namespace',
+                            // A require binds no name; a local that cannot be written keeps it from shadowing one.
+                            localName: `require:${spec}`,
+                        });
+                    }
+                    return;
+                }
+                if (!recv && classId && MIXINS.has(nm) && args) {
+                    for (const c of namedChildren(args))
+                        if (c.type === 'constant' || c.type === 'scope_resolution') out.inherits.push({ classId, parentName: rbConst(c) });
+                    return;
+                }
+                const ctx = classId ? { enclosingClassId: classId } : {};
+                if (recv && (recv.type === 'constant' || recv.type === 'scope_resolution')) {
+                    const cls = rbConst(recv);
+                    if (nm === 'new') out.rawEdges.push({ sourceId: scopeId, relation: 'calls', targetName: cls, confidenceHint: 'EXTRACTED', callStyle: 'new' });
+                    else {
+                        out.rawEdges.push({ sourceId: scopeId, relation: 'uses', targetName: cls, confidenceHint: 'EXTRACTED' });
+                        out.rawEdges.push({ sourceId: scopeId, relation: 'calls', targetName: nm, confidenceHint: 'AMBIGUOUS', callStyle: 'scoped', scopeName: cls, ...ctx });
+                    }
+                } else if (!recv || recv.type === 'self') {
+                    out.rawEdges.push({
+                        sourceId: scopeId,
+                        relation: 'calls',
+                        targetName: nm,
+                        confidenceHint: classId ? 'INFERRED' : 'AMBIGUOUS',
+                        callStyle: classId ? 'this' : 'free',
+                        ...ctx,
+                    });
+                } else if (nm) {
+                    out.rawEdges.push({ sourceId: scopeId, relation: 'calls', targetName: nm, confidenceHint: 'AMBIGUOUS', callStyle: 'dynamic', ...ctx });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        for (const c of namedChildren(n)) walk(c, classId, scopeId);
+    };
+    walk(root, null, file);
 }