opencode-adaptive-snip 0.1.0

package/dist/store.js

@@ -0,0 +1,119 @@
+import { renameSync, mkdirSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { compileRules } from "./rules.js";
+export function resolveProjectPath(projectDir, filePath) {
+    const root = resolve(projectDir);
+    const fullPath = resolve(root, filePath);
+    const rel = relative(root, fullPath);
+    if (rel === "" || (!rel.startsWith("..") && !rel.startsWith("/") && rel !== "..")) {
+        return fullPath;
+    }
+    throw new Error(`Path escapes project directory: ${filePath}`);
+}
+export function isSafeSnipPrefix(prefix) {
+    return /^snip(?:\s+[A-Za-z0-9][A-Za-z0-9._=:/-]*|\s+--[A-Za-z0-9][A-Za-z0-9._=:/-]*)*$/.test(prefix);
+}
+function isValidLearnedSuggestion(suggestion) {
+    if (!Number.isFinite(suggestion.confidence))
+        return false;
+    if (suggestion.confidence < 0 || suggestion.confidence > 1)
+        return false;
+    if (!suggestion.pattern.startsWith("^"))
+        return false;
+    if (!isSafeSnipPrefix(suggestion.snip))
+        return false;
+    try {
+        new RegExp(suggestion.pattern);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class SnipRuleStore {
+    projectDir;
+    filePath;
+    constructor(projectDir, filePath) {
+        this.projectDir = projectDir;
+        this.filePath = filePath;
+    }
+    async load() {
+        const fullPath = resolveProjectPath(this.projectDir, this.filePath);
+        try {
+            const file = Bun.file(fullPath);
+            return await file.json();
+        }
+        catch (e) {
+            const err = e;
+            if (err?.code === "ENOENT") {
+                return { version: 1, rules: [] };
+            }
+            console.warn(`[adaptive-snip] Failed to load rule store: ${e}`);
+            return { version: 1, rules: [] };
+        }
+    }
+    async save(store) {
+        const fullPath = resolveProjectPath(this.projectDir, this.filePath);
+        const tmpPath = fullPath + ".tmp";
+        mkdirSync(dirname(fullPath), { recursive: true });
+        await Bun.write(tmpPath, JSON.stringify(store, null, 2));
+        renameSync(tmpPath, fullPath);
+    }
+    async getCompiledsnipRules() {
+        const store = await this.load();
+        return compileRules(store.rules);
+    }
+    async mergeLearned(suggestions, minConfidence, maxRules) {
+        const store = await this.load();
+        for (const suggestion of suggestions) {
+            if (suggestion.confidence < minConfidence)
+                continue;
+            if (!isValidLearnedSuggestion(suggestion)) {
+                console.warn("[adaptive-snip] Ignoring unsafe learned snip rule:", suggestion.pattern);
+                continue;
+            }
+            const configConflict = store.rules.some((r) => r.pattern === suggestion.pattern && r.source === "config");
+            if (configConflict)
+                continue;
+            const existingIndex = store.rules.findIndex((r) => r.pattern === suggestion.pattern && r.source === "learned");
+            if (existingIndex !== -1) {
+                const existing = store.rules[existingIndex];
+                if ((existing.confidence ?? 0) < suggestion.confidence) {
+                    store.rules[existingIndex] = {
+                        ...existing,
+                        snip: suggestion.snip,
+                        confidence: suggestion.confidence,
+                        description: suggestion.description ?? existing.description,
+                        updatedAt: new Date().toISOString(),
+                    };
+                }
+            }
+            else {
+                const newRule = {
+                    pattern: suggestion.pattern,
+                    snip: suggestion.snip,
+                    confidence: suggestion.confidence,
+                    description: suggestion.description,
+                    source: "learned",
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                store.rules.push(newRule);
+            }
+        }
+        const configRules = store.rules.filter((r) => r.source === "config");
+        const learnedRules = store.rules.filter((r) => r.source === "learned");
+        if (learnedRules.length > maxRules) {
+            learnedRules.sort((a, b) => (a.confidence ?? 0) - (b.confidence ?? 0));
+            const keep = learnedRules.slice(learnedRules.length - maxRules);
+            store.rules = [...configRules, ...keep];
+        }
+        store.analytics = {
+            ...store.analytics,
+            lastAnalysisAt: new Date().toISOString(),
+            totalCommandsAnalyzed: (store.analytics?.totalCommandsAnalyzed ?? 0) + suggestions.length,
+        };
+        await this.save(store);
+        return store;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,185 @@
+import type { Hooks, Plugin, PluginInput, PluginModule } from "@opencode-ai/plugin";
+export type { Hooks, Plugin, PluginInput, PluginModule };
+export interface SnipRule {
+    /** Regex pattern (JSON-serializable), e.g. "^go test" */
+    pattern: string;
+    /** Snip prefix to prepend, e.g. "snip --timeout 120", "snip" */
+    snip: string;
+    /** Regex flags, e.g. "i" for case-insensitive */
+    flags?: string;
+    /** Human-readable description */
+    description?: string;
+    /** Confidence 0-1, higher = more confident. LLM-generated only */
+    confidence?: number;
+    /** Origin of this rule */
+    source: "config" | "learned";
+    /** ISO 8601 timestamp */
+    createdAt?: string;
+    /** ISO 8601 timestamp */
+    updatedAt?: string;
+}
+export interface RuleStore {
+    /** Schema version */
+    version: number;
+    /** All rules (config + learned) */
+    rules: SnipRule[];
+    /** Analytics metadata */
+    analytics?: RuleAnalytics;
+}
+export interface RuleAnalytics {
+    /** Last time LLM analysis ran */
+    lastAnalysisAt?: string;
+    /** Total sessions plugin has been active in */
+    totalSessions?: number;
+    /** Total commands sent for LLM analysis */
+    totalCommandsAnalyzed?: number;
+}
+export interface CompiledSnipRule {
+    regex: RegExp;
+    snip: string;
+    source: "config" | "learned";
+    confidence?: number;
+}
+export interface AnalyzeConfig {
+    /** Whether analyze mode is enabled */
+    enabled: boolean;
+    /** Auto-create LLM sessions to learn from command patterns */
+    autoLearn: boolean;
+    /** Number of command-output pairs to buffer before analysis */
+    batchSize: number;
+    /** Minimum confidence to save a learned rule */
+    minConfidence: number;
+    /** Maximum number of learned rules to keep */
+    maxRules: number;
+    /** Override LLM model for analysis */
+    llmModel?: {
+        providerID: string;
+        modelID: string;
+    };
+    /** Minimum minutes between analyses */
+    cooldownMinutes: number;
+}
+export interface AdaptiveSnipOptions {
+    /** Analyze mode config. true = defaults, false = disabled */
+    analyze?: boolean | Partial<AnalyzeConfig>;
+    /** User-provided rules (source = "config"), highest priority */
+    rules?: SnipRule[];
+    /** Fallback snip prefix. null = no fallback. undefined = no fallback */
+    fallback?: SnipFallback | null;
+    /** Path relative to project dir, default ".opencode/snip-rules.json" */
+    ruleFile?: string;
+}
+export interface NormalizedAdaptiveSnipOptions {
+    /** Fully resolved analyze config */
+    analyze: AnalyzeConfig;
+    /** User-provided rules (source = "config"), highest priority */
+    rules: SnipRule[];
+    /** Fallback snip prefix. null/undefined = no fallback */
+    fallback?: SnipFallback | null;
+    /** Path relative to project dir */
+    ruleFile: string;
+}
+export interface SnipFallback {
+    /** Fallback snip prefix, e.g. "snip" */
+    prefix: string;
+}
+export interface CommandPair {
+    callID: string;
+    command: string;
+    output: string;
+    startedAt: number;
+    endedAt: number;
+    duration: number;
+}
+export interface ParsedCommand {
+    /** Env var prefix, e.g. "FOO=bar " or "" */
+    envPrefix: string;
+    /** Command after stripping env vars */
+    bareCommand: string;
+    /** Whether command is an unproxyable shell builtin */
+    isBuiltin: boolean;
+    /** Segments split by operators: ["cmd1", " && ", "cmd2"] */
+    segments: string[];
+    /** First segment before unquoted pipe */
+    firstPipeSegment: string;
+    /** Whether command has an unquoted pipe */
+    hasPipe: boolean;
+    /** Index of first unquoted pipe, or -1 */
+    pipeIndex?: number;
+}
+export interface LLMRuleSuggestion {
+    pattern: string;
+    snip: string;
+    confidence: number;
+    description?: string;
+}
+export interface LLMAnalysisResponse {
+    rules: LLMRuleSuggestion[];
+}
+export declare const ANALYSIS_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly rules: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly pattern: {
+                        readonly type: "string";
+                        readonly pattern: "^\\^";
+                        readonly description: "Regex to match the command";
+                    };
+                    readonly snip: {
+                        readonly type: "string";
+                        readonly pattern: "^snip(?:\\s+[A-Za-z0-9][A-Za-z0-9._=:/-]*|\\s+--[A-Za-z0-9][A-Za-z0-9._=:/-]*)*$";
+                        readonly description: "Snip prefix to prepend to command";
+                    };
+                    readonly confidence: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly maximum: 1;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["pattern", "snip", "confidence"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: readonly ["rules"];
+    readonly additionalProperties: false;
+};
+export interface ClassifierDecision {
+    command: string;
+    shouldSnip: boolean;
+    reason: string;
+}
+export interface ClassifierResponse {
+    decisions: ClassifierDecision[];
+}
+export declare const CLASSIFIER_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly decisions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly command: {
+                        readonly type: "string";
+                    };
+                    readonly shouldSnip: {
+                        readonly type: "boolean";
+                    };
+                    readonly reason: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["command", "shouldSnip", "reason"];
+            };
+        };
+    };
+    readonly required: readonly ["decisions"];
+};

package/dist/types.js

@@ -0,0 +1,54 @@
+// ── LLM Structured Output Schema (JSON Schema) ──
+export const ANALYSIS_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        rules: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        pattern: "^\\^",
+                        description: "Regex to match the command",
+                    },
+                    snip: {
+                        type: "string",
+                        pattern: "^snip(?:\\s+[A-Za-z0-9][A-Za-z0-9._=:/-]*|\\s+--[A-Za-z0-9][A-Za-z0-9._=:/-]*)*$",
+                        description: "Snip prefix to prepend to command",
+                    },
+                    confidence: {
+                        type: "number",
+                        minimum: 0,
+                        maximum: 1,
+                    },
+                    description: {
+                        type: "string",
+                    },
+                },
+                required: ["pattern", "snip", "confidence"],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: ["rules"],
+    additionalProperties: false,
+};
+export const CLASSIFIER_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        decisions: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    command: { type: "string" },
+                    shouldSnip: { type: "boolean" },
+                    reason: { type: "string" },
+                },
+                required: ["command", "shouldSnip", "reason"],
+            },
+        },
+    },
+    required: ["decisions"],
+};

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ParsedCommand } from "./types.js";
+export declare const ENV_VAR_RE: RegExp;
+export declare const UNPROXYABLE_COMMANDS: Set<string>;
+export declare const OPERATOR_RE: RegExp;
+export declare function readEnvPrefix(cmd: string): string;
+export declare function stripEnvPrefix(cmd: string): string;
+export declare function isBuiltin(cmd: string): boolean;
+export declare function findFirstPipe(cmd: string): number;
+export declare function splitOperators(cmd: string): string[];
+export declare function isOperatorSegment(segment: string): boolean;
+export declare function isAlreadyPrefixed(cmd: string, prefix: string): boolean;
+export declare function parseCommand(cmd: string): ParsedCommand;

