@howaboua/opencode-chat 0.1.0

package/dist/semantic/index.d.ts

@@ -0,0 +1,41 @@
+export { ensureModel } from "./embedder";
+type IndexProgress = {
+    total: number;
+    processed: number;
+    indexed: number;
+    skipped: number;
+    chunks: number;
+    currentPath?: string;
+};
+type IndexOptions = {
+    mode?: "changed" | "full";
+    onProgress?: (progress: IndexProgress) => void;
+    maxTargets?: number;
+    maxBytes?: number;
+};
+export declare function ensureSemanticIndex(worktree: string, options?: IndexOptions): Promise<{
+    total: number;
+    processed: number;
+    indexed: number;
+    skipped: number;
+    chunks: number;
+    mode: "changed" | "full";
+    skippedReason?: undefined;
+} | {
+    total: number;
+    processed: number;
+    indexed: number;
+    skipped: number;
+    chunks: number;
+    mode: "changed" | "full";
+    skippedReason: string;
+}>;
+export declare function semanticSearch(worktree: string, query: string, limit: number): Promise<{
+    score: number;
+    path: string;
+    start_line: number;
+    end_line: number;
+    content: string;
+    embedding: Uint8Array;
+}[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/semantic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../semantic/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAoCxC,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,YAAY,GAAG;IAClB,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAA;IACzB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAA;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAoDD,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;;;;;;;;;;;;;;;;GAwGrF;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;UAQzE,MAAM;gBACA,MAAM;cACR,MAAM;aACP,MAAM;eACJ,UAAU;KAQxB"}

package/dist/semantic/index.js

@@ -0,0 +1,178 @@
+/**
+ * Semantic indexing and search orchestration.
+ * Coordinates chunking, embedding, and SQLite storage for vector search.
+ */
+import * as path from "path";
+import * as fs from "fs/promises";
+import { Database } from "bun:sqlite";
+import { chunkFile } from "./chunker";
+import { getEmbedder, encodeEmbedding, decodeEmbedding, cosineSimilarity, getModelDir } from "./embedder";
+export { ensureModel } from "./embedder";
+const DB_FILENAME = "semantic.sqlite";
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_CHUNKS_PER_FILE = 200;
+const EMBED_BATCH_SIZE = 16;
+const TEXT_EXTENSIONS = new Set([
+    ".md",
+    ".mdx",
+    ".txt",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".css",
+    ".html",
+    ".sh",
+    ".bash",
+    ".zsh",
+]);
+const SKIP_DIRS = [".git", "node_modules", ".opencode", "dist", "build", "out", ".next", ".turbo", "coverage"];
+function getDb(dbPath) {
+    const db = new Database(dbPath);
+    db.run("PRAGMA journal_mode = WAL");
+    db.run("PRAGMA synchronous = NORMAL");
+    db.run("CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, mtime INTEGER)");
+    db.run("CREATE TABLE IF NOT EXISTS chunks (id INTEGER PRIMARY KEY, path TEXT, start_line INTEGER, end_line INTEGER, content TEXT, embedding BLOB)");
+    return db;
+}
+function isSkippedPath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    return SKIP_DIRS.some((dir) => normalized.includes(`/${dir}/`));
+}
+function isTextFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext ? TEXT_EXTENSIONS.has(ext) : true;
+}
+async function collectTargets(worktree, mode, filesQuery) {
+    const glob = new Bun.Glob("**/*");
+    const targets = [];
+    const skipped = [];
+    let totalBytes = 0;
+    for await (const relPath of glob.scan({ cwd: worktree, absolute: false, onlyFiles: true, followSymlinks: false })) {
+        if (isSkippedPath(`/${relPath}`))
+            continue;
+        const absPath = path.join(worktree, relPath);
+        if (!isTextFile(absPath))
+            continue;
+        const stat = await fs.stat(absPath);
+        if (stat.size > MAX_FILE_BYTES)
+            continue;
+        if (mode === "changed") {
+            const existing = filesQuery.get(absPath);
+            if (existing && existing.mtime === Math.floor(stat.mtimeMs)) {
+                skipped.push(absPath);
+                continue;
+            }
+        }
+        targets.push({ absPath, stat });
+        totalBytes += stat.size;
+    }
+    return { targets, skipped, totalBytes };
+}
+export async function ensureSemanticIndex(worktree, options = {}) {
+    const dbDir = path.join(worktree, ".opencode", "chat");
+    await fs.mkdir(dbDir, { recursive: true });
+    const db = getDb(path.join(dbDir, DB_FILENAME));
+    const mode = options.mode ?? "changed";
+    const filesQuery = db.prepare("SELECT mtime FROM files WHERE path = ?");
+    const upsertFile = db.prepare("INSERT OR REPLACE INTO files (path, mtime) VALUES (?, ?)");
+    const deleteChunks = db.prepare("DELETE FROM chunks WHERE path = ?");
+    const insertChunk = db.prepare("INSERT INTO chunks (path, start_line, end_line, content, embedding) VALUES (?, ?, ?, ?, ?)");
+    if (mode === "full") {
+        db.run("DELETE FROM chunks");
+        db.run("DELETE FROM files");
+    }
+    const { targets, skipped, totalBytes } = await collectTargets(worktree, mode, filesQuery);
+    let processed = 0;
+    let indexed = 0;
+    let chunksTotal = 0;
+    const report = (currentPath) => {
+        options.onProgress?.({
+            total: targets.length,
+            processed,
+            indexed,
+            skipped: skipped.length,
+            chunks: chunksTotal,
+            currentPath,
+        });
+    };
+    if (targets.length === 0) {
+        report();
+        return { total: 0, processed: 0, indexed: 0, skipped: skipped.length, chunks: 0, mode };
+    }
+    if (typeof options.maxTargets === "number" && targets.length > options.maxTargets) {
+        report("skip:too-many-files");
+        return {
+            total: targets.length,
+            processed: 0,
+            indexed: 0,
+            skipped: skipped.length,
+            chunks: 0,
+            mode,
+            skippedReason: "too-many-files",
+        };
+    }
+    if (typeof options.maxBytes === "number" && totalBytes > options.maxBytes) {
+        report("skip:too-large");
+        return {
+            total: targets.length,
+            processed: 0,
+            indexed: 0,
+            skipped: skipped.length,
+            chunks: 0,
+            mode,
+            skippedReason: "too-large",
+        };
+    }
+    const model = await getEmbedder(getModelDir(dbDir));
+    report();
+    for (const target of targets) {
+        report(target.absPath);
+        const text = await Bun.file(target.absPath).text();
+        processed += 1;
+        if (!text.trim() || text.includes("\u0000"))
+            continue;
+        const chunks = chunkFile(target.absPath, text);
+        if (chunks.length === 0 || chunks.length > MAX_CHUNKS_PER_FILE)
+            continue;
+        deleteChunks.run(target.absPath);
+        const embeddings = [];
+        for await (const batch of model.passageEmbed(chunks.map((c) => c.content), EMBED_BATCH_SIZE)) {
+            embeddings.push(...batch);
+        }
+        db.run("BEGIN");
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            insertChunk.run(chunk.path, chunk.startLine, chunk.endLine, chunk.content, encodeEmbedding(embeddings[i]));
+        }
+        upsertFile.run(target.absPath, Math.floor(target.stat.mtimeMs));
+        db.run("COMMIT");
+        indexed += 1;
+        chunksTotal += chunks.length;
+        report(target.absPath);
+    }
+    return { total: targets.length, processed, indexed, skipped: skipped.length, chunks: chunksTotal, mode };
+}
+export async function semanticSearch(worktree, query, limit) {
+    const dbDir = path.join(worktree, ".opencode", "chat");
+    const db = getDb(path.join(dbDir, DB_FILENAME));
+    const model = await getEmbedder(getModelDir(dbDir));
+    const queryVec = new Float32Array(await model.queryEmbed(query));
+    const rows = db.query("SELECT path, start_line, end_line, content, embedding FROM chunks").all();
+    const scored = rows
+        .map((row) => ({ ...row, score: cosineSimilarity(queryVec, decodeEmbedding(row.embedding)) }))
+        .sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+}

