@stupify/cli 0.0.3 → 0.0.5

package/src/hooks.ts

@@ -0,0 +1,134 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { gitPath, gitRoot } from "./git.ts";
+import type { HookAction } from "./types.ts";
+
+const execFileAsync = promisify(execFile);
+const START = "# stupify hook start";
+const END = "# stupify hook end";
+
+export async function runHookCommand(action: HookAction): Promise<string> {
+  if (action === "status") return hookStatus();
+  if (action === "install") return installHook();
+  return uninstallHook();
+}
+
+export function hookSnippet(): string {
+  return managedBlock("stupify --staged");
+}
+
+async function hookStatus(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  if (!existsSync(hookPath)) return "Stupify hook: not installed";
+
+  const content = await readFile(hookPath, "utf8");
+  if (hasManagedBlock(content)) return "Stupify hook: installed";
+  return "Stupify hook: existing non-Stupify pre-commit hook found";
+}
+
+async function installHook(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  const block = await managedBlockForInstall();
+  if (!existsSync(hookPath)) {
+    await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: installed";
+  }
+
+  const content = await readFile(hookPath, "utf8");
+  if (hasManagedBlock(content)) {
+    await writeFile(hookPath, `${replaceManagedBlock(content, block).trimEnd()}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: updated";
+  }
+
+  if (isEffectivelyEmptyHook(content)) {
+    await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: installed";
+  }
+
+  return `Stupify hook: existing non-Stupify pre-commit hook found; not modified.
+Add this snippet manually if you want Stupify in that hook:
+${block}`;
+}
+
+async function uninstallHook(): Promise<string> {
+  const hookPath = await preCommitHookPath();
+  if (!existsSync(hookPath)) return "Stupify hook: not installed";
+
+  const content = await readFile(hookPath, "utf8");
+  if (!hasManagedBlock(content)) return "Stupify hook: not installed";
+
+  const next = replaceManagedBlock(content, "").trim();
+  if (isEffectivelyEmptyHook(next)) {
+    await rm(hookPath, { force: true });
+    return "Stupify hook: uninstalled";
+  }
+
+  await writeFile(hookPath, `${next}\n`, "utf8");
+  await chmod(hookPath, 0o755);
+  return "Stupify hook: uninstalled";
+}
+
+async function preCommitHookPath(): Promise<string> {
+  const [root, hook] = await Promise.all([gitRoot(), gitPath("hooks/pre-commit")]);
+  return path.isAbsolute(hook) ? hook : path.join(root, hook);
+}
+
+function hasManagedBlock(content: string): boolean {
+  return content.includes(START) && content.includes(END);
+}
+
+async function managedBlockForInstall(): Promise<string> {
+  if (await commandExists("stupify")) return managedBlock("stupify --staged");
+
+  const root = await gitRoot();
+  const localEntrypoint = path.join(root, "packages", "cli", "src", "stupify.ts");
+  if (existsSync(localEntrypoint) && await commandExists("bun")) {
+    return managedBlock(`bun ${shellQuote(localEntrypoint)} --staged`);
+  }
+
+  return managedBlock("stupify --staged");
+}
+
+function managedBlock(command: string): string {
+  return `${START}
+${command} || true
+${END}`;
+}
+
+function replaceManagedBlock(content: string, replacement: string): string {
+  const pattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}`);
+  return content.replace(pattern, replacement);
+}
+
+function isEffectivelyEmptyHook(content: string): boolean {
+  return content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && line !== "#!/bin/sh" && line !== "#!/usr/bin/env sh")
+    .length === 0;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], {
+      maxBuffer: 1024 * 1024,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/model.ts

@@ -24,14 +24,22 @@ import type { ModelId } from "./types.ts";
 const execFileAsync = promisify(execFile);
 const LLAMA_SERVER_HOST = "127.0.0.1";
 
-export type ModelProfile = "scout" | "audit";
+export type ModelProfile = "scout";
 
 type ModelRuntime = Readonly<{
   profile: ModelProfile;
   baseUrl: string;
   port: string;
+  contextSize: number;
   reasoning: "on" | "off" | "auto";
   reasoningBudget?: number;
+  gpuLayers?: number;
+  batchSize?: number;
+  ubatchSize?: number;
+  parallel?: number;
+  threads?: number;
+  threadsBatch?: number;
+  flashAttention?: boolean;
 }>;
 
 export type LocalModel = Readonly<{
@@ -41,13 +49,6 @@ export type LocalModel = Readonly<{
   profile: ModelProfile;
 }>;
 
-export async function loadLocalModels(modelId: ModelId) {
-  const modelPath = await firstRunModelBootstrap(modelId);
-  const scoutModel = await loadLocalModel(modelPath, modelId, "scout");
-  const auditModel = await loadLocalModel(modelPath, modelId, "audit");
-  return { scoutModel, auditModel };
-}
-
 export async function firstRunModelBootstrap(
   modelId: ModelId,
 ): Promise<string> {
@@ -107,18 +108,6 @@ export async function loadLocalModel(
 }
 
 function modelRuntime(profile: ModelProfile): ModelRuntime {
-  if (profile === "audit") {
-    const baseUrl =
-      process.env.STUPIFY_AUDIT_LLAMA_SERVER_URL ?? "http://127.0.0.1:8092";
-    return {
-      profile,
-      baseUrl,
-      port: new URL(baseUrl).port || "8092",
-      reasoning: "on",
-      reasoningBudget: 4_096,
-    };
-  }
-
   const baseUrl =
     process.env.STUPIFY_SCOUT_LLAMA_SERVER_URL ??
     process.env.STUPIFY_LLAMA_SERVER_URL ??
@@ -127,7 +116,15 @@ function modelRuntime(profile: ModelProfile): ModelRuntime {
     profile,
     baseUrl,
     port: new URL(baseUrl).port || "8091",
+    contextSize: envInteger("STUPIFY_LLAMA_CONTEXT") ?? 65_536,
     reasoning: "off",
+    gpuLayers: envInteger("STUPIFY_LLAMA_GPU_LAYERS") ?? 999,
+    batchSize: envInteger("STUPIFY_LLAMA_BATCH") ?? 2_048,
+    ubatchSize: envInteger("STUPIFY_LLAMA_UBATCH") ?? 512,
+    parallel: envInteger("STUPIFY_LLAMA_PARALLEL") ?? 2,
+    threads: envInteger("STUPIFY_LLAMA_THREADS"),
+    threadsBatch: envInteger("STUPIFY_LLAMA_THREADS_BATCH"),
+    flashAttention: envBoolean("STUPIFY_LLAMA_FLASH_ATTN"),
   };
 }
 
@@ -182,11 +179,18 @@ async function startLlamaServer(
     "--port",
     runtime.port,
     "-c",
-    "65536",
+    String(runtime.contextSize),
     "--reasoning",
     runtime.reasoning,
     "--no-warmup",
   ];
+  if (runtime.gpuLayers !== undefined) args.push("-ngl", String(runtime.gpuLayers));
+  if (runtime.batchSize !== undefined) args.push("-b", String(runtime.batchSize));
+  if (runtime.ubatchSize !== undefined) args.push("-ub", String(runtime.ubatchSize));
+  if (runtime.parallel !== undefined) args.push("-np", String(runtime.parallel));
+  if (runtime.threads !== undefined) args.push("-t", String(runtime.threads));
+  if (runtime.threadsBatch !== undefined) args.push("-tb", String(runtime.threadsBatch));
+  if (runtime.flashAttention !== undefined) args.push("-fa", runtime.flashAttention ? "on" : "off");
   if (runtime.reasoningBudget !== undefined) {
     args.push("--reasoning-budget", String(runtime.reasoningBudget));
   }
@@ -242,11 +246,20 @@ async function managedServerPid(runtime: ModelRuntime): Promise<number | null> {
 }
 
 function pidPath(runtime: ModelRuntime): string {
-  const filename =
-    runtime.profile === "scout"
-      ? "llama-server.pid"
-      : `llama-server-${runtime.profile}.pid`;
-  return path.join(cacheDir(), filename);
+  return path.join(cacheDir(), "llama-server.pid");
+}
+
+function envInteger(name: string, fallback?: number): number | undefined {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return fallback;
+  const value = Number(raw);
+  return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+function envBoolean(name: string): boolean | undefined {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return undefined;
+  return /^(1|true|yes|on)$/i.test(raw);
 }
 
 async function waitForServer(baseUrl: string, modelId: ModelId): Promise<void> {

package/src/prompts.ts

@@ -1,234 +1,98 @@
-import type {
-  AuditPromptName,
-  CandidateContext,
-  DiffBatch,
-  SemChangeSet,
-  SemContext,
-  SemContextPack,
-  StupifyCheck,
-} from "./types.ts";
-
-export function scoutPrompt(batch: DiffBatch, checks: readonly StupifyCheck[], sourceLabel: string): string {
-  return `Pick diff hunks that match enabled checks.
-Return JSON only:
-{ "candidates": ["exact POINTER"] }
-
-Rules:
-- Use POINTER values exactly as shown.
-- Return at most 3 candidates.
-- Return { "candidates": [] } if clean.
-- Pick definitions over usage sites.
-
-${formatCompactChecks(checks)}
-
-SOURCE:
-${sourceLabel}
-
-DIFF BATCH ${batch.id}:
-${batch.text}`;
-}
-
-export function auditPrompt(
-  contexts: readonly CandidateContext[],
-  checks: readonly StupifyCheck[],
-  sourceLabel: string,
-): string {
-  return `Audit candidate diff regions against enabled checks.
+import type { SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
+
+export function searchPrompt(input: Readonly<{
+  changeSet: SemChangeSet;
+  contexts: readonly SemContext[];
+  pack: SemContextPack;
+  patterns: readonly StupifyCheck[];
+  includeCounterReason: boolean;
+}>): string {
+  return `You are Stupify's local search model.
+Stupify checks whether AI-assisted coding may be replacing developer judgment.
+You will receive:
+1. Semantic changed entities selected by a fast local counter.
+2. Compressed local file context from Repomix.
+3. A list of search targets. Each target has exactly one assigned pattern.
+
+Your job:
+Evaluate each target only against its assigned pattern.
+False positives are expensive.
+Only emit a match if the assigned pattern clearly applies to that exact target.
+Do not perform general code review.
+Do not suggest improvements.
+Do not choose a pattern.
+Do not apply other patterns.
+Do not report issues for unlisted targets.
+Do not emit clean results.
+Omitted target = clean.
 Return JSON only:
 {
-  "findings": [{ "checkId": "check_id", "why": "one sentence", "proof": "exact POINTER" }],
-  "summary": "one short sentence"
-}
-
-Rules:
-- Use only checks listed below.
-- checkId must be a check ID, never a POINTER.
-- proof must be one exact POINTER from candidate regions.
-- why describes the suspicious structure, not an identifier.
-- Do not describe an issue in summary unless it is also in findings.
-- If no findings, return { "findings": [], "summary": "No clear judgment-offload signal found." }.
-
-Allowed proof pointers:
-${contexts.map((context) => `- ${context.pointer}`).join("\n")}
-
-${formatFullChecks(checks)}
-
-SOURCE:
-${sourceLabel}
-
-CANDIDATE REGIONS:
-${contexts.map(formatContext).join("\n\n")}`;
-}
-
-export function semScoutPrompt(
-  changeSet: SemChangeSet,
-  checks: readonly StupifyCheck[],
-  maxCandidates: number,
-): string {
-  return `Pick changed entity/check targets worth auditing.
-Return JSON only:
-{ "targets": [{ "entityId": "exact entityId", "checkId": "check_id", "reason": "short scout reason" }] }
-
-Rules:
-- Use entityId values exactly as shown.
-- Each target has exactly one checkId.
-- Return at most ${maxCandidates} targets.
-- Return { "targets": [] } if clean.
-- Pick definitions over usage sites.
-- Prefer high recall, but do not attach unrelated checks.
-
-${formatCompactChecks(checks)}
-
-SOURCE:
-${changeSet.label}
-
-SEM CHANGE SUMMARY:
-${JSON.stringify(changeSet.summary, null, 2)}
-
-SEM ENTITY CHANGES:
-${changeSet.changes.map(formatSemChange).join("\n\n")}`;
-}
-
-export function findingsAuditPrompt(
-  contexts: readonly SemContext[],
-  pack: SemContextPack,
-  checks: readonly StupifyCheck[],
-  sourceLabel: string,
-  promptName: AuditPromptName,
-): string {
-  const task =
-    promptName === "high_bar"
-      ? `You are Stupify's audit model.
-You are reviewing candidate/check targets for signs that AI-assisted coding may have replaced engineering judgment.
-Only emit a finding if it is clearly useful to a developer.
-A useful finding must:
-- match the target's check exactly
-- point to a concrete change pattern
-- explain why the change may reflect judgment-offload
-- avoid generic code-review commentary
-If the target is normal engineering work, omit it.
-If the target is merely plausible but not strong, omit it.
-If the target does not exactly match its assigned check, omit it.`
-      : `You are Stupify's auditor.
-Audit only the listed target/check pairs.
-Emit only exceptions.`;
-
-  const highBarRules =
-    promptName === "high_bar"
-      ? `- Prefer clean over weak.
-- Prefer no finding over generic finding.
-- Do not emit style feedback unless the assigned check is truly about style.
-- Do not turn functional refactors into style mismatch findings.`
-      : "";
-
-  return `${task}
-Return JSON only:
-{
-  "findings": [
+  "matches": [
     {
       "targetId": "t001",
-      "why": "one sentence",
+      "reason": "one sentence",
       "proof": "short pointer"
     }
-  ],
-  "uncertain": [
-    {
-      "targetId": "t002",
-      "why": "one sentence"
-    }
   ]
 }
 
 Rules:
-- Inspect every target.
-- Each target has exactly one check.
-- Emit a finding only when the target clearly matches its check.
-- Emit uncertain only when the target may match, but evidence is insufficient.
-- If a target is clean, emit nothing for it.
-- Omitted target means clean.
-- Do not output clean reviews.
-- Do not explain clean targets.
-- Do not write "no evidence" as a finding.
-- Do not put negative statements in findings.
-- Prefer omission over weak findings.
-- Use only provided targetIds.
-- Do not search for other checks.
+- Use only targetIds from the input.
+- Emit at most 5 matches.
+- Prefer omission over a weak match.
 - Do not quote source code.
-- Use packed file context only as supporting evidence for these candidate entities.
-${highBarRules}
-
-Targets:
-${contexts.map((context) => formatAuditTarget(context, checks)).join("\n\n")}
+- Do not write generic feedback.
+- Do not emit "no evidence" or "does not apply."
+- Proof must point to concrete changed product code that implements the pattern.
+- Proof must not be a file header or start with "diff --git".
+- Do not use pattern registry text, prompt text, docs, tests, or examples as proof.
+- Do not treat pattern or prompt wording as the code being evaluated.
+- Do not treat plain conditionals, guard clauses, skip paths, or error handling as indirection.
+- For unnecessary_complexity, identify the exact new named abstraction in proof.
+- If unnecessary_complexity proof would only be a file, hunk, or conditional block, omit it.
+- If nothing clearly matches, return { "matches": [] }.
 
 SOURCE:
-${sourceLabel}
-
-CANDIDATE ENTITY DELTAS:
-${contexts.map(formatSemContext).join("\n\n")}
-
-PACKED FILE CONTEXT (${pack.provider}, ${pack.filePaths.length} files, ${pack.totalTokens} tokens):
-${pack.text || "(none)"}`;
-}
+${input.changeSet.label}
 
-function formatCompactChecks(checks: readonly StupifyCheck[]): string {
-  return `Checks:
-${checks.map((check) => `- ${check.id}: ${check.lookFor.join("; ")}`).join("\n")}`;
-}
+SEARCH TARGETS:
+${input.contexts.map((context) => formatSearchTarget(context, patternForContext(context, input.patterns), input.includeCounterReason)).join("\n\n") || "(none)"}
 
-function formatFullChecks(checks: readonly StupifyCheck[]): string {
-  return checks.map(formatCheck).join("\n\n");
+REPOMIX CONTEXT (${input.pack.filePaths.length} files, ${input.pack.totalTokens} tokens):
+${input.pack.text || "(none)"}`;
 }
 
-function formatCheck(check: StupifyCheck): string {
-  return `# ${check.name}
-ID: ${check.id}
-Q: ${check.question}
+function formatSearchPattern(check: StupifyCheck): string {
+  return `Pattern: ${check.id} (${check.name})
+Question: ${check.searchPrompt ?? check.question}
 Look for:
 ${check.lookFor.map((signal) => `- ${signal}`).join("\n")}
 Ignore when:
 ${check.ignoreWhen.map((signal) => `- ${signal}`).join("\n")}
 Match examples:
-${(check.examples?.match ?? []).map((example) => `- ${example}`).join("\n")}
-No-match examples:
-${(check.examples?.noMatch ?? []).map((example) => `- ${example}`).join("\n")}`;
+${(check.searchExamples?.match ?? check.examples?.match ?? []).map((example) => `- ${example}`).join("\n")}
+Non-match examples:
+${(check.searchExamples?.nonMatch ?? check.examples?.noMatch ?? []).map((example) => `- ${example}`).join("\n")}`;
 }
 
-function formatContext(context: CandidateContext): string {
-  return `POINTER ${context.pointer}
-${context.text}`;
-}
-
-function formatSemChange(change: SemChangeSet["changes"][number]): string {
-  return `ENTITY ${change.entityId}
-TYPE ${change.entityType}
-CHANGE ${change.changeType}
-PATH ${change.filePath}`;
-}
-
-function formatSemContext(context: SemContext): string {
+function formatSearchTarget(context: SemContext, pattern: StupifyCheck, includeCounterReason: boolean): string {
   return `TARGET ${context.targetId}
+ASSIGNED ${formatSearchPattern(pattern)}
+SEM TARGET:
 ENTITY ${context.entityId}
 NAME ${context.entityName}
 KIND ${context.entityKind}
 CHANGE ${context.changeKind}
-CHECK ${context.checkId}
-SCOUT_REASON ${context.reason}
-CONTEXT:
-${context.text}`;
-}
-
-function formatAuditTarget(context: SemContext, checks: readonly StupifyCheck[]): string {
-  const check = checks.find((item) => item.id === context.checkId);
-  return `- targetId=${context.targetId} checkId=${context.checkId} entityId=${context.entityId}
-scoutReason=${context.reason}
-${check ? formatCheck(check) : ""}`;
+FILE ${context.filePath ?? "(unknown)"}
+${includeCounterReason ? `COUNTER_REASON ${context.reason}` : ""}`.trim();
 }
 
-function shortenCode(value: string | null): string {
-  if (!value) return "(none)";
-  const lines = value.split(/\r?\n/);
-  const limit = 80;
-  if (lines.length <= limit) return value;
-  return `${lines.slice(0, limit).join("\n")}
-[stupify: sem entity content shortened after ${limit} lines]`;
+function patternForContext(context: SemContext, patterns: readonly StupifyCheck[]): StupifyCheck {
+  return patterns.find((pattern) => pattern.id === context.checkId) ?? {
+    id: context.checkId,
+    name: context.checkId,
+    question: `Does this target match ${context.checkId}?`,
+    lookFor: [],
+    ignoreWhen: [],
+  };
 }