@stupify/cli 0.0.3 → 0.0.5

package/src/analysis.ts

@@ -1,95 +1,36 @@
-import { auditPrompt, findingsAuditPrompt, scoutPrompt, semScoutPrompt } from "./prompts.ts";
 import { cachedJson, fingerprint } from "./cache.ts";
 import type { LocalModel } from "./model.ts";
-import type {
-  CandidateContext,
-  CheckId,
-  DiffBatch,
-  AuditPromptName,
-  AuditReviewResult,
-  Finding,
-  FindingsResult,
-  NetDiff,
-  SemCandidate,
-  SemChangeSet,
-  SemContext,
-  SemContextPack,
-  SourceId,
-  StupifyCheck,
-} from "./types.ts";
+import { searchPrompt } from "./prompts.ts";
+import type { SearchMatch, SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
 
-export async function scoutBatch(
+export async function runSearch(
   model: LocalModel,
-  batch: DiffBatch,
-  checks: readonly StupifyCheck[],
-  sourceLabel: string,
-): Promise<readonly string[]> {
-  const raw = await runJsonPrompt(model, scoutPrompt(batch, checks, sourceLabel), scoutSchema(batch), 0);
-  return uncheckedCandidates(raw);
+  request: SearchRequest,
+): Promise<readonly SearchMatch[]> {
+  const raw = await runJsonPrompt(model, request.prompt, request.schema, 0);
+  return uncheckedSearchMatches(raw, request.contexts);
 }
 
-export async function auditCandidates(
-  model: LocalModel,
-  diff: NetDiff,
-  contexts: readonly CandidateContext[],
-  checks: readonly StupifyCheck[],
-): Promise<FindingsResult> {
-  if (contexts.length === 0) return { findings: [], summary: "No candidate regions found." };
-
-  const raw = await runJsonPrompt(model, auditPrompt(contexts, checks, diff.label), auditSchema(contexts), 0);
-  return uncheckedRawAuditResult(raw, diff.id);
-}
-
-export async function scoutSemChanges(
-  model: LocalModel,
-  changeSet: SemChangeSet,
-  checks: readonly StupifyCheck[],
-  maxCandidates: number,
-): Promise<readonly SemCandidate[]> {
-  const raw = await runJsonPrompt(
-    model,
-    semScoutPrompt(changeSet, checks, maxCandidates),
-    semScoutSchema(changeSet, checks, maxCandidates),
-    0,
-  );
-  return uncheckedSemCandidates(raw, changeSet.id);
-}
-
-export async function runFindingsAudit(
-  model: LocalModel,
-  changeSet: SemChangeSet,
-  contexts: readonly SemContext[],
-  pack: SemContextPack,
-  checks: readonly StupifyCheck[],
-  request = findingsAuditRequest(changeSet, contexts, pack, checks),
-): Promise<AuditReviewResult> {
-  if (contexts.length === 0) {
-    return {
-      findings: [],
-      summary: "No candidate entities found.",
-      stats: { totalTargets: 0, finding: 0, clean: 0, uncertain: 0, invalid: 0 },
-    };
-  }
-
-  const raw = await runJsonPrompt(
-    model,
-    request.prompt,
-    request.schema,
-    0,
-  );
-  return uncheckedFindingsAuditResult(raw, changeSet.id, contexts);
-}
+export type SearchRequest = Readonly<{
+  prompt: string;
+  schema: unknown;
+  contexts: readonly SemContext[];
+}>;
 
-export function findingsAuditRequest(
-  changeSet: SemChangeSet,
-  contexts: readonly SemContext[],
-  pack: SemContextPack,
-  checks: readonly StupifyCheck[],
-  promptName: AuditPromptName = "strict",
-): Readonly<{ prompt: string; schema: unknown }> {
+export function searchRequest(input: Readonly<{
+  changeSet: SemChangeSet;
+  contexts: readonly SemContext[];
+  pack: SemContextPack;
+  patterns: readonly StupifyCheck[];
+  includeCounterReasonInPrompt?: boolean;
+}>): SearchRequest {
   return {
-    prompt: findingsAuditPrompt(contexts, pack, checks, changeSet.label, promptName),
-    schema: findingsAuditSchema(contexts),
+    prompt: searchPrompt({
+      ...input,
+      includeCounterReason: input.includeCounterReasonInPrompt ?? false,
+    }),
+    schema: searchSchema(input.contexts),
+    contexts: input.contexts,
   };
 }
 
@@ -119,214 +60,53 @@ export async function countPromptTokens(model: LocalModel, prompt: string): Prom
   return cached.count;
 }
 
-function findingsAuditSchema(contexts: readonly SemContext[]): unknown {
-  const targetIds = contexts.map((context) => context.targetId);
-  const findingItem = {
-    type: "object",
-    properties: {
-      targetId: { type: "string", enum: targetIds },
-      why: { type: "string" },
-      proof: { type: "string" },
-    },
-    required: ["targetId", "why", "proof"],
-    additionalProperties: false,
-  };
-  const uncertainItem = {
-    type: "object",
-    properties: {
-      targetId: { type: "string", enum: targetIds },
-      why: { type: "string" },
-    },
-    required: ["targetId", "why"],
-    additionalProperties: false,
-  };
-  return {
-    type: "object",
-    properties: {
-      findings: {
-        type: "array",
-        items: findingItem,
-      },
-      uncertain: {
-        type: "array",
-        items: uncertainItem,
-      },
-    },
-    additionalProperties: false,
-  };
-}
-
-function auditSchema(contexts: readonly CandidateContext[]): unknown {
-  return auditSchemaFromProofs(contexts.map((context) => context.pointer));
-}
-
-function auditSchemaFromProofs(proofs: readonly string[]): unknown {
-  return {
-    type: "object",
-    properties: {
-      findings: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            checkId: { type: "string" },
-            why: { type: "string" },
-            proof: { type: "string", enum: proofs },
-          },
-          required: ["checkId", "why", "proof"],
-          additionalProperties: false,
-        },
-      },
-      summary: { type: "string" },
-    },
-    required: ["findings", "summary"],
-    additionalProperties: false,
-  };
-}
-
-function semScoutSchema(
-  changeSet: SemChangeSet,
-  checks: readonly StupifyCheck[],
-  maxCandidates: number,
-): unknown {
+function searchSchema(contexts: readonly SemContext[]): unknown {
   return {
     type: "object",
     properties: {
-      targets: {
+      matches: {
         type: "array",
-        maxItems: maxCandidates,
+        maxItems: 5,
         items: {
           type: "object",
           properties: {
-            entityId: { type: "string", enum: changeSet.changes.map((change) => change.entityId) },
-            checkId: { type: "string", enum: checks.map((check) => check.id) },
+            targetId: { type: "string", enum: contexts.map((context) => context.targetId) },
             reason: { type: "string" },
+            proof: { type: "string" },
           },
-          required: ["entityId", "checkId", "reason"],
+          required: ["targetId", "reason", "proof"],
           additionalProperties: false,
         },
       },
     },
-    required: ["targets"],
-    additionalProperties: false,
-  };
-}
-
-function scoutSchema(batch: DiffBatch): unknown {
-  return {
-    type: "object",
-    properties: {
-      candidates: {
-        type: "array",
-        maxItems: 3,
-        items: { type: "string", enum: batch.hunks.map((hunk) => hunk.pointer) },
-      },
-    },
-    required: ["candidates"],
+    required: ["matches"],
     additionalProperties: false,
   };
 }
 
-type RawScoutOutput = Readonly<{ candidates?: readonly string[] }>;
-type RawAuditOutput = Readonly<{
-  findings?: readonly RawFinding[];
-  summary?: string;
+type RawSearchOutput = Readonly<{
+  matches?: readonly RawSearchMatch[];
 }>;
-type RawSemScoutOutput = Readonly<{
-  targets?: readonly RawSemCandidate[];
-  candidates?: readonly RawSemCandidate[];
-}>;
-type RawSemCandidate = Readonly<{
+type RawSearchMatch = Readonly<{
   targetId?: string;
-  entityId?: string;
-  checkId?: string;
-  checkIds?: readonly string[];
   reason?: string;
-}>;
-type RawFinding = Readonly<{
-  checkId?: string;
-  why?: string;
   proof?: string;
 }>;
-type RawFindingReview = RawFinding & Readonly<{ targetId?: string }>;
-type RawFindingsAuditOutput = Readonly<{
-  findings?: readonly RawFindingReview[];
-  uncertain?: readonly RawFindingReview[];
-}>;
-
-function uncheckedCandidates(value: unknown): readonly string[] {
-  return [...((value as RawScoutOutput).candidates ?? [])];
-}
 
-function uncheckedRawAuditResult(value: unknown, sourceId: SourceId): FindingsResult {
-  const output = value as RawAuditOutput;
-  const findings = (output.findings ?? []).map((finding): Finding => ({
-    sourceId,
-    checkId: (finding.checkId ?? "") as CheckId,
-    why: finding.why ?? "",
-    proof: finding.proof ?? "",
-  }));
-  return { findings, summary: output.summary ?? defaultSummary(findings.length) };
-}
-
-function uncheckedSemCandidates(value: unknown, sourceId: SourceId): readonly SemCandidate[] {
-  const output = value as RawSemScoutOutput;
-  const rawTargets = output.targets ?? output.candidates ?? [];
-  return rawTargets.flatMap((candidate) => {
-    if (candidate.checkId) {
-      return [{
-        sourceId,
-        targetId: candidate.targetId ?? "",
-        entityId: candidate.entityId ?? "",
-        checkId: candidate.checkId as CheckId,
-        reason: candidate.reason ?? "",
-      }];
-    }
-    return (candidate.checkIds ?? []).map((checkId) => ({
-      sourceId,
-      targetId: candidate.targetId ?? "",
-      entityId: candidate.entityId ?? "",
-      checkId: checkId as CheckId,
-      reason: candidate.reason ?? "",
-    }));
-  });
-}
-
-function uncheckedFindingsAuditResult(
-  value: unknown,
-  sourceId: SourceId,
-  contexts: readonly SemContext[],
-): AuditReviewResult {
-  const output = value as RawFindingsAuditOutput;
-  const targetsById = new Map(contexts.map((context) => [context.targetId, context]));
-  const findings = (output.findings ?? []).map((finding): Finding => {
-    const target = targetsById.get(finding.targetId ?? "");
-    return {
-      sourceId,
-      checkId: (target?.checkId ?? "") as CheckId,
-      why: finding.why ?? "",
-      proof: finding.proof ?? "",
-    };
+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 ?? "",
+    }];
   });
-  const uncertain = output.uncertain?.length ?? 0;
-  const totalTargets = contexts.length;
-  return {
-    findings,
-    summary: defaultSummary(findings.length),
-    stats: {
-      totalTargets,
-      finding: findings.length,
-      clean: Math.max(0, totalTargets - findings.length - uncertain),
-      uncertain,
-      invalid: 0,
-    },
-  };
-}
-
-function defaultSummary(findingCount: number): string {
-  return findingCount === 0
-    ? "No clear judgment-offload signal found."
-    : `${findingCount} finding review${findingCount === 1 ? "" : "s"} accepted.`;
 }
 
 async function runJsonPrompt(

package/src/checks.ts

@@ -11,7 +11,19 @@ export const defaultChecks: readonly StupifyCheck[] = [
     ],
     ignoreWhen: [
       "test fixture, mock, or intentional external contract",
-    ],
+      "public API DTO filters, omits, protects, renames, or versions fields",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find only local/private payload or schema shapes that clearly copy another local shape one-for-one without creating a boundary. Do not match ordinary Input/Output/Request/Response types by name alone, public DTOs, external contracts, client types, or types that omit/protect private fields.",
+    searchExamples: {
+      match: [
+        "LocalUserPayload repeats User fields and maps id/email/displayName one-for-one.",
+      ],
+      nonMatch: [
+        "PublicWebhookDto omits privateNotes from InternalJob.",
+        "A client type describes an external dependency boundary.",
+      ],
+    },
   },
   {
     id: checkId("unnecessary_complexity"),
@@ -23,6 +35,35 @@ export const defaultChecks: readonly StupifyCheck[] = [
     ignoreWhen: [
       "isolates dependency, removes duplication, or improves testability",
     ],
+    hookMode: "warn",
+    searchPrompt: `Find staged changes where a locally simple decision is made harder to understand by new indirection.
+Only match when the staged diff clearly shows:
+- a new named helper, wrapper, service, adapter, boundary, or abstraction
+- and the surrounding change still appears locally simple
+- and the new structure makes the decision harder to see
+Do not match:
+- plain conditionals, guard clauses, skip paths, or error handling
+- normal feature structure
+- exported utilities that are part of a real feature
+- command plumbing
+- prompt/instruction files
+- domain configuration
+- refactors that make ownership clearer
+- changes where the payoff is unclear from the diff
+Prefer no match over a weak match.`,
+    searchExamples: {
+      match: [
+        "A small inline operation becomes a helper/service/wrapper with one obvious caller.",
+        "A straightforward flow is split across files in a way that hides the decision.",
+        "A new abstraction appears before there is evidence it buys clarity, correctness, reuse, or isolation.",
+      ],
+      nonMatch: [
+        "A real external dependency boundary is isolated.",
+        "A security/auth boundary becomes clearer.",
+        "A refactor removes larger complexity elsewhere.",
+        "Framework-required structure is added.",
+      ],
+    },
   },
   {
     id: checkId("fake_precision_windowing"),
@@ -68,6 +109,22 @@ export const defaultChecks: readonly StupifyCheck[] = [
     ignoreWhen: [
       "comment explains intent, constraint, workaround, or public API behavior",
     ],
+    hookMode: "warn",
+    searchPrompt: "Find staged changes where comments appear to substitute for judgment rather than clarify it.",
+    searchExamples: {
+      match: [
+        "New comments narrate obvious code instead of explaining tradeoffs.",
+        "A simple change gains multiple generic comments that restate control flow.",
+        "Comments make the code look more deliberate without adding useful reasoning.",
+      ],
+      nonMatch: [
+        "Comments explain a real domain constraint.",
+        "Comments document an external API quirk.",
+        "Comments clarify a surprising edge case.",
+        "Comments are sparse and specific.",
+        "Comments explain provider, finance, reconciliation, timezone, or ledger behavior.",
+      ],
+    },
   },
   {
     id: checkId("lint_bypass"),
@@ -81,6 +138,16 @@ export const defaultChecks: readonly StupifyCheck[] = [
       "type-level test",
       "generated file convention",
     ],
+    hookMode: "warn",
+    searchPrompt: "Find only broad lint/type bypasses that hide useful feedback. Match bare @ts-ignore, bare @ts-expect-error, broad casts, any, or eslint/biome suppressions without a concrete inline reason. Do not match targeted suppressions that include a reason for a known framework, test, mock, or external-library limitation.",
+    searchExamples: {
+      match: [
+        "A bare // @ts-ignore hides property access on unknown input.",
+      ],
+      nonMatch: [
+        "// @ts-expect-error explains a known external library typing gap.",
+      ],
+    },
   },
   {
     id: checkId("inconsistent_patterns"),
@@ -104,7 +171,19 @@ export const defaultChecks: readonly StupifyCheck[] = [
     ignoreWhen: [
       "existing utility has wrong contract",
       "new helper is clearer as a tiny private expression",
-    ],
+      "helper is domain-specific or used by multiple local call sites",
+    ],
+    hookMode: "warn",
+    searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, group, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
+    searchExamples: {
+      match: [
+        "clampValue returns min, max, or value.",
+      ],
+      nonMatch: [
+        "formatCurrencyHelper is used by invoice and refund labels.",
+        "Subscription tier constants encode domain configuration.",
+      ],
+    },
   },
   {
     id: checkId("operator_style_mismatch"),
@@ -123,6 +202,16 @@ export const defaultChecks: readonly StupifyCheck[] = [
 export function enabledChecks(checkIds: readonly string[] | null): readonly StupifyCheck[] {
   if (!checkIds) return defaultChecks.filter((check) => check.enabledByDefault !== false);
 
+  return checksById(checkIds);
+}
+
+export function searchChecks(checkIds: readonly string[] | null): readonly StupifyCheck[] {
+  if (!checkIds) return defaultChecks.filter((check) => check.hookMode === "warn");
+
+  return checksById(checkIds);
+}
+
+function checksById(checkIds: readonly string[]): readonly StupifyCheck[] {
   const checksById = new Map<string, StupifyCheck>(defaultChecks.map((check) => [check.id, check]));
   return checkIds.map((id) => {
     const check = checksById.get(id);