@polycode-projects/seonix 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# @polycode-projects/seonix
+
+**A deterministic, offline, $0 code-graph tool that makes a cheap coding agent
+edit like an expensive one.** SEONIX indexes a repository with Python's `ast` +
+`git log` — **zero model calls** — into a typed code graph, then renders a bounded
+**edit digest** you inject once at session start. Your agent edits from turn 1
+without fishing through the repo.
+
+> **Headline.** On Django localisation tasks the no-MCP `seonix` digest cut input
+> tokens **+72% median on Sonnet 4.6** and **+65% on Haiku 4.5** (−58% billed cost
+> per both-solved task), **6/6 solved**, **$0 to index**. The win is
+> model-conditional — full method, numbers and the measurement contract are in the
+> repo.
+
+- **Website / live demo:** https://seonix.polycode.co.uk
+- **Source + benchmarks:** https://gitlab.com/polycode-projects/seonix
+- **Licence:** AGPL-3.0-only
+
+## Install
+
+```bash
+npm i -g @polycode-projects/seonix        # global — gives you the `seonix` bin on PATH
+# or one-shot, no install:
+npx @polycode-projects/seonix index /abs/path/to/repo
+```
+
+**Runtime prerequisites:** Node ≥ 24, **Python 3**, and **git** on `PATH` (the
+indexer shells out to Python's `ast` and `git log`). Indexing is fully local and
+deterministic — no API keys, no network calls, **$0**.
+
+## Quickstart
+
+```bash
+# 1. index your repo (deterministic, offline) — writes a machine-local .seonix/
+seonix index /abs/path/to/repo
+
+# 2. self-locate the touched modules from the task text (no human-chosen target)
+seonix cli seonix_search '{"repo_path":"/abs/path/to/repo","query":"<your task>"}'
+
+# 3. render the bounded edit digest for those modules
+seonix cli digest '{"repo_path":"/abs/path/to/repo","modules":["<top hits>"]}' > digest.txt
+
+# 4. inject digest.txt once at session start, then run your coding agent
+claude --prompt "Use the seonix digest below to localise and make the change. $(cat digest.txt)"
+```
+
+Add `.seonix/` to your `.gitignore` — it is machine-local and rebuilt from source.
+
+## The shape that ships
+
+The product is the **no-MCP digest path**: render the digest, inject it once, run
+with **no server**. The interactive MCP tool loop is retired — even mitigated it
+never cleared the 50% bar; the round-trip *count*, not the resident schema, is the
+cost. Use `seonix_search` (`locate`, self-derives the target) in production; pass
+a known target (`oracle`) only to measure the headroom.
+
+## Visualise
+
+```bash
+seonix viz --focus <Symbol> --out graph.html
+```
+
+Renders a focused, portable Cytoscape sub-graph of the typed code-map as one
+self-contained HTML file — the same view that runs live on the website.
+
+## Languages
+
+Python (stdlib `ast`), JS/TS (ts-morph), and C# (Roslyn, with a tree-sitter
+fallback) — all merged into the one typed graph. The C# extractor source ships in
+`roslyn/`; build it on the consumer side if you index C#.
+
+## Licence & safety
+
+**AGPL-3.0-only.** The network clause is intended for a hosted MCP tool — hosted
+derivatives stay open. The `seonix:` ontology vocabulary is CC-BY-4.0 (NOTICE
+credits SEON + FAMIX). SEONIX never writes to your global agent config and never
+phones home; everything it writes lives under `.seonix/`.

