@stupify/cli 0.0.14 → 0.0.16

package/dist/stupify.js

@@ -5,11 +5,12 @@ import { countPromptTokens, runSearch, searchRequest } from "./analysis.js";
 import { searchChecks } from "./checks.js";
 import { parseCommand } from "./command.js";
 import { counterScoutPlan } from "./counter-scout.js";
-import { runDoctor } from "./doctor.js";
-import { runHookCommand } from "./hooks.js";
+import { renderDoctorToUi, runDoctor } from "./doctor.js";
+import { blameEntity } from "./git.js";
+import { renderHookResultToUi, runHookCommand } from "./hooks.js";
 import { firstRunModelBootstrap, loadLocalModel } from "./model.js";
 import { entityContextsFromChanges, emptyContextPack, repomixContextPack, repomixSearchConfig } from "./repomix-provider.js";
-import { helpText, renderSearchRun } from "./render.js";
+import { helpText, renderSearchRun, renderSearchRunToUi } from "./render.js";
 import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
 import { semChangeSetForCommand } from "./sem-provider.js";
 import { createTracer } from "./trace.js";
@@ -20,26 +21,37 @@ export async function main(argv = process.argv.slice(2)) {
     try {
         const command = parseCommand(argv);
         if (command.kind === "help") {
-            ui.writeStdout(helpText());
+            ui.intro("stupify");
+            ui.note(helpText().trim(), "Help");
+            ui.outro("Local-only. Warn-only.");
             return 0;
         }
         if (command.kind === "hook") {
-            ui.writeStdout(await runHookCommand(command.action));
+            ui.intro("stupify");
+            renderHookResultToUi(await runHookCommand(command.action), ui);
+            ui.outro("Hook mode is warn-only. Commits are not blocked.");
             return 0;
         }
         if (command.kind === "doctor") {
             const result = await runDoctor();
-            ui.writeStdout(result.text);
+            ui.intro("stupify");
+            renderDoctorToUi(result, ui);
+            ui.outro(result.exitCode === 0 ? "Ready." : "Fix missing required dependencies, then rerun doctor.");
             return result.exitCode;
         }
         if (command.kind === "bench-search") {
             const { runSearchBench } = await import("./search-bench.js");
-            ui.writeStdout(await runSearchBench(command.configPath));
+            ui.intro("stupify");
+            ui.note(await runSearchBench(command.configPath), "Search bench");
+            ui.outro("Bench complete.");
             return 0;
         }
         ui = createCliUi({ quiet: command.json });
         const run = await runSearchCommand(command, startedAt, ui);
-        ui.writeStdout(renderSearchRun(run, command));
+        if (command.json)
+            ui.writeStdout(renderSearchRun(run, command));
+        else
+            renderSearchRunToUi(run, command, ui);
         return 0;
     }
     catch (error) {
@@ -48,12 +60,32 @@ export async function main(argv = process.argv.slice(2)) {
     }
 }
 export async function runSearchCommand(command, startedAt, ui = createCliUi({ quiet: command.json })) {
+    const activeSpans = new Map();
     const t = createTracer({
         writeLine: () => undefined,
         onEvent: (event) => {
             if (command.json)
                 return;
-            ui.step(formatStep(event.name, event.ms, event.count, event.detail));
+            if (event.phase === "start") {
+                activeSpans.set(event.name, ui.spinner(formatStartStep(event.name, event.detail)));
+                return;
+            }
+            const active = activeSpans.get(event.name);
+            activeSpans.delete(event.name);
+            const message = event.phase === "error"
+                ? formatErrorStep(event.name, event.ms)
+                : formatStep(event.name, event.ms, event.count, event.detail);
+            if (!active) {
+                if (event.phase === "error")
+                    ui.error(message);
+                else
+                    ui.step(message);
+                return;
+            }
+            if (event.phase === "error")
+                active.error(message);
+            else
+                active.stop(message);
         },
     });
     const profile = await loadSearchProfile(command.searchProfilePath);
@@ -85,6 +117,7 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
                     elapsedMs: Date.now() - startedAt,
                     modelCalls: 0,
                     committers: changeSet.committers,
+                    commitSubjects: changeSet.commitSubjects,
                     skipped: true,
                     skipReason: "no_candidates",
                     filesChanged: changeSet.summary.fileCount,
@@ -124,6 +157,7 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
                     elapsedMs: Date.now() - startedAt,
                     modelCalls: 0,
                     committers: changeSet.committers,
+                    commitSubjects: changeSet.commitSubjects,
                     skipped: true,
                     skipReason: "no_candidates",
                     filesChanged: changeSet.summary.fileCount,
@@ -143,7 +177,7 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
         const pack = profile?.context === "sem" || searchContexts.length === contexts.length
             ? initialPack
             : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-        const batches = await buildSearchBatches({
+        const { value: batches } = await t.trace("search.batches", () => buildSearchBatches({
             command,
             changeSet,
             contexts: searchContexts,
@@ -153,6 +187,12 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
             includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
             maxSearchInputTokens,
             baseRepomixConfig,
+        }), {
+            startDetail: `${searchContexts.length} targets`,
+            count: (result) => result.batches.length,
+            detail: (result) => result.wasSplit
+                ? `${result.skippedTargets} oversized targets skipped`
+                : `${result.estimatedInputTokens} estimated tokens`,
         });
         if (batches.batches.length === 0) {
             return {
@@ -167,6 +207,7 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
                     inputTokens: batches.estimatedInputTokens,
                     inputTokenCap: maxSearchInputTokens,
                     committers: changeSet.committers,
+                    commitSubjects: changeSet.commitSubjects,
                     skipped: true,
                     skipReason: "input_too_large",
                     filesChanged: changeSet.summary.fileCount,
@@ -201,7 +242,10 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
         let inputTokens = 0;
         let exactSkippedTargets = batches.skippedTargets;
         for (const batch of batches.batches) {
-            const batchInputTokens = await countPromptTokens(model, batch.request.prompt);
+            const { value: batchInputTokens } = await t.trace("prompt.tokens", () => countPromptTokens(model, batch.request.prompt), {
+                startDetail: `${batch.contexts.length} targets`,
+                count: (tokens) => tokens,
+            });
             inputTokens += batchInputTokens;
             if (batchInputTokens > maxSearchInputTokens) {
                 exactSkippedTargets += batch.contexts.length;
@@ -210,11 +254,14 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
                 }
                 continue;
             }
-            const { value } = await t.trace("search.model", () => runSearch(model, batch.request), { count: (v) => v.length });
+            const { value } = await t.trace("search.model", () => runSearch(model, batch.request), {
+                startDetail: `${batch.contexts.length} targets`,
+                count: (v) => v.length,
+            });
             modelCalls += 1;
             matches.push(...withCheckWhy(value, checks));
         }
-        const uniqueMatches = dedupeMatches(matches);
+        const uniqueMatches = await withEntityBlame(dedupeMatches(matches), changeSet.target, command);
         return {
             schemaVersion: "search.v1",
             mode: "search",
@@ -227,6 +274,7 @@ export async function runSearchCommand(command, startedAt, ui = createCliUi({ qu
                 inputTokens,
                 inputTokenCap: maxSearchInputTokens,
                 committers: changeSet.committers,
+                commitSubjects: changeSet.commitSubjects,
                 filesChanged: changeSet.summary.fileCount,
                 entitiesScanned: changeSet.summary.total,
                 candidates: contexts.length,
@@ -261,9 +309,24 @@ function withCheckWhy(matches, checks) {
     const checksById = new Map(checks.map((check) => [check.id, check]));
     return matches.map((match) => ({
         ...match,
+        patternName: checksById.get(match.patternId)?.name,
         checkWhy: checksById.get(match.patternId)?.why,
     }));
 }
+async function withEntityBlame(matches, targetRev, command) {
+    if (command.kind === "staged" || command.kind === "stdin")
+        return matches;
+    return Promise.all(matches.map(async (match) => {
+        if (!match.filePath || !match.entityName)
+            return match;
+        const blame = await blameEntity({
+            filePath: match.filePath,
+            entityName: match.entityName,
+            rev: targetRev,
+        });
+        return blame ? { ...match, blame } : match;
+    }));
+}
 async function buildSearchBatches(input) {
     const first = makeSearchBatch(input, input.contexts, input.initialPack);
     if (first.estimatedInputTokens <= input.maxSearchInputTokens) {
@@ -344,15 +407,45 @@ function printRunPlan(command, patternIds, ui) {
         `Patterns: ${patternIds.join(", ")}`,
     ].join("\n"), "Run");
 }
+function formatStartStep(name, detail) {
+    if (name === "entity.diff")
+        return "Diff: running sem over the selected git range";
+    if (name === "context.pack")
+        return "Context: packing selected target files with Repomix";
+    if (name === "search.batches")
+        return `Search: preparing token-bounded model batches${detail ? ` for ${detail}` : ""}`;
+    if (name === "prompt.tokens")
+        return `Tokens: counting search prompt${detail ? ` for ${detail}` : ""}`;
+    if (name === "search.model")
+        return `Model: searching selected target/check pairs${detail ? ` (${detail})` : ""}`;
+    return `${name}: working`;
+}
 function formatStep(name, ms, count, detail) {
     if (name === "entity.diff")
         return `Diff: ${detail ?? "changed files"}, ${count ?? 0} changed entities (${ms}ms)`;
     if (name === "context.pack")
         return `Context: ${count ?? 0} files, ${detail ?? "0 tokens"} (${ms}ms)`;
+    if (name === "search.batches")
+        return `Search: ${count ?? 0} model batches, ${detail ?? "0 estimated tokens"} (${ms}ms)`;
+    if (name === "prompt.tokens")
+        return `Tokens: ${count ?? 0} prompt tokens (${ms}ms)`;
     if (name === "search.model")
         return `Model: ${count ?? 0} matches (${ms}ms)`;
     return `${name}: ${ms}ms`;
 }
+function formatErrorStep(name, ms) {
+    if (name === "entity.diff")
+        return `Diff failed after ${ms}ms`;
+    if (name === "context.pack")
+        return `Context packing failed after ${ms}ms`;
+    if (name === "search.batches")
+        return `Search batch preparation failed after ${ms}ms`;
+    if (name === "prompt.tokens")
+        return `Token counting failed after ${ms}ms`;
+    if (name === "search.model")
+        return `Model search failed after ${ms}ms`;
+    return `${name} failed after ${ms}ms`;
+}
 function scoutPlanLine(plan, entitiesScanned) {
     if (plan.targets.length === 0) {
         return `Scout: deterministic counters scanned ${entitiesScanned} entities; no target/check pairs selected`;

package/dist/trace.d.ts

@@ -11,12 +11,14 @@ export type Tracer = {
 };
 export type SpanTraceEvent = Readonly<{
     name: string;
+    phase: "start" | "end" | "error";
     ms: number;
     count?: number;
     detail?: string;
 }>;
 export type SpanTraceOptions<T> = Readonly<{
     fields?: TraceFields;
+    startDetail?: string | (() => string);
     count?: (value: T) => number;
     detail?: (value: T) => string;
 }>;

package/dist/trace.js

@@ -16,6 +16,12 @@ export function createTracer(options) {
     }
     function trace(span, fn, options) {
         const startedAtMs = nowMs();
+        onEvent?.({
+            name: span,
+            phase: "start",
+            ms: 0,
+            detail: typeof options?.startDetail === "function" ? options.startDetail() : options?.startDetail,
+        });
         try {
             const out = fn();
             if (isPromiseLike(out)) {
@@ -26,6 +32,7 @@ export function createTracer(options) {
                         durationMs = nowMs() - startedAtMs;
                         const event = {
                             name: span,
+                            phase: "end",
                             ms: Math.round(durationMs),
                             count: options?.count?.(value),
                             detail: options?.detail?.(value),
@@ -33,6 +40,15 @@ export function createTracer(options) {
                         onEvent?.(event);
                         return { value, ms: event.ms };
                     }
+                    catch (error) {
+                        durationMs = nowMs() - startedAtMs;
+                        onEvent?.({
+                            name: span,
+                            phase: "error",
+                            ms: Math.round(durationMs),
+                        });
+                        throw error;
+                    }
                     finally {
                         durationMs ??= nowMs() - startedAtMs;
                         emit(span, durationMs, options?.fields);
@@ -43,6 +59,7 @@ export function createTracer(options) {
             emit(span, durationMs, options?.fields);
             const event = {
                 name: span,
+                phase: "end",
                 ms: Math.round(durationMs),
                 count: options?.count?.(out),
                 detail: options?.detail?.(out),
@@ -52,6 +69,11 @@ export function createTracer(options) {
         }
         catch (error) {
             const durationMs = nowMs() - startedAtMs;
+            onEvent?.({
+                name: span,
+                phase: "error",
+                ms: Math.round(durationMs),
+            });
             emit(span, durationMs, options?.fields);
             throw error;
         }

package/dist/types.d.ts

@@ -92,6 +92,11 @@ export type StagedDiff = Readonly<{
     text: string;
     stats: NetDiffStats;
 }>;
+export type BlameSummary = Readonly<{
+    commit: string;
+    author: string;
+    subject: string;
+}>;
 export type NetDiff = Readonly<{
     id: SourceId;
     label: string;
@@ -106,6 +111,7 @@ export type SourceRange = Readonly<{
     base: string;
     target: string;
     committers?: readonly string[];
+    commitSubjects?: readonly string[];
     stats: NetDiffStats;
 }>;
 export type SemChange = Readonly<{
@@ -132,6 +138,7 @@ export type SemChangeSet = Readonly<{
     base: string;
     target: string;
     committers?: readonly string[];
+    commitSubjects?: readonly string[];
     contextCwd: string;
     cleanup: () => Promise<void>;
     changes: readonly SemChange[];
@@ -197,10 +204,15 @@ export type SearchProfile = Readonly<{
 export type SearchMatch = Readonly<{
     targetId: string;
     patternId: CheckId;
+    patternName?: string;
     checkWhy?: string;
     reason: string;
     proof: string;
     snapshot?: string;
+    filePath?: string;
+    entityName?: string;
+    entityKind?: string;
+    blame?: BlameSummary;
 }>;
 export type SearchRunJson = Readonly<{
     schemaVersion: "search.v1";
@@ -218,6 +230,7 @@ export type SearchRunJson = Readonly<{
         skipped?: boolean;
         skipReason?: "input_too_large" | "no_candidates";
         committers?: readonly string[];
+        commitSubjects?: readonly string[];
         filesChanged?: number;
         entitiesScanned?: number;
         candidates?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Local-only diagnostic CLI for checking whether AI is making you dumber.",
   "private": false,
   "type": "module",
@@ -9,7 +9,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/Octember/stupif.ai.git",
+    "url": "git+https://github.com/Octember/stupif.ai.git",
     "directory": "packages/cli"
   },
   "homepage": "https://stupif.ai",
@@ -23,16 +23,18 @@
     "local-first",
     "code-review"
   ],
-  "license": "UNLICENSED",
+  "license": "MIT",
   "engines": {
     "node": ">=20"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "files": [
     "dist",
     "src",
+    "LICENSE",
     "README.md",
     "package.json"
   ],

package/src/analysis.ts

@@ -107,6 +107,9 @@ function uncheckedSearchMatches(value: unknown, contexts: readonly SemContext[])
       reason: match.reason ?? "",
       proof: sourcePointer(context),
       snapshot: sourceSnapshot(context),
+      filePath: context.filePath,
+      entityName: context.entityName,
+      entityKind: context.entityKind,
     }];
   });
 }

package/src/constants.ts

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.14";
+export const VERSION = "0.0.16";
 import type { ModelConfig, ModelId } from "./types.ts";
 
 export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";

package/src/doctor.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
 import { runHookCommand } from "./hooks.ts";
+import type { CliUi } from "./ui.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -17,7 +18,13 @@ type DoctorCheck = Readonly<{
   required?: boolean;
 }>;
 
-export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: string }>> {
+export type DoctorResult = Readonly<{
+  exitCode: number;
+  text: string;
+  checks: readonly DoctorCheck[];
+}>;
+
+export async function runDoctor(): Promise<DoctorResult> {
   const checks = await Promise.all([
     gitCheck(),
     hookCheck(),
@@ -30,9 +37,28 @@ export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: st
   return {
     exitCode: requiredMissing ? 1 : 0,
     text: renderDoctor(checks),
+    checks,
   };
 }
 
+export function renderDoctorToUi(result: DoctorResult, ui: CliUi): void {
+  const missingRequired = result.checks.filter((check) => check.required && check.status === "missing");
+  if (missingRequired.length > 0) {
+    ui.error(`Doctor found ${missingRequired.length} missing required dependency.`);
+  } else {
+    ui.success("Doctor checks complete.");
+  }
+
+  ui.note(
+    result.checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`).join("\n"),
+    "Doctor",
+  );
+  ui.note(
+    "Local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
+    "Privacy",
+  );
+}
+
 async function gitCheck(): Promise<DoctorCheck> {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });

package/src/git.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { sourceId, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
+import { sourceId, type BlameSummary, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -106,6 +106,27 @@ export async function gitUserLabel(): Promise<string> {
   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),
@@ -124,11 +145,12 @@ async function netDiff(base: string, target: string, label: string, id?: NetDiff
 }
 
 async function sourceRange(base: string, target: string, label: string, id?: SourceRange["id"]): Promise<SourceRange> {
-  const [stats, shortBase, shortTarget, committers] = await Promise.all([
+  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}`),
@@ -136,6 +158,7 @@ async function sourceRange(base: string, target: string, label: string, id?: Sou
     base,
     target,
     committers,
+    commitSubjects,
     stats,
   };
 }
@@ -160,6 +183,17 @@ async function committersForRange(base: string, target: string): Promise<readonl
   }
 }
 
+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[] = [];
@@ -304,3 +338,43 @@ async function commitMessage(commit: string): Promise<string> {
 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

@@ -5,6 +5,7 @@ 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";
@@ -16,6 +17,22 @@ export async function runHookCommand(action: HookAction): Promise<string> {
   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");
 }