@stupify/cli 0.0.8 → 0.0.10

package/dist/analysis.js

@@ -1,5 +1,6 @@
 import { cachedJson, fingerprint } from "./cache.js";
 import { searchPrompt } from "./prompts.js";
+import { diagnostic, diagnosticError } from "./ui.js";
 export async function runSearch(model, request) {
     const raw = await runJsonPrompt(model, request.prompt, request.schema, 0);
     return uncheckedSearchMatches(raw, request.contexts);
@@ -100,8 +101,8 @@ Your previous response was not valid JSON. Return the requested JSON object only
     const retryParsed = parseJson(retry);
     if (retryParsed.ok)
         return retryParsed.value;
-    console.error("Raw model output:");
-    console.error(retry);
+    diagnosticError("Raw model output:");
+    diagnostic(retry);
     throw new Error("Model returned invalid JSON.");
 }
 async function complete(model, prompt, schema, temperature) {

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.0.8";
+export declare const VERSION = "0.0.10";
 import type { ModelConfig, ModelId } from "./types.ts";
 export declare const DEFAULT_MODEL_ID: ModelId;
 export declare const MODEL_REGISTRY: Record<ModelId, ModelConfig>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.8";
+export const VERSION = "0.0.10";
 export const DEFAULT_MODEL_ID = "gemma-4-e2b";
 export const MODEL_REGISTRY = {
     "gemma-4-e2b": {

package/dist/git.d.ts

@@ -9,3 +9,4 @@ export declare function netDiffFromStdin(text: string): Promise<NetDiff>;
 export declare function stagedDiff(): Promise<StagedDiff>;
 export declare function gitRoot(): Promise<string>;
 export declare function gitPath(pathspec: string): Promise<string>;
+export declare function gitUserLabel(): Promise<string>;

package/dist/git.js

@@ -87,6 +87,15 @@ export async function gitPath(pathspec) {
         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";
+}
 async function netDiff(base, target, label, id) {
     const [text, stats, shortBase, shortTarget] = await Promise.all([
         diff(base, target),
@@ -104,19 +113,53 @@ async function netDiff(base, target, label, id) {
     };
 }
 async function sourceRange(base, target, label, id) {
-    const [stats, shortBase, shortTarget] = await Promise.all([
+    const [stats, shortBase, shortTarget, committers] = await Promise.all([
         diffStats(base, target),
         shortCommit(base),
         shortCommit(target),
+        committersForRange(base, target),
     ]);
     return {
         id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
         label,
         base,
         target,
+        committers,
         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 [];
+    }
+}
+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", [

package/dist/model.d.ts

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

package/dist/model.js

@@ -1,42 +1,39 @@
 import { execFile, spawn } from "node:child_process";
-import { createReadStream, createWriteStream } from "node:fs";
 import { mkdir, open, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { homedir, platform } from "node:os";
-import { stdin as input, stderr as statusOutput, stdout as output, } from "node:process";
-import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { MODEL_REGISTRY } from "./constants.js";
 const execFileAsync = promisify(execFile);
 const LLAMA_SERVER_HOST = "127.0.0.1";
-export async function firstRunModelBootstrap(modelId) {
+export async function firstRunModelBootstrap(modelId, ui) {
     const selectedModel = MODEL_REGISTRY[modelId];
     const modelDir = path.join(cacheDir(), "models");
     const modelPath = path.join(modelDir, selectedModel.file);
     if (await exists(modelPath))
         return modelPath;
-    console.error(`No local Stupify model found.
+    ui.note(`No local Stupify model found.
 Stupify runs locally.
 Download this model now?
 Model: ${selectedModel.name}
-Size: ${selectedModel.size}`);
-    if (!(await confirm("Continue? y/N ")))
+Size: ${selectedModel.size}`, "Setup", { force: true });
+    if (!(await ui.confirm("Continue?")))
         throw new Error("Setup cancelled.");
     await mkdir(modelDir, { recursive: true });
-    await downloadModel(modelPath, selectedModel.url);
+    await downloadModel(modelPath, selectedModel.url, ui);
     if (!(await exists(modelPath)))
         throw new Error("Model download failed: file was not created.");
     return modelPath;
 }
-export async function loadLocalModel(modelPath, modelId, profile = "scout") {
+export async function loadLocalModel(modelPath, modelId, profile, ui) {
     const selectedModel = MODEL_REGISTRY[modelId];
     const runtime = modelRuntime(profile);
     const runningModel = await runningServerModel(runtime.baseUrl);
     if (runningModel) {
         if (runningModel !== modelId)
-            await stopManagedServer(runtime);
+            await stopManagedServer(runtime, ui);
         if (runningModel === modelId) {
-            console.error(`Using local model: ${selectedModel.name}`);
+            ui.info(`Using local model: ${selectedModel.name}`);
             return {
                 id: modelId,
                 name: selectedModel.name,
@@ -46,8 +43,16 @@ export async function loadLocalModel(modelPath, modelId, profile = "scout") {
         }
     }
     await ensureLlamaServerBinary();
-    await startLlamaServer(modelPath, modelId, selectedModel.name, runtime);
-    await waitForServer(runtime.baseUrl, modelId);
+    await startLlamaServer(modelPath, modelId, selectedModel.name, runtime, ui);
+    const ready = ui.spinner(`Waiting for local ${profile} model`);
+    try {
+        await waitForServer(runtime.baseUrl, modelId);
+        ready.stop(`Local ${profile} model ready`);
+    }
+    catch (error) {
+        ready.error(`Local ${profile} model failed to start`);
+        throw error;
+    }
     return {
         id: modelId,
         name: selectedModel.name,
@@ -101,14 +106,14 @@ Install llama.cpp first:
   brew install llama.cpp`);
     }
 }
-async function startLlamaServer(modelPath, modelId, modelName, runtime) {
+async function startLlamaServer(modelPath, modelId, modelName, runtime, ui) {
     const logDir = path.join(cacheDir(), "logs");
     await mkdir(logDir, { recursive: true });
     const logPath = path.join(logDir, "llama-server.log");
     const out = await open(logPath, "a");
     const err = await open(logPath, "a");
-    console.error(`Starting local model server: ${modelName}`);
-    console.error(`llama-server log: ${logPath}`);
+    ui.step(`Starting local model server: ${modelName}`);
+    ui.info(`llama-server log: ${logPath}`);
     const args = [
         "-m",
         modelPath,
@@ -151,14 +156,14 @@ async function startLlamaServer(modelPath, modelId, modelName, runtime) {
     await out.close();
     await err.close();
 }
-async function stopManagedServer(runtime) {
+async function stopManagedServer(runtime, ui) {
     const pid = await managedServerPid(runtime);
     if (!pid) {
         const runningModel = await runningServerModel(runtime.baseUrl);
         throw new Error(`A llama-server is already running with ${runningModel ?? "another model"}.
 Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server.`);
     }
-    console.error("Restarting local model server for selected model.");
+    ui.step("Restarting local model server for selected model.");
     try {
         process.kill(pid, "SIGTERM");
     }
@@ -214,10 +219,11 @@ async function waitForServer(baseUrl, modelId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function downloadModel(modelPath, modelUrl) {
+async function downloadModel(modelPath, modelUrl, ui) {
     const tempPath = `${modelPath}.download`;
     await rm(tempPath, { force: true });
-    console.error("Downloading model...");
+    const downloadSpinner = ui.spinner("Downloading model");
+    let downloadProgress = null;
     try {
         const response = await fetch(modelUrl);
         if (!response.ok || !response.body)
@@ -225,8 +231,13 @@ async function downloadModel(modelPath, modelUrl) {
         const total = Number(response.headers.get("content-length") ?? 0);
         let received = 0;
         let lastPrint = 0;
+        let lastProgressBytes = 0;
         const reader = response.body.getReader();
         const file = await open(tempPath, "wx");
+        if (total > 0) {
+            downloadSpinner.clear();
+            downloadProgress = ui.progress("Downloading model", total);
+        }
         try {
             while (true) {
                 const { done, value } = await reader.read();
@@ -237,42 +248,30 @@ async function downloadModel(modelPath, modelUrl) {
                 const now = Date.now();
                 if (total > 0 && now - lastPrint > 500) {
                     lastPrint = now;
-                    statusOutput.write(`\r${formatBytes(received)} / ${formatBytes(total)}`);
+                    downloadProgress?.advance(received - lastProgressBytes, `${formatBytes(received)} / ${formatBytes(total)}`);
+                    lastProgressBytes = received;
                 }
             }
         }
         finally {
             await file.close();
         }
-        if (total > 0)
-            statusOutput.write(`\r${formatBytes(received)} / ${formatBytes(total)}\n`);
+        if (downloadProgress && received > lastProgressBytes) {
+            downloadProgress.advance(received - lastProgressBytes, `${formatBytes(received)} / ${formatBytes(total)}`);
+        }
+        const activeProgress = downloadProgress ?? downloadSpinner;
+        activeProgress.stop(total > 0
+            ? `Downloaded ${formatBytes(received)} / ${formatBytes(total)}`
+            : "Downloaded model");
         await rename(tempPath, modelPath);
     }
     catch (error) {
+        const activeProgress = downloadProgress ?? downloadSpinner;
+        activeProgress.error("Model download failed");
         await rm(tempPath, { force: true });
         throw error;
     }
 }
-async function confirm(question) {
-    const rl = createInterface(terminalIo());
-    try {
-        const answer = (await rl.question(question)).trim().toLowerCase();
-        return answer === "y" || answer === "yes";
-    }
-    finally {
-        rl.close();
-    }
-}
-function terminalIo() {
-    if (input.isTTY)
-        return { input, output };
-    if (platform() !== "win32")
-        return {
-            input: createReadStream("/dev/tty"),
-            output: createWriteStream("/dev/tty"),
-        };
-    throw new Error("No local Stupify model found. Run `stupify` once in an interactive terminal to set up the model.");
-}
 function cacheDir() {
     if (process.env.STUPIFY_CACHE_DIR)
         return process.env.STUPIFY_CACHE_DIR;

package/dist/render.js

@@ -1,38 +1,37 @@
 import { VERSION } from "./constants.js";
+import { format } from "./ui.js";
 export function renderSearchRun(run, command) {
     if (command.json)
         return JSON.stringify(run, null, 2);
     if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
-        return `🧙 stupify 🪄
-Search input is too large for precise local search.
-Size:
+        return `${format.heading("Search input is too large for precise local search.")}
+${format.heading("Size:")}
 ~${run.stats.inputTokens ?? "unknown"} tokens
-Limit:
+${format.heading("Limit:")}
 ${run.stats.inputTokenCap ?? "unknown"} tokens
 Stupify skipped the search rather than review truncated context.
 Nothing was blocked.
-Try:
+${format.heading("Try:")}
 rerun with ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
     }
     if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
-        return `🧙 stupify 🪄
-Search complete.
-Patterns: ${run.patterns.join(", ")}
-No search targets found.`;
+        return `${format.heading("Search complete.")}
+${format.label("Patterns:")} ${run.patterns.join(", ")}
+${format.success("No search targets found.")}`;
     }
     if (run.matches.length === 0) {
-        return `🧙 stupify 🪄
-Search complete.
-Patterns: ${run.patterns.join(", ")}
-No judgment-offload signals found.`;
+        return `${format.heading("Search complete.")}
+${format.label("Patterns:")} ${run.patterns.join(", ")}
+${format.success("No judgment-offload signals found.")}`;
     }
-    return `🧙 stupify 🪄
-Possible judgment-offload detected:
-${run.matches.map((match, index) => `${index + 1}. ${match.patternId}
-   Why: ${match.checkWhy ?? "This pattern may indicate judgment-offload."}
-   Match: ${match.reason}
-   Proof: ${match.proof}`).join("\n")}
-Search mode is warn-only.`;
+    return `${format.warn("AI SLOP DETECTED")}
+${run.matches.map((match, index) => `${index + 1}.
+   ${format.muted("who:")} ${committerLabel(run)}
+   ${format.muted("what:")} ${match.patternId} - ${match.reason}
+   ${format.muted("when:")} ${sourceLabel(command)}
+   ${format.muted("where:")} ${match.proof}
+   ${format.muted("why:")} ${match.checkWhy ?? "This pattern may indicate judgment-offload."}`).join("\n")}
+${format.muted("Search mode is warn-only.")}`;
 }
 export function helpText() {
     return `Stupify ${VERSION}
@@ -92,3 +91,22 @@ function sourceHint(command) {
         return `--commits ${command.count}`;
     return "--stdin";
 }
+function sourceLabel(command) {
+    if (command.kind === "staged")
+        return "staged changes";
+    if (command.kind === "since")
+        return `since ${command.since}`;
+    if (command.kind === "commit")
+        return `commit ${command.commit}`;
+    if (command.kind === "commits")
+        return `last ${command.count} commits`;
+    return "stdin diff";
+}
+function committerLabel(run) {
+    const committers = (run.stats.committers ?? []).filter(Boolean);
+    if (committers.length === 0)
+        return "unknown committer";
+    if (committers.length <= 3)
+        return committers.join(", ");
+    return `${committers.slice(0, 3).join(", ")} +${committers.length - 3} more`;
+}

package/dist/sem-provider.js

@@ -6,17 +6,19 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { cachedJson, fingerprint } from "./cache.js";
 import { readDiffFromStdin } from "./diff.js";
-import { sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, stagedDiff, } from "./git.js";
+import { gitUserLabel, sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, stagedDiff, } from "./git.js";
+import { diagnostic } from "./ui.js";
 import { sourceId } from "./types.js";
 const execFileAsync = promisify(execFile);
 export async function semChangeSetForCommand(command) {
     if (command.kind === "stdin")
-        return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem);
+        return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem, "stdin", ["stdin"]);
     if (command.kind === "staged") {
-        const diff = await stagedDiff();
+        const [diff, committer] = await Promise.all([stagedDiff(), gitUserLabel()]);
+        const committers = [committer];
         if (!diff.text.trim())
-            return emptyChangeSet("staged", diff.stats);
-        return semChangeSetFromPatch(diff.text, command.debugSem, "staged");
+            return emptyChangeSet("staged", diff.stats, committers);
+        return semChangeSetFromPatch(diff.text, command.debugSem, "staged", committers);
     }
     if (command.kind === "commit") {
         const range = await sourceRangeForCommit(command.commit);
@@ -27,12 +29,13 @@ export async function semChangeSetForCommand(command) {
     const raw = await cachedSemDiff(["diff", "--from", range.base, "--to", range.target, "--format", "json"], range, command.debugSem);
     return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
 }
-function emptyChangeSet(label, stats) {
+function emptyChangeSet(label, stats, committers) {
     return {
         id: sourceId(label),
         label,
         base: label,
         target: label,
+        committers,
         contextCwd: process.cwd(),
         cleanup: async () => undefined,
         changes: [],
@@ -56,7 +59,7 @@ async function semRangeForCommand(command) {
         return sourceRangeForRecentCommits(command.count);
     throw new Error("sem cannot resolve stdin as a git range.");
 }
-async function semChangeSetFromPatch(patch, debugSem, label = "stdin") {
+async function semChangeSetFromPatch(patch, debugSem, label = "stdin", committers) {
     if (!patch.trim())
         throw new Error("No diff received on stdin.");
     const raw = await cachedJson("sem-diff", fingerprint({
@@ -71,6 +74,7 @@ async function semChangeSetFromPatch(patch, debugSem, label = "stdin") {
             label,
             base: label,
             target: label,
+            committers,
             stats: { filesChanged: 0, additions: 0, deletions: 0 },
         }),
         contextCwd: process.cwd(),
@@ -105,7 +109,7 @@ async function withContextWorkspace(changeSet, debugSem) {
 }
 async function runSem(args, debugSem, cwd = process.cwd()) {
     if (debugSem)
-        console.error(`sem ${args.join(" ")}`);
+        diagnostic(`sem ${args.join(" ")}`);
     const { command, commandArgs } = resolveSemCommand(args);
     try {
         const { stdout, stderr } = await execFileAsync(command, commandArgs, {
@@ -113,7 +117,7 @@ async function runSem(args, debugSem, cwd = process.cwd()) {
             maxBuffer: 128 * 1024 * 1024,
         });
         if (debugSem && stderr.trim())
-            console.error(stderr.trim());
+            diagnostic(stderr.trim());
         return JSON.parse(stdout);
     }
     catch (error) {
@@ -123,7 +127,7 @@ async function runSem(args, debugSem, cwd = process.cwd()) {
 }
 async function runSemWithInput(args, stdin, debugSem) {
     if (debugSem)
-        console.error(`sem ${args.join(" ")}`);
+        diagnostic(`sem ${args.join(" ")}`);
     const { command, commandArgs } = resolveSemCommand(args);
     return new Promise((resolve, reject) => {
         const child = spawn(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
@@ -135,7 +139,7 @@ async function runSemWithInput(args, stdin, debugSem) {
         child.on("close", (code) => {
             const stderrText = Buffer.concat(stderr).toString("utf8");
             if (debugSem && stderrText.trim())
-                console.error(stderrText.trim());
+                diagnostic(stderrText.trim());
             if (code !== 0) {
                 reject(new Error(`sem failed with exit code ${code}${stderrText ? `: ${stderrText.trim()}` : ""}`));
                 return;
@@ -152,7 +156,7 @@ async function runSemWithInput(args, stdin, debugSem) {
 }
 async function git(args, debugSem) {
     if (debugSem)
-        console.error(`git ${args.join(" ")}`);
+        diagnostic(`git ${args.join(" ")}`);
     await execFileAsync("git", [...args], { maxBuffer: 128 * 1024 * 1024 });
 }
 async function cleanupWorktree(tempDir, worktreeAdded, debugSem) {
@@ -194,6 +198,7 @@ function normalizeSemDiff(value, range) {
         label: range.label,
         base: range.base,
         target: range.target,
+        committers: range.committers,
         contextCwd: process.cwd(),
         cleanup: async () => undefined,
         changes,

package/dist/stupify.d.ts

@@ -1,4 +1,38 @@
 #!/usr/bin/env node
 import type { SearchCommand, SearchRunJson } from "./types.ts";
 export declare function main(argv?: string[]): Promise<number>;
-export declare function runSearchCommand(command: SearchCommand, startedAt: number): Promise<SearchRunJson>;
+export declare function runSearchCommand(command: SearchCommand, startedAt: number, ui?: {
+    intro(title: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    outro(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    note(message: string, title?: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    info(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    step(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    success(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    warn(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    error(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): void;
+    debug(message: string): void;
+    confirm(message: string): Promise<boolean>;
+    spinner(message: string, logOptions?: Readonly<{
+        force?: boolean;
+    }>): import("@clack/prompts").SpinnerResult;
+    progress(message: string, max: number, logOptions?: Readonly<{
+        force?: boolean;
+    }>): import("@clack/prompts").ProgressResult;
+    writeStdout(text: string): void;
+}): Promise<SearchRunJson>;