@danielblomma/cortex-mcp 1.0.3 → 1.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielblomma/cortex-mcp",
   "mcpName": "io.github.DanielBlomma/cortex",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Local, repo-scoped context platform for coding assistants. Semantic search, graph relationships, and architectural rule context.",
   "type": "module",
   "author": "Daniel Blomma",

package/scaffold/scripts/bootstrap.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 MCP_DIR="$REPO_ROOT/mcp"
-TOTAL_STEPS=5
+TOTAL_STEPS=6
 STEP_INDEX=0
 
 print_logo() {
@@ -38,6 +38,8 @@ info "note: upstream RyuGraph dependencies may print deprecation warnings during
 NPM_CONFIG_CACHE="$MCP_DIR/.npm-cache" npm --prefix "$MCP_DIR" install --no-fund --no-update-notifier --loglevel=warn
 NPM_CONFIG_CACHE="$REPO_ROOT/scripts/parsers/.npm-cache" npm --prefix "$REPO_ROOT/scripts/parsers" install --no-fund --no-update-notifier --loglevel=warn
 
+source "$REPO_ROOT/scripts/lib/enterprise-check.sh"
+
 step "Indexing repository context"
 "$REPO_ROOT/scripts/ingest.sh"
 

package/scaffold/scripts/dashboard.mjs

@@ -403,26 +403,7 @@ function computeTopConnected() {
 
 // ── Data: estimate tokens per task (realistic comparison) ────
 function estimatePerTaskTokens(baseline) {
-  // Read all entity types for accurate excerpt averaging
-  const entityFiles = [
-    "entities.file.jsonl",
-    "entities.chunk.jsonl",
-    "entities.rule.jsonl",
-    "entities.adr.jsonl"
-  ];
-
-  let totalExcerptChars = 0;
-  let entityCount = 0;
-
-  for (const file of entityFiles) {
-    const entities = readJsonlSafe(path.join(CACHE_DIR, file));
-    for (const e of entities) {
-      totalExcerptChars += (e.excerpt || e.body || "").slice(0, 500).length;
-      entityCount++;
-    }
-  }
-
-  if (entityCount === 0 || baseline.files === 0) {
+  if (baseline.files === 0) {
     return { codebase: baseline.tokens, baselinePerTask: 0, cortexPerTask: 0,
              filesPerTask: 0, queriesPerTask: 0, ratio: 0, reduction: 0 };
   }
@@ -434,14 +415,13 @@ function estimatePerTaskTokens(baseline) {
   const baselinePerTask = filesPerTask * avgFileTokens;
 
   // --- With Cortex: ~3 search queries per task, top 5 results each ---
+  // Fixed cost per result: search returns truncated snippets + metadata.
+  // More entities in the index = better precision, NOT more tokens per query.
   const TYPICAL_SEARCHES_PER_TASK = 3;
   const topK = 5;
-  const avgExcerptChars = totalExcerptChars / entityCount;
-  // Per result: excerpt + JSON metadata (~350 chars for id, type, title, path, scores, etc.)
-  const perResultChars = avgExcerptChars + 350;
-  // Per query: top-K results + response wrapper (~300 chars for query, ranking, counts)
-  const perQueryChars = topK * perResultChars + 300;
-  const perQueryTokens = Math.round(perQueryChars / 4);
+  const PER_RESULT_CHARS = 850; // ~500 char snippet + ~350 char metadata
+  const PER_QUERY_OVERHEAD = 300; // query wrapper, ranking, counts
+  const perQueryTokens = Math.round((topK * PER_RESULT_CHARS + PER_QUERY_OVERHEAD) / 4);
   const cortexPerTask = TYPICAL_SEARCHES_PER_TASK * perQueryTokens;
 
   const ratio = cortexPerTask > 0 ? Math.round(baselinePerTask / cortexPerTask) : 0;

package/scaffold/scripts/ingest.mjs

@@ -9,6 +9,10 @@ import {
   isVbNetParserAvailable,
   parseCode as parseVbNetCode
 } from "./parsers/vbnet.mjs";
+import {
+  isCSharpParserAvailable,
+  parseCode as parseCSharpCode
+} from "./parsers/csharp.mjs";
 import {
   isCppParserAvailable,
   parseCode as parseCppCode
@@ -199,6 +203,14 @@ const CHUNK_PARSERS = new Map([
       isAvailable: isVbNetParserAvailable
     }
   ],
+  [
+    ".cs",
+    {
+      language: "csharp",
+      parse: parseCSharpCode,
+      isAvailable: isCSharpParserAvailable
+    }
+  ],
   [
     ".sql",
     {

package/scaffold/scripts/parsers/csharp.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * Conditional C# parser bridge for Cortex.
+ *
+ * Uses a Roslyn sidecar via `dotnet run` when a .NET runtime is available.
+ * If no runtime exists, callers should skip structured chunk extraction and
+ * fall back to plain file-level indexing.
+ */
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEFAULT_DOTNET_COMMAND = "dotnet";
+const DEFAULT_PROJECT_PATH = path.join(__dirname, "dotnet", "CSharpParser", "CSharpParser.csproj");
+
+let runtimeCache = null;
+
+function getDotnetCommand() {
+  const override = process.env.CORTEX_DOTNET_CMD;
+  return override && override.trim().length > 0 ? override.trim() : DEFAULT_DOTNET_COMMAND;
+}
+
+function getProjectPath() {
+  const override = process.env.CORTEX_CSHARP_PARSER_PROJECT;
+  return override && override.trim().length > 0 ? override.trim() : DEFAULT_PROJECT_PATH;
+}
+
+export function resetCSharpParserRuntimeCache() {
+  runtimeCache = null;
+}
+
+export function getCSharpParserRuntime() {
+  if (runtimeCache) {
+    return runtimeCache;
+  }
+
+  const command = getDotnetCommand();
+  const versionProbe = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    timeout: 5000
+  });
+
+  if (versionProbe.error || versionProbe.status !== 0) {
+    runtimeCache = {
+      available: false,
+      command,
+      projectPath: getProjectPath(),
+      reason:
+        versionProbe.error?.message ||
+        versionProbe.stderr?.trim() ||
+        "dotnet runtime not available"
+    };
+    return runtimeCache;
+  }
+
+  runtimeCache = {
+    available: true,
+    command,
+    projectPath: getProjectPath(),
+    version: versionProbe.stdout.trim()
+  };
+  return runtimeCache;
+}
+
+export function isCSharpParserAvailable() {
+  return getCSharpParserRuntime().available;
+}
+
+export function parseCode(code, filePath, language = "csharp") {
+  const runtime = getCSharpParserRuntime();
+  if (!runtime.available) {
+    return { chunks: [], errors: [] };
+  }
+
+  const args = [
+    "run",
+    "--project",
+    runtime.projectPath,
+    "--configuration",
+    "Release",
+    "--",
+    "--stdin",
+    "--file",
+    filePath,
+    "--language",
+    language
+  ];
+
+  const result = spawnSync(runtime.command, args, {
+    input: code,
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 10 * 1024 * 1024
+  });
+
+  if (result.error || result.status !== 0) {
+    return {
+      chunks: [],
+      errors: [
+        {
+          message:
+            result.error?.message ||
+            result.stderr?.trim() ||
+            `C# parser failed with exit code ${result.status ?? "unknown"}`
+        }
+      ]
+    };
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return {
+      chunks: Array.isArray(parsed.chunks) ? parsed.chunks : [],
+      errors: Array.isArray(parsed.errors) ? parsed.errors : []
+    };
+  } catch (error) {
+    return {
+      chunks: [],
+      errors: [
+        {
+          message: `C# parser returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const fs = await import("node:fs");
+  const filePath = process.argv[2];
+
+  if (!filePath) {
+    console.error("Usage: csharp.mjs <file.cs>");
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const result = parseCode(code, filePath, "csharp");
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/parsers/dotnet/CSharpParser/CSharpParser.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+  </ItemGroup>
+</Project>

package/scaffold/scripts/parsers/dotnet/CSharpParser/Program.cs

@@ -0,0 +1,406 @@
+using System.Text.Json;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+var options = ParseArgs(args);
+if (string.IsNullOrWhiteSpace(options.FilePath))
+{
+    Console.Error.WriteLine("Missing required --file argument.");
+    Environment.Exit(1);
+}
+
+var source = options.UseStdin
+    ? Console.In.ReadToEnd()
+    : File.ReadAllText(options.FilePath);
+
+var parseResult = ParseCSharp(source, options.FilePath, options.Language);
+var json = JsonSerializer.Serialize(parseResult, new JsonSerializerOptions
+{
+    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    WriteIndented = false
+});
+
+Console.WriteLine(json);
+
+return;
+
+static ParseOptions ParseArgs(string[] args)
+{
+    var options = new ParseOptions();
+    for (var index = 0; index < args.Length; index += 1)
+    {
+        var arg = args[index];
+        switch (arg)
+        {
+            case "--stdin":
+                options.UseStdin = true;
+                break;
+            case "--file":
+                if (index + 1 < args.Length)
+                {
+                    options.FilePath = args[++index];
+                }
+                break;
+            case "--language":
+                if (index + 1 < args.Length)
+                {
+                    options.Language = args[++index];
+                }
+                break;
+        }
+    }
+
+    return options;
+}
+
+static ParserOutput ParseCSharp(string source, string filePath, string language)
+{
+    var tree = CSharpSyntaxTree.ParseText(source, path: filePath);
+    var root = tree.GetCompilationUnitRoot();
+    var diagnostics = tree.GetDiagnostics()
+        .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+        .Select(diagnostic => new ParserError(
+            diagnostic.GetMessage(),
+            diagnostic.Location.GetLineSpan().StartLinePosition.Line + 1,
+            diagnostic.Location.GetLineSpan().StartLinePosition.Character + 1
+        ))
+        .ToList();
+
+    if (diagnostics.Count > 0)
+    {
+        return new ParserOutput(new List<ChunkOutput>(), diagnostics);
+    }
+
+    var collector = new CSharpChunkCollector(tree, root, source, language);
+    return new ParserOutput(collector.Collect(), diagnostics);
+}
+
+sealed class CSharpChunkCollector
+{
+    private readonly SyntaxTree _tree;
+    private readonly CompilationUnitSyntax _root;
+    private readonly string _source;
+    private readonly string _language;
+    private readonly string[] _imports;
+
+    public CSharpChunkCollector(SyntaxTree tree, CompilationUnitSyntax root, string source, string language)
+    {
+        _tree = tree;
+        _root = root;
+        _source = source;
+        _language = language;
+        _imports = CollectUsings(root);
+    }
+
+    private static string[] CollectUsings(CompilationUnitSyntax root)
+    {
+        var usings = new List<string>();
+
+        // Top-level using directives (including global using)
+        foreach (var directive in root.Usings)
+        {
+            var name = directive.Name?.ToString();
+            if (!string.IsNullOrWhiteSpace(name))
+            {
+                usings.Add(name);
+            }
+        }
+
+        // Namespace-scoped using directives
+        foreach (var member in root.Members)
+        {
+            if (member is BaseNamespaceDeclarationSyntax ns)
+            {
+                foreach (var directive in ns.Usings)
+                {
+                    var name = directive.Name?.ToString();
+                    if (!string.IsNullOrWhiteSpace(name))
+                    {
+                        usings.Add(name);
+                    }
+                }
+            }
+        }
+
+        return usings.Distinct(StringComparer.Ordinal).ToArray();
+    }
+
+    public List<ChunkOutput> Collect()
+    {
+        var chunks = new List<ChunkOutput>();
+
+        foreach (var member in _root.Members)
+        {
+            CollectMember(chunks, member, null);
+        }
+
+        return chunks;
+    }
+
+    private void CollectMember(List<ChunkOutput> chunks, MemberDeclarationSyntax member, string? parentName)
+    {
+        switch (member)
+        {
+            case BaseNamespaceDeclarationSyntax namespaceDecl:
+                foreach (var nested in namespaceDecl.Members)
+                {
+                    CollectMember(chunks, nested, parentName);
+                }
+                break;
+
+            case ClassDeclarationSyntax classDecl:
+                AddTypeChunk(chunks, classDecl.Identifier.Text, "class", classDecl, parentName);
+                foreach (var nested in classDecl.Members)
+                {
+                    CollectTypeMember(chunks, nested, classDecl.Identifier.Text);
+                }
+                break;
+
+            case StructDeclarationSyntax structDecl:
+                AddTypeChunk(chunks, structDecl.Identifier.Text, "struct", structDecl, parentName);
+                foreach (var nested in structDecl.Members)
+                {
+                    CollectTypeMember(chunks, nested, structDecl.Identifier.Text);
+                }
+                break;
+
+            case InterfaceDeclarationSyntax interfaceDecl:
+                AddTypeChunk(chunks, interfaceDecl.Identifier.Text, "interface", interfaceDecl, parentName);
+                foreach (var nested in interfaceDecl.Members)
+                {
+                    CollectTypeMember(chunks, nested, interfaceDecl.Identifier.Text);
+                }
+                break;
+
+            case EnumDeclarationSyntax enumDecl:
+                AddTypeChunk(chunks, enumDecl.Identifier.Text, "enum", enumDecl, parentName);
+                break;
+
+            case RecordDeclarationSyntax recordDecl:
+                AddTypeChunk(chunks, recordDecl.Identifier.Text, "record", recordDecl, parentName);
+                foreach (var nested in recordDecl.Members)
+                {
+                    CollectTypeMember(chunks, nested, recordDecl.Identifier.Text);
+                }
+                break;
+        }
+    }
+
+    private void CollectTypeMember(List<ChunkOutput> chunks, MemberDeclarationSyntax member, string parentTypeName)
+    {
+        switch (member)
+        {
+            case MethodDeclarationSyntax methodDecl:
+                AddMethodChunk(chunks, methodDecl, parentTypeName);
+                break;
+            case ConstructorDeclarationSyntax ctorDecl:
+                AddConstructorChunk(chunks, ctorDecl, parentTypeName);
+                break;
+            case PropertyDeclarationSyntax propDecl:
+                AddPropertyChunk(chunks, propDecl, parentTypeName);
+                break;
+            case EventDeclarationSyntax eventDecl:
+                AddTypeChunk(chunks, $"{parentTypeName}.{eventDecl.Identifier.Text}", "event", eventDecl, null);
+                break;
+            case FieldDeclarationSyntax fieldDecl:
+                foreach (var variable in fieldDecl.Declaration.Variables)
+                {
+                    AddTypeChunk(chunks, $"{parentTypeName}.{variable.Identifier.Text}", "field", fieldDecl, null);
+                }
+                break;
+            case ClassDeclarationSyntax nestedClass:
+                AddTypeChunk(chunks, $"{parentTypeName}.{nestedClass.Identifier.Text}", "class", nestedClass, null);
+                foreach (var nested in nestedClass.Members)
+                {
+                    CollectTypeMember(chunks, nested, $"{parentTypeName}.{nestedClass.Identifier.Text}");
+                }
+                break;
+            case StructDeclarationSyntax nestedStruct:
+                AddTypeChunk(chunks, $"{parentTypeName}.{nestedStruct.Identifier.Text}", "struct", nestedStruct, null);
+                foreach (var nested in nestedStruct.Members)
+                {
+                    CollectTypeMember(chunks, nested, $"{parentTypeName}.{nestedStruct.Identifier.Text}");
+                }
+                break;
+            case RecordDeclarationSyntax nestedRecord:
+                AddTypeChunk(chunks, $"{parentTypeName}.{nestedRecord.Identifier.Text}", "record", nestedRecord, null);
+                foreach (var nested in nestedRecord.Members)
+                {
+                    CollectTypeMember(chunks, nested, $"{parentTypeName}.{nestedRecord.Identifier.Text}");
+                }
+                break;
+            case EnumDeclarationSyntax nestedEnum:
+                AddTypeChunk(chunks, $"{parentTypeName}.{nestedEnum.Identifier.Text}", "enum", nestedEnum, null);
+                break;
+        }
+    }
+
+    private void AddTypeChunk(List<ChunkOutput> chunks, string name, string kind, SyntaxNode node, string? parentName)
+    {
+        chunks.Add(BuildChunk(
+            parentName is null ? name : $"{parentName}.{name}",
+            kind,
+            BuildSignature(kind, name, node),
+            node,
+            GetCalls(node),
+            _imports,
+            IsExported(node)
+        ));
+    }
+
+    private void AddMethodChunk(List<ChunkOutput> chunks, MethodDeclarationSyntax node, string parentTypeName)
+    {
+        var name = $"{parentTypeName}.{node.Identifier.Text}";
+        chunks.Add(BuildChunk(
+            name,
+            "method",
+            $"{node.ReturnType} {node.Identifier.Text}{node.ParameterList}",
+            node,
+            GetCalls(node),
+            _imports,
+            IsExported(node)
+        ));
+    }
+
+    private void AddConstructorChunk(List<ChunkOutput> chunks, ConstructorDeclarationSyntax node, string parentTypeName)
+    {
+        chunks.Add(BuildChunk(
+            $"{parentTypeName}.ctor",
+            "constructor",
+            $"{node.Identifier.Text}{node.ParameterList}",
+            node,
+            GetCalls(node),
+            _imports,
+            IsExported(node)
+        ));
+    }
+
+    private void AddPropertyChunk(List<ChunkOutput> chunks, PropertyDeclarationSyntax node, string parentTypeName)
+    {
+        chunks.Add(BuildChunk(
+            $"{parentTypeName}.{node.Identifier.Text}",
+            "property",
+            $"{node.Type} {node.Identifier.Text}",
+            node,
+            GetCalls(node),
+            _imports,
+            IsExported(node)
+        ));
+    }
+
+    private ChunkOutput BuildChunk(
+        string name,
+        string kind,
+        string signature,
+        SyntaxNode node,
+        IReadOnlyCollection<string> calls,
+        IReadOnlyCollection<string> imports,
+        bool exported)
+    {
+        var span = node.GetLocation().GetLineSpan();
+        return new ChunkOutput(
+            name,
+            kind,
+            signature,
+            node.ToFullString(),
+            span.StartLinePosition.Line + 1,
+            span.EndLinePosition.Line + 1,
+            _language,
+            exported,
+            calls.ToArray(),
+            imports.ToArray()
+        );
+    }
+
+    private static string BuildSignature(string kind, string name, SyntaxNode node)
+    {
+        return node switch
+        {
+            ClassDeclarationSyntax c => $"{ModifiersOf(c.Modifiers)} class {c.Identifier}{c.TypeParameterList}{BaseListOf(c.BaseList)}".Trim(),
+            StructDeclarationSyntax s => $"{ModifiersOf(s.Modifiers)} struct {s.Identifier}{s.TypeParameterList}{BaseListOf(s.BaseList)}".Trim(),
+            InterfaceDeclarationSyntax i => $"{ModifiersOf(i.Modifiers)} interface {i.Identifier}{i.TypeParameterList}{BaseListOf(i.BaseList)}".Trim(),
+            EnumDeclarationSyntax e => $"{ModifiersOf(e.Modifiers)} enum {e.Identifier}{BaseListOf(e.BaseList)}".Trim(),
+            RecordDeclarationSyntax r => $"{ModifiersOf(r.Modifiers)} record {r.Identifier}{r.TypeParameterList}{r.ParameterList}{BaseListOf(r.BaseList)}".Trim(),
+            _ => $"{kind} {name}"
+        };
+    }
+
+    private static string ModifiersOf(SyntaxTokenList modifiers)
+    {
+        return modifiers.Count > 0 ? modifiers.ToString() : "";
+    }
+
+    private static string BaseListOf(BaseListSyntax? baseList)
+    {
+        return baseList is not null ? $" : {baseList.Types}" : "";
+    }
+
+    private static bool IsExported(SyntaxNode node)
+    {
+        SyntaxTokenList modifiers = node switch
+        {
+            TypeDeclarationSyntax typeDecl => typeDecl.Modifiers,
+            MethodDeclarationSyntax methodDecl => methodDecl.Modifiers,
+            ConstructorDeclarationSyntax ctorDecl => ctorDecl.Modifiers,
+            PropertyDeclarationSyntax propDecl => propDecl.Modifiers,
+            EventDeclarationSyntax eventDecl => eventDecl.Modifiers,
+            FieldDeclarationSyntax fieldDecl => fieldDecl.Modifiers,
+            _ => default
+        };
+
+        if (modifiers.Count == 0)
+        {
+            return false;
+        }
+
+        return modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword));
+    }
+
+    private static IReadOnlyCollection<string> GetCalls(SyntaxNode node)
+    {
+        return node.DescendantNodes()
+            .OfType<InvocationExpressionSyntax>()
+            .Select(invocation => invocation.Expression)
+            .Select(GetInvocationName)
+            .Where(name => !string.IsNullOrWhiteSpace(name))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+    }
+
+    private static string? GetInvocationName(ExpressionSyntax expression)
+    {
+        return expression switch
+        {
+            IdentifierNameSyntax identifier => identifier.Identifier.Text,
+            GenericNameSyntax genericName => genericName.Identifier.Text,
+            MemberAccessExpressionSyntax memberAccess => memberAccess.Name.Identifier.Text,
+            InvocationExpressionSyntax nestedInvocation => GetInvocationName(nestedInvocation.Expression),
+            _ => null
+        };
+    }
+}
+
+sealed record ParseOptions
+{
+    public bool UseStdin { get; set; }
+    public string FilePath { get; set; } = "";
+    public string Language { get; set; } = "csharp";
+}
+
+sealed record ChunkOutput(
+    string Name,
+    string Kind,
+    string Signature,
+    string Body,
+    int StartLine,
+    int EndLine,
+    string Language,
+    bool Exported,
+    string[] Calls,
+    string[] Imports
+);
+
+sealed record ParserError(string Message, int Line, int Column);
+
+sealed record ParserOutput(List<ChunkOutput> Chunks, List<ParserError> Errors);