@vibgrate/cli 1.0.77 → 1.0.79

package/dist/cli.js

@@ -554,19 +554,23 @@ function validateFactLine(line) {
   return { valid: true, fact: envelope };
 }
 function resolveHcsWorkerBin() {
+  const base = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
+  const bundledPath = path6.resolve(base, "..", "dist", "hcs-worker.js");
+  if (existsSync(bundledPath)) return bundledPath;
+  const siblingPath = path6.resolve(base, "hcs-worker.js");
+  if (existsSync(siblingPath)) return siblingPath;
   try {
     const resolved = import.meta.resolve("@vibgrate/hcs-node-worker");
     const resolvedPath = resolved.startsWith("file://") ? new URL(resolved).pathname : resolved;
     if (existsSync(resolvedPath)) return resolvedPath;
   } catch {
   }
-  const base = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
   const monorepoPath = path6.resolve(base, "..", "..", "..", "vibgrate-hcs", "node", "dist", "main.js");
   if (existsSync(monorepoPath)) return monorepoPath;
   const devPath = path6.resolve(base, "..", "..", "..", "vibgrate-hcs", "node", "src", "main.ts");
   if (existsSync(devPath)) return devPath;
   throw new Error(
-    'Cannot locate @vibgrate/hcs-node-worker. Run "pnpm build" in packages/vibgrate-hcs/node or install @vibgrate/hcs-node-worker.'
+    'Cannot locate HCS worker. Run "pnpm build" in the CLI package to bundle the worker into dist/.'
   );
 }
 var NODE_WORKER_AST_LANGS = /* @__PURE__ */ new Set(["typescript", "javascript"]);
@@ -584,7 +588,8 @@ 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"]);
+var ALL_WORKER_LANGS = /* @__PURE__ */ new Set([...NODE_WORKER_ALL_LANGS, ...NATIVE_AST_LANGS]);
 async function runNodeWorker(rootDir, language, opts) {
   const workerBin = resolveHcsWorkerBin();
   const args = [];
@@ -661,6 +666,145 @@ async function runNodeWorker(rootDir, language, opts) {
     });
   });
 }
+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": {
+      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}'. Install the toolchain (${language === "go" ? "Go" : language === "python" ? "Python 3" : language === "java" ? "Java 17+" : "dotnet SDK"}) or build the worker binary.`
+      ],
+      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 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. Is the required toolchain installed and on PATH?` : `[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) {
@@ -893,25 +1037,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();
@@ -935,11 +1070,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;