@stupify/cli 0.0.14 → 0.0.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stupify contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,6 +2,8 @@
 
 Local-only diagnostic CLI for checking whether AI is making you dumber.
 
+Released under the MIT License.
+
 Stupify has one analysis path:
 
 ```text
@@ -48,7 +50,8 @@ stupify --staged --max-search-input-tokens 24000
 ```
 
 The package is prepared for the public `@stupify` npm scope. Publishing should
-run the TypeScript build first so the executable points at `dist/stupify.js`.
+use the repository release workflow so npm receives Trusted Publishing
+provenance. See the repository release docs.
 
 This iteration intentionally does not run findings audit, validators, judges,
 baselines, hosted LLM APIs, GitHub integration, dashboards, or repo-wide

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.0.14";
+export declare const VERSION = "0.0.15";
 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.14";
+export const VERSION = "0.0.15";
 export const DEFAULT_MODEL_ID = "gemma-4-e2b";
 export const MODEL_REGISTRY = {
     "gemma-4-e2b": {

package/dist/stupify.js

@@ -48,12 +48,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);
@@ -143,7 +163,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 +173,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 {
@@ -201,7 +227,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,7 +239,10 @@ 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));
         }
@@ -344,15 +376,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "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/constants.ts

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

package/src/stupify.ts

@@ -59,11 +59,28 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
 }
 
 export async function runSearchCommand(command: SearchCommand, startedAt: number, ui = createCliUi({ quiet: command.json })): Promise<SearchRunJson> {
+  const activeSpans = new Map<string, ReturnType<CliUi["spinner"]>>();
   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);
     },
   });
 
@@ -162,17 +179,27 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     const pack = profile?.context === "sem" || searchContexts.length === contexts.length
       ? initialPack
       : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-    const batches = await buildSearchBatches({
-      command,
-      changeSet,
-      contexts: searchContexts,
-      initialPack: pack,
-      checks,
-      profile,
-      includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
-      maxSearchInputTokens,
-      baseRepomixConfig,
-    });
+    const { value: batches } = await t.trace(
+      "search.batches",
+      () => buildSearchBatches({
+        command,
+        changeSet,
+        contexts: searchContexts,
+        initialPack: pack,
+        checks,
+        profile,
+        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 {
@@ -222,7 +249,14 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     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;
@@ -234,7 +268,10 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       const { value } = await t.trace(
         "search.model",
         () => runSearch(model, batch.request),
-        { count: (v) => v.length },
+        {
+          startDetail: `${batch.contexts.length} targets`,
+          count: (v) => v.length,
+        },
       );
       modelCalls += 1;
       matches.push(...withCheckWhy(value, checks));
@@ -441,13 +478,33 @@ function printRunPlan(
   );
 }
 
+function formatStartStep(name: string, detail?: string): string {
+  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: string, ms: number, count?: number, detail?: string): string {
   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: string, ms: number): string {
+  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: CounterScoutPlan, entitiesScanned: number): string {
   if (plan.targets.length === 0) {
     return `Scout: deterministic counters scanned ${entitiesScanned} entities; no target/check pairs selected`;

package/src/trace.ts

@@ -9,6 +9,7 @@ export type Tracer = {
 
 export type SpanTraceEvent = Readonly<{
   name: string;
+  phase: "start" | "end" | "error";
   ms: number;
   count?: number;
   detail?: string;
@@ -16,6 +17,7 @@ export type SpanTraceEvent = Readonly<{
 
 export type SpanTraceOptions<T> = Readonly<{
   fields?: TraceFields;
+  startDetail?: string | (() => string);
   count?: (value: T) => number;
   detail?: (value: T) => string;
 }>;
@@ -53,6 +55,12 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
     options?: SpanTraceOptions<T>,
   ): Promise<{ value: T; ms: number }> | { value: T; ms: number } {
     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)) {
@@ -63,12 +71,21 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
             durationMs = nowMs() - startedAtMs;
             const event: SpanTraceEvent = {
               name: span,
+              phase: "end",
               ms: Math.round(durationMs),
               count: options?.count?.(value),
               detail: options?.detail?.(value),
             };
             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);
@@ -80,6 +97,7 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
       emit(span, durationMs, options?.fields);
       const event: SpanTraceEvent = {
         name: span,
+        phase: "end",
         ms: Math.round(durationMs),
         count: options?.count?.(out),
         detail: options?.detail?.(out),
@@ -88,6 +106,11 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
       return { value: out, ms: event.ms };
     } catch (error) {
       const durationMs = nowMs() - startedAtMs;
+      onEvent?.({
+        name: span,
+        phase: "error",
+        ms: Math.round(durationMs),
+      });
       emit(span, durationMs, options?.fields);
       throw error;
     }