@stupify/cli 0.0.2 → 0.0.4

package/src/doctor.ts

@@ -0,0 +1,140 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
+import { runHookCommand } from "./hooks.ts";
+
+const execFileAsync = promisify(execFile);
+
+type CheckStatus = "ok" | "missing" | "info";
+
+type DoctorCheck = Readonly<{
+  label: string;
+  status: CheckStatus;
+  detail: string;
+  required?: boolean;
+}>;
+
+export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: string }>> {
+  const checks = await Promise.all([
+    gitCheck(),
+    hookCheck(),
+    semCheck(),
+    repomixCheck(),
+    llamaServerCheck(),
+    modelCacheCheck(),
+  ]);
+  const requiredMissing = checks.some((check) => check.required && check.status === "missing");
+  return {
+    exitCode: requiredMissing ? 1 : 0,
+    text: renderDoctor(checks),
+  };
+}
+
+async function gitCheck(): Promise<DoctorCheck> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });
+    return { label: "git repo", status: "ok", detail: stdout.trim(), required: true };
+  } catch {
+    return { label: "git repo", status: "missing", detail: "not inside a git repository", required: true };
+  }
+}
+
+async function hookCheck(): Promise<DoctorCheck> {
+  try {
+    const status = await runHookCommand("status");
+    return { label: "pre-commit hook", status: "info", detail: status.replace(/^Stupify hook:\s*/, "") };
+  } catch (error) {
+    return { label: "pre-commit hook", status: "info", detail: errorMessage(error) };
+  }
+}
+
+async function semCheck(): Promise<DoctorCheck> {
+  const packageBin = resolvePackage("@ataraxy-labs/sem/bin/sem.js");
+  if (packageBin) return { label: "sem", status: "ok", detail: "@ataraxy-labs/sem package binary found", required: true };
+  if (await commandExists("sem")) return { label: "sem", status: "ok", detail: "sem found on PATH", required: true };
+  return { label: "sem", status: "missing", detail: "install @ataraxy-labs/sem or put sem on PATH", required: true };
+}
+
+async function repomixCheck(): Promise<DoctorCheck> {
+  if (resolvePackage("repomix")) return { label: "Repomix", status: "ok", detail: "repomix package found", required: true };
+  return { label: "Repomix", status: "missing", detail: "repomix package is not installed", required: true };
+}
+
+async function llamaServerCheck(): Promise<DoctorCheck> {
+  if (await commandExists("llama-server")) return { label: "llama-server", status: "ok", detail: "llama-server found on PATH", required: true };
+  return { label: "llama-server", status: "missing", detail: "install llama.cpp, for example `brew install llama.cpp`", required: true };
+}
+
+async function modelCacheCheck(): Promise<DoctorCheck> {
+  const model = MODEL_REGISTRY[DEFAULT_MODEL_ID];
+  const modelPath = path.join(cacheDir(), "models", model.file);
+  if (await fileExists(modelPath)) return { label: "default model", status: "ok", detail: `${model.name} cached` };
+  return {
+    label: "default model",
+    status: "info",
+    detail: `${model.name} not cached yet; first interactive search can download it locally`,
+  };
+}
+
+function renderDoctor(checks: readonly DoctorCheck[]): string {
+  const lines = [
+    "Stupify doctor",
+    "",
+    ...checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`),
+    "",
+    "Privacy: local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
+  ];
+  return lines.join("\n");
+}
+
+function icon(status: CheckStatus): string {
+  if (status === "ok") return "OK";
+  if (status === "missing") return "MISSING";
+  return "INFO";
+}
+
+function resolvePackage(specifier: string): string | null {
+  try {
+    const require = createRequire(import.meta.url);
+    return require.resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], { maxBuffer: 1024 * 1024 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    const { stat } = await import("node:fs/promises");
+    return (await stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function cacheDir(): string {
+  if (process.env.STUPIFY_CACHE_DIR) return process.env.STUPIFY_CACHE_DIR;
+  if (process.env.XDG_CACHE_HOME) return path.join(process.env.XDG_CACHE_HOME, "stupify");
+  if (platform() === "darwin") return path.join(homedir(), "Library", "Caches", "stupify");
+  if (platform() === "win32" && process.env.LOCALAPPDATA) return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
+  return path.join(homedir(), ".cache", "stupify");
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/git.ts

@@ -0,0 +1,262 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { sourceId, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
+
+const execFileAsync = promisify(execFile);
+
+export async function netDiffSince(since: string): Promise<NetDiff> {
+  const range = await sourceRangeSince(since);
+  return netDiff(range.base, range.target, range.label, range.id);
+}
+
+export async function netDiffForCommit(commit: string): Promise<NetDiff> {
+  const range = await sourceRangeForCommit(commit);
+  return netDiff(range.base, range.target, range.label, range.id);
+}
+
+export async function netDiffForRecentCommits(count: number): Promise<NetDiff> {
+  const range = await sourceRangeForRecentCommits(count);
+  return netDiff(range.base, range.target, range.label, range.id);
+}
+
+export async function sourceRangeSince(since: string): Promise<SourceRange> {
+  const [base, target] = await Promise.all([baseBefore(since), revParse("HEAD")]);
+  return sourceRange(base, target, `last ${since}`);
+}
+
+export async function sourceRangeForCommit(commit: string): Promise<SourceRange> {
+  const [base, target, shortTarget, message] = await Promise.all([
+    revParse(`${commit}^1`),
+    revParse(commit),
+    shortCommit(commit),
+    commitMessage(commit),
+  ]);
+  return sourceRange(base, target, firstLine(message) || shortTarget, sourceId(shortTarget));
+}
+
+export async function sourceRangeForRecentCommits(count: number): Promise<SourceRange> {
+  const commits = await recentCommits(count);
+  if (commits.length === 0) throw new Error("No non-merge commits found.");
+
+  const oldest = commits[0];
+  const newest = commits[commits.length - 1];
+  const [base, target, shortBase, shortTarget] = await Promise.all([
+    revParse(`${oldest}^1`),
+    revParse(newest),
+    shortCommit(`${oldest}^1`),
+    shortCommit(newest),
+  ]);
+
+  return sourceRange(base, target, `${commits.length} recent commits`, sourceId(`range:${shortBase}..${shortTarget}`));
+}
+
+export async function netDiffFromStdin(text: string): Promise<NetDiff> {
+  if (!text.trim()) throw new Error("No diff received on stdin.");
+  return {
+    id: sourceId("stdin"),
+    label: "stdin",
+    base: "stdin",
+    target: "stdin",
+    text,
+    stats: statsFromDiff(text),
+  };
+}
+
+export async function stagedDiff(): Promise<StagedDiff> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "diff",
+      "--cached",
+      "--no-ext-diff",
+      "--no-color",
+      "--unified=3",
+      "--",
+    ], { maxBuffer: 64 * 1024 * 1024 });
+    return { text: stdout, stats: statsFromDiff(stdout) };
+  } catch {
+    throw new Error("Could not read staged changes. Run stupify inside a git repository.");
+  }
+}
+
+export async function gitRoot(): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+    return stdout.trim();
+  } catch {
+    throw new Error("Could not find a git repository.");
+  }
+}
+
+export async function gitPath(pathspec: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", pathspec]);
+    return stdout.trim();
+  } catch {
+    throw new Error(`Could not resolve git path: ${pathspec}`);
+  }
+}
+
+async function netDiff(base: string, target: string, label: string, id?: NetDiff["id"]): Promise<NetDiff> {
+  const [text, stats, shortBase, shortTarget] = await Promise.all([
+    diff(base, target),
+    diffStats(base, target),
+    shortCommit(base),
+    shortCommit(target),
+  ]);
+  return {
+    id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
+    label,
+    base,
+    target,
+    text,
+    stats,
+  };
+}
+
+async function sourceRange(base: string, target: string, label: string, id?: SourceRange["id"]): Promise<SourceRange> {
+  const [stats, shortBase, shortTarget] = await Promise.all([
+    diffStats(base, target),
+    shortCommit(base),
+    shortCommit(target),
+  ]);
+  return {
+    id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
+    label,
+    base,
+    target,
+    stats,
+  };
+}
+
+async function baseBefore(since: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "log",
+      "--first-parent",
+      "--before",
+      since,
+      "-1",
+      "--format=%H",
+    ]);
+    const commit = stdout.trim();
+    if (commit) return commit;
+    return rootCommit();
+  } catch {
+    throw new Error(`Could not resolve base commit before ${since}.`);
+  }
+}
+
+async function rootCommit(): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-list", "--max-parents=0", "HEAD"]);
+    return stdout.trim().split(/\r?\n/, 1)[0] ?? "";
+  } catch {
+    throw new Error("Could not resolve repository root commit.");
+  }
+}
+
+async function diff(base: string, target: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "diff",
+      "--no-ext-diff",
+      "--no-color",
+      "--unified=8",
+      base,
+      target,
+      "--",
+    ], { maxBuffer: 128 * 1024 * 1024 });
+    if (!stdout.trim()) throw new Error("empty diff");
+    return stdout;
+  } catch {
+    throw new Error(`No diff found for ${base}..${target}.`);
+  }
+}
+
+async function diffStats(base: string, target: string): Promise<NetDiffStats> {
+  try {
+    const { stdout } = await execFileAsync("git", ["diff", "--numstat", base, target, "--"], {
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    return statsFromNumstat(stdout);
+  } catch {
+    return { filesChanged: 0, additions: 0, deletions: 0 };
+  }
+}
+
+function statsFromDiff(diffText: string): NetDiffStats {
+  const files = new Set<string>();
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diffText.split(/\r?\n/)) {
+    const fileMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+    if (fileMatch) files.add(fileMatch[1]);
+    else if (line.startsWith("+") && !line.startsWith("+++")) additions += 1;
+    else if (line.startsWith("-") && !line.startsWith("---")) deletions += 1;
+  }
+  return { filesChanged: files.size, additions, deletions };
+}
+
+function statsFromNumstat(numstat: string): NetDiffStats {
+  let filesChanged = 0;
+  let additions = 0;
+  let deletions = 0;
+
+  for (const line of numstat.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const [added, deleted] = line.split(/\s+/, 3);
+    filesChanged += 1;
+    additions += Number(added) || 0;
+    deletions += Number(deleted) || 0;
+  }
+
+  return { filesChanged, additions, deletions };
+}
+
+async function recentCommits(count: number): Promise<readonly string[]> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "log",
+      "--first-parent",
+      "--no-merges",
+      "--format=%H",
+      `-${count}`,
+    ]);
+    return stdout.split(/\r?\n/).filter(Boolean).reverse();
+  } catch {
+    throw new Error(`Could not read last ${count} commits.`);
+  }
+}
+
+async function revParse(rev: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", rev]);
+    return stdout.trim();
+  } catch {
+    throw new Error(`Could not resolve ${rev}.`);
+  }
+}
+
+async function shortCommit(commit: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--short", commit]);
+    return stdout.trim();
+  } catch {
+    throw new Error(`Could not resolve commit ${commit}.`);
+  }
+}
+
+async function commitMessage(commit: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["show", "--no-patch", "--format=%B", commit], {
+      maxBuffer: 1024 * 1024,
+    });
+    return stdout;
+  } catch {
+    throw new Error(`Could not read commit message for ${commit}.`);
+  }
+}
+
+function firstLine(value: string): string {
+  return value.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+}

package/src/hooks.ts

@@ -0,0 +1,134 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { gitPath, gitRoot } from "./git.ts";
+import type { HookAction } from "./types.ts";
+
+const execFileAsync = promisify(execFile);
+const START = "# stupify hook start";
+const END = "# stupify hook end";
+
+export async function runHookCommand(action: HookAction): Promise<string> {
+  if (action === "status") return hookStatus();
+  if (action === "install") return installHook();
+  return uninstallHook();
+}
+
+export function hookSnippet(): string {
+  return managedBlock("stupify --staged");
+}
+
+async function hookStatus(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  if (!existsSync(hookPath)) return "Stupify hook: not installed";
+
+  const content = await readFile(hookPath, "utf8");
+  if (hasManagedBlock(content)) return "Stupify hook: installed";
+  return "Stupify hook: existing non-Stupify pre-commit hook found";
+}
+
+async function installHook(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  const block = await managedBlockForInstall();
+  if (!existsSync(hookPath)) {
+    await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: installed";
+  }
+
+  const content = await readFile(hookPath, "utf8");
+  if (hasManagedBlock(content)) {
+    await writeFile(hookPath, `${replaceManagedBlock(content, block).trimEnd()}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: updated";
+  }
+
+  if (isEffectivelyEmptyHook(content)) {
+    await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: installed";
+  }
+
+  return `Stupify hook: existing non-Stupify pre-commit hook found; not modified.
+Add this snippet manually if you want Stupify in that hook:
+${block}`;
+}
+
+async function uninstallHook(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  if (!existsSync(hookPath)) return "Stupify hook: not installed";
+
+  const content = await readFile(hookPath, "utf8");
+  if (!hasManagedBlock(content)) return "Stupify hook: not installed";
+
+  const next = replaceManagedBlock(content, "").trim();
+  if (isEffectivelyEmptyHook(next)) {
+    await rm(hookPath, { force: true });
+    return "Stupify hook: uninstalled";
+  }
+
+  await writeFile(hookPath, `${next}\n`, "utf8");
+  await chmod(hookPath, 0o755);
+  return "Stupify hook: uninstalled";
+}
+
+async function preCommitHookPath(): Promise<string> {
+  const [root, hook] = await Promise.all([gitRoot(), gitPath("hooks/pre-commit")]);
+  return path.isAbsolute(hook) ? hook : path.join(root, hook);
+}
+
+function hasManagedBlock(content: string): boolean {
+  return content.includes(START) && content.includes(END);
+}
+
+async function managedBlockForInstall(): Promise<string> {
+  if (await commandExists("stupify")) return managedBlock("stupify --staged");
+
+  const root = await gitRoot();
+  const localEntrypoint = path.join(root, "packages", "cli", "src", "stupify.ts");
+  if (existsSync(localEntrypoint) && await commandExists("bun")) {
+    return managedBlock(`bun ${shellQuote(localEntrypoint)} --staged`);
+  }
+
+  return managedBlock("stupify --staged");
+}
+
+function managedBlock(command: string): string {
+  return `${START}
+${command} || true
+${END}`;
+}
+
+function replaceManagedBlock(content: string, replacement: string): string {
+  const pattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}`);
+  return content.replace(pattern, replacement);
+}
+
+function isEffectivelyEmptyHook(content: string): boolean {
+  return content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && line !== "#!/bin/sh" && line !== "#!/usr/bin/env sh")
+    .length === 0;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], {
+      maxBuffer: 1024 * 1024,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { main } from "./stupify.ts";