@stupify/cli 0.0.16 → 0.1.0

package/src/git.ts

@@ -1,380 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { sourceId, type BlameSummary, 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];
-  if (!oldest || !newest) throw new Error("Could not resolve recent commit range.");
-  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}`);
-  }
-}
-
-export async function gitUserLabel(): Promise<string> {
-  const [name, email] = await Promise.all([
-    gitConfig("user.name"),
-    gitConfig("user.email"),
-  ]);
-  if (name && email) return `${name} <${email}>`;
-  return name || email || "working tree";
-}
-
-export async function blameEntity(input: Readonly<{
-  filePath: string;
-  entityName: string;
-  rev: string;
-}>): Promise<BlameSummary | null> {
-  try {
-    const { stdout } = await execFileAsync("git", [
-      "blame",
-      "--line-porcelain",
-      "-L",
-      `:${input.entityName}`,
-      input.rev,
-      "--",
-      input.filePath,
-    ], { maxBuffer: 16 * 1024 * 1024 });
-    return summarizeBlame(stdout);
-  } catch {
-    return null;
-  }
-}
-
-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, committers, commitSubjects] = await Promise.all([
-    diffStats(base, target),
-    shortCommit(base),
-    shortCommit(target),
-    committersForRange(base, target),
-    commitSubjectsForRange(base, target),
-  ]);
-  return {
-    id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
-    label,
-    base,
-    target,
-    committers,
-    commitSubjects,
-    stats,
-  };
-}
-
-async function gitConfig(key: string): Promise<string> {
-  try {
-    const { stdout } = await execFileAsync("git", ["config", "--get", key]);
-    return stdout.trim();
-  } catch {
-    return "";
-  }
-}
-
-async function committersForRange(base: string, target: string): Promise<readonly string[]> {
-  try {
-    const { stdout } = await execFileAsync("git", ["log", "--format=%cn <%ce>", `${base}..${target}`], {
-      maxBuffer: 4 * 1024 * 1024,
-    });
-    return uniqueLines(stdout);
-  } catch {
-    return [];
-  }
-}
-
-async function commitSubjectsForRange(base: string, target: string): Promise<readonly string[]> {
-  try {
-    const { stdout } = await execFileAsync("git", ["log", "--format=%s", `${base}..${target}`], {
-      maxBuffer: 4 * 1024 * 1024,
-    });
-    return uniqueLines(stdout);
-  } catch {
-    return [];
-  }
-}
-
-function uniqueLines(value: string): readonly string[] {
-  const seen = new Set<string>();
-  const lines: string[] = [];
-  for (const line of value.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    lines.push(trimmed);
-  }
-  return lines;
-}
-
-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?.[1]) 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() ?? "";
-}
-
-function summarizeBlame(output: string): BlameSummary | null {
-  const entries = new Map<string, { commit: string; author: string; subject: string; count: number }>();
-  let currentCommit = "";
-  let currentAuthor = "";
-  let currentSubject = "";
-  for (const line of output.split(/\r?\n/)) {
-    const header = /^([0-9a-f]{40})\s+/.exec(line);
-    if (header?.[1]) {
-      currentCommit = header[1];
-      currentAuthor = "";
-      currentSubject = "";
-      continue;
-    }
-    if (line.startsWith("author ")) {
-      currentAuthor = line.slice("author ".length).trim();
-      continue;
-    }
-    if (line.startsWith("summary ")) {
-      currentSubject = line.slice("summary ".length).trim();
-      continue;
-    }
-    if (!line.startsWith("\t") || !currentCommit) continue;
-    const previous = entries.get(currentCommit);
-    entries.set(currentCommit, {
-      commit: currentCommit,
-      author: currentAuthor || previous?.author || "unknown author",
-      subject: currentSubject || previous?.subject || currentCommit.slice(0, 7),
-      count: (previous?.count ?? 0) + 1,
-    });
-  }
-
-  const [best] = [...entries.values()].sort((a, b) => b.count - a.count);
-  if (!best) return null;
-  return {
-    commit: best.commit.slice(0, 7),
-    author: best.author,
-    subject: best.subject,
-  };
-}

package/src/hooks.ts

@@ -1,151 +0,0 @@
-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";
-import type { CliUi } from "./ui.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 renderHookResultToUi(result: string, ui: CliUi): void {
-  const [firstLine = "Stupify hook: no status returned", ...rest] = result.split(/\r?\n/);
-  if (firstLine.includes("not installed")) {
-    ui.info(firstLine);
-  } else if (firstLine.includes("installed") || firstLine.includes("updated") || firstLine.includes("uninstalled")) {
-    ui.success(firstLine);
-  } else if (firstLine.includes("existing non-Stupify")) {
-    ui.warn(firstLine);
-  } else {
-    ui.info(firstLine);
-  }
-
-  const detail = rest.join("\n").trim();
-  if (detail) ui.note(detail, "Hook");
-}
-
-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

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