@stupify/cli 0.0.2 → 0.0.4

package/dist/hooks.js

@@ -0,0 +1,117 @@
+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.js";
+const execFileAsync = promisify(execFile);
+const START = "# stupify hook start";
+const END = "# stupify hook end";
+export async function runHookCommand(action) {
+    if (action === "status")
+        return hookStatus();
+    if (action === "install")
+        return installHook();
+    return uninstallHook();
+}
+export function hookSnippet() {
+    return managedBlock("stupify --staged");
+}
+async function hookStatus() {
+    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() {
+    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() {
+    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() {
+    const [root, hook] = await Promise.all([gitRoot(), gitPath("hooks/pre-commit")]);
+    return path.isAbsolute(hook) ? hook : path.join(root, hook);
+}
+function hasManagedBlock(content) {
+    return content.includes(START) && content.includes(END);
+}
+async function managedBlockForInstall() {
+    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) {
+    return `${START}
+${command} || true
+${END}`;
+}
+function replaceManagedBlock(content, replacement) {
+    const pattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}`);
+    return content.replace(pattern, replacement);
+}
+function isEffectivelyEmptyHook(content) {
+    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) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], {
+            maxBuffer: 1024 * 1024,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { main } from "./stupify.ts";

package/dist/index.js

@@ -0,0 +1 @@
+export { main } from "./stupify.js";

package/dist/model.d.ts

@@ -0,0 +1,10 @@
+import type { ModelId } from "./types.ts";
+export type ModelProfile = "scout";
+export type LocalModel = 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

@@ -0,0 +1,297 @@
+import { execFile, spawn } from "node:child_process";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, open, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { stdin as input, stderr as statusOutput, stdout as output, } from "node:process";
+import { createInterface } from "node:readline/promises";
+import path from "node:path";
+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 firstRunModelBootstrap(modelId) {
+    const selectedModel = MODEL_REGISTRY[modelId];
+    const modelDir = path.join(cacheDir(), "models");
+    const modelPath = path.join(modelDir, selectedModel.file);
+    if (await exists(modelPath))
+        return modelPath;
+    console.error(`No local Stupify model found.
+Stupify runs locally.
+Download this model now?
+Model: ${selectedModel.name}
+Size: ${selectedModel.size}`);
+    if (!(await confirm("Continue? y/N ")))
+        throw new Error("Setup cancelled.");
+    await mkdir(modelDir, { recursive: true });
+    await downloadModel(modelPath, selectedModel.url);
+    if (!(await exists(modelPath)))
+        throw new Error("Model download failed: file was not created.");
+    return modelPath;
+}
+export async function loadLocalModel(modelPath, modelId, profile = "scout") {
+    const selectedModel = MODEL_REGISTRY[modelId];
+    const runtime = modelRuntime(profile);
+    const runningModel = await runningServerModel(runtime.baseUrl);
+    if (runningModel) {
+        if (runningModel !== modelId)
+            await stopManagedServer(runtime);
+        if (runningModel === modelId) {
+            console.error(`Using already-loaded local ${profile} model: ${selectedModel.name}`);
+            return {
+                id: modelId,
+                name: selectedModel.name,
+                baseUrl: runtime.baseUrl,
+                profile,
+            };
+        }
+    }
+    await ensureLlamaServerBinary();
+    await startLlamaServer(modelPath, modelId, selectedModel.name, runtime);
+    await waitForServer(runtime.baseUrl, modelId);
+    return {
+        id: modelId,
+        name: selectedModel.name,
+        baseUrl: runtime.baseUrl,
+        profile,
+    };
+}
+function modelRuntime(profile) {
+    const baseUrl = process.env.STUPIFY_SCOUT_LLAMA_SERVER_URL ??
+        process.env.STUPIFY_LLAMA_SERVER_URL ??
+        "http://127.0.0.1:8091";
+    return {
+        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) {
+    try {
+        const response = await fetch(`${baseUrl}/v1/models`, {
+            signal: AbortSignal.timeout(500),
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        const id = body.data?.[0]?.id;
+        return typeof id === "string" ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureLlamaServerBinary() {
+    try {
+        await execFileAsync("llama-server", ["--version"], {
+            maxBuffer: 1024 * 1024,
+        });
+    }
+    catch {
+        throw new Error(`Stupify needs llama-server for local inference.
+Install llama.cpp first:
+  brew install llama.cpp`);
+    }
+}
+async function startLlamaServer(modelPath, modelId, modelName, runtime) {
+    const logDir = path.join(cacheDir(), "logs");
+    await mkdir(logDir, { recursive: true });
+    const logPath = path.join(logDir, "llama-server.log");
+    const out = await open(logPath, "a");
+    const err = await open(logPath, "a");
+    console.error(`Starting local ${runtime.profile} model server: ${modelName}`);
+    console.error(`llama-server log: ${logPath}`);
+    const args = [
+        "-m",
+        modelPath,
+        "-a",
+        modelId,
+        "--host",
+        LLAMA_SERVER_HOST,
+        "--port",
+        runtime.port,
+        "-c",
+        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));
+    }
+    const child = spawn("llama-server", args, {
+        detached: true,
+        stdio: ["ignore", out.fd, err.fd],
+    });
+    child.unref();
+    if (child.pid)
+        await writeFile(pidPath(runtime), String(child.pid));
+    await out.close();
+    await err.close();
+}
+async function stopManagedServer(runtime) {
+    const pid = await managedServerPid(runtime);
+    if (!pid) {
+        const runningModel = await runningServerModel(runtime.baseUrl);
+        throw new Error(`A llama-server is already running with ${runningModel ?? "another model"}.
+Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server.`);
+    }
+    console.error(`Restarting local ${runtime.profile} model server for selected model.`);
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        await rm(pidPath(runtime), { force: true });
+        return;
+    }
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+        if (!(await runningServerModel(runtime.baseUrl))) {
+            await rm(pidPath(runtime), { force: true });
+            return;
+        }
+        await sleep(250);
+    }
+    throw new Error("Timed out while stopping existing llama-server.");
+}
+async function managedServerPid(runtime) {
+    try {
+        const value = Number((await readFile(pidPath(runtime), "utf8")).trim());
+        return Number.isInteger(value) && value > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function pidPath(runtime) {
+    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;
+    while (Date.now() < deadline) {
+        const runningModel = await runningServerModel(baseUrl);
+        if (runningModel === modelId)
+            return;
+        await sleep(500);
+    }
+    throw new Error(`llama-server did not become ready for ${modelId}.`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function downloadModel(modelPath, modelUrl) {
+    const tempPath = `${modelPath}.download`;
+    await rm(tempPath, { force: true });
+    console.error("Downloading model...");
+    try {
+        const response = await fetch(modelUrl);
+        if (!response.ok || !response.body)
+            throw new Error(`Model download failed: HTTP ${response.status}`);
+        const total = Number(response.headers.get("content-length") ?? 0);
+        let received = 0;
+        let lastPrint = 0;
+        const reader = response.body.getReader();
+        const file = await open(tempPath, "wx");
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                received += value.byteLength;
+                await file.write(value);
+                const now = Date.now();
+                if (total > 0 && now - lastPrint > 500) {
+                    lastPrint = now;
+                    statusOutput.write(`\r${formatBytes(received)} / ${formatBytes(total)}`);
+                }
+            }
+        }
+        finally {
+            await file.close();
+        }
+        if (total > 0)
+            statusOutput.write(`\r${formatBytes(received)} / ${formatBytes(total)}\n`);
+        await rename(tempPath, modelPath);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+}
+async function confirm(question) {
+    const rl = createInterface(terminalIo());
+    try {
+        const answer = (await rl.question(question)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+function terminalIo() {
+    if (input.isTTY)
+        return { input, output };
+    if (platform() !== "win32")
+        return {
+            input: createReadStream("/dev/tty"),
+            output: createWriteStream("/dev/tty"),
+        };
+    throw new Error("No local Stupify model found. Run `stupify` once in an interactive terminal to set up the model.");
+}
+function cacheDir() {
+    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");
+}
+async function exists(filePath) {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function formatBytes(bytes) {
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/dist/prompts.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,87 @@
+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:
+{
+  "matches": [
+    {
+      "targetId": "t001",
+      "reason": "one sentence",
+      "proof": "short pointer"
+    }
+  ]
+}
+
+Rules:
+- Use only targetIds from the input.
+- Emit at most 5 matches.
+- Prefer omission over a weak match.
+- Do not quote source code.
+- 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:
+${input.changeSet.label}
+
+SEARCH TARGETS:
+${input.contexts.map((context) => formatSearchTarget(context, patternForContext(context, input.patterns), input.includeCounterReason)).join("\n\n") || "(none)"}
+
+REPOMIX CONTEXT (${input.pack.filePaths.length} files, ${input.pack.totalTokens} tokens):
+${input.pack.text || "(none)"}`;
+}
+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.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 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}
+FILE ${context.filePath ?? "(unknown)"}
+${includeCounterReason ? `COUNTER_REASON ${context.reason}` : ""}`.trim();
+}
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,93 @@
+import { VERSION } from "./constants.js";
+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 (run.stats.skipped && run.stats.skipReason === "no_candidates") {
+        return `🧙 stupify 🪄
+Search complete.
+Patterns: ${run.patterns.join(", ")}
+No search targets found.`;
+    }
+    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}
+
+Usage:
+  stupify
+  stupify --since "2 weeks ago"
+  stupify --commit <commit>
+  stupify --commits <count>
+  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:
+  --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:
+  Findings audit, validators, judges, baselines, sharing, hosted server calls, GitHub, dashboards, or repo-wide crawling.
+`;
+}
+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

@@ -0,0 +1,12 @@
+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[], 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;