@danielblomma/cortex-mcp 1.3.2 → 1.4.1

package/scaffold/scripts/parsers/csharp.mjs

@@ -2,11 +2,16 @@
 /**
  * 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.
+ * Uses a Roslyn sidecar via a pre-published DLL when a .NET SDK is available.
+ * On first use the sidecar is published to bin/Release/<tfm>/publish/ and the
+ * DLL path is cached; subsequent invocations skip the msbuild cycle and run
+ * `dotnet <dll>` directly — roughly 10× faster per call than `dotnet run`.
+ *
+ * If no runtime/SDK exists, callers should skip structured chunk extraction
+ * and fall back to plain file-level indexing.
  */
 
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
@@ -15,8 +20,10 @@ 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");
+const DEFAULT_TARGET_FRAMEWORK = "net10.0";
 
 let runtimeCache = null;
+let publishCache = null;
 
 function getDotnetCommand() {
   const override = process.env.CORTEX_DOTNET_CMD;
@@ -28,8 +35,51 @@ function getProjectPath() {
   return override && override.trim().length > 0 ? override.trim() : DEFAULT_PROJECT_PATH;
 }
 
+function getTargetFramework() {
+  const override = process.env.CORTEX_CSHARP_PARSER_TFM;
+  return override && override.trim().length > 0 ? override.trim() : DEFAULT_TARGET_FRAMEWORK;
+}
+
+function getPublishDir() {
+  const override = process.env.CORTEX_CSHARP_PUBLISH_DIR;
+  if (override && override.trim().length > 0) return override.trim();
+  const projectDir = path.dirname(getProjectPath());
+  return path.join(projectDir, "bin", "Release", getTargetFramework(), "publish");
+}
+
+function getDllPath() {
+  return path.join(getPublishDir(), "CSharpParser.dll");
+}
+
+function getMaxSourceMtime() {
+  const projectDir = path.dirname(getProjectPath());
+  const sources = [getProjectPath(), path.join(projectDir, "Program.cs")];
+  let max = 0;
+  for (const src of sources) {
+    try {
+      const mtime = fs.statSync(src).mtimeMs;
+      if (mtime > max) max = mtime;
+    } catch {
+      // missing source — treated as stale below
+    }
+  }
+  return max;
+}
+
+function needsPublish() {
+  const dll = getDllPath();
+  let dllMtime;
+  try {
+    dllMtime = fs.statSync(dll).mtimeMs;
+  } catch {
+    return true;
+  }
+  return getMaxSourceMtime() > dllMtime;
+}
+
 export function resetCSharpParserRuntimeCache() {
   runtimeCache = null;
+  publishCache = null;
 }
 
 export function getCSharpParserRuntime() {
@@ -69,19 +119,69 @@ export function isCSharpParserAvailable() {
   return getCSharpParserRuntime().available;
 }
 
+export function ensureCSharpParserPublished() {
+  if (publishCache) return publishCache;
+
+  const runtime = getCSharpParserRuntime();
+  if (!runtime.available) {
+    publishCache = { ok: false, reason: runtime.reason };
+    return publishCache;
+  }
+
+  const dllPath = getDllPath();
+  if (!needsPublish()) {
+    publishCache = { ok: true, dllPath };
+    return publishCache;
+  }
+
+  if (!process.env.CORTEX_QUIET) {
+    process.stderr.write("[cortex] Publishing Roslyn C# parser (one-time, ~15s)...\n");
+  }
+
+  const result = spawnSync(
+    runtime.command,
+    [
+      "publish",
+      runtime.projectPath,
+      "-c", "Release",
+      "-o", getPublishDir(),
+      "--nologo",
+      "-v", "quiet"
+    ],
+    { encoding: "utf8", timeout: 180000 }
+  );
+
+  if (result.error || result.status !== 0) {
+    publishCache = {
+      ok: false,
+      reason:
+        result.error?.message ||
+        result.stderr?.trim() ||
+        `dotnet publish failed with exit code ${result.status ?? "unknown"}`
+    };
+    return publishCache;
+  }
+
+  publishCache = { ok: true, dllPath };
+  return publishCache;
+}
+
 export function parseCode(code, filePath, language = "csharp") {
   const runtime = getCSharpParserRuntime();
   if (!runtime.available) {
     return { chunks: [], errors: [] };
   }
 
+  const published = ensureCSharpParserPublished();
+  if (!published.ok) {
+    return {
+      chunks: [],
+      errors: [{ message: `C# parser publish failed: ${published.reason}` }]
+    };
+  }
+
   const args = [
-    "run",
-    "--project",
-    runtime.projectPath,
-    "--configuration",
-    "Release",
-    "--",
+    published.dllPath,
     "--stdin",
     "--file",
     filePath,
@@ -128,8 +228,95 @@ export function parseCode(code, filePath, language = "csharp") {
   }
 }
 
+/**
+ * Batch-parse an entire C# project as one CSharpCompilation, enabling
+ * SemanticModel-based call resolution. Calls are emitted as fully-
+ * qualified names (e.g. "System.IO.File.ReadAllText") instead of
+ * short names. Unresolved calls fall back to the syntax name.
+ *
+ * @param {Array<{path: string, content: string}>} files
+ * @returns {Map<string, {chunks: Array, errors: Array}>}
+ */
+export function parseProject(files) {
+  const runtime = getCSharpParserRuntime();
+  if (!runtime.available) {
+    const empty = new Map();
+    for (const file of files) {
+      empty.set(file.path, { chunks: [], errors: [] });
+    }
+    return empty;
+  }
+
+  const published = ensureCSharpParserPublished();
+  if (!published.ok) {
+    const errors = [{ message: `C# parser publish failed: ${published.reason}` }];
+    const fallback = new Map();
+    for (const file of files) {
+      fallback.set(file.path, { chunks: [], errors });
+    }
+    return fallback;
+  }
+
+  const args = [published.dllPath, "--batch"];
+
+  const payload = JSON.stringify({
+    files: files.map((f) => ({ path: f.path, source: f.content }))
+  });
+
+  const result = spawnSync(runtime.command, args, {
+    input: payload,
+    encoding: "utf8",
+    timeout: 120000,
+    maxBuffer: 256 * 1024 * 1024
+  });
+
+  if (result.error || result.status !== 0) {
+    const errors = [
+      {
+        message:
+          result.error?.message ||
+          result.stderr?.trim() ||
+          `C# batch parser failed with exit code ${result.status ?? "unknown"}`
+      }
+    ];
+    const fallback = new Map();
+    for (const file of files) {
+      fallback.set(file.path, { chunks: [], errors });
+    }
+    return fallback;
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    const out = new Map();
+    const perFile = parsed.files ?? {};
+    for (const file of files) {
+      const entry = perFile[file.path];
+      if (entry) {
+        out.set(file.path, {
+          chunks: Array.isArray(entry.chunks) ? entry.chunks : [],
+          errors: Array.isArray(entry.errors) ? entry.errors : []
+        });
+      } else {
+        out.set(file.path, { chunks: [], errors: [] });
+      }
+    }
+    return out;
+  } catch (error) {
+    const errors = [
+      {
+        message: `C# batch parser returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+      }
+    ];
+    const fallback = new Map();
+    for (const file of files) {
+      fallback.set(file.path, { chunks: [], errors });
+    }
+    return fallback;
+  }
+}
+
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const fs = await import("node:fs");
   const filePath = process.argv[2];
 
   if (!filePath) {

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

@@ -9,5 +9,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net100" Version="1.8.5" />
   </ItemGroup>
 </Project>

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

@@ -4,9 +4,16 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 var options = ParseArgs(args);
+
+if (options.Batch)
+{
+    RunBatchMode();
+    return;
+}
+
 if (string.IsNullOrWhiteSpace(options.FilePath))
 {
-    Console.Error.WriteLine("Missing required --file argument.");
+    Console.Error.WriteLine("Missing required --file argument (or use --batch for project-wide mode).");
     Environment.Exit(1);
 }
 
@@ -14,12 +21,8 @@ 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
-});
+var parseResult = ParseCSharp(source, options.FilePath, options.Language, semanticModel: null);
+var json = JsonSerializer.Serialize(parseResult, JsonOut());
 
 Console.WriteLine(json);
 
@@ -48,16 +51,31 @@ static ParseOptions ParseArgs(string[] args)
                     options.Language = args[++index];
                 }
                 break;
+            case "--batch":
+                options.Batch = true;
+                break;
         }
     }
 
     return options;
 }
 
-static ParserOutput ParseCSharp(string source, string filePath, string language)
+static JsonSerializerOptions JsonOut() => new()
+{
+    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    WriteIndented = false
+};
+
+static JsonSerializerOptions JsonIn() => new()
+{
+    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    PropertyNameCaseInsensitive = true
+};
+
+static ParserOutput ParseCSharp(string source, string filePath, string language, SemanticModel? semanticModel)
 {
-    var tree = CSharpSyntaxTree.ParseText(source, path: filePath);
-    var root = tree.GetCompilationUnitRoot();
+    var tree = semanticModel?.SyntaxTree ?? CSharpSyntaxTree.ParseText(source, path: filePath);
+    var root = (CompilationUnitSyntax)tree.GetRoot();
     var diagnostics = tree.GetDiagnostics()
         .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
         .Select(diagnostic => new ParserError(
@@ -72,24 +90,73 @@ static ParserOutput ParseCSharp(string source, string filePath, string language)
         return new ParserOutput(new List<ChunkOutput>(), diagnostics);
     }
 
-    var collector = new CSharpChunkCollector(tree, root, source, language);
+    var collector = new CSharpChunkCollector(tree, root, source, language, semanticModel);
     return new ParserOutput(collector.Collect(), diagnostics);
 }
 
+static void RunBatchMode()
+{
+    var input = Console.In.ReadToEnd();
+    BatchInput? batch;
+    try
+    {
+        batch = JsonSerializer.Deserialize<BatchInput>(input, JsonIn());
+    }
+    catch (JsonException ex)
+    {
+        Console.Error.WriteLine($"Invalid batch JSON: {ex.Message}");
+        Environment.Exit(1);
+        return;
+    }
+
+    if (batch?.Files == null || batch.Files.Count == 0)
+    {
+        var empty = new BatchOutput { Files = new Dictionary<string, ParserOutput>() };
+        Console.WriteLine(JsonSerializer.Serialize(empty, JsonOut()));
+        return;
+    }
+
+    var trees = batch.Files
+        .Where(f => !string.IsNullOrEmpty(f.Path))
+        .Select(f => CSharpSyntaxTree.ParseText(f.Source ?? string.Empty, path: f.Path!))
+        .ToList();
+
+    var references = Basic.Reference.Assemblies.Net100.References.All.ToList();
+    var compilation = CSharpCompilation.Create(
+        "Cortex",
+        trees,
+        references,
+        new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+    );
+
+    var result = new BatchOutput { Files = new Dictionary<string, ParserOutput>() };
+    foreach (var tree in trees)
+    {
+        var model = compilation.GetSemanticModel(tree);
+        var file = batch.Files.First(f => f.Path == tree.FilePath);
+        var parseResult = ParseCSharp(file.Source ?? string.Empty, tree.FilePath, "csharp", model);
+        result.Files[tree.FilePath] = parseResult;
+    }
+
+    Console.WriteLine(JsonSerializer.Serialize(result, JsonOut()));
+}
+
 sealed class CSharpChunkCollector
 {
     private readonly SyntaxTree _tree;
     private readonly CompilationUnitSyntax _root;
     private readonly string _source;
     private readonly string _language;
+    private readonly SemanticModel? _model;
     private readonly string[] _imports;
 
-    public CSharpChunkCollector(SyntaxTree tree, CompilationUnitSyntax root, string source, string language)
+    public CSharpChunkCollector(SyntaxTree tree, CompilationUnitSyntax root, string source, string language, SemanticModel? model)
     {
         _tree = tree;
         _root = root;
         _source = source;
         _language = language;
+        _model = model;
         _imports = CollectUsings(root);
     }
 
@@ -97,7 +164,6 @@ sealed class CSharpChunkCollector
     {
         var usings = new List<string>();
 
-        // Top-level using directives (including global using)
         foreach (var directive in root.Usings)
         {
             var name = directive.Name?.ToString();
@@ -107,7 +173,6 @@ sealed class CSharpChunkCollector
             }
         }
 
-        // Namespace-scoped using directives
         foreach (var member in root.Members)
         {
             if (member is BaseNamespaceDeclarationSyntax ns)
@@ -129,12 +194,10 @@ sealed class CSharpChunkCollector
     public List<ChunkOutput> Collect()
     {
         var chunks = new List<ChunkOutput>();
-
         foreach (var member in _root.Members)
         {
             CollectMember(chunks, member, null);
         }
-
         return chunks;
     }
 
@@ -357,25 +420,50 @@ sealed class CSharpChunkCollector
         return modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword));
     }
 
-    private static IReadOnlyCollection<string> GetCalls(SyntaxNode node)
+    private IReadOnlyCollection<string> GetCalls(SyntaxNode node)
     {
         return node.DescendantNodes()
             .OfType<InvocationExpressionSyntax>()
-            .Select(invocation => invocation.Expression)
-            .Select(GetInvocationName)
+            .Select(ResolveCallName)
             .Where(name => !string.IsNullOrWhiteSpace(name))
+            .Select(name => name!)
             .Distinct(StringComparer.Ordinal)
             .ToArray();
     }
 
-    private static string? GetInvocationName(ExpressionSyntax expression)
+    private string? ResolveCallName(InvocationExpressionSyntax invocation)
+    {
+        if (_model != null)
+        {
+            var info = _model.GetSymbolInfo(invocation);
+            var method = info.Symbol as IMethodSymbol
+                ?? info.CandidateSymbols.OfType<IMethodSymbol>().FirstOrDefault();
+            if (method != null)
+            {
+                return FullyQualifiedMethodName(method);
+            }
+        }
+        return GetInvocationSyntaxName(invocation.Expression);
+    }
+
+    private static string FullyQualifiedMethodName(IMethodSymbol method)
+    {
+        var container = method.ContainingType?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) ?? "";
+        if (container.StartsWith("global::", StringComparison.Ordinal))
+        {
+            container = container.Substring("global::".Length);
+        }
+        return string.IsNullOrEmpty(container) ? method.Name : $"{container}.{method.Name}";
+    }
+
+    private static string? GetInvocationSyntaxName(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),
+            InvocationExpressionSyntax nestedInvocation => GetInvocationSyntaxName(nestedInvocation.Expression),
             _ => null
         };
     }
@@ -384,6 +472,7 @@ sealed class CSharpChunkCollector
 sealed record ParseOptions
 {
     public bool UseStdin { get; set; }
+    public bool Batch { get; set; }
     public string FilePath { get; set; } = "";
     public string Language { get; set; } = "csharp";
 }
@@ -404,3 +493,19 @@ sealed record ChunkOutput(
 sealed record ParserError(string Message, int Line, int Column);
 
 sealed record ParserOutput(List<ChunkOutput> Chunks, List<ParserError> Errors);
+
+sealed class BatchInput
+{
+    public List<BatchFile> Files { get; set; } = new();
+}
+
+sealed class BatchFile
+{
+    public string? Path { get; set; }
+    public string? Source { get; set; }
+}
+
+sealed class BatchOutput
+{
+    public Dictionary<string, ParserOutput> Files { get; set; } = new();
+}