@stupify/cli 0.0.2 → 0.0.4

package/dist/types.d.ts

@@ -0,0 +1,320 @@
+declare const brand: unique symbol;
+type Brand<Value, Name extends string> = Value & {
+    readonly [brand]: Name;
+};
+export type SourceId = Brand<string, "SourceId">;
+export type CheckId = Brand<string, "CheckId">;
+export declare function sourceId(value: string): SourceId;
+export declare function checkId(value: string): CheckId;
+export type SearchMode = "warn" | "off";
+export type HookAction = "install" | "uninstall" | "status";
+export type SearchSource = "since" | "stdin" | "commit" | "commits" | "staged";
+type SearchOptions = Readonly<{
+    checkIds: readonly string[] | null;
+    json: boolean;
+    model: ModelId;
+    debugSem: boolean;
+    maxCandidates: number;
+    maxSearchInputTokens: number;
+    searchProfilePath: string | null;
+    includeCounterReasonInPrompt: boolean;
+}>;
+export type Command = Readonly<{
+    kind: "help";
+}> | Readonly<{
+    kind: "hook";
+    action: HookAction;
+}> | Readonly<{
+    kind: "doctor";
+}> | Readonly<{
+    kind: "bench-search";
+    configPath: string;
+}> | (Readonly<{
+    kind: "since";
+    since: string;
+    mode: "search";
+    source: "since";
+}> & SearchOptions) | (Readonly<{
+    kind: "stdin";
+    mode: "search";
+    source: "stdin";
+}> & SearchOptions) | (Readonly<{
+    kind: "commit";
+    commit: string;
+    mode: "search";
+    source: "commit";
+}> & SearchOptions) | (Readonly<{
+    kind: "commits";
+    count: number;
+    mode: "search";
+    source: "commits";
+}> & SearchOptions) | (Readonly<{
+    kind: "staged";
+    mode: "search";
+    source: "staged";
+}> & SearchOptions);
+export type SearchCommand = Exclude<Command, Readonly<{
+    kind: "help";
+}> | Readonly<{
+    kind: "hook";
+    action: HookAction;
+}> | Readonly<{
+    kind: "doctor";
+}> | Readonly<{
+    kind: "bench-search";
+    configPath: string;
+}>>;
+export type StupifyCheck = Readonly<{
+    id: CheckId;
+    name: string;
+    question: string;
+    lookFor: readonly string[];
+    ignoreWhen: readonly string[];
+    enabledByDefault?: boolean;
+    hookMode?: SearchMode;
+    searchPrompt?: string;
+    searchExamples?: Readonly<{
+        match: readonly string[];
+        nonMatch: readonly string[];
+    }>;
+    examples?: Readonly<{
+        match?: readonly string[];
+        noMatch?: readonly string[];
+    }>;
+}>;
+export type NetDiffStats = Readonly<{
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+}>;
+export type StagedDiff = Readonly<{
+    text: string;
+    stats: NetDiffStats;
+}>;
+export type NetDiff = Readonly<{
+    id: SourceId;
+    label: string;
+    base: string;
+    target: string;
+    text: string;
+    stats: NetDiffStats;
+}>;
+export type SourceRange = Readonly<{
+    id: SourceId;
+    label: string;
+    base: string;
+    target: string;
+    stats: NetDiffStats;
+}>;
+export type SemChange = Readonly<{
+    entityId: string;
+    entityName: string;
+    entityType: string;
+    filePath: string;
+    changeType: string;
+    beforeContent: string | null;
+    afterContent: string | null;
+}>;
+export type SemChangeSummary = Readonly<{
+    added: number;
+    deleted: number;
+    modified: number;
+    moved: number;
+    renamed: number;
+    fileCount: number;
+    total: number;
+}>;
+export type SemChangeSet = Readonly<{
+    id: SourceId;
+    label: string;
+    base: string;
+    target: string;
+    contextCwd: string;
+    cleanup: () => Promise<void>;
+    changes: readonly SemChange[];
+    summary: SemChangeSummary;
+}>;
+export type SemCandidate = Readonly<{
+    sourceId: SourceId;
+    targetId: string;
+    entityId: string;
+    checkId: CheckId;
+    reason: string;
+}>;
+export type SemContext = Readonly<{
+    targetId: string;
+    entityId: string;
+    entityName: string;
+    entityKind: string;
+    changeKind: string;
+    checkId: CheckId;
+    reason: string;
+    filePath?: string;
+    text: string;
+}>;
+export type SemContextPack = Readonly<{
+    provider: "repomix";
+    filePaths: readonly string[];
+    totalCharacters: number;
+    totalTokens: number;
+    text: string;
+    config: RepomixSearchConfig;
+}>;
+export type RepomixSearchConfig = Readonly<{
+    compress: boolean;
+    showLineNumbers: boolean;
+    removeEmptyLines: boolean;
+    maxFileSizeBytes: number;
+    maxTotalSizeBytes: number;
+    ignorePatterns: readonly string[];
+}>;
+export type SearchProfileRepomixConfig = Readonly<{
+    compress?: boolean;
+    showLineNumbers?: boolean;
+    removeEmptyLines?: boolean;
+    maxFileBytes?: number;
+    maxTotalBytes?: number;
+    ignorePatterns?: readonly string[];
+}>;
+export type SearchProfilePattern = Readonly<{
+    enabled?: boolean;
+    searchPrompt?: string;
+    matchExamples?: readonly string[];
+    nonMatchExamples?: readonly string[];
+}>;
+export type SearchProfile = Readonly<{
+    id: string;
+    context?: "repomix" | "sem";
+    maxCandidates?: number;
+    maxSearchInputTokens?: number;
+    includeCounterReasonInPrompt?: boolean;
+    repomix?: SearchProfileRepomixConfig;
+    patterns?: Readonly<Record<string, SearchProfilePattern>>;
+}>;
+export type SearchMatch = Readonly<{
+    targetId: string;
+    patternId: CheckId;
+    reason: string;
+    proof: string;
+}>;
+export type SearchRunJson = Readonly<{
+    schemaVersion: "search.v1";
+    mode: "search";
+    source: SearchSource;
+    model: Readonly<{
+        id: ModelId;
+    }>;
+    patterns: readonly CheckId[];
+    stats: Readonly<{
+        elapsedMs: number;
+        modelCalls: number;
+        inputTokens?: number;
+        inputTokenCap?: number;
+        skipped?: boolean;
+        skipReason?: "input_too_large" | "no_candidates";
+        filesChanged?: number;
+        entitiesScanned?: number;
+        candidates?: number;
+        repomixFiles?: number;
+        repomixTokens?: number;
+        repomixConfig?: RepomixSearchConfig;
+        searchTargets?: number;
+        profileId?: string;
+        targetsByPattern?: Readonly<Record<string, number>>;
+        targetsPreview?: readonly SearchTargetPreview[];
+    }>;
+    matches: readonly SearchMatch[];
+}>;
+export type SearchTargetPreview = Readonly<{
+    targetId: string;
+    patternId: CheckId;
+    entityKind?: string;
+    sourceKind?: string;
+}>;
+export type SearchBenchConfig = Readonly<{
+    name: string;
+    profiles: readonly string[];
+    fixtures: string;
+    realSmokeRuns?: readonly SearchBenchSmokeRun[];
+    realCommitReplay?: readonly SearchBenchCommitReplay[];
+}>;
+export type SearchBenchSmokeRun = Readonly<{
+    id: string;
+    cwd?: string;
+    args: readonly string[];
+}>;
+export type SearchBenchCommitReplay = Readonly<{
+    id: string;
+    repoEnv?: string;
+    cwd?: string;
+    limit: number;
+    since?: string;
+    nonMerge?: boolean;
+    profiles: readonly string[];
+}>;
+export type SearchFixture = Readonly<{
+    id: string;
+    description: string;
+    stagedPatch: string;
+    checks: readonly string[];
+    expected: readonly SearchFixtureExpectation[];
+}>;
+export type SearchFixtureExpectation = Readonly<{
+    patternId: string;
+    shouldMatch: boolean;
+}>;
+export type SearchBenchRun = Readonly<{
+    profileId: string;
+    fixtureId?: string;
+    smokeId?: string;
+    elapsedMs: number;
+    modelCalls: number;
+    patterns: readonly CheckId[];
+    targets: number;
+    targetsByPattern: Readonly<Record<string, number>>;
+    inputTokens: number;
+    repomixPackedTokens?: number;
+    skipped: boolean;
+    skipReason?: string;
+    matches: readonly SearchMatch[];
+    expected?: readonly SearchFixtureExpectation[];
+    score?: number;
+    targetsPreview: readonly SearchTargetPreview[];
+    matchesUsingCounterReasonAsProof: number;
+    error?: string;
+}>;
+export type SearchBenchReplayRun = Readonly<{
+    profileId: string;
+    replayId: string;
+    commitId: string;
+    outcome: SearchReplayOutcome;
+    changedFiles: number;
+    addedLines: number;
+    deletedLines: number;
+    elapsedMs: number;
+    skipped: boolean;
+    skipReason?: string;
+    targets: number;
+    inputTokens: number;
+    repomixPackedTokens?: number;
+    modelCalls: number;
+    matches: readonly SearchMatch[];
+    matchesByPattern: Readonly<Record<string, number>>;
+    error?: string;
+}>;
+export type SearchReplayOutcome = "no_candidates" | "ran_no_matches" | "ran_with_matches" | "skipped_input_too_large" | "error";
+export type ModelId = "gemma-4-e2b" | "gemma-4-e4b" | "gemma-4-26b-a4b" | "qwen3-4b-magicquant" | "qwen2.5-coder-1.5b" | "qwen2.5-coder-7b" | "qwen2.5-coder-32b";
+export type ModelConfig = Readonly<{
+    id: ModelId;
+    name: string;
+    file: string;
+    url: string;
+    size: string;
+}>;
+export type TraceEvent = Readonly<{
+    name: string;
+    ms: number;
+    count?: number;
+    detail?: string;
+}>;
+export {};

