@vibgrate/cli 1.0.78 → 1.0.80

package/dist/{chunk-TKNDQ337.js → chunk-22VJDYG5.js}

@@ -2,7 +2,6 @@ import {
   FileCache,
   Semaphore,
   ensureDir,
-  findCsprojFiles,
   findFiles,
   findPackageJsonFiles,
   findSolutionFiles,
@@ -2344,11 +2343,17 @@ function parseTfmMajor(tfm) {
   if (fxMatch) return null;
   return null;
 }
-function parseCsproj(xml, filePath) {
+function isDotnetProjectFile(name) {
+  return name.endsWith(".csproj") || name.endsWith(".vbproj");
+}
+function stripDotnetProjectExtension(filePath) {
+  return path5.basename(filePath).replace(/\.(cs|vb)proj$/i, "");
+}
+function parseDotnetProjectFile(xml, filePath) {
   const parsed = parser.parse(xml);
   const project = parsed?.Project;
   if (!project) {
-    return { targetFrameworks: [], packageReferences: [], projectReferences: [], projectName: path5.basename(filePath, ".csproj") };
+    return { targetFrameworks: [], packageReferences: [], projectReferences: [], projectName: stripDotnetProjectExtension(filePath) };
   }
   const propertyGroups = Array.isArray(project.PropertyGroup) ? project.PropertyGroup : project.PropertyGroup ? [project.PropertyGroup] : [];
   const targetFrameworks = [];
@@ -2385,34 +2390,34 @@ function parseCsproj(xml, filePath) {
     targetFrameworks: [...new Set(targetFrameworks)],
     packageReferences,
     projectReferences,
-    projectName: path5.basename(filePath, ".csproj")
+    projectName: stripDotnetProjectExtension(filePath)
   };
 }
 async function scanDotnetProjects(rootDir, nugetCache, cache, projectScanTimeout) {
-  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findCsprojFiles(rootDir);
+  const projectFiles = cache ? await cache.findFiles(rootDir, isDotnetProjectFile) : await findFiles(rootDir, isDotnetProjectFile);
   const slnFiles = cache ? await cache.findSolutionFiles(rootDir) : await findSolutionFiles(rootDir);
-  const slnCsprojPaths = /* @__PURE__ */ new Set();
+  const slnProjectPaths = /* @__PURE__ */ new Set();
   for (const slnPath of slnFiles) {
     try {
       const slnContent = cache ? await cache.readTextFile(slnPath) : await readTextFile(slnPath);
       const slnDir = path5.dirname(slnPath);
-      const projectRegex = /Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.csproj)"/g;
+      const projectRegex = /Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.(?:cs|vb)proj)"/g;
       let match;
       while ((match = projectRegex.exec(slnContent)) !== null) {
         if (match[1]) {
           const csprojPath = path5.resolve(slnDir, match[1].replace(/\\/g, "/"));
-          slnCsprojPaths.add(csprojPath);
+          slnProjectPaths.add(csprojPath);
         }
       }
     } catch {
     }
   }
-  const allCsprojFiles = /* @__PURE__ */ new Set([...csprojFiles, ...slnCsprojPaths]);
+  const allCsprojFiles = /* @__PURE__ */ new Set([...projectFiles, ...slnProjectPaths]);
   const results = [];
   const STUCK_TIMEOUT_MS = projectScanTimeout ?? cache?.projectScanTimeout ?? 18e4;
   for (const csprojPath of allCsprojFiles) {
     try {
-      const scanPromise = scanOneCsproj(csprojPath, rootDir, nugetCache, cache);
+      const scanPromise = scanOneDotnetProjectFile(csprojPath, rootDir, nugetCache, cache);
       const result = await withTimeout(scanPromise, STUCK_TIMEOUT_MS);
       if (result.ok) {
         results.push(result.value);
@@ -2433,9 +2438,9 @@ async function scanDotnetProjects(rootDir, nugetCache, cache, projectScanTimeout
   }
   return results;
 }
-async function scanOneCsproj(csprojPath, rootDir, nugetCache, cache) {
+async function scanOneDotnetProjectFile(csprojPath, rootDir, nugetCache, cache) {
   const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
-  const data = parseCsproj(xml, csprojPath);
+  const data = parseDotnetProjectFile(xml, csprojPath);
   const csprojDir = path5.dirname(csprojPath);
   const primaryTfm = data.targetFrameworks[0];
   let runtimeMajorsBehind;
@@ -2516,7 +2521,7 @@ async function scanOneCsproj(csprojPath, rootDir, nugetCache, cache) {
   const projectReferences = data.projectReferences.map((refPath) => {
     const absRefPath = path5.resolve(csprojDir, refPath);
     const relRefPath = normalizePath(path5.relative(rootDir, path5.dirname(absRefPath)));
-    const refName = path5.basename(absRefPath, ".csproj");
+    const refName = stripDotnetProjectExtension(absRefPath);
     return {
       path: relRefPath || ".",
       name: refName,
@@ -7918,7 +7923,7 @@ async function scanPlatformMatrix(rootDir, cache) {
   }
   result.nativeModules.sort();
   result.osAssumptions = [...osAssumptions].sort();
-  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findFiles(rootDir, (name) => name.endsWith(".csproj"));
+  const csprojFiles = cache ? await cache.findFiles(rootDir, (name) => name.endsWith(".csproj") || name.endsWith(".vbproj")) : await findFiles(rootDir, (name) => name.endsWith(".csproj") || name.endsWith(".vbproj"));
   const tfms = /* @__PURE__ */ new Set();
   for (const csprojPath of csprojFiles) {
     try {
@@ -11702,7 +11707,7 @@ async function discoverSolutions(rootDir, fileCache) {
       const rootBasename = path32.basename(rootDir);
       const relSolutionPath = [rootBasename, path32.relative(rootDir, solutionFile).replace(/\\/g, "/")].join("/");
       const projectPaths = /* @__PURE__ */ new Set();
-      const projectRegex = /Project\("[^"]*"\)\s*=\s*"([^"]*)",\s*"([^"]+\.csproj)"/g;
+      const projectRegex = /Project\("[^"]*"\)\s*=\s*"([^"]*)",\s*"([^"]+\.(?:cs|vb)proj)"/g;
       let match;
       while ((match = projectRegex.exec(content)) !== null) {
         const projectRelative = match[2];

package/dist/{chunk-DKSPLRJV.js → chunk-UH7CY33M.js}

@@ -1,6 +1,6 @@
 import {
   runScan
-} from "./chunk-TKNDQ337.js";
+} from "./chunk-22VJDYG5.js";
 import {
   writeJsonFile
 } from "./chunk-JQHUH6A3.js";

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   baselineCommand
-} from "./chunk-DKSPLRJV.js";
+} from "./chunk-UH7CY33M.js";
 import {
   VERSION,
   computeHmac,
@@ -12,7 +12,7 @@ import {
   pushCommand,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-TKNDQ337.js";
+} from "./chunk-22VJDYG5.js";
 import {
   Semaphore,
   ensureDir,
@@ -42,7 +42,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk.green("\u2714") + ` Created ${chalk.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import("./baseline-NRKROYVK.js");
+    const { runBaseline } = await import("./baseline-WDQNMJ4M.js");
     await runBaseline(rootDir);
   }
   console.log("");
@@ -417,7 +417,7 @@ import * as path6 from "path";
 import * as os2 from "os";
 import * as fs2 from "fs/promises";
 import { existsSync } from "fs";
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { Command as Command5 } from "commander";
 import chalk5 from "chalk";
 var EXIT_SUCCESS = 0;
@@ -440,7 +440,9 @@ var LANGUAGE_EXTENSIONS = {
   go: /* @__PURE__ */ new Set([".go"]),
   python: /* @__PURE__ */ new Set([".py"]),
   java: /* @__PURE__ */ new Set([".java"]),
-  csharp: /* @__PURE__ */ new Set([".cs"])
+  csharp: /* @__PURE__ */ new Set([".cs"]),
+  cplusplus: /* @__PURE__ */ new Set([".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx", ".h", ".ixx", ".vcxproj"]),
+  vbnet: /* @__PURE__ */ new Set([".vb"])
 };
 var SUPPORTED_LANGUAGES = new Set(Object.keys(LANGUAGE_EXTENSIONS));
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -489,6 +491,13 @@ var TEST_PATTERNS = [
 function isTestPath(relPath) {
   return TEST_PATTERNS.some((p) => p.test(relPath));
 }
+function normalizeLanguageToken(language) {
+  const normalized = language.trim().toLowerCase();
+  if (normalized === "vb.net" || normalized === "visualbasic" || normalized === "visual-basic") {
+    return "vbnet";
+  }
+  return normalized;
+}
 async function detectLanguages(rootDir, includeTests) {
   const counts = /* @__PURE__ */ new Map();
   async function walk(dir, relBase) {
@@ -582,13 +591,81 @@ var NODE_WORKER_TEXT_LANGS = /* @__PURE__ */ new Set([
   "php",
   "dart",
   "scala",
-  "cobol"
+  "cobol",
+  "cplusplus"
 ]);
 var NODE_WORKER_ALL_LANGS = /* @__PURE__ */ new Set([
   ...NODE_WORKER_AST_LANGS,
   ...NODE_WORKER_TEXT_LANGS
 ]);
-var EXTERNAL_WORKER_LANGS = /* @__PURE__ */ new Set(["go", "python", "java", "csharp"]);
+var NATIVE_AST_LANGS = /* @__PURE__ */ new Set(["go", "python", "java", "csharp", "vbnet"]);
+var ALL_WORKER_LANGS = /* @__PURE__ */ new Set([...NODE_WORKER_ALL_LANGS, ...NATIVE_AST_LANGS]);
+var NATIVE_RUNTIME_REQUIREMENTS = {
+  go: {
+    command: "go",
+    displayName: "Go toolchain",
+    installGuideByPlatform: {
+      darwin: "brew install go",
+      linux: "Install Go 1.22+ from https://go.dev/dl/ or your distro package manager.",
+      win32: "winget install GoLang.Go"
+    },
+    docsUrl: "https://go.dev/doc/install"
+  },
+  python: {
+    command: "python3",
+    displayName: "Python 3 runtime",
+    installGuideByPlatform: {
+      darwin: "brew install python",
+      linux: "Install Python 3.10+ from your distro package manager (apt/dnf/pacman).",
+      win32: "winget install Python.Python.3.12"
+    },
+    docsUrl: "https://www.python.org/downloads/"
+  },
+  java: {
+    command: "java",
+    displayName: "Java 17+ runtime",
+    installGuideByPlatform: {
+      darwin: "brew install --cask temurin",
+      linux: "Install OpenJDK 17+ (for example: apt install openjdk-17-jre).",
+      win32: "winget install EclipseAdoptium.Temurin.17.JRE"
+    },
+    docsUrl: "https://adoptium.net/"
+  },
+  csharp: {
+    command: "dotnet",
+    displayName: ".NET SDK/runtime",
+    installGuideByPlatform: {
+      darwin: "brew install --cask dotnet-sdk",
+      linux: "Install .NET 8 SDK/runtime from https://dotnet.microsoft.com/download.",
+      win32: "winget install Microsoft.DotNet.SDK.8"
+    },
+    docsUrl: "https://dotnet.microsoft.com/download"
+  },
+  vbnet: {
+    command: "dotnet",
+    displayName: ".NET SDK/runtime",
+    installGuideByPlatform: {
+      darwin: "brew install --cask dotnet-sdk",
+      linux: "Install .NET 8 SDK/runtime from https://dotnet.microsoft.com/download.",
+      win32: "winget install Microsoft.DotNet.SDK.8"
+    },
+    docsUrl: "https://dotnet.microsoft.com/download"
+  }
+};
+function commandExistsOnPath(command) {
+  const probeArgs = process.platform === "win32" ? ["/c", command, "--version"] : ["--version"];
+  const probeCmd = process.platform === "win32" ? "cmd" : command;
+  const result = spawnSync(probeCmd, probeArgs, { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+function buildNativeInstallHint(language) {
+  const req = NATIVE_RUNTIME_REQUIREMENTS[language];
+  if (!req) {
+    return "See HCS runtime setup docs for prerequisites: https://vibgrate.com/help";
+  }
+  const platformHint = req.installGuideByPlatform[process.platform] ?? `Install ${req.displayName} and ensure '${req.command}' is available on PATH.`;
+  return `${platformHint} More details: ${req.docsUrl}`;
+}
 async function runNodeWorker(rootDir, language, opts) {
   const workerBin = resolveHcsWorkerBin();
   const args = [];
@@ -665,6 +742,189 @@ async function runNodeWorker(rootDir, language, opts) {
     });
   });
 }
+function resolveDotnetPublishedWorker(workersDir) {
+  const candidatesByPlatform = {
+    win32: ["hcs-worker-win-x64.exe"],
+    linux: ["hcs-worker-linux-x64"],
+    darwin: ["hcs-worker-osx-arm64", "hcs-worker-osx-x64"],
+    aix: [],
+    android: [],
+    freebsd: [],
+    haiku: [],
+    openbsd: [],
+    cygwin: [],
+    netbsd: [],
+    sunos: []
+  };
+  const candidates = candidatesByPlatform[process.platform] ?? [];
+  for (const filename of candidates) {
+    const fullPath = path6.join(workersDir, filename);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function resolveNativeWorker(language, projectDir) {
+  const base = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
+  const hcsFromBundle = path6.resolve(base, "..", "..", "vibgrate-hcs");
+  const hcsFromSrc = path6.resolve(base, "..", "..", "..", "vibgrate-hcs");
+  const hcsRoot = existsSync(hcsFromBundle) ? hcsFromBundle : hcsFromSrc;
+  const workersDir = path6.resolve(base, "workers");
+  switch (language) {
+    case "go": {
+      const bin = path6.join(workersDir, process.platform === "win32" ? "vibgrate-hcs-go.exe" : "vibgrate-hcs-go");
+      if (existsSync(bin)) {
+        return { cmd: bin, args: ["--project", projectDir, "--output", "ndjson"] };
+      }
+      const src = path6.join(hcsRoot, "go");
+      if (existsSync(path6.join(src, "main.go"))) {
+        return { cmd: "go", args: ["run", ".", "--project", projectDir, "--output", "ndjson"], cwd: src };
+      }
+      return null;
+    }
+    case "python": {
+      const bin = path6.join(workersDir, "vibgrate-hcs-python");
+      if (existsSync(bin)) {
+        return { cmd: bin, args: ["--project", projectDir, "--output", "ndjson"] };
+      }
+      const src = path6.join(hcsRoot, "python");
+      if (existsSync(path6.join(src, "pyproject.toml"))) {
+        return {
+          cmd: "python3",
+          args: ["-m", "vibgrate_hcs_python.main", "--project", projectDir, "--output", "ndjson"],
+          cwd: src
+        };
+      }
+      return null;
+    }
+    case "java": {
+      const jar = path6.join(workersDir, "vibgrate-hcs-jvm.jar");
+      if (existsSync(jar)) {
+        return { cmd: "java", args: ["-jar", jar, "--project", projectDir, "--output", "ndjson"] };
+      }
+      const src = path6.join(hcsRoot, "jvm");
+      if (existsSync(path6.join(src, "build.gradle.kts"))) {
+        const gradlew = path6.join(src, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+        const launcher = existsSync(gradlew) ? gradlew : "gradle";
+        return {
+          cmd: launcher,
+          args: ["-q", "--console=plain", "run", `--args=--project ${projectDir} --output ndjson`],
+          cwd: src
+        };
+      }
+      return null;
+    }
+    case "csharp":
+    case "vbnet": {
+      const publishedWorker = resolveDotnetPublishedWorker(workersDir);
+      if (publishedWorker) {
+        return { cmd: publishedWorker, args: ["--project", projectDir, "--output", "ndjson"] };
+      }
+      const dll = path6.join(workersDir, "VibgrateHcsWorker.dll");
+      if (existsSync(dll)) {
+        return { cmd: "dotnet", args: [dll, "--project", projectDir, "--output", "ndjson"] };
+      }
+      const csproj = path6.join(hcsRoot, "dotnet", "src", "VibgrateHcsWorker", "VibgrateHcsWorker.csproj");
+      if (existsSync(csproj)) {
+        return {
+          cmd: "dotnet",
+          args: ["run", "--project", csproj, "--", "--project", projectDir, "--output", "ndjson"]
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+async function runNativeWorker(rootDir, language, opts) {
+  const spec = resolveNativeWorker(language, rootDir);
+  if (!spec) {
+    return {
+      language,
+      facts: [],
+      errors: [
+        `[error] No native worker found for '${language}'. Build/package workers for this platform or use source mode.`,
+        `[hint] ${buildNativeInstallHint(language)}`
+      ],
+      exitCode: EXIT_PARSE_FAILURE
+    };
+  }
+  return new Promise((resolve6) => {
+    const facts = [];
+    const errors = [];
+    let stdoutBuf = "";
+    let killed = false;
+    if (opts.verbose) {
+      process.stderr.write(chalk5.dim(`[${language}] Spawning: ${spec.cmd} ${spec.args.join(" ")}
+`));
+    }
+    const runtimeReq = NATIVE_RUNTIME_REQUIREMENTS[language];
+    const usesPathCommand = runtimeReq && spec.cmd === runtimeReq.command;
+    if (usesPathCommand && !commandExistsOnPath(spec.cmd)) {
+      resolve6({
+        language,
+        facts: [],
+        errors: [
+          `[error] Required runtime command '${spec.cmd}' is not available on PATH.`,
+          `[hint] ${buildNativeInstallHint(language)}`,
+          "[hint] You can also package native workers into dist/workers to avoid local toolchain requirements."
+        ],
+        exitCode: EXIT_PARSE_FAILURE
+      });
+      return;
+    }
+    const child = spawn(spec.cmd, spec.args, {
+      cwd: spec.cwd ?? rootDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdoutBuf += chunk.toString();
+      const lines = stdoutBuf.split("\n");
+      stdoutBuf = lines.pop();
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) facts.push(trimmed);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        if (opts.verbose) {
+          process.stderr.write(chalk5.dim(`[${language}] ${trimmed}
+`));
+        }
+        if (trimmed.startsWith("[error]")) {
+          errors.push(trimmed);
+        }
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (stdoutBuf.trim()) facts.push(stdoutBuf.trim());
+      if (killed) {
+        resolve6({ language, facts, errors: ["Worker killed: timeout exceeded"], exitCode: EXIT_TIMEOUT });
+      } else {
+        resolve6({ language, facts, errors, exitCode: code ?? 0 });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      const isNotFound = err.code === "ENOENT";
+      errors.push(
+        isNotFound ? `[error] '${spec.cmd}' not found. ${buildNativeInstallHint(language)}` : `[error] Failed to spawn native worker: ${err.message}`
+      );
+      resolve6({ language, facts, errors, exitCode: EXIT_PARSE_FAILURE });
+    });
+  });
+}
 async function pushFacts(facts, dsn, verbose) {
   const parsed = parseDsn(dsn);
   if (!parsed) {
@@ -872,7 +1132,7 @@ var extractCommand = new Command5("extract").description("Analyze source code an
   }
   let targetLanguages;
   if (opts.language) {
-    targetLanguages = opts.language.split(",").map((l) => l.trim().toLowerCase()).filter(Boolean);
+    targetLanguages = opts.language.split(",").map((l) => normalizeLanguageToken(l)).filter(Boolean);
     for (const lang of targetLanguages) {
       if (!SUPPORTED_LANGUAGES.has(lang)) {
         process.stderr.write(chalk5.red(`Unknown language: "${lang}"
@@ -897,25 +1157,16 @@ var extractCommand = new Command5("extract").description("Analyze source code an
       }
     }
   }
-  const runnableLanguages = targetLanguages.filter((l) => NODE_WORKER_ALL_LANGS.has(l));
-  const skippedLanguages = targetLanguages.filter((l) => EXTERNAL_WORKER_LANGS.has(l));
-  const unknownWorkerLangs = targetLanguages.filter(
-    (l) => !NODE_WORKER_ALL_LANGS.has(l) && !EXTERNAL_WORKER_LANGS.has(l)
-  );
-  if (skippedLanguages.length > 0 && opts.verbose) {
-    process.stderr.write(chalk5.yellow(
-      `Skipping languages without built-in HCS worker: ${skippedLanguages.join(", ")}
-` + chalk5.dim("These require dedicated external workers.\n")
+  const runnableLanguages = targetLanguages.filter((l) => ALL_WORKER_LANGS.has(l));
+  const unknownWorkerLangs = targetLanguages.filter((l) => !ALL_WORKER_LANGS.has(l));
+  if (unknownWorkerLangs.length > 0 && opts.verbose) {
+    process.stderr.write(chalk5.dim(
+      `No worker registered for: ${unknownWorkerLangs.join(", ")} \u2014 skipping.
+`
     ));
   }
   if (runnableLanguages.length === 0) {
     process.stderr.write(chalk5.yellow("No languages with available HCS workers found.\n"));
-    if (skippedLanguages.length > 0) {
-      process.stderr.write(chalk5.dim(
-        `Detected: ${skippedLanguages.join(", ")} \u2014 these require external workers not yet integrated.
-`
-      ));
-    }
     process.exit(EXIT_SUCCESS);
   }
   const startTime = Date.now();
@@ -939,11 +1190,15 @@ var extractCommand = new Command5("extract").description("Analyze source code an
         hasTimeout = true;
         return;
       }
-      const result = await runNodeWorker(rootDir, language, {
+      const result = NODE_WORKER_ALL_LANGS.has(language) ? await runNodeWorker(rootDir, language, {
         includeTests: opts.includeTests ?? false,
         verbose: opts.verbose ?? false,
         timeoutMs: remaining,
         onProgress: (event) => progress.onProgress(language, event)
+      }) : await runNativeWorker(rootDir, language, {
+        verbose: opts.verbose ?? false,
+        timeoutMs: remaining,
+        onProgress: (event) => progress.onProgress(language, event)
       });
       if (result.exitCode === EXIT_TIMEOUT) {
         hasTimeout = true;