@stupify/cli 0.0.16 → 0.2.0

package/dist/git.js

@@ -1,368 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { sourceId } from "./types.js";
-const execFileAsync = promisify(execFile);
-export async function netDiffSince(since) {
-    const range = await sourceRangeSince(since);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function netDiffForCommit(commit) {
-    const range = await sourceRangeForCommit(commit);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function netDiffForRecentCommits(count) {
-    const range = await sourceRangeForRecentCommits(count);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function sourceRangeSince(since) {
-    const [base, target] = await Promise.all([baseBefore(since), revParse("HEAD")]);
-    return sourceRange(base, target, `last ${since}`);
-}
-export async function sourceRangeForCommit(commit) {
-    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) {
-    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) {
-    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() {
-    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() {
-    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) {
-    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() {
-    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) {
-    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, target, label, id) {
-    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, target, label, id) {
-    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) {
-    try {
-        const { stdout } = await execFileAsync("git", ["config", "--get", key]);
-        return stdout.trim();
-    }
-    catch {
-        return "";
-    }
-}
-async function committersForRange(base, target) {
-    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, target) {
-    try {
-        const { stdout } = await execFileAsync("git", ["log", "--format=%s", `${base}..${target}`], {
-            maxBuffer: 4 * 1024 * 1024,
-        });
-        return uniqueLines(stdout);
-    }
-    catch {
-        return [];
-    }
-}
-function uniqueLines(value) {
-    const seen = new Set();
-    const lines = [];
-    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) {
-    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() {
-    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, target) {
-    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, target) {
-    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) {
-    const files = new Set();
-    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) {
-    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) {
-    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) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", rev]);
-        return stdout.trim();
-    }
-    catch {
-        throw new Error(`Could not resolve ${rev}.`);
-    }
-}
-async function shortCommit(commit) {
-    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) {
-    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) {
-    return value.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
-}
-function summarizeBlame(output) {
-    const entries = new Map();
-    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/dist/hooks.d.ts

@@ -1,5 +0,0 @@
-import type { HookAction } from "./types.ts";
-import type { CliUi } from "./ui.ts";
-export declare function runHookCommand(action: HookAction): Promise<string>;
-export declare function renderHookResultToUi(result: string, ui: CliUi): void;
-export declare function hookSnippet(): string;

package/dist/hooks.js

@@ -1,135 +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.js";
-const execFileAsync = promisify(execFile);
-const START = "# stupify hook start";
-const END = "# stupify hook end";
-export async function runHookCommand(action) {
-    if (action === "status")
-        return hookStatus();
-    if (action === "install")
-        return installHook();
-    return uninstallHook();
-}
-export function renderHookResultToUi(result, ui) {
-    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() {
-    return managedBlock("stupify --staged");
-}
-async function hookStatus() {
-    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() {
-    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() {
-    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() {
-    const [root, hook] = await Promise.all([gitRoot(), gitPath("hooks/pre-commit")]);
-    return path.isAbsolute(hook) ? hook : path.join(root, hook);
-}
-function hasManagedBlock(content) {
-    return content.includes(START) && content.includes(END);
-}
-async function managedBlockForInstall() {
-    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) {
-    return `${START}
-${command} || true
-${END}`;
-}
-function replaceManagedBlock(content, replacement) {
-    const pattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}`);
-    return content.replace(pattern, replacement);
-}
-function isEffectivelyEmptyHook(content) {
-    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) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function commandExists(command) {
-    try {
-        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], {
-            maxBuffer: 1024 * 1024,
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/model.d.ts

@@ -1,11 +0,0 @@
-import type { ModelId } from "./types.ts";
-import type { CliUi } from "./ui.ts";
-export type ModelProfile = "scout";
-export type LocalModel = Readonly<{
-    id: ModelId;
-    name: string;
-    baseUrl: string;
-    profile: ModelProfile;
-}>;
-export declare function firstRunModelBootstrap(modelId: ModelId, ui: CliUi): Promise<string>;
-export declare function loadLocalModel(modelPath: string, modelId: ModelId, profile: ModelProfile, ui: CliUi): Promise<LocalModel>;