package/bin/cli.mjs

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+// seonix — local typed-edge code-graph MCP. Two-mode contract, mirroring
+// codebase-memory-mcp so it drops into the same benchmark harness:
+//
+//   seonix                                              → stdio MCP server
+//   seonix cli index_repository '{"repo_path":"<abs>"}' → deterministic index
+//   seonix cli digest '{"repo_path":"<abs>","modules":[…]}' → architecture map + per-module
+//                                                           context bundles to stdout (no-MCP arm)
+//   seonix cli <toolName> '{…args}'                     → invoke ANY MCP tool via Bash (no MCP)
+//   seonix hook-augment                                 → PreToolUse Grep/Glob augmenter (stdin→stdout)
+//   seonix viz [--focus <sym>] [--depth N] [--out f.html] → render a focused sub-graph to HTML
+//
+// The index step is offline and model-free (Python ast + git). It writes the
+// graph artifact to <repo_path>/.seonix/graph.json; the server (started with
+// cwd = that repo) loads it by default. No flags, no config files.
+
+import { join } from "node:path";
+import { startServer } from "../src/server.mjs";
+import { dispatchTool, buildContextBundle } from "../src/server.mjs";
+import { indexRepository } from "../src/extract.mjs";
+import { loadConfig, DEFAULT_GRAPH_REL } from "../src/config.mjs";
+import * as source from "../src/source.mjs";
+import { parseEntities, renderSearch, rankModulesByProximity, searchModulesRanked } from "../src/codegraph.mjs";
+
+/** Build a config pointed at a specific repo's artifact (for `cli` sub-commands that
+ *  take a repo_path), or fall back to the cwd-derived default. */
+function configFor(repoPath) {
+  return repoPath ? { graphFile: join(repoPath, DEFAULT_GRAPH_REL) } : loadConfig();
+}
+
+/** Parse the trailing JSON payload of a `cli` sub-command (best-effort). */
+function parsePayload(payload) {
+  if (!payload) return {};
+  try { return JSON.parse(payload); }
+  catch { return null; }
+}
+
+const DIGEST_MODULE_CAP = 12;   // bound the no-MCP digest — a handful of changed modules
+const DIGEST_SECONDARY_CAP = 2; // B2: at most this many SECONDARY modules get a (trimmed) bundle
+const TIER_RANK = { NONE: 0, TINY: 1, MID: 2, LARGE: 3, FULL: 4 };
+
+/** `cli digest` — print a machine-readable header + a repo architecture map + the
+ *  seonix_context edit bundle for each requested module to stdout (reuses the server's exact
+ *  renderer via buildContextBundle, so no render logic is duplicated). This stdout is injected
+ *  into the no-MCP arm's prompt.
+ *
+ *  B2: the FIRST (primary) module gets a full size-adaptive bundle; the remaining modules are
+ *  RANKED by import/cochange proximity to the primary and only the top few get a TRIMMED
+ *  (signatures + insertion region) bundle — so a 2-module task no longer pays for two full
+ *  bundles. The leading header line lets the rig record tier/topup telemetry. */
+async function runDigest(args) {
+  const repoPath = args.repo_path;
+  if (!repoPath) { process.stderr.write("seonix: digest requires repo_path\n"); process.exit(2); }
+  const modules = Array.isArray(args.modules) ? args.modules.slice(0, DIGEST_MODULE_CAP) : [];
+  // Tuning-flag contract (threaded to buildContextBundle → sizeBundle): `min` → leanest TINY/no
+  // top-up; `untuned` → pre-B010 escalation. Neither → the tuned default. The digest header still
+  // reports the EFFECTIVE tier/topup returned per module, so rig telemetry stays correct.
+  const min = Boolean(args.min);
+  const untuned = Boolean(args.untuned);
+  const config = configFor(repoPath);
+  const body = [];
+  let effTier = "NONE"; // largest tier emitted across all modules
+  let topup = false;    // whether any module's auto-sizing escalated above TINY
+  let emitted = 0;      // module bundles actually emitted (primary + trimmed secondaries)
+
+  try {
+    body.push("# Repository architecture\n" + (await dispatchTool("seonix_architecture", {}, { config })));
+  } catch (e) {
+    body.push(`# Repository architecture\n(unavailable: ${e?.message || e})`);
+  }
+
+  const emit = async (m, trim) => {
+    try {
+      const { text, tier, topup: t } = await buildContextBundle({ symbol: m, min, untuned }, { config, source, trim });
+      body.push(`\n# Context bundle: ${m}${trim ? " (secondary, trimmed)" : ""}\n` + text);
+      if ((TIER_RANK[tier] || 0) > (TIER_RANK[effTier] || 0)) effTier = tier;
+      if (t) topup = true;
+      emitted += 1;
+    } catch (e) {
+      body.push(`\n# Context bundle: ${m}\n(no bundle: ${e?.message || e})`);
+    }
+  };
+
+  if (modules.length) {
+    const [primary, ...rest] = modules;
+    // rank the secondaries by proximity to the primary (best-effort: keep input order on error)
+    let ranked = rest;
+    if (rest.length) {
+      try { ranked = rankModulesByProximity(parseEntities(await source.fetchEntities(config)), primary, rest); }
+      catch { ranked = rest; }
+    }
+    const secondaries = ranked.slice(0, DIGEST_SECONDARY_CAP);
+    const overflow = ranked.slice(DIGEST_SECONDARY_CAP);
+    await emit(primary, false);
+    for (const m of secondaries) await emit(m, true);
+    if (overflow.length) body.push(`\n# Related modules (not expanded; query seonix_context if needed): ${overflow.join(", ")}`);
+  }
+
+  // HARD CONTRACT: first line is the machine-readable digest header the rig greps.
+  const header = `# seonix-digest tier=${effTier} topup=${topup} modules=${emitted}`;
+  process.stdout.write([header, ...body].join("\n") + "\n");
+}
+
+/** Read all of stdin (best-effort; resolves "" if none). */
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    if (process.stdin.isTTY) return resolve("");
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (data += c));
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", () => resolve(data));
+  });
+}
+
+/** PreToolUse Grep/Glob augmenter: emit seon graph context as additionalContext.
+ *  Mirrors cbm's hook-augment. Silent on any failure (exit 0, no output) so it can
+ *  never block a tool call. */
+async function hookAugment() {
+  try {
+    const raw = await readStdin();
+    const evt = JSON.parse(raw || "{}");
+    const ti = evt.tool_input || evt.toolInput || {};
+    const query = String(ti.pattern || ti.query || ti.glob || "").trim();
+    if (!query) return;
+    const graph = parseEntities(await source.fetchEntities(loadConfig()));
+    if (!graph.individuals.length) return;
+    const text = renderSearch(graph, query);
+    if (!text || /^no module matches|^empty query/.test(text)) return;
+    const additionalContext =
+      "seon typed code-map hits for this search (prefer seonix_context / seonix_snippet over reading files):\n" + text;
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext } }));
+  } catch {
+    /* silent — never block the tool */
+  }
+}
+
+async function main() {
+  const [mode, sub, payload] = process.argv.slice(2);
+
+  if (mode === "cli") {
+    // index mode: `cli index_repository '{"repo_path":"<abs>"}'`
+    if (sub === "index_repository") {
+      const args = parsePayload(payload);
+      if (args === null) {
+        process.stderr.write("seonix: index_repository expects a JSON arg, e.g. '{\"repo_path\":\"/abs\"}'\n");
+        process.exit(2);
+      }
+      const repoPath = args.repo_path;
+      if (!repoPath) {
+        process.stderr.write("seonix: index_repository requires repo_path\n");
+        process.exit(2);
+      }
+      const t0 = Date.now();
+      const { graphFile, counts } = await indexRepository(repoPath);
+      process.stderr.write(
+        `seonix: indexed ${counts.modules} modules, ${counts.functions} symbols, ` +
+          `${counts.edges} edges (${counts.callsSymbol} callsSymbol, ${counts.touchesSymbol} touchesSymbol), ` +
+          `${counts.commits} commits in ${Date.now() - t0}ms → ${graphFile}\n`,
+      );
+      process.stderr.write(
+        `seonix: history-symbol pass +${counts.historyMs}ms over ${counts.baseMs}ms base ` +
+          `= ${counts.historyPct}% (depth ${counts.historySymbolDepth}; budget ≤10%)\n`,
+      );
+      return;
+    }
+
+    // digest mode: architecture map + per-module context bundles → stdout (no-MCP arm)
+    if (sub === "digest") {
+      const args = parsePayload(payload);
+      if (args === null) {
+        process.stderr.write("seonix: digest expects a JSON arg, e.g. '{\"repo_path\":\"/abs\",\"modules\":[…]}'\n");
+        process.exit(2);
+      }
+      await runDigest(args);
+      return;
+    }
+
+    // locate mode (TUNING #3): `cli seonix_locate '{"query":"…","repo_path":"<abs>"}'` emits the
+    // ranked modules as `<relpath>\t<score>`, one per line (highest first), using renderSearch's
+    // exact ranking. The rig keeps rank-1 always and rank-2 only when score2/score1 is close — it
+    // needs the raw scores, which the text renderer hides. Independent of the tuning flags.
+    if (sub === "seonix_locate") {
+      const args = parsePayload(payload);
+      if (args === null) {
+        process.stderr.write("seonix: seonix_locate expects a JSON arg, e.g. '{\"query\":\"…\",\"repo_path\":\"/abs\"}'\n");
+        process.exit(2);
+      }
+      const config = configFor(args.repo_path);
+      try {
+        const graph = parseEntities(await source.fetchEntities(config));
+        const ranked = searchModulesRanked(graph, args.query || "");
+        process.stdout.write(ranked.map((r) => `${r.path}\t${r.score}`).join("\n") + "\n");
+      } catch (e) {
+        process.stderr.write(`seonix: ${e?.message || e}\n`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // tool-query fallback: any other `cli <toolName> '{…}'` routes to the MCP dispatcher,
+    // so "cold" tools are invokable from Bash without an MCP connection.
+    if (sub) {
+      const args = parsePayload(payload);
+      if (args === null) {
+        process.stderr.write(`seonix: ${sub} expects a JSON arg, e.g. '{"symbol":"<name>"}'\n`);
+        process.exit(2);
+      }
+      const config = configFor(args.repo_path);
+      try {
+        const text = await dispatchTool(sub, args, { config });
+        process.stdout.write(text + "\n");
+      } catch (e) {
+        process.stderr.write(`seonix: ${e?.message || e}\n`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    process.stderr.write("seonix: `cli` needs a sub-command (index_repository | digest | <toolName>)\n");
+    process.exit(2);
+  }
+
+  if (mode === "hook-augment") {
+    await hookAugment();
+    return;
+  }
+
+  if (mode === "viz") {
+    const { runVizCli } = await import("../src/viz.mjs");
+    await runVizCli(process.argv.slice(3));
+    return;
+  }
+
+  if (mode === undefined) {
+    await startServer(); // bare invocation → MCP stdio server
+    return;
+  }
+
+  process.stderr.write(`seonix: unknown invocation "${process.argv.slice(2).join(" ")}". ` +
+    "Use bare (MCP server), `cli index_repository …`, `hook-augment`, or `viz`.\n");
+  process.exit(2);
+}
+
+main().catch((e) => {
+  process.stderr.write(`seonix: ${e?.message || e}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@polycode-projects/seonix",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "SEONIX — a deterministic, offline, $0 code-graph tool that makes a cheap coding agent edit like an expensive one. Indexes a repo with Python ast + git (zero model calls) and renders a bounded edit-digest.",
+  "license": "AGPL-3.0-only",
+  "author": "Polycode Limited",
+  "homepage": "https://seonix.polycode.co.uk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/polycode-projects/seonix.git",
+    "directory": "packages/seonix"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/polycode-projects/seonix/-/issues"
+  },
+  "keywords": [
+    "code-graph",
+    "mcp",
+    "coding-agent",
+    "ast",
+    "claude-code",
+    "offline",
+    "deterministic",
+    "token-reduction"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "seonix": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "roslyn/*.cs",
+    "roslyn/*.csproj",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cytoscape": "^3.30.0",
+    "ts-morph": "^24.0.0"
+  },
+  "scripts": {
+    "test": "node --test \"test/**/*.test.mjs\"",
+    "viz": "node bin/cli.mjs viz"
+  }
+}

package/roslyn/Program.cs

@@ -0,0 +1,150 @@
+// Roslyn (syntax-level) C# extractor — bake-off candidate + picked C# path.
+// Parses each .cs with CSharpSyntaxTree.ParseText (NO compilation / no nuget
+// restore of the target repo) → deterministic, offline, zero-LLM. Emits the SAME
+// {modules:[{path,dotted,imports,defines,calls,exports}]} contract the Python
+// extract_ast.py prints, so seonix's extract.mjs/codegraph.mjs/digest consume it
+// unchanged. Semantic-model promotion (resolved call targets/types, Group-B->A) is
+// the documented ceiling, NOT done here (syntax-level keeps it project-agnostic).
+using System.Text.Json;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+var skipDirs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) {
+    ".git",".seonix",".hg",".svn","node_modules","bin","obj","out","dist","build","packages","TestResults",".vs"
+};
+
+if (args.Length < 1) { Console.Error.WriteLine("usage: roslyn-extract <root>"); return 2; }
+var root = Path.GetFullPath(args[0]);
+
+var files = new List<string>();
+void Walk(string dir) {
+    string[] entries;
+    try { entries = Directory.GetFileSystemEntries(dir); } catch { return; }
+    Array.Sort(entries, StringComparer.Ordinal);
+    foreach (var e in entries) {
+        var name = Path.GetFileName(e);
+        if (Directory.Exists(e)) {
+            if (skipDirs.Contains(name) || name.StartsWith(".")) continue;
+            Walk(e);
+        } else if (name.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)
+                   && !name.EndsWith(".g.cs", StringComparison.OrdinalIgnoreCase)
+                   && !name.EndsWith(".Designer.cs", StringComparison.OrdinalIgnoreCase)
+                   && !name.EndsWith(".AssemblyInfo.cs", StringComparison.OrdinalIgnoreCase)) {
+            files.Add(e);
+        }
+    }
+}
+Walk(root);
+
+string Rel(string abs) => Path.GetRelativePath(root, abs).Replace('\\', '/');
+int LineOf(SyntaxNode n) => n.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
+int EndLineOf(SyntaxNode n) => n.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
+string Clip(string s, int n) => s.Length <= n ? s : s.Substring(0, n);
+string OneLine(string s) => System.Text.RegularExpressions.Regex.Replace(s ?? "", "\\s+", " ").Trim();
+
+List<string> CallsIn(SyntaxNode body) {
+    var set = new SortedSet<string>(StringComparer.Ordinal);
+    if (body == null) return new List<string>();
+    foreach (var inv in body.DescendantNodes().OfType<InvocationExpressionSyntax>()) {
+        var expr = inv.Expression;
+        string name = expr switch {
+            MemberAccessExpressionSyntax ma => ma.ToString(),
+            IdentifierNameSyntax id => id.Identifier.Text,
+            _ => expr.ToString()
+        };
+        name = OneLine(name);
+        if (name.Length > 0) set.Add(Clip(name, 80));
+    }
+    return set.ToList();
+}
+
+string Vis(SyntaxTokenList mods) {
+    if (mods.Any(m => m.Text == "private")) return "private";
+    if (mods.Any(m => m.Text == "protected")) return "protected";
+    return "";
+}
+bool IsPublic(SyntaxTokenList mods) => mods.Any(m => m.Text == "public");
+
+var modules = new List<object>();
+var failures = new List<string>();
+
+foreach (var file in files) {
+    string text;
+    try { text = File.ReadAllText(file); } catch { failures.Add(Rel(file)); continue; }
+    SyntaxTree tree;
+    try { tree = CSharpSyntaxTree.ParseText(text); }
+    catch { failures.Add(Rel(file)); continue; }
+    var rootNode = tree.GetRoot();
+    if (rootNode.ContainsDiagnostics) { /* Roslyn recovers; extract best-effort */ }
+
+    var imports = new SortedSet<string>(StringComparer.Ordinal);
+    foreach (var u in rootNode.DescendantNodes().OfType<UsingDirectiveSyntax>()) {
+        if (u.StaticKeyword.Text == "static") continue;
+        var nm = u.Name?.ToString();
+        if (!string.IsNullOrEmpty(nm)) imports.Add(nm);
+    }
+
+    string primaryNs = rootNode.DescendantNodes().OfType<BaseNamespaceDeclarationSyntax>()
+        .Select(n => n.Name.ToString()).FirstOrDefault() ?? "";
+
+    var defines = new List<object>();
+    var exports = new SortedSet<string>(StringComparer.Ordinal);
+
+    foreach (var type in rootNode.DescendantNodes().OfType<TypeDeclarationSyntax>()) {
+        var cname = type.Identifier.Text;
+        var bases = type.BaseList?.Types.Select(t => Clip(OneLine(t.ToString()), 80)).ToList() ?? new List<string>();
+        var cdef = new Dictionary<string, object> {
+            ["name"] = cname, ["kind"] = "class", ["lineno"] = LineOf(type), ["end_lineno"] = EndLineOf(type),
+            ["bases"] = bases, ["decorators"] = type.AttributeLists.SelectMany(a => a.Attributes).Select(a => OneLine(a.ToString())).ToList()
+        };
+        if (IsPublic(type.Modifiers)) exports.Add(cname);
+        var v = Vis(type.Modifiers); if (v != "") cdef["visibility"] = v;
+        defines.Add(cdef);
+
+        foreach (var mem in type.Members) {
+            if (mem is MethodDeclarationSyntax m) {
+                var md = new Dictionary<string, object> {
+                    ["name"] = $"{cname}.{m.Identifier.Text}", ["kind"] = "method",
+                    ["lineno"] = LineOf(m), ["end_lineno"] = EndLineOf(m), ["decorators"] = m.AttributeLists.SelectMany(a => a.Attributes).Select(a => OneLine(a.ToString())).ToList(),
+                    ["params"] = Clip(OneLine(string.Join(", ", m.ParameterList.Parameters.Select(p => p.ToString()))), 160),
+                    ["returns"] = Clip(OneLine(m.ReturnType.ToString()), 80),
+                    ["calls"] = CallsIn(m.Body as SyntaxNode ?? m.ExpressionBody)
+                };
+                if (m.Modifiers.Any(x => x.Text == "static")) md["is_static"] = true;
+                var mv = Vis(m.Modifiers); if (mv != "") md["visibility"] = mv;
+                defines.Add(md);
+            } else if (mem is ConstructorDeclarationSyntax ctor) {
+                defines.Add(new Dictionary<string, object> {
+                    ["name"] = $"{cname}.{ctor.Identifier.Text}", ["kind"] = "method",
+                    ["lineno"] = LineOf(ctor), ["end_lineno"] = EndLineOf(ctor), ["decorators"] = new List<string>(),
+                    ["params"] = Clip(OneLine(string.Join(", ", ctor.ParameterList.Parameters.Select(p => p.ToString()))), 160),
+                    ["calls"] = CallsIn(ctor.Body as SyntaxNode ?? ctor.ExpressionBody)
+                });
+            } else if (mem is PropertyDeclarationSyntax prop) {
+                defines.Add(new Dictionary<string, object> {
+                    ["name"] = $"{cname}.{prop.Identifier.Text}", ["kind"] = "attribute",
+                    ["lineno"] = LineOf(prop), ["end_lineno"] = EndLineOf(prop), ["decorators"] = new List<string>()
+                });
+            } else if (mem is FieldDeclarationSyntax fld) {
+                foreach (var vd in fld.Declaration.Variables) {
+                    defines.Add(new Dictionary<string, object> {
+                        ["name"] = $"{cname}.{vd.Identifier.Text}", ["kind"] = "attribute",
+                        ["lineno"] = LineOf(fld), ["end_lineno"] = EndLineOf(fld), ["decorators"] = new List<string>()
+                    });
+                }
+            }
+        }
+    }
+
+    string dotted = primaryNs.Length > 0 ? primaryNs : Rel(file).Replace(".cs", "").Replace('/', '.');
+    modules.Add(new Dictionary<string, object> {
+        ["path"] = Rel(file), ["dotted"] = dotted, ["imports"] = imports.ToList(),
+        ["defines"] = defines, ["calls"] = CallsIn(rootNode), ["exports"] = exports.ToList()
+    });
+}
+
+var payload = new Dictionary<string, object> { ["modules"] = modules, ["failures"] = failures, ["fileCount"] = files.Count };
+var opts = new JsonSerializerOptions { WriteIndented = false };
+Console.Out.Write(JsonSerializer.Serialize(payload, opts));
+return 0;

package/roslyn/RoslynExtract.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>disable</Nullable>
+    <AssemblyName>roslyn-extract</AssemblyName>
+    <InvariantGlobalization>true</InvariantGlobalization>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
+  </ItemGroup>
+</Project>