package/dist/types.js

@@ -0,0 +1,6 @@
+export function sourceId(value) {
+    return value;
+}
+export function checkId(value) {
+    return value;
+}

package/package.json

@@ -1,12 +1,49 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.2",
-  "description": "stupif.ai CLI",
+  "version": "0.0.4",
+  "description": "Local-only diagnostic CLI for checking whether AI is making you dumber.",
+  "private": false,
+  "type": "module",
   "bin": {
-    "stupify": "./bin/stupify.mjs"
+    "stupify": "dist/stupify.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/Octember/stupif.ai.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://stupif.ai",
+  "bugs": {
+    "url": "https://github.com/Octember/stupif.ai/issues"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "developer-tools",
+    "local-first",
+    "code-review"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
-    "bin"
+    "dist",
+    "src",
+    "README.md",
+    "package.json"
   ],
-  "license": "MIT"
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "bun run build",
+    "typecheck": "tsc -p tsconfig.json",
+    "smoke": "bun run build && node ./dist/stupify.js --help"
+  },
+  "dependencies": {
+    "@ataraxy-labs/sem": "^0.3.24",
+    "repomix": "^1.14.0"
+  }
 }

package/src/analysis.ts

@@ -0,0 +1,188 @@
+import { cachedJson, fingerprint } from "./cache.ts";
+import type { LocalModel } from "./model.ts";
+import { searchPrompt } from "./prompts.ts";
+import type { SearchMatch, SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
+
+export async function runSearch(
+  model: LocalModel,
+  request: SearchRequest,
+): Promise<readonly SearchMatch[]> {
+  const raw = await runJsonPrompt(model, request.prompt, request.schema, 0);
+  return uncheckedSearchMatches(raw, request.contexts);
+}
+
+export type SearchRequest = Readonly<{
+  prompt: string;
+  schema: unknown;
+  contexts: readonly SemContext[];
+}>;
+
+export function searchRequest(input: Readonly<{
+  changeSet: SemChangeSet;
+  contexts: readonly SemContext[];
+  pack: SemContextPack;
+  patterns: readonly StupifyCheck[];
+  includeCounterReasonInPrompt?: boolean;
+}>): SearchRequest {
+  return {
+    prompt: searchPrompt({
+      ...input,
+      includeCounterReason: input.includeCounterReasonInPrompt ?? false,
+    }),
+    schema: searchSchema(input.contexts),
+    contexts: input.contexts,
+  };
+}
+
+export async function countPromptTokens(model: LocalModel, prompt: string): Promise<number> {
+  const cached = await cachedJson(
+    "prompt-tokens",
+    fingerprint({
+      version: 1,
+      modelId: model.id,
+      profile: model.profile,
+      prompt,
+    }),
+    async () => {
+      const response = await fetch(`${model.baseUrl}/tokenize`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ content: prompt }),
+      });
+      if (!response.ok) {
+        throw new Error(`llama-server tokenize failed: HTTP ${response.status} ${await response.text()}`);
+      }
+      const body = await response.json() as { tokens?: unknown };
+      if (!Array.isArray(body.tokens)) throw new Error("llama-server tokenize returned no tokens.");
+      return { count: body.tokens.length };
+    },
+  );
+  return cached.count;
+}
+
+function searchSchema(contexts: readonly SemContext[]): unknown {
+  return {
+    type: "object",
+    properties: {
+      matches: {
+        type: "array",
+        maxItems: 5,
+        items: {
+          type: "object",
+          properties: {
+            targetId: { type: "string", enum: contexts.map((context) => context.targetId) },
+            reason: { type: "string" },
+            proof: { type: "string" },
+          },
+          required: ["targetId", "reason", "proof"],
+          additionalProperties: false,
+        },
+      },
+    },
+    required: ["matches"],
+    additionalProperties: false,
+  };
+}
+
+type RawSearchOutput = Readonly<{
+  matches?: readonly RawSearchMatch[];
+}>;
+type RawSearchMatch = Readonly<{
+  targetId?: string;
+  reason?: string;
+  proof?: string;
+}>;
+
+function uncheckedSearchMatches(value: unknown, contexts: readonly SemContext[]): readonly SearchMatch[] {
+  const output = value as RawSearchOutput;
+  const contextsByTargetId = new Map(contexts.map((context) => [context.targetId, context]));
+  return (output.matches ?? []).flatMap((match): readonly SearchMatch[] => {
+    const targetId = match.targetId ?? "";
+    const context = contextsByTargetId.get(targetId);
+    if (!context) return [];
+    return [{
+      targetId,
+      patternId: context.checkId,
+      reason: match.reason ?? "",
+      proof: match.proof ?? "",
+    }];
+  });
+}
+
+async function runJsonPrompt(
+  model: LocalModel,
+  prompt: string,
+  schema: unknown,
+  temperature: number,
+): Promise<unknown> {
+  return cachedJson(
+    "model-json",
+    fingerprint({
+      version: 1,
+      modelId: model.id,
+      profile: model.profile,
+      prompt,
+      schema,
+      temperature,
+    }),
+    () => runJsonPromptUncached(model, prompt, schema, temperature),
+  );
+}
+
+async function runJsonPromptUncached(
+  model: LocalModel,
+  prompt: string,
+  schema: unknown,
+  temperature: number,
+): Promise<unknown> {
+  const first = await complete(model, prompt, schema, temperature);
+  const parsed = parseJson(first);
+  if (parsed.ok) return parsed.value;
+
+  const retry = await complete(model, `${prompt}
+
+Your previous response was not valid JSON. Return the requested JSON object only.`, schema, temperature);
+  const retryParsed = parseJson(retry);
+  if (retryParsed.ok) return retryParsed.value;
+
+  console.error("Raw model output:");
+  console.error(retry);
+  throw new Error("Model returned invalid JSON.");
+}
+
+async function complete(
+  model: LocalModel,
+  prompt: string,
+  schema: unknown,
+  temperature: number,
+): Promise<string> {
+  const response = await fetch(`${model.baseUrl}/v1/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      model: model.id,
+      messages: [{ role: "user", content: prompt }],
+      temperature,
+      response_format: {
+        type: "json_object",
+        schema,
+      },
+    }),
+  });
+
+  if (!response.ok) throw new Error(`llama-server request failed: HTTP ${response.status} ${await response.text()}`);
+
+  const body = await response.json() as { choices?: Array<{ message?: { content?: unknown } }> };
+  const content = body.choices?.[0]?.message?.content;
+  if (typeof content !== "string") throw new Error("llama-server returned no message content.");
+  return content;
+}
+
+function parseJson(raw: string): Readonly<{ ok: true; value: unknown }> | Readonly<{ ok: false }> {
+  try {
+    const value = JSON.parse(raw);
+    return { ok: true, value };
+  } catch {
+    return { ok: false };
+  }
+}

package/src/cache.ts

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+
+export function fingerprint(value: unknown): string {
+  const text = typeof value === "string" ? value : stableStringify(value);
+  return createHash("sha256").update(text).digest("hex");
+}
+
+export async function cachedJson<T>(
+  namespace: string,
+  key: string,
+  compute: () => Promise<T>,
+): Promise<T> {
+  const filePath = cachePath(namespace, key);
+  try {
+    const value = JSON.parse(await readFile(filePath, "utf8")) as T;
+    console.error(`cache hit ${namespace} ${key.slice(0, 12)}`);
+    return value;
+  } catch {
+    console.error(`cache miss ${namespace} ${key.slice(0, 12)}`);
+  }
+
+  const value = await compute();
+  await writeCache(filePath, value).catch(() => undefined);
+  return value;
+}
+
+function cachePath(namespace: string, key: string): string {
+  return path.join(cacheRoot(), "intermediate-v1", safeNamespace(namespace), `${key}.json`);
+}
+
+async function writeCache(filePath: string, value: unknown): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(value), "utf8");
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true });
+    throw error;
+  }
+}
+
+function cacheRoot(): string {
+  if (process.env.STUPIFY_CACHE_DIR) return process.env.STUPIFY_CACHE_DIR;
+  if (process.env.XDG_CACHE_HOME) return path.join(process.env.XDG_CACHE_HOME, "stupify");
+  if (platform() === "darwin") return path.join(homedir(), "Library", "Caches", "stupify");
+  if (platform() === "win32" && process.env.LOCALAPPDATA) return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
+  return path.join(homedir(), ".cache", "stupify");
+}
+
+function safeNamespace(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const record = value as Record<string, unknown>;
+  return `{${Object.keys(record).sort().map((key) =>
+    `${JSON.stringify(key)}:${stableStringify(record[key])}`
+  ).join(",")}}`;
+}