opencode-adaptive-snip 0.1.0

package/dist/analyze.d.ts

@@ -0,0 +1,23 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AnalyzeConfig, CommandPair, LLMAnalysisResponse } from "./types.js";
+import { SnipRuleStore } from "./store.js";
+type OpenCodeClient = PluginInput["client"];
+export declare class LearnAnalyzer {
+    private config;
+    private store;
+    private client;
+    private buffer;
+    private lastAnalysisAt;
+    private inFlight;
+    constructor(config: AnalyzeConfig, store: SnipRuleStore, client: OpenCodeClient);
+    addPair(pair: CommandPair): void;
+    shouldAnalyze(): boolean;
+    analyze(): Promise<LLMAnalysisResponse>;
+    private runAnalysis;
+    private buildClassifierSystemPrompt;
+    private buildRuleCrafterSystemPrompt;
+    private withSession;
+    buildUserPrompt(pairs?: CommandPair[]): string;
+    get bufferSize(): number;
+}
+export {};

package/dist/analyze.js

@@ -0,0 +1,333 @@
+import { ANALYSIS_JSON_SCHEMA, CLASSIFIER_JSON_SCHEMA } from "./types.js";
+import { SnipRuleStore } from "./store.js";
+const SENSITIVE_COMMAND_RE = /^(?:cat|less|more|head|tail|sed|awk|env|printenv|git\s+(?:show|grep)|git\s+diff(?!\s+--stat\b))\b/;
+function redactSensitiveText(text) {
+    return text
+        .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]+=*/gi, "$1[REDACTED]")
+        .replace(/\bsk-[A-Za-z0-9_-]{16,}\b/g, "sk-[REDACTED]")
+        .replace(/\b(api[_-]?key|token|secret|password|authorization)(\s*[:=]\s*)([^\s"'`]+)/gi, "$1$2[REDACTED]");
+}
+function shouldCollectPair(pair) {
+    return !SENSITIVE_COMMAND_RE.test(pair.command.trimStart());
+}
+export class LearnAnalyzer {
+    config;
+    store;
+    client;
+    buffer = [];
+    lastAnalysisAt = 0;
+    inFlight = null;
+    constructor(config, store, client) {
+        this.config = config;
+        this.store = store;
+        this.client = client;
+    }
+    addPair(pair) {
+        if (!shouldCollectPair(pair))
+            return;
+        this.buffer.push(pair);
+    }
+    shouldAnalyze() {
+        return (!this.inFlight &&
+            this.buffer.length >= this.config.batchSize &&
+            Date.now() - this.lastAnalysisAt >=
+                this.config.cooldownMinutes * 60 * 1000);
+    }
+    async analyze() {
+        if (this.inFlight)
+            return this.inFlight;
+        this.inFlight = this.runAnalysis().finally(() => {
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async runAnalysis() {
+        if (this.buffer.length === 0) {
+            return { rules: [] };
+        }
+        const pairs = this.buffer.slice(0, this.config.batchSize);
+        const classifierResult = await this.withSession("snip-classifier", async (sessionId) => {
+            const body = {
+                system: this.buildClassifierSystemPrompt(),
+                parts: [{ type: "text", text: this.buildUserPrompt(pairs) }],
+                format: { type: "json_schema", schema: CLASSIFIER_JSON_SCHEMA },
+            };
+            if (this.config.llmModel) {
+                body.model = this.config.llmModel;
+            }
+            const result = await this.client.session.prompt({
+                path: { id: sessionId },
+                body: body,
+            });
+            if (!result.data) {
+                throw new Error("Classifier prompt returned no data");
+            }
+            const textPart = result.data.parts?.find((p) => p.type === "text");
+            if (!textPart?.text) {
+                throw new Error("No text part in classifier response");
+            }
+            const parsed = JSON.parse(textPart.text);
+            if (!parsed || !Array.isArray(parsed.decisions)) {
+                throw new Error("Classifier returned invalid JSON");
+            }
+            return parsed;
+        });
+        if (!classifierResult.ok) {
+            this.lastAnalysisAt = Date.now();
+            return { rules: [] };
+        }
+        const yesCommands = new Set(classifierResult.value.decisions.filter((d) => d.shouldSnip).map((d) => d.command));
+        if (yesCommands.size === 0) {
+            this.buffer = this.buffer.slice(pairs.length);
+            this.lastAnalysisAt = Date.now();
+            return { rules: [] };
+        }
+        const yesPairs = pairs.filter((p) => yesCommands.has(p.command));
+        const crafterResult = await this.withSession("snip-rule-crafter", async (sessionId) => {
+            const body = {
+                system: this.buildRuleCrafterSystemPrompt(),
+                parts: [{ type: "text", text: this.buildUserPrompt(yesPairs) }],
+                format: { type: "json_schema", schema: ANALYSIS_JSON_SCHEMA },
+            };
+            if (this.config.llmModel) {
+                body.model = this.config.llmModel;
+            }
+            const result = await this.client.session.prompt({
+                path: { id: sessionId },
+                body: body,
+            });
+            if (!result.data) {
+                throw new Error("Rule crafter prompt returned no data");
+            }
+            const textPart = result.data.parts?.find((p) => p.type === "text");
+            if (!textPart?.text) {
+                throw new Error("No text part in rule crafter response");
+            }
+            const parsed = JSON.parse(textPart.text);
+            if (!parsed || !Array.isArray(parsed.rules)) {
+                throw new Error("Rule crafter returned invalid JSON");
+            }
+            return parsed;
+        });
+        if (!crafterResult.ok) {
+            this.lastAnalysisAt = Date.now();
+            return { rules: [] };
+        }
+        if (this.config.autoLearn) {
+            await this.store.mergeLearned(crafterResult.value.rules, this.config.minConfidence, this.config.maxRules);
+        }
+        this.buffer = this.buffer.slice(pairs.length);
+        this.lastAnalysisAt = Date.now();
+        return crafterResult.value;
+    }
+    buildClassifierSystemPrompt() {
+        return `[ROLE]
+You are a shell command classifier. Your only task is to decide whether each
+command-output pair would benefit from "snip" preprocessing — a tool that
+filters and summarizes shell command output to reduce token usage for LLMs.
+
+[TASK]
+For each command-output pair below, classify it as:
+- shouldSnip=true: Output is verbose, repetitive, or large enough to warrant snip
+- shouldSnip=false: Output is short, essential, or already concise
+
+[CONSTRAINTS]
+
+SHOULD SNIP (return true) when output is:
+1. Very long (> 1000 lines or > 50000 characters)
+2. Highly repetitive (test results, build logs, linter warnings)
+3. Contains progress bars, ANSI codes, spinners, verbose debug output
+4. Would consume significant LLM context (> 10000 tokens)
+
+MUST NOT SNIP (return false) when output is:
+1. Short and informative (< 500 characters)
+2. Essential for LLM task (file contents, git diffs, error stacks)
+3. Already concise, well-structured, low-token
+4. Shell builtins (cd, export, echo, pwd, alias, source, type, unset, read, ulimit)
+
+[OUTPUT FORMAT]
+Return ONLY valid JSON. Start with {, end with }. No markdown fences.
+{
+  "decisions": [
+    { "command": "...", "shouldSnip": true, "reason": "..." }
+  ]
+}
+
+[FEW-SHOT EXAMPLES]
+
+Example 1 — Short informative output (NO snip):
+Input:
+---
+Command: git diff --stat
+Output (first 5000 chars):
+ src/auth.ts      |  12 +++++++++---
+ src/config.ts    |   5 +++--
+ 2 files changed, 14 insertions(+), 5 deletions(-)
+Duration: 300ms
+---
+Expected:
+{"decisions":[{"command":"git diff --stat","shouldSnip":false,"reason":"Short diff stat output, ~100 chars, essential for understanding changes"}]}
+
+Example 2 — Verbose test output (SNIP):
+Input:
+---
+Command: npm test
+Output (first 5000 chars):
+> myapp@1.0.0 test
+> jest --verbose
+
+PASS src/auth.test.ts
+  ✓ should login (45ms)
+  ✓ should logout (12ms)
+  ✓ should reject invalid token (8ms)
+  ... (1200 more lines of test output)
+Duration: 45000ms
+---
+Expected:
+{"decisions":[{"command":"npm test","shouldSnip":true,"reason":"1200+ lines of test output, highly repetitive, 45s duration"}]}
+
+[INSTRUCTION]
+Analyze each command-output pair. Be conservative — if unsure, return false.
+Return exactly one decision per input pair. Start your response with {"decisions":`;
+    }
+    buildRuleCrafterSystemPrompt() {
+        return `[ROLE]
+You are a regex pattern crafter specializing in shell command matching.
+Given commands that have been classified as needing "snip" preprocessing,
+create precise regex patterns and snip prefix configurations.
+
+[TASK]
+For each command that needs snip, create:
+1. A regex pattern that matches the command (and similar variants)
+2. A snip prefix with appropriate timeout
+3. A confidence score
+
+[SNIP PREFIX RULES]
+- Default for most commands: "snip"
+- Slow commands (tests, builds, compilations): "snip --timeout 120"
+- Very slow commands (cargo, mvn, docker build): "snip --timeout 180"
+- Git commands: "snip" (no timeout needed)
+
+[REGEX PATTERN RULES]
+- ALWAYS anchor with ^ (start of string)
+- Match command name and common subcommands with alternation: ^cmd (sub1|sub2)
+- Use simple groups, avoid complex lookaheads/backreferences
+- Do NOT overfit to exact arguments (^(npm test).* is WRONG)
+- Escape special chars: \\+ \\| \\. \\* \\? \\[ \\] \\( \\)
+- CORRECT:  ^go (test|build|vet|lint)
+- CORRECT:  ^npm (install|test|run build)
+- CORRECT:  ^cargo (test|build|clippy)
+- INCORRECT: ^go test .*  (overfit, matches exact args)
+- INCORRECT: go test      (missing ^ anchor)
+- INCORRECT: ^npm test -v (overfit to flags)
+
+[CONFIDENCE]
+- 0.90-1.00: Output is clearly, consistently, and severely excessive
+- 0.70-0.89: Likely excessive with some ambiguity
+- 0.50-0.69: Possibly useful but uncertain — include if evidence supports it
+- BELOW 0.50: MUST NOT output. Omit from rules array entirely.
+
+[OUTPUT FORMAT]
+Return ONLY valid JSON. Start with {, end with }. No markdown fences.
+{
+  "rules": [
+    {
+      "pattern": "regex pattern here",
+      "snip": "snip prefix here",
+      "confidence": 0.95,
+      "description": "why this rule was created"
+    }
+  ]
+}
+
+[FEW-SHOT EXAMPLES]
+
+Example 1 — Verbose test runner:
+Input:
+---
+Command: npm test
+Output (first 5000 chars):
+> myapp@1.0.0 test
+> jest --verbose
+
+PASS src/auth.test.ts
+  ✓ should login (45ms)
+  ✓ should logout (12ms)
+  ✓ should reject invalid token (8ms)
+  ... (1200 more lines of test output)
+Duration: 45000ms
+---
+Expected:
+{"rules":[{"pattern":"^npm test","snip":"snip --timeout 120","confidence":0.95,"description":"npm test produces 1200+ lines of test runner output, duration 45s"}]}
+
+Example 2 — Build system:
+Input:
+---
+Command: cargo build
+Output (first 5000 chars):
+   Compiling serde v1.0.210
+   Compiling tokio v1.42.0
+   Compiling myapp v0.1.0 (/home/user/myapp)
+   ... (800 more lines of compilation output)
+warning: unused import: \`std::mem\`
+ --> src/main.rs:3:5
+  |
+3 | use std::mem;
+  |     ^^^^^^^^
+  |
+  = note: \`#[warn(unused_imports)]\` on by default
+Duration: 120000ms
+---
+Expected:
+{"rules":[{"pattern":"^cargo build","snip":"snip --timeout 180","confidence":0.98,"description":"cargo build produces 800+ lines of compilation output with warnings, duration 120s"}]}
+
+[INSTRUCTION]
+For each command, craft ONE precise regex rule. Be conservative — if unsure about confidence, use lower value.
+Start your response with {"rules":`;
+    }
+    async withSession(title, fn) {
+        let session = null;
+        try {
+            session = await this.client.session.create({
+                body: { title },
+            });
+            if (!session.data?.id) {
+                console.warn(`[adaptive-snip] ${title} session creation returned no ID`);
+                return { ok: false };
+            }
+            return { ok: true, value: await fn(session.data.id) };
+        }
+        catch (e) {
+            console.warn(`[adaptive-snip] ${title} session failed:`, e);
+            return { ok: false };
+        }
+        finally {
+            if (session?.data?.id) {
+                try {
+                    await this.client.session.delete({ path: { id: session.data.id } });
+                }
+                catch (e) {
+                    console.warn(`[adaptive-snip] Failed to cleanup ${title} session:`, e);
+                }
+            }
+        }
+    }
+    buildUserPrompt(pairs) {
+        const limit = this.config.batchSize;
+        const source = pairs ?? this.buffer;
+        const selected = source.slice(0, limit);
+        let prompt = "";
+        for (const pair of selected) {
+            const output = pair.output.length > 5000
+                ? pair.output.slice(0, 5000)
+                : pair.output;
+            const command = redactSensitiveText(pair.command);
+            const truncatedOutput = redactSensitiveText(output);
+            prompt += `---\nCommand: ${command}\nOutput (first 5000 chars):\n${truncatedOutput}\nDuration: ${pair.duration}ms\n---\n\n`;
+        }
+        return prompt;
+    }
+    get bufferSize() {
+        return this.buffer.length;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { AdaptiveSnipOptions, NormalizedAdaptiveSnipOptions } from "./types.js";
+export declare function normalizeConfig(options?: Partial<AdaptiveSnipOptions>, projectDir?: string): Promise<NormalizedAdaptiveSnipOptions>;

package/dist/config.js

@@ -0,0 +1,81 @@
+import { join, relative, resolve } from "node:path";
+const DEFAULT_ANALYZE = {
+    enabled: true,
+    autoLearn: true,
+    batchSize: 20,
+    minConfidence: 0.7,
+    maxRules: 50,
+    cooldownMinutes: 60,
+};
+const DISABLED_ANALYZE = {
+    enabled: false,
+    autoLearn: false,
+    batchSize: 20,
+    minConfidence: 0.7,
+    maxRules: 50,
+    cooldownMinutes: 60,
+};
+const DEFAULT_RULE_FILE = ".opencode/snip-rules.json";
+/** Auto-discovered config file name in project root */
+const DEFAULT_CONFIG_FILE = "adaptive-snip.json";
+const DEFAULT_OPTIONS_PARTIAL = {
+    analyze: undefined,
+    rules: [],
+    fallback: undefined,
+    ruleFile: DEFAULT_RULE_FILE,
+};
+function normalizeAnalyze(analyze) {
+    if (analyze === true)
+        return { ...DEFAULT_ANALYZE };
+    if (analyze === false)
+        return { ...DISABLED_ANALYZE };
+    if (analyze === undefined)
+        return { ...DISABLED_ANALYZE };
+    const merged = { ...DEFAULT_ANALYZE, ...analyze };
+    if (merged.autoLearn && !merged.enabled) {
+        console.warn("[adaptive-snip] analyze.autoLearn=true but analyze.enabled=false; forcing autoLearn=false");
+        merged.autoLearn = false;
+    }
+    return merged;
+}
+async function loadConfigFile(projectDir) {
+    const fullPath = join(projectDir, DEFAULT_CONFIG_FILE);
+    try {
+        const file = Bun.file(fullPath);
+        return await file.json();
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code === "ENOENT")
+            return {};
+        console.warn(`[adaptive-snip] Failed to load ${DEFAULT_CONFIG_FILE}: ${e}`);
+        return {};
+    }
+}
+function resolveRuleFile(ruleFile, projectDir) {
+    if (!projectDir)
+        return ruleFile;
+    const root = resolve(projectDir);
+    const fullPath = resolve(root, ruleFile);
+    const rel = relative(root, fullPath);
+    if (rel === "" || (!rel.startsWith("..") && !rel.startsWith("/") && rel !== "..")) {
+        return ruleFile;
+    }
+    console.warn(`[adaptive-snip] Ignoring ruleFile outside project directory: ${ruleFile}`);
+    return DEFAULT_RULE_FILE;
+}
+export async function normalizeConfig(options, projectDir) {
+    const fileConfig = projectDir
+        ? await loadConfigFile(projectDir)
+        : {};
+    const merged = {
+        ...DEFAULT_OPTIONS_PARTIAL,
+        ...fileConfig,
+        ...(options ?? {}),
+    };
+    const analyze = normalizeAnalyze(merged.analyze);
+    const rules = [...(merged.rules ?? [])];
+    const fallback = merged.fallback === null ? null : (merged.fallback ?? undefined);
+    const ruleFile = resolveRuleFile(merged.ruleFile ?? DEFAULT_RULE_FILE, projectDir);
+    return { analyze, rules, fallback, ruleFile };
+}

package/dist/events.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import { LearnAnalyzer } from "./analyze.js";
+export declare function createEventListener(analyzer: LearnAnalyzer | null): NonNullable<Hooks["event"]>;

package/dist/events.js

@@ -0,0 +1,57 @@
+import { LearnAnalyzer } from "./analyze.js";
+export function createEventListener(analyzer) {
+    const pending = new Map();
+    const STALE_MS = 10 * 60 * 1000;
+    function cleanupStale() {
+        const now = Date.now();
+        for (const [callID, entry] of pending) {
+            if (now - entry.startedAt > STALE_MS) {
+                pending.delete(callID);
+            }
+        }
+    }
+    return ({ event }) => {
+        if (!analyzer)
+            return Promise.resolve();
+        if (event.type === "session.next.shell.started") {
+            const started = event.properties;
+            pending.set(started.callID, {
+                command: started.command,
+                startedAt: Date.now(),
+            });
+            cleanupStale();
+            return Promise.resolve();
+        }
+        if (event.type === "session.next.shell.ended") {
+            const ended = event.properties;
+            const started = pending.get(ended.callID);
+            if (!started) {
+                console.warn("[adaptive-snip] Unpaired shell.ended event for callID:", ended.callID);
+                return Promise.resolve();
+            }
+            pending.delete(ended.callID);
+            const output = typeof ended.output === "string"
+                ? ended.output
+                : JSON.stringify(ended.output);
+            const truncatedOutput = output.length > 5000
+                ? output.slice(0, 5000) + "... [truncated]"
+                : output;
+            const endedAt = Date.now();
+            const pair = {
+                callID: ended.callID,
+                command: started.command,
+                output: truncatedOutput,
+                startedAt: started.startedAt,
+                endedAt,
+                duration: endedAt - started.startedAt,
+            };
+            analyzer.addPair(pair);
+            if (analyzer.shouldAnalyze()) {
+                analyzer.analyze().catch((e) => {
+                    console.warn("[adaptive-snip] Analyzer.analyze() failed:", e);
+                });
+            }
+        }
+        return Promise.resolve();
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { Hooks, PluginInput } from "./types.js";
+export declare function adaptiveSnip(input: PluginInput, options?: Record<string, unknown>): Promise<Hooks>;
+declare const _default: {
+    server: typeof adaptiveSnip;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,20 @@
+import { normalizeConfig } from "./config.js";
+import { SnipRuleStore } from "./store.js";
+import { LearnAnalyzer } from "./analyze.js";
+import { createSnipHook } from "./snip.js";
+import { createEventListener } from "./events.js";
+export async function adaptiveSnip(input, options) {
+    const opts = await normalizeConfig(options, input.directory);
+    const store = new SnipRuleStore(input.directory, opts.ruleFile);
+    let analyzer = null;
+    if (opts.analyze.enabled) {
+        analyzer = new LearnAnalyzer(opts.analyze, store, input.client);
+    }
+    return Promise.resolve({
+        event: createEventListener(analyzer),
+        "tool.execute.before": createSnipHook(opts, store),
+    });
+}
+export default {
+    server: adaptiveSnip,
+};

package/dist/rules.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledSnipRule, SnipFallback, SnipRule } from "./types.js";
+export declare function compileRules(rules: SnipRule[]): CompiledSnipRule[];
+export declare function matchRule(cmd: string, compiled: CompiledSnipRule[]): CompiledSnipRule | null;
+export declare function resolveSnip(cmd: string, compiled: CompiledSnipRule[], fallback?: SnipFallback | null): string | null;

package/dist/rules.js

@@ -0,0 +1,39 @@
+function sanitizeFlags(flags) {
+    return [...new Set((flags ?? "").replace(/[gy]/g, "").split(""))].join("");
+}
+export function compileRules(rules) {
+    const compiled = [];
+    for (const rule of rules) {
+        try {
+            const regex = new RegExp(rule.pattern, sanitizeFlags(rule.flags));
+            compiled.push({
+                regex,
+                snip: rule.snip,
+                source: rule.source,
+                confidence: rule.confidence,
+            });
+        }
+        catch {
+            console.warn(`[adaptive-snip] Invalid regex in rule: ${rule.pattern}`);
+        }
+    }
+    return compiled;
+}
+export function matchRule(cmd, compiled) {
+    for (const rule of compiled) {
+        rule.regex.lastIndex = 0;
+        if (rule.regex.test(cmd)) {
+            rule.regex.lastIndex = 0;
+            return rule;
+        }
+    }
+    return null;
+}
+export function resolveSnip(cmd, compiled, fallback) {
+    const match = matchRule(cmd, compiled);
+    if (match)
+        return match.snip;
+    if (fallback)
+        return fallback.prefix;
+    return null;
+}

package/dist/snip.d.ts

@@ -0,0 +1,4 @@
+import type { AdaptiveSnipOptions } from "./types.js";
+import { SnipRuleStore } from "./store.js";
+import type { Hooks } from "@opencode-ai/plugin";
+export declare function createSnipHook(opts: AdaptiveSnipOptions, store: SnipRuleStore): NonNullable<Hooks["tool.execute.before"]>;

package/dist/snip.js

@@ -0,0 +1,57 @@
+import { isAlreadyPrefixed, isOperatorSegment, parseCommand, splitOperators } from "./utils.js";
+import { compileRules, resolveSnip } from "./rules.js";
+import { SnipRuleStore } from "./store.js";
+export function createSnipHook(opts, store) {
+    return async ({ tool }, output) => {
+        if (tool !== "bash")
+            return;
+        const cmd = output.args?.command;
+        if (!cmd || typeof cmd !== "string")
+            return;
+        const parsed = parseCommand(cmd);
+        const learnedRules = await store.getCompiledsnipRules();
+        const configRules = compileRules(opts.rules ?? []);
+        const allRules = [...configRules, ...learnedRules];
+        function prefixSegment(segment) {
+            const leading = segment.match(/^\s*/)?.[0] ?? "";
+            const trailing = segment.match(/\s*$/)?.[0] ?? "";
+            const core = segment.slice(leading.length, segment.length - trailing.length);
+            if (!core)
+                return segment;
+            const segmentParsed = parseCommand(core);
+            if (!segmentParsed.bareCommand.trim())
+                return segment;
+            if (segmentParsed.isBuiltin)
+                return segment;
+            const prefix = resolveSnip(segmentParsed.bareCommand, allRules, opts.fallback);
+            if (!prefix)
+                return segment;
+            if (isAlreadyPrefixed(segmentParsed.bareCommand, prefix))
+                return segment;
+            if (segmentParsed.hasPipe && segmentParsed.pipeIndex !== undefined) {
+                const beforePipe = segmentParsed.bareCommand
+                    .slice(0, segmentParsed.pipeIndex)
+                    .trimEnd();
+                const afterPipe = segmentParsed.bareCommand.slice(segmentParsed.pipeIndex);
+                return `${leading}${segmentParsed.envPrefix}${prefix} ${beforePipe} ${afterPipe}${trailing}`;
+            }
+            return `${leading}${segmentParsed.envPrefix}${prefix} ${segmentParsed.bareCommand}${trailing}`;
+        }
+        if (!parsed.bareCommand.trim())
+            return;
+        if (parsed.isBuiltin)
+            return;
+        const segments = splitOperators(cmd);
+        if (segments.length === 1) {
+            const next = prefixSegment(cmd);
+            if (next !== cmd)
+                output.args.command = next;
+            return;
+        }
+        const prefixed = segments
+            .map((segment) => isOperatorSegment(segment) ? segment : prefixSegment(segment))
+            .join("");
+        if (prefixed !== cmd)
+            output.args.command = prefixed;
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,12 @@
+import type { CompiledSnipRule, LLMRuleSuggestion, RuleStore } from "./types.js";
+export declare function resolveProjectPath(projectDir: string, filePath: string): string;
+export declare function isSafeSnipPrefix(prefix: string): boolean;
+export declare class SnipRuleStore {
+    private projectDir;
+    private filePath;
+    constructor(projectDir: string, filePath: string);
+    load(): Promise<RuleStore>;
+    save(store: RuleStore): Promise<void>;
+    getCompiledsnipRules(): Promise<CompiledSnipRule[]>;
+    mergeLearned(suggestions: LLMRuleSuggestion[], minConfidence: number, maxRules: number): Promise<RuleStore>;
+}