@stupify/cli 0.0.3 → 0.0.4

package/dist/model.d.ts

@@ -1,24 +1,10 @@
 import type { ModelId } from "./types.ts";
-export type ModelProfile = "scout" | "audit";
+export type ModelProfile = "scout";
 export type LocalModel = Readonly<{
     id: ModelId;
     name: string;
     baseUrl: string;
     profile: ModelProfile;
 }>;
-export declare function loadLocalModels(modelId: ModelId): Promise<{
-    scoutModel: Readonly<{
-        id: ModelId;
-        name: string;
-        baseUrl: string;
-        profile: ModelProfile;
-    }>;
-    auditModel: Readonly<{
-        id: ModelId;
-        name: string;
-        baseUrl: string;
-        profile: ModelProfile;
-    }>;
-}>;
 export declare function firstRunModelBootstrap(modelId: ModelId): Promise<string>;
 export declare function loadLocalModel(modelPath: string, modelId: ModelId, profile?: ModelProfile): Promise<LocalModel>;

package/dist/model.js

@@ -9,12 +9,6 @@ import { promisify } from "node:util";
 import { MODEL_REGISTRY } from "./constants.js";
 const execFileAsync = promisify(execFile);
 const LLAMA_SERVER_HOST = "127.0.0.1";
-export async function loadLocalModels(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) {
     const selectedModel = MODEL_REGISTRY[modelId];
     const modelDir = path.join(cacheDir(), "models");
@@ -62,16 +56,6 @@ export async function loadLocalModel(modelPath, modelId, profile = "scout") {
     };
 }
 function modelRuntime(profile) {
-    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 ??
         "http://127.0.0.1:8091";
@@ -79,7 +63,15 @@ function modelRuntime(profile) {
         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"),
     };
 }
 async function runningServerModel(baseUrl) {
@@ -127,11 +119,25 @@ async function startLlamaServer(modelPath, modelId, modelName, runtime) {
         "--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));
     }
@@ -180,10 +186,20 @@ async function managedServerPid(runtime) {
     }
 }
 function pidPath(runtime) {
-    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, fallback) {
+    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) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === "")
+        return undefined;
+    return /^(1|true|yes|on)$/i.test(raw);
 }
 async function waitForServer(baseUrl, modelId) {
     const deadline = Date.now() + 120_000;

package/dist/prompts.d.ts

@@ -1,5 +1,8 @@
-import type { AuditPromptName, CandidateContext, DiffBatch, SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
-export declare function scoutPrompt(batch: DiffBatch, checks: readonly StupifyCheck[], sourceLabel: string): string;
-export declare function auditPrompt(contexts: readonly CandidateContext[], checks: readonly StupifyCheck[], sourceLabel: string): string;
-export declare function semScoutPrompt(changeSet: SemChangeSet, checks: readonly StupifyCheck[], maxCandidates: number): string;
-export declare function findingsAuditPrompt(contexts: readonly SemContext[], pack: SemContextPack, checks: readonly StupifyCheck[], sourceLabel: string, promptName: AuditPromptName): string;
+import type { SemChangeSet, SemContext, SemContextPack, StupifyCheck } from "./types.ts";
+export declare function searchPrompt(input: Readonly<{
+    changeSet: SemChangeSet;
+    contexts: readonly SemContext[];
+    pack: SemContextPack;
+    patterns: readonly StupifyCheck[];
+    includeCounterReason: boolean;
+}>): string;

package/dist/prompts.js

@@ -1,197 +1,87 @@
-export function scoutPrompt(batch, checks, sourceLabel) {
-    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, checks, sourceLabel) {
-    return `Audit candidate diff regions against enabled checks.
-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, checks, maxCandidates) {
-    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, pack, checks, sourceLabel, promptName) {
-    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}
+export function searchPrompt(input) {
+    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": [
+  "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}
+${input.changeSet.label}
 
-CANDIDATE ENTITY DELTAS:
-${contexts.map(formatSemContext).join("\n\n")}
+SEARCH TARGETS:
+${input.contexts.map((context) => formatSearchTarget(context, patternForContext(context, input.patterns), input.includeCounterReason)).join("\n\n") || "(none)"}
 
-PACKED FILE CONTEXT (${pack.provider}, ${pack.filePaths.length} files, ${pack.totalTokens} tokens):
-${pack.text || "(none)"}`;
-}
-function formatCompactChecks(checks) {
-    return `Checks:
-${checks.map((check) => `- ${check.id}: ${check.lookFor.join("; ")}`).join("\n")}`;
+REPOMIX CONTEXT (${input.pack.filePaths.length} files, ${input.pack.totalTokens} tokens):
+${input.pack.text || "(none)"}`;
 }
-function formatFullChecks(checks) {
-    return checks.map(formatCheck).join("\n\n");
-}
-function formatCheck(check) {
-    return `# ${check.name}
-ID: ${check.id}
-Q: ${check.question}
+function formatSearchPattern(check) {
+    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")}`;
-}
-function formatContext(context) {
-    return `POINTER ${context.pointer}
-${context.text}`;
+${(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 formatSemChange(change) {
-    return `ENTITY ${change.entityId}
-TYPE ${change.entityType}
-CHANGE ${change.changeType}
-PATH ${change.filePath}`;
-}
-function formatSemContext(context) {
+function formatSearchTarget(context, pattern, includeCounterReason) {
     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, checks) {
-    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) {
-    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, patterns) {
+    return patterns.find((pattern) => pattern.id === context.checkId) ?? {
+        id: context.checkId,
+        name: context.checkId,
+        question: `Does this target match ${context.checkId}?`,
+        lookFor: [],
+        ignoreWhen: [],
+    };
 }

package/dist/render.d.ts

@@ -1,3 +1,3 @@
-import type { AnalysisReport, AnalyzeCommand } from "./types.ts";
-export declare function renderReport(report: AnalysisReport, command: AnalyzeCommand): string;
+import type { SearchCommand, SearchRunJson } from "./types.ts";
+export declare function renderSearchRun(run: SearchRunJson, command: SearchCommand): string;
 export declare function helpText(): string;

package/dist/render.js

@@ -1,40 +1,37 @@
 import { VERSION } from "./constants.js";
-export function renderReport(report, command) {
-    if (command.json) {
-        return JSON.stringify({
-            schemaVersion: "0.4",
-            model: { id: report.run.modelId },
-            checks: report.run.checkIds,
-            run: report.run,
-            findings: report.result.findings,
-            summary: report.result.summary,
-        }, null, 2);
+export function renderSearchRun(run, command) {
+    if (command.json)
+        return JSON.stringify(run, null, 2);
+    if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
+        return `🧙 stupify 🪄
+Search input is too large for precise local search.
+Size:
+~${run.stats.inputTokens ?? "unknown"} tokens
+Limit:
+${run.stats.inputTokenCap ?? "unknown"} tokens
+Stupify skipped the search rather than review truncated context.
+Nothing was blocked.
+Try:
+stupify ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
     }
-    if (report.run.engine === "sem") {
-        return `Search:
-  ${report.run.entitiesScanned} entities scanned
-  ${report.run.candidateCount} candidate entities found
-Audit:
-  ${report.run.auditedCandidateCount} candidates inspected
-  ${report.result.findings.length} findings
-${renderAuditStats(report)}
-${renderWarnings(report)}
-Findings:
-${renderFindings(report)}
-Timing:
-  total_ms=${report.run.timingsMs.total} entity_diff_ms=${report.run.timingsMs.diff} model_ms=${report.run.timingsMs.modelLoad} scout_ms=${report.run.timingsMs.search} context_audit_ms=${report.run.timingsMs.audit}`;
+    if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
+        return `🧙 stupify 🪄
+Search complete.
+Patterns: ${run.patterns.join(", ")}
+No search targets found.`;
     }
-    return `Search:
-  ${report.run.batchesScanned} batches scanned
-  ${report.run.candidateCount} candidate regions found
-Audit:
-  ${report.run.auditedCandidateCount} candidates inspected
-  ${report.result.findings.length} findings
-${renderWarnings(report)}
-Findings:
-${renderFindings(report)}
-Timing:
-  total_ms=${report.run.timingsMs.total} diff_ms=${report.run.timingsMs.diff} model_ms=${report.run.timingsMs.modelLoad} search_ms=${report.run.timingsMs.search} audit_ms=${report.run.timingsMs.audit}`;
+    if (run.matches.length === 0) {
+        return `🧙 stupify 🪄
+Search complete.
+Patterns: ${run.patterns.join(", ")}
+No judgment-offload signals found.`;
+    }
+    return `🧙 stupify 🪄
+Possible judgment-offload detected:
+${run.matches.map((match, index) => `${index + 1}. ${match.patternId}
+   ${match.reason}
+   Proof: ${match.proof}`).join("\n")}
+Search mode is warn-only.`;
 }
 export function helpText() {
     return `Stupify ${VERSION}
@@ -44,58 +41,53 @@ Usage:
   stupify --since "2 weeks ago"
   stupify --commit <commit>
   stupify --commits <count>
-  stupify experiment <config.json>
+  stupify --staged
+  stupify --mode search --staged
+  stupify hook install|uninstall|status
+  stupify doctor
+  stupify bench search experiments/search-bench.json
   git diff HEAD~1..HEAD | stupify --stdin
 
 Options:
-  --since <date>        Analyze the net diff from the first commit before this git date to HEAD.
-  --commit <commit>     Analyze one commit as a net diff.
-  --commits <count>     Analyze the net diff across the last N non-merge commits.
-  --stdin               Read a git diff from stdin.
-  --engine <engine>     raw-diff or sem. Default: raw-diff.
-  --scout <mode>        llm or counter for --engine sem. Default: counter.
-  --audit-context <mode>
-                         none or repomix for --engine sem. Default: repomix.
-  --audit-prompt <name> strict or high_bar for --engine sem. Default: high_bar.
-  --debug-sem           Print sem commands and stderr.
-  --debug-targets       Include audited sem target details in JSON output.
-  --max-candidates <n>  Max semantic candidates for --engine sem. Default: 10.
-  --audit-batch-size <n>
-                         Semantic candidates per audit model call. Default: 25.
-  --max-audit-input-tokens <n>
-                         Max findings-audit input tokens before splitting. Default: 20000.
-  --audit-concurrency <n>
-                         Parallel findings-audit model calls. Default: 2.
-  --checks <ids>        Comma-separated check ids.
-  --model <id>          gemma-4-e2b, gemma-4-e4b, gemma-4-26b-a4b, qwen3-4b-magicquant, qwen2.5-coder-1.5b, qwen2.5-coder-7b, or qwen2.5-coder-32b.
-  --json                Print JSON only.
+  --staged             Search staged changes.
+  --mode <mode>        search. Search is the only analysis mode.
+  --since <date>       Search the net diff from the first commit before this git date to HEAD.
+  --commit <commit>    Search one commit as a net diff.
+  --commits <count>    Search the net diff across the last N non-merge commits.
+  --stdin              Read a git diff from stdin.
+  --debug-sem          Print sem commands and stderr.
+  --max-candidates <n> Max semantic search targets. Default: 10.
+  --max-search-input-tokens <n>
+                        Max search input tokens before skipping. Default: 12000.
+  --checks <ids>       Comma-separated pattern ids.
+  --model <id>         gemma-4-e2b, gemma-4-e4b, gemma-4-26b-a4b, qwen3-4b-magicquant, qwen2.5-coder-1.5b, qwen2.5-coder-7b, or qwen2.5-coder-32b.
+  --search-profile <path>
+                       Dev/bench-only search profile override.
+  --include-counter-reason-in-prompt
+                       Debug/bench-only: include counter reason in the model prompt.
+  --json               Print JSON only.
+
+Diagnostics:
+  stupify doctor       Check local setup, hook status, and privacy boundary.
 
 Default:
   stupify is equivalent to stupify --since "2 weeks ago".
 
+Pipeline:
+  sem diff -> counter scout -> Repomix context -> local search model.
+
 Not included:
-  Baselines, sharing, hosted server calls, Ollama, GitHub, dashboards, or repo-wide scanning.
-`;
-}
-function renderFindings(report) {
-    if (report.result.findings.length === 0)
-        return "  None.";
-    return report.result.findings
-        .map((finding) => `- ${finding.checkId}
-  ${finding.why}
-  Proof: ${finding.proof}`)
-        .join("\n");
-}
-function renderWarnings(report) {
-    if (report.run.warnings.length === 0)
-        return "";
-    return `Warnings:
-${report.run.warnings.map((warning) => `  ${warning}`).join("\n")}
+  Findings audit, validators, judges, baselines, sharing, hosted server calls, GitHub, dashboards, or repo-wide crawling.
 `;
 }
-function renderAuditStats(report) {
-    const stats = report.run.auditStats;
-    if (!stats)
-        return "";
-    return `  ${stats.totalTargets} targets reviewed: ${stats.finding} finding, ${stats.uncertain} uncertain, ${stats.clean} clean, ${stats.invalid} invalid`;
+function sourceHint(command) {
+    if (command.kind === "staged")
+        return "--staged";
+    if (command.kind === "since")
+        return `--since "${command.since}"`;
+    if (command.kind === "commit")
+        return `--commit ${command.commit}`;
+    if (command.kind === "commits")
+        return `--commits ${command.count}`;
+    return "--stdin";
 }

package/dist/repomix-provider.d.ts

@@ -1,4 +1,12 @@
-import type { SemCandidate, SemChange, SemContext, SemContextPack } from "./types.ts";
+import type { RepomixSearchConfig, SemCandidate, SemChange, SemContext, SemContextPack } from "./types.ts";
 export declare function emptyContextPack(): SemContextPack;
-export declare function repomixContextPack(cwd: string, contexts: readonly SemContext[], changes: readonly SemChange[]): Promise<SemContextPack>;
+export declare function repomixContextPack(cwd: string, contexts: readonly SemContext[], changes: readonly SemChange[], config?: Readonly<{
+    compress: boolean;
+    showLineNumbers: boolean;
+    removeEmptyLines: boolean;
+    maxFileSizeBytes: number;
+    maxTotalSizeBytes: number;
+    ignorePatterns: readonly string[];
+}>): Promise<SemContextPack>;
 export declare function entityContextsFromChanges(candidates: readonly SemCandidate[], changes: readonly SemChange[]): readonly SemContext[];
+export declare function repomixSearchConfig(): RepomixSearchConfig;