@polycode-projects/seonix 0.1.0

package/src/config.mjs

@@ -0,0 +1,28 @@
+// Configuration for the seonix MCP server. Unlike the marginalia original
+// (remote API + key), this server reads a LOCAL graph artifact written by the
+// deterministic indexer — so the only knob is where that artifact lives.
+//
+//   SEONIX_GRAPH_FILE — path to the JSON graph artifact. Default:
+//                     <cwd>/.seonix/graph.json. MCP launchers start the server with
+//                     cwd = the indexed worktree, so the default resolves to the
+//                     artifact `cli index_repository` wrote there — no config needed.
+
+import { join } from "node:path";
+
+export const DEFAULT_GRAPH_REL = join(".seonix", "graph.json");
+
+/** A clean, caller-facing tool error — message shown to the MCP client verbatim,
+ *  never a stack. */
+export class ToolError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolError";
+  }
+}
+
+export function loadConfig(env = process.env, cwd = process.cwd()) {
+  const graphFile = env.SEONIX_GRAPH_FILE && env.SEONIX_GRAPH_FILE.trim()
+    ? env.SEONIX_GRAPH_FILE.trim()
+    : join(cwd, DEFAULT_GRAPH_REL);
+  return { graphFile };
+}

package/src/cs_roslyn.mjs

@@ -0,0 +1,38 @@
+// C# extractor — Roslyn (syntax-level) via the bundled dotnet tool. PICKED C#
+// candidate when dotnet is present. Spawns roslyn/publish/roslyn-extract which
+// 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";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const TOOL_DLL = join(here, "..", "roslyn", "publish", "roslyn-extract.dll");
+
+export async function toolAvailable() {
+  try { await access(TOOL_DLL); return true; } catch { return false; }
+}
+
+function run(cmd, args) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { env: { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: "1", DOTNET_NOLOGO: "1" } });
+    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", (e) => resolve({ code: -1, out, err: String(e) }));
+  });
+}
+
+export async function ingest(root) {
+  if (!(await toolAvailable())) throw new Error("roslyn-extract.dll not built (run dotnet publish in roslyn/)");
+  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;
+  try { parsed = JSON.parse(out); }
+  catch { throw new Error(`roslyn-extract produced non-JSON (${out.slice(0, 120)})`); }
+  return { modules: parsed.modules || [], failures: parsed.failures || [], fileCount: parsed.fileCount || 0 };
+}
+
+export const meta = { id: "roslyn", language: "c#", lib: "Roslyn (Microsoft.CodeAnalysis.CSharp, syntax-level)", exts: [".cs"] };

package/src/cs_treesitter.mjs

