harnery 0.7.1 → 0.9.0

package/src/commands/callers.ts

@@ -1,14 +1,17 @@
 import { spawn } from "node:child_process";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { resolveSearchEngine, type SearchEngine } from "../lib/tools/ripgrep.ts";
 
 /**
  * `harn callers <symbol>`: find references to a symbol across the monorepo with
- * kind classification (call / import / type / decl / ref). Thin wrapper over
- * grep -rnw with post-filtering: declarations + single-line comments are
- * filtered out by default, and lines starting with " * " (multi-line comment
- * continuation) are dropped. Inherent text-based-search limitations: multi-line
- * string literals and block-comment interiors aren't excluded.
+ * kind classification (call / import / type / decl / ref). Whole-word search
+ * (ripgrep when available, GNU grep fallback — same engine + provisioning path
+ * as `harn grep`, honoring HARNERY_GREP_ENGINE) with post-filtering:
+ * declarations + single-line comments are filtered out by default, and lines
+ * starting with " * " (multi-line comment continuation) are dropped. Inherent
+ * text-based-search limitations: multi-line string literals and block-comment
+ * interiors aren't excluded. Repos are searched in parallel.
  */
 
 interface CallersOpts {
@@ -116,21 +119,31 @@ async function runCallers(
   }
 
   const started = Date.now();
+  const { engine, rgBin } = await resolveSearchEngine("callers");
   const repos = resolveRepos(opts, context);
   const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 500;
 
+  // Search every repo concurrently, each capped at the global limit, then
+  // apply the global budget in repo order so truncation stays deterministic.
+  // In --all-repos mode the parent scan prunes submodule dirs (each submodule
+  // is scanned on its own), so a match is attributed to exactly one repo.
+  const perRepo = await Promise.all(
+    repos.map((repo) => {
+      const pruneDirs = opts.allRepos && repo.name === "parent" ? (context?.submodules ?? []) : [];
+      return searchInRepo(symbol, opts, repo, limit, engine, rgBin, pruneDirs);
+    }),
+  );
+
   const allCallers: Caller[] = [];
   let truncated = false;
-
-  for (const repo of repos) {
-    if (allCallers.length >= limit) {
-      truncated = true;
-      break;
-    }
-    const remaining = limit - allCallers.length;
-    const found = await grepInRepo(symbol, opts, repo, remaining);
+  let budget = limit;
+  for (let i = 0; i < repos.length; i++) {
+    const found = perRepo[i] ?? { callers: [], truncated: false };
     if (found.truncated) truncated = true;
-    allCallers.push(...found.callers);
+    const take = Math.min(found.callers.length, Math.max(0, budget));
+    if (found.callers.length > take) truncated = true;
+    allCallers.push(...found.callers.slice(0, take));
+    budget -= take;
   }
 
   const by_kind: Record<string, number> = {};
@@ -184,24 +197,72 @@ function resolveRepos(
   return [{ name: "cwd", cwd: process.cwd() }];
 }
 
-function grepInRepo(
-  symbol: string,
-  opts: CallersOpts,
-  repo: { name: string; cwd: string },
-  limit: number,
-): Promise<{ callers: Caller[]; truncated: boolean }> {
-  const args: string[] = ["-rnw", "--color=never", "-I", "-E"];
-  for (const d of DEFAULT_EXCLUDE_DIRS) args.push(`--exclude-dir=${d}`);
-  for (const f of DEFAULT_EXCLUDE_FILES) args.push(`--exclude=${f}`);
+function resolveLangGlobs(opts: CallersOpts): string[] | undefined {
   const langGlobs = opts.lang ? LANG_GLOBS[opts.lang] : undefined;
   if (opts.lang && !langGlobs) {
     throw new Error(`unknown --lang "${opts.lang}". Valid: ${Object.keys(LANG_GLOBS).join(", ")}`);
   }
+  return langGlobs;
+}
+
+function buildCallersGrepArgs(
+  symbol: string,
+  opts: CallersOpts,
+  extraExcludeDirs: readonly string[],
+): string[] {
+  const args: string[] = ["-rnw", "-H", "--color=never", "-I", "-E"];
+  for (const d of DEFAULT_EXCLUDE_DIRS) args.push(`--exclude-dir=${d}`);
+  for (const f of DEFAULT_EXCLUDE_FILES) args.push(`--exclude=${f}`);
+  for (const d of extraExcludeDirs) args.push(`--exclude-dir=${d}`);
+  const langGlobs = resolveLangGlobs(opts);
   if (langGlobs) for (const g of langGlobs) args.push(`--include=${g}`);
   args.push("--", symbol, ".");
+  return args;
+}
+
+function buildCallersRgArgs(
+  symbol: string,
+  opts: CallersOpts,
+  extraExcludeDirs: readonly string[],
+): string[] {
+  // --hidden --no-ignore --no-config: match grep semantics (dotdirs searched,
+  // .gitignore ignored, user rg config can't skew results). -w = whole word.
+  // Lang globs (positives) go before dir excludes (negatives) since rg globs
+  // are last-match-wins.
+  const args: string[] = [
+    "-nw",
+    "--no-heading",
+    "--with-filename",
+    "--color=never",
+    "--no-config",
+    "--hidden",
+    "--no-ignore",
+  ];
+  const langGlobs = resolveLangGlobs(opts);
+  if (langGlobs) for (const g of langGlobs) args.push(`--glob=${g}`);
+  for (const d of DEFAULT_EXCLUDE_DIRS) args.push(`--glob=!${d}`);
+  for (const f of DEFAULT_EXCLUDE_FILES) args.push(`--glob=!${f}`);
+  for (const d of extraExcludeDirs) args.push(`--glob=!${d}`);
+  args.push("--", symbol, ".");
+  return args;
+}
+
+function searchInRepo(
+  symbol: string,
+  opts: CallersOpts,
+  repo: { name: string; cwd: string },
+  limit: number,
+  engine: SearchEngine,
+  rgBin: string,
+  extraExcludeDirs: readonly string[],
+): Promise<{ callers: Caller[]; truncated: boolean }> {
+  const [bin, args] =
+    engine === "rg"
+      ? ([rgBin, buildCallersRgArgs(symbol, opts, extraExcludeDirs)] as const)
+      : (["grep", buildCallersGrepArgs(symbol, opts, extraExcludeDirs)] as const);
 
   return new Promise((resolveP, reject) => {
-    const proc = spawn("grep", args, { cwd: repo.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const proc = spawn(bin, args, { cwd: repo.cwd, stdio: ["ignore", "pipe", "pipe"] });
     const callers: Caller[] = [];
     let buffer = "";
     let stderr = "";
@@ -237,8 +298,11 @@ function grepInRepo(
         const parsed = parseCallerLine(buffer, symbol, opts, repo.name);
         if (parsed) callers.push(parsed);
       }
-      if (code !== null && code !== 0 && code !== 1 && !truncated) {
-        reject(new Error(`grep exited ${code}: ${stderr.trim() || "(no stderr)"}`));
+      // Exit 1 = no matches (both engines): normal. Exit 2 with nothing
+      // collected = a real failure; with matches, a partial walk error we
+      // tolerate (surface what was found).
+      if (code !== null && code !== 0 && code !== 1 && !truncated && callers.length === 0) {
+        reject(new Error(`${bin} exited ${code}: ${stderr.trim() || "(no stderr)"}`));
         return;
       }
       resolveP({ callers, truncated });

package/src/commands/doctor.ts

@@ -17,8 +17,16 @@ import os from "node:os";
 import path from "node:path";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
-import { resolveBinName } from "../core/config.ts";
+import { resolveBinName, ripgrepAutoInstall } from "../core/config.ts";
 import { loadHarnessWiring } from "../core/hooks/harness/wiring.ts";
+import { probeBilling } from "../core/workflow/billing.ts";
+import {
+  HARNESS_BINARIES,
+  HARNESS_INSTALL_HINTS,
+  HARNESS_LOGIN_HINTS,
+} from "../core/workflow/harnesses.ts";
+import type { HarnessName } from "../core/workflow/types.ts";
+import { findRg, installRg, managedRgPath, rgInstallSupported } from "../lib/tools/ripgrep.ts";
 
 type Severity = "ok" | "warn" | "fail";
 
@@ -31,6 +39,7 @@ interface Check {
 
 interface CheckOpts {
   json?: boolean;
+  fix?: boolean;
 }
 
 export function registerDoctorCommand(program: Command, emit: EmitContext): void {
@@ -41,7 +50,18 @@ export function registerDoctorCommand(program: Command, emit: EmitContext): void
         "unless a required dep (Node, git) is missing.",
     )
     .option("--json", "Machine-readable JSON output")
-    .action((opts: CheckOpts) => {
+    .option(
+      "--fix",
+      "Install missing managed tools (currently: ripgrep, pinned + checksum-verified)",
+    )
+    .action(async (opts: CheckOpts) => {
+      if (opts.fix && !findRg() && rgInstallSupported()) {
+        try {
+          await installRg((line) => emit.text(`${line}\n`));
+        } catch (err) {
+          emit.text(`ripgrep install failed: ${(err as Error).message}\n`);
+        }
+      }
       const checks = runChecks();
       const requiredFailed = checks.some((c) => c.severity === "fail");
 
@@ -80,8 +100,12 @@ export function runChecks(): Check[] {
     checkNode(),
     checkGit(),
     checkBun(),
+    checkRipgrep(),
     checkHarneryDir(),
     checkHarnessHooks(),
+    checkWorkflowHarness("claude-code"),
+    checkWorkflowHarness("codex"),
+    checkWorkflowHarness("cursor"),
     checkRestic(),
     checkRclone(),
     checkPlaywright(),
@@ -89,6 +113,40 @@ export function runChecks(): Check[] {
   ];
 }
 
+function checkRipgrep(): Check {
+  const found = findRg();
+  if (found) {
+    const r = whichVersion(found);
+    const managed = found === managedRgPath() ? ", managed" : "";
+    return {
+      name: "ripgrep",
+      severity: "ok",
+      detail: `${r.out.replace(/^ripgrep\s*/, "")} (${found === "rg" ? "PATH" : found}${managed})`,
+    };
+  }
+  if (!rgInstallSupported()) {
+    return {
+      name: "ripgrep",
+      severity: "warn",
+      detail: "missing (grep fallback; no pinned artifact for this OS/arch)",
+      hint: "https://github.com/BurntSushi/ripgrep#installation",
+    };
+  }
+  if (ripgrepAutoInstall()) {
+    return {
+      name: "ripgrep",
+      severity: "warn",
+      detail: "missing (autoInstall on: will self-provision on first grep)",
+    };
+  }
+  return {
+    name: "ripgrep",
+    severity: "warn",
+    detail: "missing (grep fallback works, just slower)",
+    hint: `${resolveBinName()} doctor --fix  (pinned + checksum-verified, installs to the harnery tools dir)`,
+  };
+}
+
 function whichVersion(bin: string, args: string[] = ["--version"]): { ok: boolean; out: string } {
   const r = spawnSync(bin, args, { encoding: "utf-8" });
   if (r.status !== 0) return { ok: false, out: "" };
@@ -96,6 +154,41 @@ function whichVersion(bin: string, args: string[] = ["--version"]): { ok: boolea
   return { ok: true, out };
 }
 
+/**
+ * One workflow spawn target: is the harness CLI installed, and how will its
+ * headless children bill (subscription login vs API key — see billing.ts)?
+ * Missing is a warn, not a fail: workflows degrade to the harnesses you have.
+ */
+function checkWorkflowHarness(harness: HarnessName): Check {
+  const bin = HARNESS_BINARIES[harness];
+  const name = `workflow:${harness}`;
+  const r = whichVersion(bin);
+  if (!r.ok) {
+    return {
+      name,
+      severity: "warn",
+      detail: `${bin} missing (workflow --harness ${harness} unavailable)`,
+      hint: `${HARNESS_INSTALL_HINTS[harness]}  then: ${HARNESS_LOGIN_HINTS[harness]}`,
+    };
+  }
+  const probe = probeBilling(harness);
+  if (probe.login === "absent" && !probe.apiKeyPresent) {
+    return {
+      name,
+      severity: "warn",
+      detail: `${r.out} — installed, but no stored login or API key detected`,
+      hint: HARNESS_LOGIN_HINTS[harness],
+    };
+  }
+  const billing =
+    probe.mode === "subscription"
+      ? probe.login === "present"
+        ? "billing: subscription"
+        : "billing: subscription (login unverifiable, CLI is the authority)"
+      : `billing: ${probe.mode} (${probe.apiKeySource})`;
+  return { name, severity: "ok", detail: `${r.out} — ${billing}` };
+}
+
 function checkNode(): Check {
   const v = process.versions.node;
   const major = Number.parseInt(v.split(".")[0], 10);