harnery 0.0.1 → 0.2.0

package/src/commands/env.ts

@@ -0,0 +1,254 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { exec, sh } from "../lib/exec.ts";
+
+/**
+ * `env`: show environment status across runtimes, docker, gcp, bq, git.
+ *
+ * Monorepo state (repoRoot, submodules) flows in via HarneryProgramContext.
+ * When neither is provided (harn invoked outside a monorepo), the git section
+ * reports just the current branch and skips the submodule row.
+ *
+ * Color hints are intentionally string labels (`"ok"`/`"missing"`/...) rather
+ * than ANSI-wrapper functions, so consumer adapters can consume them as
+ * metadata; defaultEmit just JSON-stringifies.
+ */
+
+interface Check {
+  label: string;
+  value: string;
+  status?: "ok" | "missing" | "warn" | "info";
+}
+
+export function registerEnvCommand(
+  program: Command,
+  emit: EmitContext,
+  context?: HarneryProgramContext,
+): void {
+  program
+    .command("env [section]")
+    .description("Show environment status (docker, gcp, bq, node, python, git)")
+    .action(async (section?: string) => {
+      try {
+        await handleEnv(section, emit, context);
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        emit.error({ code: "env_error", message: msg });
+        process.exit(1);
+      }
+    });
+}
+
+async function handleEnv(
+  section: string | undefined,
+  emit: EmitContext,
+  context: HarneryProgramContext | undefined,
+): Promise<void> {
+  const sections: Record<string, () => Promise<Check[]>> = {
+    runtimes: checkRuntimes,
+    docker: checkDocker,
+    gcp: checkGcp,
+    bq: checkBigQuery,
+    git: () => checkGit(context),
+  };
+
+  if (section) {
+    const fn = sections[section];
+    if (!fn) {
+      emit.error({
+        code: "unknown_section",
+        message: `Unknown section "${section}". Valid: ${Object.keys(sections).join(", ")}`,
+      });
+      process.exit(1);
+    }
+    const checks = await fn();
+    emit.data({ ok: true, section, checks: checks.map(toRow) });
+    return;
+  }
+
+  const results = await Promise.all(
+    Object.entries(sections).map(async ([name, fn]) => ({
+      name,
+      checks: await fn().catch(() => [
+        { label: name, value: "check failed", status: "missing" as const },
+      ]),
+    })),
+  );
+
+  emit.data({
+    ok: true,
+    sections: Object.fromEntries(results.map(({ name, checks }) => [name, checks.map(toRow)])),
+  });
+}
+
+function toRow(check: Check): { label: string; value: string } {
+  return { label: check.label, value: check.value };
+}
+
+async function checkRuntimes(): Promise<Check[]> {
+  const checks: Check[] = [];
+
+  const [node, bun, python, php] = await Promise.all([
+    exec(["node", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+    exec(["bun", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+    exec(["python3", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+    exec(["php", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+  ]);
+
+  if (node.exitCode === 0) checks.push({ label: "Node.js", value: node.stdout, status: "ok" });
+  else checks.push({ label: "Node.js", value: "not found", status: "missing" });
+
+  if (bun.exitCode === 0) checks.push({ label: "Bun", value: bun.stdout, status: "ok" });
+  else checks.push({ label: "Bun", value: "not found", status: "missing" });
+
+  if (python.exitCode === 0)
+    checks.push({ label: "Python", value: python.stdout.replace("Python ", ""), status: "ok" });
+  else checks.push({ label: "Python", value: "not found", status: "missing" });
+
+  if (php.exitCode === 0) {
+    const ver = php.stdout.split("\n")[0]?.match(/PHP (\S+)/)?.[1] ?? php.stdout;
+    checks.push({ label: "PHP", value: ver, status: "ok" });
+  } else {
+    checks.push({ label: "PHP", value: "not found", status: "info" });
+  }
+
+  return checks;
+}
+
+async function checkDocker(): Promise<Check[]> {
+  const checks: Check[] = [];
+
+  const dockerVersion = await exec(["docker", "--version"]).catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+
+  if (dockerVersion.exitCode !== 0) {
+    return [{ label: "Docker", value: "not installed", status: "missing" }];
+  }
+
+  const ver = dockerVersion.stdout.match(/Docker version (\S+)/)?.[1] ?? dockerVersion.stdout;
+  checks.push({ label: "Docker", value: ver, status: "ok" });
+
+  const ps = await sh('docker ps --format "{{.Names}}" 2>/dev/null').catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+
+  if (ps.exitCode === 0) {
+    const names = ps.stdout.split("\n").filter(Boolean);
+    checks.push({
+      label: "Containers",
+      value: names.length > 0 ? `${names.length} running` : "none running",
+      status: names.length > 0 ? "ok" : "info",
+    });
+  } else {
+    checks.push({ label: "Containers", value: "docker ps unavailable", status: "info" });
+  }
+
+  return checks;
+}
+
+async function checkGcp(): Promise<Check[]> {
+  const checks: Check[] = [];
+
+  const account = await sh("gcloud config get-value account 2>/dev/null").catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+  const project = await sh("gcloud config get-value project 2>/dev/null").catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+
+  if (account.exitCode === 0 && account.stdout) {
+    checks.push({ label: "GCP Account", value: account.stdout, status: "ok" });
+  } else {
+    checks.push({ label: "GCP Account", value: "not authenticated", status: "missing" });
+  }
+
+  if (project.exitCode === 0 && project.stdout) {
+    checks.push({ label: "GCP Project", value: project.stdout, status: "ok" });
+  } else {
+    checks.push({ label: "GCP Project", value: "not set", status: "missing" });
+  }
+
+  return checks;
+}
+
+async function checkBigQuery(): Promise<Check[]> {
+  const checks: Check[] = [];
+
+  const result = await sh("bq ls --max_results=1 2>/dev/null").catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+
+  if (result.exitCode === 0) {
+    checks.push({ label: "BigQuery", value: "connected", status: "ok" });
+  } else {
+    checks.push({ label: "BigQuery", value: "not connected (check GCP auth)", status: "missing" });
+  }
+
+  const datasets = await sh("bq ls --format=json --max_results=20 2>/dev/null").catch(() => ({
+    stdout: "",
+    exitCode: 1,
+    stderr: "",
+  }));
+
+  if (datasets.exitCode === 0 && datasets.stdout) {
+    try {
+      const ds = JSON.parse(datasets.stdout) as { datasetReference?: { datasetId?: string } }[];
+      const names = ds
+        .map((d) => d.datasetReference?.datasetId)
+        .filter(Boolean)
+        .join(", ");
+      if (names) checks.push({ label: "Datasets", value: names, status: "info" });
+    } catch {
+      // Ignore parse failures
+    }
+  }
+
+  return checks;
+}
+
+async function checkGit(context: HarneryProgramContext | undefined): Promise<Check[]> {
+  const checks: Check[] = [];
+  const cwd = context?.repoRoot ?? process.cwd();
+
+  const branch = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+  checks.push({ label: "Branch", value: branch.stdout, status: "info" });
+
+  if (context?.repoRoot && context.submodules && context.submodules.length > 0) {
+    const initialized = context.submodules.filter((name) =>
+      isSubmoduleInitialized(resolve(context.repoRoot as string, name)),
+    );
+    const total = context.submodules.length;
+    checks.push({
+      label: "Submodules",
+      value: `${initialized.length}/${total} initialized`,
+      status: initialized.length === total ? "ok" : "warn",
+    });
+  }
+
+  return checks;
+}
+
+function isSubmoduleInitialized(dir: string): boolean {
+  if (!existsSync(dir)) return false;
+  try {
+    // readdirSync lists every entry (dotfiles included, `.`/`..` excluded):
+    // the non-recursive "is this dir non-empty?" check this needs, on both
+    // Bun and Node (replaces the Bun-only `new Bun.Glob("*").scanSync`).
+    return readdirSync(dir).length > 0;
+  } catch {
+    return false;
+  }
+}

package/src/commands/fetch.ts

@@ -0,0 +1,136 @@
+import { writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { CookieJar } from "../lib/cookies/index.ts";
+import { fetchWithJar } from "../lib/http/index.ts";
+
+/**
+ * `harn fetch`: HTTP request with cookie-jar attach + persist.
+ *
+ * Default jar is the same one `harn cookies` reads/writes
+ * (`~/.cache/harnery/cookies.json`), so cookies set during a `harn browse`
+ * session flow naturally to subsequent `harn fetch` calls.
+ */
+
+const DEFAULT_STORE = resolve(homedir(), ".cache", "harnery", "cookies.json");
+
+interface FetchOpts {
+  method: string;
+  header?: string[];
+  data?: string;
+  output?: string;
+  store?: string;
+  cookies?: boolean;
+  redirect: string;
+  timeout: string;
+  status?: boolean;
+  headers?: boolean;
+  json?: boolean;
+}
+
+export function registerFetchCommand(
+  program: Command,
+  emit: EmitContext,
+  context?: HarneryProgramContext,
+): void {
+  program
+    .command("fetch <url>")
+    .description(
+      "HTTP GET (or --method) with cookie-jar attach + persist. " +
+        "Default jar is ~/.cache/harnery/cookies.json (shared with harn cookies / harn browse).",
+    )
+    .option("-X, --method <method>", "HTTP method", "GET")
+    .option("-H, --header <header...>", "Extra request header (repeatable, format: 'Name: value')")
+    .option("-d, --data <body>", "Request body")
+    .option("-o, --output <file>", "Write response body to file (default: stdout)")
+    .option("--store <path>", `Cookie store path (default ${DEFAULT_STORE})`)
+    .option("--no-cookies", "Skip cookie-jar attach + persist")
+    .option("--redirect <mode>", "Redirect handling: follow | error | manual", "follow")
+    .option("--timeout <ms>", "Request timeout in milliseconds", "30000")
+    .option("--status", "Print status to stderr")
+    .option("--headers", "Print response headers to stderr")
+    .option("--json", "Output the full FetchResult (status, headers, body) as JSON")
+    .action(async (url: string, opts: FetchOpts) => {
+      try {
+        await runFetch(url, opts, emit, context);
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        emit.error({ code: "fetch_error", message: msg });
+        process.exit(1);
+      }
+    });
+}
+
+async function runFetch(
+  url: string,
+  opts: FetchOpts,
+  emit: EmitContext,
+  context: HarneryProgramContext | undefined,
+): Promise<void> {
+  const headers: Record<string, string> = {};
+  for (const h of opts.header ?? []) {
+    const idx = h.indexOf(":");
+    if (idx < 0) {
+      throw new Error(`Bad header (expected 'Name: value'): ${h}`);
+    }
+    headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+  }
+
+  const jar =
+    opts.cookies !== false
+      ? new CookieJar({ path: opts.store ?? DEFAULT_STORE, source: "bp-fetch" })
+      : null;
+
+  const timeoutMs = Number.parseInt(opts.timeout, 10);
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  let result: Awaited<ReturnType<typeof fetchWithJar>>;
+  try {
+    result = await fetchWithJar(url, {
+      method: opts.method,
+      headers,
+      body: opts.data,
+      jar,
+      redirect: opts.redirect as RequestRedirect,
+      signal: ac.signal,
+      extraHeaders: context?.extraHeaders,
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (opts.json) {
+    emit.data(result as unknown as Record<string, unknown>);
+    return;
+  }
+  if (opts.status) {
+    emit.log(`${result.status} ${result.statusText}  ${result.url}`, "info");
+  }
+  if (opts.headers) {
+    for (const [k, v] of Object.entries(result.headers)) {
+      emit.log(`${k}: ${v}`, "info");
+    }
+  }
+
+  if (opts.output) {
+    writeFileSync(opts.output, result.body);
+    emit.file(opts.output, {
+      bytes: result.body.length,
+      status: result.status,
+      status_text: result.statusText,
+    });
+  } else {
+    // Body is potentially binary; route as text since most fetch responses
+    // are text/HTML/JSON. Binary callers should use --output.
+    emit.text(result.body);
+  }
+
+  if (jar && result.cookiesSaved > 0) {
+    emit.log(
+      `saved ${result.cookiesSaved} cookie${result.cookiesSaved === 1 ? "" : "s"} to ${jar.path}`,
+      "info",
+    );
+  }
+}

package/src/commands/file-history.ts

@@ -0,0 +1,202 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.ts";
+import { exec } from "../lib/exec.ts";
+
+/**
+ * `file-history <path>`: concise per-file git history. Total commits, distinct
+ * authors, first/last touched dates, total line impact, and the N most-recent
+ * commits with +/- counts. Follows renames. Submodule-aware via git itself:
+ * runs the log inside whichever repo `git rev-parse --show-toplevel` resolves
+ * from the file's directory, so submodule files get the submodule's history.
+ */
+
+interface FileHistoryOpts {
+  limit?: string;
+  since?: string;
+  author?: string;
+  json?: boolean;
+}
+
+interface CommitEntry {
+  sha: string;
+  short_sha: string;
+  author: string;
+  date: string;
+  subject: string;
+  added: number;
+  removed: number;
+}
+
+interface FileHistoryResult {
+  file: string;
+  repo: string;
+  total_commits: number;
+  authors: { name: string; commits: number }[];
+  first_commit: { sha: string; date: string } | null;
+  last_commit: { sha: string; date: string } | null;
+  total_added: number;
+  total_removed: number;
+  commits: CommitEntry[];
+}
+
+export function registerFileHistoryCommand(program: Command, emit: EmitContext): void {
+  program
+    .command("file-history <path>")
+    .description(
+      "Concise per-file git history: summary stats + N most-recent commits with line impact.",
+    )
+    .option("--limit <n>", "Show N most-recent commits", "20")
+    .option("--since <date>", "Restrict to commits since DATE (e.g. '30 days ago', '2026-01-01')")
+    .option("--author <pat>", "Filter to commits by author (substring match)")
+    .option("--json", "Structured JSON envelope")
+    .action(async (path: string, opts: FileHistoryOpts) => {
+      try {
+        const result = await runFileHistory(path, opts);
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(result);
+          return;
+        }
+        emit.text(`${renderFileHistory(result)}\n`);
+      } catch (err) {
+        emit.error({ code: "file_history_failed", message: (err as Error).message });
+        process.exit(1);
+      }
+    });
+}
+
+async function runFileHistory(path: string, opts: FileHistoryOpts): Promise<FileHistoryResult> {
+  const absPath = resolve(path);
+  if (!existsSync(absPath)) throw new Error(`no such file: ${path}`);
+
+  const repo = await detectRepo(absPath);
+  const relPath = relative(repo.cwd, absPath);
+  if (relPath.startsWith("..")) {
+    throw new Error(`path outside detected repo (${repo.cwd}): ${absPath}`);
+  }
+
+  const args = [
+    "log",
+    "--no-merges",
+    "--follow",
+    "--pretty=format:%H%x09%an%x09%aI%x09%s",
+    "--shortstat",
+  ];
+  if (opts.since) args.push(`--since=${opts.since}`);
+  if (opts.author) args.push(`--author=${opts.author}`);
+  args.push("--", relPath);
+
+  const log = await exec(["git", ...args], { cwd: repo.cwd, timeout: 30_000 });
+  if (log.exitCode !== 0) throw new Error(`git log failed: ${log.stderr || log.stdout}`);
+
+  const commits = parseGitLog(log.stdout);
+
+  const authorMap = new Map<string, number>();
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  for (const c of commits) {
+    authorMap.set(c.author, (authorMap.get(c.author) || 0) + 1);
+    totalAdded += c.added;
+    totalRemoved += c.removed;
+  }
+  const authors = Array.from(authorMap.entries())
+    .map(([name, commits]) => ({ name, commits }))
+    .sort((a, b) => b.commits - a.commits);
+
+  const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 20;
+  const recentCommits = commits.slice(0, Number.isFinite(limit) ? limit : 20);
+
+  return {
+    file: relPath,
+    repo: repo.name,
+    total_commits: commits.length,
+    authors,
+    first_commit:
+      commits.length > 0
+        ? { sha: commits[commits.length - 1]!.short_sha, date: commits[commits.length - 1]!.date }
+        : null,
+    last_commit: commits.length > 0 ? { sha: commits[0]!.short_sha, date: commits[0]!.date } : null,
+    total_added: totalAdded,
+    total_removed: totalRemoved,
+    commits: recentCommits,
+  };
+}
+
+function parseGitLog(output: string): CommitEntry[] {
+  const commits: CommitEntry[] = [];
+  const lines = output.split("\n");
+  let current: CommitEntry | null = null;
+
+  for (const line of lines) {
+    if (line.includes("\t")) {
+      if (current) commits.push(current);
+      const [sha, author, date, ...rest] = line.split("\t");
+      current = {
+        sha: sha!,
+        short_sha: sha!.slice(0, 8),
+        author: author!,
+        date: date!,
+        subject: rest.join("\t"),
+        added: 0,
+        removed: 0,
+      };
+    } else if (current && /\bfile[s]?\b.*changed/.test(line)) {
+      const ins = line.match(/(\d+) insertion/);
+      const del = line.match(/(\d+) deletion/);
+      if (ins) current.added = Number.parseInt(ins[1]!, 10);
+      if (del) current.removed = Number.parseInt(del[1]!, 10);
+    }
+  }
+  if (current) commits.push(current);
+
+  return commits;
+}
+
+async function detectRepo(absPath: string): Promise<{ name: string; cwd: string }> {
+  const dir = dirname(absPath);
+  const result = await exec(["git", "rev-parse", "--show-toplevel"], { cwd: dir });
+  if (result.exitCode !== 0) {
+    throw new Error(`not inside a git repository: ${absPath}`);
+  }
+  const cwd = result.stdout.trim();
+  return { name: basename(cwd), cwd };
+}
+
+function renderFileHistory(r: FileHistoryResult): string {
+  const lines: string[] = [];
+  lines.push(`file-history · ${r.repo}/${r.file}`);
+  lines.push("");
+
+  if (r.total_commits === 0) {
+    lines.push("(no commits found for this path)");
+    return lines.join("\n");
+  }
+
+  lines.push(
+    `summary: ${r.total_commits} commit${r.total_commits === 1 ? "" : "s"} by ${r.authors.length} author${r.authors.length === 1 ? "" : "s"}, +${r.total_added}/-${r.total_removed} lines`,
+  );
+  if (r.last_commit) lines.push(`  last:  ${r.last_commit.sha}  ${r.last_commit.date}`);
+  if (r.first_commit) lines.push(`  first: ${r.first_commit.sha}  ${r.first_commit.date}`);
+
+  if (r.authors.length > 0) {
+    lines.push("");
+    lines.push("authors:");
+    for (const a of r.authors.slice(0, 5)) {
+      lines.push(`  ${a.commits.toString().padStart(3)}  ${a.name}`);
+    }
+    if (r.authors.length > 5) lines.push(`  ... +${r.authors.length - 5} more`);
+  }
+
+  lines.push("");
+  lines.push(`recent (showing ${r.commits.length} of ${r.total_commits}):`);
+  for (const c of r.commits) {
+    const dateOnly = c.date.slice(0, 10);
+    const sig = `+${c.added}/-${c.removed}`.padStart(10);
+    const author = c.author.slice(0, 18).padEnd(18);
+    lines.push(`  ${c.short_sha}  ${dateOnly}  ${sig}  ${author}  ${c.subject}`);
+  }
+
+  return lines.join("\n");
+}