@stupify/cli 0.0.9 → 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.9";
+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.9";
+export const VERSION = "0.0.10";
 export const DEFAULT_MODEL_ID = "gemma-4-e2b";
 export const MODEL_REGISTRY = {
     "gemma-4-e2b": {

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,40 +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 🪄
-AI SLOP DETECTED
+    return `${format.warn("AI SLOP DETECTED")}
 ${run.matches.map((match, index) => `${index + 1}.
-   who: ${committerLabel(run)}
-   what: ${match.patternId} - ${match.reason}
-   when: ${sourceLabel(command)}
-   where: ${match.proof}
-   why: ${match.checkWhy ?? "This pattern may indicate judgment-offload."}`).join("\n")}
-Search mode is warn-only.`;
+   ${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}

package/dist/sem-provider.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import { cachedJson, fingerprint } from "./cache.js";
 import { readDiffFromStdin } from "./diff.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) {
@@ -108,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, {
@@ -116,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) {
@@ -126,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"] });
@@ -138,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;
@@ -155,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) {

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>;

package/dist/stupify.js

@@ -13,44 +13,47 @@ import { helpText, renderSearchRun } from "./render.js";
 import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
 import { semChangeSetForCommand } from "./sem-provider.js";
 import { createTracer } from "./trace.js";
+import { createCliUi } from "./ui.js";
 export async function main(argv = process.argv.slice(2)) {
     const startedAt = Date.now();
+    let ui = createCliUi();
     try {
         const command = parseCommand(argv);
         if (command.kind === "help") {
-            console.log(helpText());
+            ui.writeStdout(helpText());
             return 0;
         }
         if (command.kind === "hook") {
-            console.log(await runHookCommand(command.action));
+            ui.writeStdout(await runHookCommand(command.action));
             return 0;
         }
         if (command.kind === "doctor") {
             const result = await runDoctor();
-            console.log(result.text);
+            ui.writeStdout(result.text);
             return result.exitCode;
         }
         if (command.kind === "bench-search") {
             const { runSearchBench } = await import("./search-bench.js");
-            console.log(await runSearchBench(command.configPath));
+            ui.writeStdout(await runSearchBench(command.configPath));
             return 0;
         }
-        const run = await runSearchCommand(command, startedAt);
-        console.log(renderSearchRun(run, command));
+        ui = createCliUi({ quiet: command.json });
+        const run = await runSearchCommand(command, startedAt, ui);
+        ui.writeStdout(renderSearchRun(run, command));
         return 0;
     }
     catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
+        ui.error(error instanceof Error ? error.message : String(error), { force: true });
         return 1;
     }
 }
-export async function runSearchCommand(command, startedAt) {
+export async function runSearchCommand(command, startedAt, ui = createCliUi({ quiet: command.json })) {
     const t = createTracer({
         writeLine: () => undefined,
         onEvent: (event) => {
             if (command.json)
                 return;
-            console.error(formatStep(event.name, event.ms, event.count, event.detail));
+            ui.step(formatStep(event.name, event.ms, event.count, event.detail));
         },
     });
     const profile = await loadSearchProfile(command.searchProfilePath);
@@ -58,7 +61,7 @@ export async function runSearchCommand(command, startedAt) {
     const patternIds = checks.map((check) => check.id);
     const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
     const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
-    printRunPlan(command, patternIds);
+    printRunPlan(command, patternIds, ui);
     const { value: changeSet } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
         count: (v) => v.summary.total,
         detail: (v) => `${v.summary.fileCount} files`,
@@ -178,13 +181,13 @@ export async function runSearchCommand(command, startedAt) {
             };
         }
         if (batches.wasSplit && !command.json) {
-            console.error(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
+            ui.warn(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
             if (batches.skippedTargets > 0) {
-                console.error(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
+                ui.warn(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
             }
         }
-        const modelPath = await firstRunModelBootstrap(command.model);
-        const model = await loadLocalModel(modelPath, command.model, "scout");
+        const modelPath = await firstRunModelBootstrap(command.model, ui);
+        const model = await loadLocalModel(modelPath, command.model, "scout", ui);
         const matches = [];
         let modelCalls = 0;
         let inputTokens = 0;
@@ -195,7 +198,7 @@ export async function runSearchCommand(command, startedAt) {
             if (batchInputTokens > maxSearchInputTokens) {
                 exactSkippedTargets += batch.contexts.length;
                 if (!command.json) {
-                    console.error(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
+                    ui.warn(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
                 }
                 continue;
             }
@@ -324,12 +327,14 @@ function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includ
         includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
     });
 }
-function printRunPlan(command, patternIds) {
+function printRunPlan(command, patternIds, ui) {
     if (command.json)
         return;
-    console.error("🧙 stupify 🪄");
-    console.error(`Search: ${sourceLabel(command)}`);
-    console.error(`Patterns: ${patternIds.join(", ")}`);
+    ui.intro("stupify");
+    ui.note([
+        `Search: ${sourceLabel(command)}`,
+        `Patterns: ${patternIds.join(", ")}`,
+    ].join("\n"), "Run");
 }
 function formatStep(name, ms, count, detail) {
     if (name === "entity.diff")

package/dist/ui.d.ts

@@ -0,0 +1,34 @@
+import { type SpinnerResult } from "@clack/prompts";
+export type CliUi = ReturnType<typeof createCliUi>;
+export type CliUiOptions = Readonly<{
+    quiet?: boolean;
+}>;
+type LogOptions = Readonly<{
+    force?: boolean;
+}>;
+export declare function createCliUi(options?: CliUiOptions): {
+    intro(title: string, logOptions?: LogOptions): void;
+    outro(message: string, logOptions?: LogOptions): void;
+    note(message: string, title?: string, logOptions?: LogOptions): void;
+    info(message: string, logOptions?: LogOptions): void;
+    step(message: string, logOptions?: LogOptions): void;
+    success(message: string, logOptions?: LogOptions): void;
+    warn(message: string, logOptions?: LogOptions): void;
+    error(message: string, logOptions?: LogOptions): void;
+    debug(message: string): void;
+    confirm(message: string): Promise<boolean>;
+    spinner(message: string, logOptions?: LogOptions): SpinnerResult;
+    progress(message: string, max: number, logOptions?: LogOptions): import("@clack/prompts").ProgressResult;
+    writeStdout(text: string): void;
+};
+export declare const format: {
+    heading: (value: string) => string;
+    label: (value: string) => string;
+    muted: (value: string) => string;
+    success: (value: string) => string;
+    warn: (value: string) => string;
+    error: (value: string) => string;
+};
+export declare function diagnostic(message: string): void;
+export declare function diagnosticError(message: string): void;
+export {};