@@ -0,0 +1,140 @@
+// C# extractor — tree-sitter-c-sharp (CST-only) candidate for the bake-off. The
+// no-.NET fallback: a uniform CST, no semantic model (no resolved call targets /
+// types). Emits the same contract shape so codegraph.mjs/digest consume it. Module
+// identity is per-file; `dotted` is the file's primary namespace.
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { walk, relPath } from "./walk.mjs";
+
+// tree-sitter is the OPTIONAL fallback backend (used only when Roslyn/dotnet is
+// absent). It is a native module and NOT a declared seonix dependency, so the
+// require is LAZY — importing this module (e.g. via extract_lang's REGISTRY) must
+// not force the native build. Resolved on first parse; a clear error if missing.
+const require = createRequire(import.meta.url);
+let _Parser = null;
+let _CSharp = null;
+function loadTreeSitter() {
+  if (_Parser) return { Parser: _Parser, CSharp: _CSharp };
+  try {
+    _Parser = require("tree-sitter");
+    _CSharp = require("tree-sitter-c-sharp");
+  } catch (e) {
+    throw new Error(
+      `tree-sitter C# fallback unavailable (install tree-sitter + tree-sitter-c-sharp, or use the Roslyn backend): ${e?.message || e}`,
+    );
+  }
+  return { Parser: _Parser, CSharp: _CSharp };
+}
+
+const EXTS = [".cs"];
+const line = (n) => n.startPosition.row + 1;
+const endLine = (n) => n.endPosition.row + 1;
+const fieldText = (n, f) => n.childForFieldName(f)?.text || "";
+
+const TYPE_DECLS = new Set(["class_declaration", "interface_declaration", "struct_declaration", "record_declaration", "enum_declaration"]);
+
+function collectCalls(node) {
+  const out = new Set();
+  const stack = [node];
+  while (stack.length) {
+    const n = stack.pop();
+    if (n.type === "invocation_expression") {
+      const fn = n.childForFieldName("function");
+      if (fn) out.add(fn.text.replace(/\s+/g, "").slice(0, 80));
+    }
+    for (let i = 0; i < n.namedChildCount; i++) stack.push(n.namedChild(i));
+  }
+  return [...out].sort();
+}
+
+function modifiersText(node) {
+  // tree-sitter-c-sharp surfaces modifiers as anonymous children before the name
+  const mods = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c.type === "modifier") mods.push(c.text);
+  }
+  return mods;
+}
+const visFrom = (mods) => mods.includes("private") ? "private" : mods.includes("protected") ? "protected" : "";
+
+export async function extractFile(absPath, root) {
+  const text = await readFile(absPath, "utf8").catch(() => null);
+  const path = relPath(root, absPath);
+  if (text == null) return { failed: true, path };
+  let tree;
+  try {
+    const { Parser, CSharp } = loadTreeSitter();
+    const p = new Parser(); p.setLanguage(CSharp);
+    tree = p.parse(text);
+  } catch { return { failed: true, path }; }
+
+  const imports = new Set();
+  const defines = [];
+  const exports = new Set();
+  let primaryNs = "";
+
+  const stack = [tree.rootNode];
+  while (stack.length) {
+    const n = stack.pop();
+    if (n.type === "using_directive") {
+      const nm = (n.childForFieldName("name") || n.namedChildren.find((c) => /name/.test(c.type)));
+      const t = (nm?.text || n.text.replace(/^using\s+|;$/g, "")).trim();
+      if (t && !/^static\s/.test(t)) imports.add(t.replace(/\s+/g, ""));
+    } else if ((n.type === "namespace_declaration" || n.type === "file_scoped_namespace_declaration") && !primaryNs) {
+      primaryNs = fieldText(n, "name");
+    } else if (TYPE_DECLS.has(n.type)) {
+      const cname = fieldText(n, "name");
+      if (cname) {
+        const mods = modifiersText(n);
+        const bases = [];
+        const baseList = n.childForFieldName("bases") || n.namedChildren.find((c) => c.type === "base_list");
+        if (baseList) for (let i = 0; i < baseList.namedChildCount; i++) bases.push(baseList.namedChild(i).text.slice(0, 80));
+        defines.push({ name: cname, kind: "class", lineno: line(n), end_lineno: endLine(n), bases, decorators: [],
+          ...(visFrom(mods) ? { visibility: visFrom(mods) } : {}) });
+        if (mods.includes("public")) exports.add(cname);
+        const body = n.childForFieldName("body");
+        if (body) {
+          for (let i = 0; i < body.namedChildCount; i++) {
+            const mem = body.namedChild(i);
+            if (mem.type === "method_declaration" || mem.type === "constructor_declaration" || mem.type === "local_function_statement") {
+              const mn = fieldText(mem, "name") || cname;
+              const mmods = modifiersText(mem);
+              const params = (mem.childForFieldName("parameters")?.text || "").replace(/\s+/g, " ").replace(/^\(|\)$/g, "").slice(0, 160);
+              const returns = (mem.childForFieldName("returns") || mem.childForFieldName("type"))?.text?.slice(0, 80) || "";
+              defines.push({ name: `${cname}.${mn}`, kind: "method", lineno: line(mem), end_lineno: endLine(mem),
+                decorators: [], params, returns, calls: collectCalls(mem),
+                ...(mmods.includes("static") ? { is_static: true } : {}),
+                ...(visFrom(mmods) ? { visibility: visFrom(mmods) } : {}) });
+            } else if (mem.type === "property_declaration") {
+              const mn = fieldText(mem, "name");
+              if (mn) defines.push({ name: `${cname}.${mn}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem), decorators: [] });
+            } else if (mem.type === "field_declaration") {
+              const v = mem.descendantsOfType?.("variable_declarator")?.[0];
+              const mn = v ? fieldText(v, "name") || v.text : "";
+              if (mn) defines.push({ name: `${cname}.${mn}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem), decorators: [] });
+            }
+          }
+        }
+        // don't descend into the type body again for nested types beyond members
+      }
+    }
+    if (!TYPE_DECLS.has(n.type)) for (let i = 0; i < n.namedChildCount; i++) stack.push(n.namedChild(i));
+  }
+
+  return { path, dotted: primaryNs || path.replace(/\.cs$/i, "").split("/").join("."),
+    imports: [...imports].sort(), defines, calls: collectCalls(tree.rootNode), exports: [...exports].sort() };
+}
+
+export async function ingest(root) {
+  const files = await walk(root, EXTS);
+  const modules = [];
+  const failures = [];
+  for (const f of files) {
+    const mod = await extractFile(f, root);
+    if (mod.failed) failures.push(mod.path); else modules.push(mod);
+  }
+  return { modules, failures, fileCount: files.length };
+}
+
+export const meta = { id: "treesitter-cs", language: "c#", lib: "tree-sitter-c-sharp", exts: EXTS };