@polycode-projects/seonix 0.10.0 → 0.10.1

package/README.md

@@ -357,6 +357,7 @@ template — see `templates/seonix.toml` and
   - `include_text`, `include_structure`, `respect_gitignore`, `markdown_sections`, `vue` — recognized and normalized, but **not yet wired to a consumer** (see "unwired keys" below).
 - **`[tune]`** — the locate/digest scoring knobs: `score_gap_k`, `literal_mention` (shipped default `true`), `demote_non_prod`, `call_adjacency`, `impl_of_interface`, `beam_search` (+ `beam_width`), `embed_rank`, `prose_layers`.
 - **`[tune.expansion]`** — graph-traversal expansion mode used by locate/the viewer's navigation: `strategy` (`none` | `beam` | `spiral` | `ppr`; `none` is the byte-identical shipped default), `nodes` (breadth/token-budget cap), `q` (proportion of most-distinctive neighbours followed per step), `depth` (hop radius).
+- **`[interfaces]`** — HTTP route↔handler edges the AST graph can't see on its own: a `Route` node per endpoint, linked to its handler by a `serves` edge, and (JS/TS + tree-sitter C#) an HTTP client call linked to the route it targets by a `callsHttp` edge. Off by default; turn it on with `enabled = true` or `SEONIX_INTERFACES=1` (env wins). Tunable: `frameworks` (default `["aspnet", "express"]`), `verbs`, `combine_controller_prefix`, `prefix_strip`, `match_threshold`.
 - **`[telemetry]`** — `enabled = true` opts in (see [Telemetry](#telemetry) below).
 
 **Precedence, everywhere:** explicit CLI arg > `seonix.toml` value > shipped
@@ -427,11 +428,15 @@ seonix supplies the graph; tmct owns the conversation. The old opt-in
 
 Python (stdlib `ast`), JS/TS (the TypeScript compiler API, including CommonJS
 `require`/`module.exports`), C# (Roslyn, with a tree-sitter fallback) and Java
-(JavaParser, with a tree-sitter fallback), all merged into the one typed graph. The C# Roslyn helper's source ships in the package under `roslyn/`; build
-it on the consumer side (needs the .NET SDK) if you index C#. The Java JavaParser
-helper is a jar built from the repository's `java/` directory (`mvn package`) and
-is not included in the npm package, so a package install indexes Java with the
-tree-sitter fallback.
+(JavaParser, with a tree-sitter fallback), all merged into the one typed graph.
+The C# Roslyn helper's source ships in the package under `roslyn/`. If the .NET
+SDK is on your PATH, seonix builds it the first time it indexes a C# repo, one
+build, cached after that. No `dotnet` on PATH just means it uses the tree-sitter
+fallback, silently, no error. Run `npm run build:roslyn` yourself first if you
+want the dll ready ahead of time, e.g. in a Docker image build. The Java
+JavaParser helper is a jar built from the repository's `java/` directory (`mvn
+package`) and is not included in the npm package, so a package install indexes
+Java with the tree-sitter fallback.
 
 ## Licence & safety
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "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.",
@@ -35,6 +35,7 @@
     "src/",
     "roslyn/*.cs",
     "roslyn/*.csproj",
+    "scripts/build-roslyn.mjs",
     "README.md",
     "LICENSE"
   ],
@@ -45,6 +46,7 @@
     "infra"
   ],
   "scripts": {
+    "build:roslyn": "node scripts/build-roslyn.mjs",
     "setup": "node scripts/setup.mjs",
     "bench": "node bench/run.mjs",
     "bench:quick": "node bench/run.mjs --instances 1 --runs 1",

package/scripts/build-roslyn.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// build-roslyn.mjs — explicit prewarm command (`npm run build:roslyn`) for the
+// Roslyn C# semantic extractor. NOT run automatically on `npm install` — the
+// dll lazy-builds on first real C# extraction attempt instead (src/cs_roslyn.mjs
+// via src/roslyn_build.mjs), so consumers who never touch C# never pay a .NET
+// build cost at install time. Use this command ahead of time when you want the
+// dll baked in up front (e.g. a Docker image build step, or a CI cache warm)
+// rather than paying the lazy-build cost on first use.
+import { ensureRoslynBuilt } from "../src/roslyn_build.mjs";
+
+await ensureRoslynBuilt();

package/src/cs_roslyn.mjs

@@ -3,15 +3,21 @@
 // prints the {modules:[…]} contract; this wrapper just shells out and parses it.
 // Falls back is the caller's job (cs_treesitter) when dotnet/the tool is absent.
 import { spawn } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { access } from "node:fs/promises";
+import { DLL as TOOL_DLL, ensureRoslynBuilt } from "./roslyn_build.mjs";
 
-const here = dirname(fileURLToPath(import.meta.url));
-const TOOL_DLL = join(here, "..", "roslyn", "publish", "roslyn-extract.dll");
+// Cached across calls within a process: chooseCs() in extract_lang.mjs calls
+// toolAvailable() once per ingestRepo() run, but tests and multi-repo indexing
+// can call it repeatedly — avoid re-spawning `dotnet --version` every time.
+// A fresh process (the normal case: one index run = one process) always
+// re-checks, so a dotnet toolchain installed after a prior failed attempt is
+// picked up automatically on the next run, no reinstall needed.
+let cachedAvailable;
 
+/** True if the Roslyn dll is present, lazily building it first (once per
+ *  process) when it's missing and `dotnet` is on PATH. */
 export async function toolAvailable() {
-  try { await access(TOOL_DLL); return true; } catch { return false; }
+  if (cachedAvailable === undefined) cachedAvailable = await ensureRoslynBuilt();
+  return cachedAvailable;
 }
 
 function run(cmd, args) {
@@ -26,7 +32,7 @@ function run(cmd, args) {
 }
 
 export async function ingest(root) {
-  if (!(await toolAvailable())) throw new Error("roslyn-extract.dll not built (run dotnet publish in roslyn/)");
+  if (!(await toolAvailable())) throw new Error("roslyn-extract.dll not available (no dotnet on PATH, or the lazy build failed — run `npm run build:roslyn` to retry with warnings)");
   const { code, out, err } = await run("dotnet", [TOOL_DLL, root]);
   if (code !== 0) throw new Error(`roslyn-extract failed (exit ${code}): ${err.slice(-300)}`);
   let parsed;

package/src/roslyn_build.mjs

@@ -0,0 +1,59 @@
+// roslyn_build.mjs — shared build logic for the Roslyn C# semantic extractor
+// (roslyn/publish/roslyn-extract.dll). Used by two callers: the lazy-build path
+// in cs_roslyn.mjs (triggered on the first real C# extraction attempt in a
+// process, not on `npm install`) and the explicit `npm run build:roslyn`
+// prewarm command (e.g. baking the dll into a Docker image ahead of time).
+//
+// Best-effort and silent-by-default: no dotnet on PATH -> skip, tree-sitter
+// (src/cs_treesitter.mjs) covers the absent case. A `dotnet publish` failure
+// (e.g. no network for the first NuGet restore) is a warning, never thrown.
+import { access } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+export const ROOT = join(here, "..");
+export const ROSLYN_DIR = join(ROOT, "roslyn");
+export const DLL = join(ROSLYN_DIR, "publish", "roslyn-extract.dll");
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      env: { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: "1", DOTNET_NOLOGO: "1" },
+      ...opts,
+    });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => (out += d));
+    child.stderr?.on("data", (d) => (err += d));
+    child.on("close", (code) => resolve({ code: code ?? -1, out, err }));
+    child.on("error", () => resolve({ code: -1, out, err: "" }));
+  });
+}
+
+async function exists(p) {
+  try { await access(p); return true; } catch { return false; }
+}
+
+/** Build the Roslyn dll if it's missing and `dotnet` is on PATH.
+ *  @returns {Promise<boolean>} true if the dll is present after this call
+ *  (already built, or built now); false otherwise (no dotnet, or publish
+ *  failed — caller falls back to tree-sitter). */
+export async function ensureRoslynBuilt({ quiet = false } = {}) {
+  if (await exists(DLL)) return true;
+
+  const dotnetCheck = await run("dotnet", ["--version"]);
+  if (dotnetCheck.code !== 0) return false; // no .NET SDK — tree-sitter fallback covers C#
+
+  const publish = await run("dotnet", ["publish", "-c", "Release", "-o", "publish"], { cwd: ROSLYN_DIR });
+  if (publish.code !== 0) {
+    if (!quiet) {
+      console.warn("[seonix] Roslyn C# extractor build failed — falling back to tree-sitter for C#.");
+      console.warn(`[seonix] dotnet publish exited ${publish.code}: ${publish.err.slice(-300)}`);
+    }
+    return false;
+  }
+  if (!quiet) console.log("[seonix] Roslyn C# extractor built (full semantic call/type resolution enabled).");
+  return true;
+}