package/dist/system.d.ts

@@ -0,0 +1,5 @@
+export declare const CHATIFIER_MARKER = "---CHATIFIER_MODE_ACTIVE---";
+export declare const UNIVERSAL_PROMPT = "You are Opencode, an interactive CLI-style assistant that helps users solve problems, explore ideas, and complete tasks efficiently. Respond conversationally, guide users step-by-step when needed, and use available tools to support their goals\u2014whether technical, analytical, or creative.\n\n# Communication Style\n- Be concise, direct, and to the point\n- Minimize output tokens while maintaining helpfulness\n- Answer directly without unnecessary preamble or postamble\n- Use clear, straightforward language\n- Avoid phrases like \"Here is...\" or \"The answer is...\"\n- Stop after working on a file unless explanation is requested\n- Focus on being helpful and accurate\n\n<example>\nuser: 2 + 2\nassistant: 4\n</example>\n\n<example>\nuser: what is 2+2?\nassistant: 4\n</example>\n\n<example>\nuser: is 11 a prime number?\nassistant: Yes\n</example>\n\n# CLI Interface\nYour output displays on a command line interface using GitHub-flavored markdown in a monospace font. All text outside tool use communicates with the user.\n\nWhen running bash commands that make changes, briefly explain what you're doing to ensure user understanding.\n\n# Task Management\nUse TodoWrite tools frequently to track tasks and provide visibility into your progress. This is essential for planning complex tasks and ensuring nothing is missed.\n\nMark tasks as completed immediately after finishing them. Don't batch completions.\n\nExample workflow:\n1. Create todo list for complex tasks\n2. Mark items as in_progress when starting\n3. Mark as completed immediately after finishing\n4. Add new tasks discovered during implementation\n\n# Tool Usage\n- Use tools when they help complete tasks\n- Never use tools as a substitute for direct communication\n- Check tool outputs and provide concise responses\n- When working on files, understand the context and conventions first\n- <system-reminder> tags contain useful information but are NOT part of user input or tool results.\n\n## Parallel Tool Execution (CRITICAL)\n**You MUST use parallel tool calling whenever possible:**\n\n- **ALWAYS** batch multiple independent tool calls in a single message\n- **NEVER** send separate messages for operations that can be done in parallel\n- **ESPECIALLY** for multiple file reads, bash commands, or API calls\n- **PRIORITY**: Parallel execution over sequential for all independent operations\n\n**When to use parallel calls:**\n- Reading multiple files at once\n- Running multiple independent bash commands\n- Checking status of multiple resources\n- Any operations that don't depend on each other\n\n**Example:**\nInstead of: `Read file A` \u2192 `Read file B` \u2192 `Read file C`\nUse: `Read file A + Read file B + Read file C` in single message \n\n# Safety & Security\n- Never introduce security vulnerabilities\n- Don't log or expose secrets/keys\n- Consider security implications before implementing features\n- Exercise extra caution with system operations that affect OS stability\n- Pay attention to commands that modify system files, services, or configurations\n- Be mindful of operations that could impact system performance or availability";
+export declare const CHATIFIER_PROMPT: string;
+export declare function replaceSystemPrompt(system: string[]): void;
+//# sourceMappingURL=system.d.ts.map