package/dist/utils.js

@@ -0,0 +1,216 @@
+export const ENV_VAR_RE = /^([A-Za-z_][A-Za-z0-9_]*=[^\s]* +)*/;
+export const UNPROXYABLE_COMMANDS = new Set([
+    "cd",
+    "source",
+    ".",
+    "export",
+    "alias",
+    "unset",
+    "set",
+    "shopt",
+    "eval",
+    "exec",
+    "echo",
+    "pwd",
+    "type",
+    "read",
+    "ulimit",
+]);
+export const OPERATOR_RE = /(\s*(?:&&|\|\||;)\s*|\s&\s?)/;
+function isNameStart(ch) {
+    return !!ch && /[A-Za-z_]/.test(ch);
+}
+function isNameChar(ch) {
+    return !!ch && /[A-Za-z0-9_]/.test(ch);
+}
+function readQuoted(input, start) {
+    const quote = input[start];
+    let i = start + 1;
+    while (i < input.length) {
+        const ch = input[i];
+        if (quote === '"' && ch === "\\") {
+            i += 2;
+            continue;
+        }
+        if (ch === quote)
+            return i + 1;
+        i++;
+    }
+    return start;
+}
+function readEnvAssignment(input, start) {
+    let i = start;
+    if (!isNameStart(input[i]))
+        return start;
+    i++;
+    while (isNameChar(input[i]))
+        i++;
+    if (input[i] !== "=")
+        return start;
+    i++;
+    if (input[i] === "'" || input[i] === '"') {
+        const quotedEnd = readQuoted(input, i);
+        if (quotedEnd === i)
+            return start;
+        i = quotedEnd;
+    }
+    else {
+        while (i < input.length && !/\s/.test(input[i]))
+            i++;
+    }
+    if (i < input.length && !/\s/.test(input[i]))
+        return start;
+    while (i < input.length && /\s/.test(input[i]))
+        i++;
+    return i;
+}
+export function readEnvPrefix(cmd) {
+    let i = 0;
+    let last = 0;
+    while (i < cmd.length) {
+        const next = readEnvAssignment(cmd, i);
+        if (next === i)
+            break;
+        last = next;
+        i = next;
+    }
+    return cmd.slice(0, last);
+}
+export function stripEnvPrefix(cmd) {
+    return cmd.slice(readEnvPrefix(cmd).length);
+}
+export function isBuiltin(cmd) {
+    const firstWord = cmd.trimStart().split(/\s+/)[0] || "";
+    return UNPROXYABLE_COMMANDS.has(firstWord);
+}
+export function findFirstPipe(cmd) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < cmd.length; i++) {
+        const ch = cmd[i];
+        if (inSingle) {
+            if (ch === "'")
+                inSingle = false;
+            continue;
+        }
+        if (inDouble) {
+            if (ch === '"')
+                inDouble = false;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            continue;
+        }
+        if (ch === "\\") {
+            i++;
+            continue;
+        }
+        if (ch === "|") {
+            if (i + 1 < cmd.length && cmd[i + 1] === "|") {
+                i++;
+                continue;
+            }
+            return i;
+        }
+    }
+    return -1;
+}
+export function splitOperators(cmd) {
+    const parts = [];
+    let start = 0;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < cmd.length; i++) {
+        const ch = cmd[i];
+        if (inSingle) {
+            if (ch === "'")
+                inSingle = false;
+            continue;
+        }
+        if (inDouble) {
+            if (ch === "\\") {
+                i++;
+                continue;
+            }
+            if (ch === '"')
+                inDouble = false;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            continue;
+        }
+        if (ch === "\\") {
+            i++;
+            continue;
+        }
+        let opStart = -1;
+        let opEnd = -1;
+        if ((ch === "&" && cmd[i + 1] === "&") || (ch === "|" && cmd[i + 1] === "|")) {
+            opStart = i;
+            opEnd = i + 2;
+        }
+        else if (ch === ";") {
+            opStart = i;
+            opEnd = i + 1;
+        }
+        else if (ch === "&") {
+            opStart = i;
+            opEnd = i + 1;
+        }
+        if (opStart === -1)
+            continue;
+        while (opStart > start && /\s/.test(cmd[opStart - 1]))
+            opStart--;
+        while (opEnd < cmd.length && /\s/.test(cmd[opEnd]))
+            opEnd++;
+        parts.push(cmd.slice(start, opStart));
+        parts.push(cmd.slice(opStart, opEnd));
+        start = opEnd;
+        i = opEnd - 1;
+    }
+    parts.push(cmd.slice(start));
+    return parts;
+}
+export function isOperatorSegment(segment) {
+    return /^(?:\s*(?:&&|\|\||;|&)\s*)$/.test(segment);
+}
+export function isAlreadyPrefixed(cmd, prefix) {
+    const trimmed = cmd.trimStart();
+    if (!trimmed || !prefix)
+        return false;
+    const firstWord = trimmed.split(/\s+/)[0];
+    if (firstWord === "snip")
+        return true;
+    if (!trimmed.startsWith(prefix))
+        return false;
+    const next = trimmed[prefix.length];
+    return next === undefined || /\s/.test(next);
+}
+export function parseCommand(cmd) {
+    const envPrefix = readEnvPrefix(cmd);
+    const bareCommand = stripEnvPrefix(cmd);
+    const isB = isBuiltin(bareCommand);
+    const pipeIdx = findFirstPipe(bareCommand);
+    const hasPipe = pipeIdx !== -1;
+    const firstPipeSegment = hasPipe ? bareCommand.substring(0, pipeIdx) : bareCommand;
+    const segments = splitOperators(bareCommand);
+    return {
+        envPrefix,
+        bareCommand,
+        isBuiltin: isB,
+        segments,
+        firstPipeSegment,
+        hasPipe,
+        pipeIndex: hasPipe ? pipeIdx : undefined,
+    };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "opencode-adaptive-snip",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that learns verbose shell commands and automatically prefixes them with snip.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.dist.json",
+    "test": "bun test",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "snip",
+    "shell",
+    "llm"
+  ],
+  "packageManager": "bun@1.3.13",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@opencode-ai/plugin": "latest",
+    "@opencode-ai/sdk": "latest",
+    "typescript": "^5"
+  }
+}