package/dist/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../system.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,gCAAgC,CAAA;AAC7D,eAAO,MAAM,gBAAgB,ukGAyEmD,CAAA;AAGhF,eAAO,MAAM,gBAAgB,QAA+C,CAAA;AAE5E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAgBnD"}

package/dist/system.js

@@ -0,0 +1,93 @@
+export const CHATIFIER_MARKER = "---CHATIFIER_MODE_ACTIVE---";
+export const UNIVERSAL_PROMPT = `You are Opencode, an interactive CLI-style assistant that helps users solve problems, explore ideas, and complete tasks efficiently. Respond conversationally, guide users step-by-step when needed, and use available tools to support their goals—whether technical, analytical, or creative.
+
+# Communication Style
+- Be concise, direct, and to the point
+- Minimize output tokens while maintaining helpfulness
+- Answer directly without unnecessary preamble or postamble
+- Use clear, straightforward language
+- Avoid phrases like "Here is..." or "The answer is..."
+- Stop after working on a file unless explanation is requested
+- Focus on being helpful and accurate
+
+<example>
+user: 2 + 2
+assistant: 4
+</example>
+
+<example>
+user: what is 2+2?
+assistant: 4
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+# CLI Interface
+Your output displays on a command line interface using GitHub-flavored markdown in a monospace font. All text outside tool use communicates with the user.
+
+When running bash commands that make changes, briefly explain what you're doing to ensure user understanding.
+
+# Task Management
+Use TodoWrite tools frequently to track tasks and provide visibility into your progress. This is essential for planning complex tasks and ensuring nothing is missed.
+
+Mark tasks as completed immediately after finishing them. Don't batch completions.
+
+Example workflow:
+1. Create todo list for complex tasks
+2. Mark items as in_progress when starting
+3. Mark as completed immediately after finishing
+4. Add new tasks discovered during implementation
+
+# Tool Usage
+- Use tools when they help complete tasks
+- Never use tools as a substitute for direct communication
+- Check tool outputs and provide concise responses
+- When working on files, understand the context and conventions first
+- <system-reminder> tags contain useful information but are NOT part of user input or tool results.
+
+## Parallel Tool Execution (CRITICAL)
+**You MUST use parallel tool calling whenever possible:**
+
+- **ALWAYS** batch multiple independent tool calls in a single message
+- **NEVER** send separate messages for operations that can be done in parallel
+- **ESPECIALLY** for multiple file reads, bash commands, or API calls
+- **PRIORITY**: Parallel execution over sequential for all independent operations
+
+**When to use parallel calls:**
+- Reading multiple files at once
+- Running multiple independent bash commands
+- Checking status of multiple resources
+- Any operations that don't depend on each other
+
+**Example:**
+Instead of: \`Read file A\` → \`Read file B\` → \`Read file C\`
+Use: \`Read file A + Read file B + Read file C\` in single message 
+
+# Safety & Security
+- Never introduce security vulnerabilities
+- Don't log or expose secrets/keys
+- Consider security implications before implementing features
+- Exercise extra caution with system operations that affect OS stability
+- Pay attention to commands that modify system files, services, or configurations
+- Be mindful of operations that could impact system performance or availability`;
+// Append marker to ensure detection works
+export const CHATIFIER_PROMPT = UNIVERSAL_PROMPT + "\n\n" + CHATIFIER_MARKER;
+export function replaceSystemPrompt(system) {
+    // console.log("[Chatifier] System prompt parts:", system.length)
+    // system.forEach((s, i) => console.log(`[Chatifier] Part ${i} preview:`, s.slice(0, 50)))
+    // Check if our marker is present in any part of the system prompt
+    const hasMarker = system.some((part) => part.includes(CHATIFIER_MARKER));
+    if (hasMarker) {
+        // console.log("[Chatifier] Marker found! Replacing system prompt.")
+        // Clear the ENTIRE system prompt (including the marker and any headers)
+        system.length = 0;
+        // Inject our universal prompt
+        system.push(UNIVERSAL_PROMPT);
+    }
+    else {
+        // console.log("[Chatifier] Marker NOT found. Skipping replacement.")
+    }
+}

package/dist/tools/bash.d.ts

@@ -0,0 +1,22 @@
+export declare function createChatBash(baseDir: string): {
+    id: string;
+    run: (args: {
+        command: string;
+        timeout?: number;
+        description: string;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            command: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            description: import("zod").ZodString;
+        };
+        execute(args: {
+            command: string;
+            description: string;
+            timeout?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=bash.d.ts.map

package/dist/tools/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../tools/bash.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM;;gBACnB;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;EAuDpF"}

package/dist/tools/bash.js

@@ -0,0 +1,59 @@
+/**
+ * chat_bash tool implementation.
+ * Runs shell commands with basic timeout and output truncation.
+ * Keeps output size bounded for predictable responses.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { MAX_OUTPUT_LENGTH } from "../util/constants";
+export function createChatBash(baseDir) {
+    const run = async (args) => {
+        if (!args.command) {
+            throw new Error("command is required");
+        }
+        const timeoutMs = args.timeout ?? 2 * 60 * 1000;
+        if (timeoutMs < 0) {
+            throw new Error(`Invalid timeout value: ${timeoutMs}. Timeout must be a positive number.`);
+        }
+        const cmd = process.platform === "win32" ? ["cmd", "/c", args.command] : ["bash", "-lc", args.command];
+        const proc = Bun.spawn(cmd, {
+            cwd: baseDir,
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const outputPromise = Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]).then(([out, err]) => out + err);
+        const timeoutPromise = new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                proc.kill();
+                clearTimeout(timer);
+                resolve(`\n\n<bash_metadata>\nCommand timed out after ${timeoutMs} ms\n</bash_metadata>`);
+            }, timeoutMs);
+        });
+        const output = await Promise.race([outputPromise, timeoutPromise]);
+        if (output.length <= MAX_OUTPUT_LENGTH)
+            return output;
+        return output.slice(0, MAX_OUTPUT_LENGTH) + "\n\n<bash_metadata>\nOutput truncated\n</bash_metadata>";
+    };
+    return {
+        id: "chat_bash",
+        run,
+        tool: tool({
+            description: `Run shell commands.
+
+Usage:
+- Study unfamiliar commands with -h or --help first
+- Verify directories exist before creating files
+- Quote paths with spaces: "path with spaces/file.txt"
+- Output limited to 30,000 characters
+- Use && to chain dependent commands, ; for independent ones
+- Prefer absolute paths over cd when possible`,
+            args: {
+                command: tool.schema.string().describe("The command to execute"),
+                timeout: tool.schema.number().optional().describe("Optional timeout in milliseconds"),
+                description: tool.schema.string().describe("Brief description of command purpose (5-10 words)"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/batch.d.ts

@@ -0,0 +1,25 @@
+import { ToolCall } from "../util/types";
+type Runner = (params: Record<string, unknown>) => Promise<string>;
+export declare function createChatBatch(runners: Record<string, Runner>, todoRead: () => Promise<string>): {
+    id: string;
+    run: (args: {
+        tool_calls: ToolCall[];
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            tool_calls: import("zod").ZodArray<import("zod").ZodObject<{
+                tool: import("zod").ZodString;
+                parameters: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>>;
+        };
+        execute(args: {
+            tool_calls: {
+                tool: string;
+                parameters: Record<string, unknown>;
+            }[];
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+export {};
+//# sourceMappingURL=batch.d.ts.map

package/dist/tools/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../tools/batch.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,KAAK,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAElE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC;;gBAoB1E;QAAE,UAAU,EAAE,QAAQ,EAAE,CAAA;KAAE;;;;;;;;;;;;;;;;EA2B/C"}

package/dist/tools/batch.js

@@ -0,0 +1,49 @@
+/**
+ * chat_batch tool implementation.
+ * Executes multiple chat_* tools with simple coordination.
+ * Limits tool calls to keep execution predictable.
+ */
+import { tool } from "@opencode-ai/plugin";
+export function createChatBatch(runners, todoRead) {
+    const allRunners = {
+        ...runners,
+        chat_todoread: async () => todoRead(),
+    };
+    const run = async (args) => {
+        const calls = args.tool_calls.slice(0, 10);
+        const results = await Promise.all(calls.map((call) => {
+            const runner = allRunners[call.tool];
+            if (!runner)
+                return Promise.resolve(`Unsupported tool: ${call.tool}`);
+            return runner(call.parameters);
+        }));
+        return results.join("\n\n");
+    };
+    return {
+        id: "chat_batch",
+        run: async (args) => run(args),
+        tool: tool({
+            description: `Run multiple tools at once.
+
+Usage:
+- 1-10 tool calls per batch
+- All calls run in parallel
+- Use for independent operations only
+- Don't use when results depend on each other`,
+            args: {
+                tool_calls: tool.schema
+                    .array(tool.schema.object({
+                    tool: tool.schema.string().describe("Name of the tool to call"),
+                    parameters: tool.schema
+                        .record(tool.schema.string(), tool.schema.unknown())
+                        .describe("Parameters for the tool"),
+                }))
+                    .min(1)
+                    .describe("Array of tool calls to execute"),
+            },
+            async execute(args) {
+                return await run({ tool_calls: args.tool_calls });
+            },
+        }),
+    };
+}

package/dist/tools/edit.d.ts

@@ -0,0 +1,25 @@
+export declare function createChatEdit(baseDir: string, repoRoot: string): {
+    id: string;
+    run: (args: {
+        filePath: string;
+        oldString: string;
+        newString: string;
+        replaceAll?: boolean;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            oldString: import("zod").ZodString;
+            newString: import("zod").ZodString;
+            replaceAll: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            filePath: string;
+            oldString: string;
+            newString: string;
+            replaceAll?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=edit.d.ts.map

package/dist/tools/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../tools/edit.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;gBACrC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;;;;;;;EAiC1G"}

package/dist/tools/edit.js

@@ -0,0 +1,44 @@
+/**
+ * chat_edit tool implementation.
+ * Performs targeted string replacements in files.
+ * Rejects ambiguous edits to prevent unintended changes.
+ */
+import * as fs from "fs/promises";
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import { resolvePath } from "../util/paths";
+import { replaceOnce } from "../util/text";
+export function createChatEdit(baseDir, repoRoot) {
+    const run = async (args) => {
+        const filePath = resolvePath(baseDir, args.filePath);
+        const content = await fs.readFile(filePath, "utf-8").catch(() => {
+            throw new Error(`File not found: ${filePath}`);
+        });
+        const updated = replaceOnce(content, args.oldString, args.newString, args.replaceAll);
+        await fs.writeFile(filePath, updated, "utf-8");
+        const title = path.relative(repoRoot, filePath);
+        return `Updated ${title}`;
+    };
+    return {
+        id: "chat_edit",
+        run,
+        tool: tool({
+            description: `Replace text in files.
+
+Usage:
+- Read the file first before editing
+- Preserve original formatting and indentation
+- Fails if oldString not found or matches multiple times
+- Use replaceAll for global replacements`,
+            args: {
+                filePath: tool.schema.string().describe("The absolute path to the file to modify"),
+                oldString: tool.schema.string().describe("The text to replace"),
+                newString: tool.schema.string().describe("The text to replace it with (must be different from oldString)"),
+                replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences of oldString (default false)"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/glob.d.ts

@@ -0,0 +1,19 @@
+export declare function createChatGlob(baseDir: string): {
+    id: string;
+    run: (args: {
+        pattern: string;
+        path?: string;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            pattern: string;
+            path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../tools/glob.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM;;gBACnB;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;EA6C5D"}

package/dist/tools/glob.js

@@ -0,0 +1,54 @@
+/**
+ * chat_glob tool implementation.
+ * Finds files by glob pattern with modification-time ordering.
+ * Mirrors core behavior with truncation hints for large result sets.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { resolvePath } from "../util/paths";
+export function createChatGlob(baseDir) {
+    const run = async (args) => {
+        const searchRoot = resolvePath(baseDir, args.path ?? baseDir);
+        const glob = new Bun.Glob(args.pattern);
+        const files = [];
+        let truncated = false;
+        for await (const file of glob.scan({ cwd: searchRoot, absolute: true, onlyFiles: true })) {
+            if (files.length >= 100) {
+                truncated = true;
+                break;
+            }
+            const mtime = await Bun.file(file)
+                .stat()
+                .then((stat) => stat.mtime.getTime())
+                .catch(() => 0);
+            files.push({ path: file, mtime });
+        }
+        files.sort((a, b) => b.mtime - a.mtime);
+        if (files.length === 0)
+            return "No files found";
+        const output = files.map((file) => file.path);
+        if (truncated) {
+            output.push("");
+            output.push("(Results are truncated. Consider using a more specific path or pattern.)");
+        }
+        return output.join("\n");
+    };
+    return {
+        id: "chat_glob",
+        run,
+        tool: tool({
+            description: `Find files by pattern.
+
+Usage:
+- Supports glob patterns like "**/*.txt" or "docs/**/*.md"
+- Returns files sorted by modification time
+- Results truncated at 100 files`,
+            args: {
+                pattern: tool.schema.string().describe("The glob pattern to match files against"),
+                path: tool.schema.string().optional().describe("The directory to search in"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}