@howaboua/opencode-chat 0.1.0

package/dist/tools/grep.d.ts

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

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

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

package/dist/tools/grep.js

@@ -0,0 +1,92 @@
+/**
+ * chat_grep tool implementation.
+ * Searches file content using regex and formats results by file.
+ * Limits output to a manageable number of matches.
+ */
+import * as fs from "fs/promises";
+import { tool } from "@opencode-ai/plugin";
+import { MAX_GREP_MATCHES } from "../util/constants";
+import { resolvePath, isBinaryFile } from "../util/paths";
+import { trimLine } from "../util/text";
+function formatMatches(matches, truncated) {
+    const outputLines = [`Found ${matches.length} matches`];
+    let currentFile = "";
+    for (const match of matches) {
+        if (currentFile !== match.path) {
+            if (currentFile !== "") {
+                outputLines.push("");
+            }
+            currentFile = match.path;
+            outputLines.push(`${match.path}:`);
+        }
+        outputLines.push(`  Line ${match.lineNum}: ${trimLine(match.lineText)}`);
+    }
+    if (truncated) {
+        outputLines.push("");
+        outputLines.push("(Results are truncated. Consider using a more specific path or pattern.)");
+    }
+    return outputLines.join("\n");
+}
+export function createChatGrep(baseDir) {
+    const run = async (args) => {
+        const searchRoot = resolvePath(baseDir, args.path ?? baseDir);
+        let matcher;
+        try {
+            matcher = new RegExp(args.pattern);
+        }
+        catch (_error) {
+            throw new Error(`Invalid regex pattern: ${args.pattern}`);
+        }
+        const globPattern = args.include ?? "**/*";
+        const glob = new Bun.Glob(globPattern);
+        const matches = [];
+        for await (const file of glob.scan({ cwd: searchRoot, absolute: true, onlyFiles: true })) {
+            if (matches.length >= MAX_GREP_MATCHES)
+                break;
+            if (await isBinaryFile(file))
+                continue;
+            const content = await fs.readFile(file, "utf-8").catch(() => "");
+            if (!content)
+                continue;
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                if (!matcher.test(lines[i]))
+                    continue;
+                const modTime = await Bun.file(file)
+                    .stat()
+                    .then((stat) => stat.mtime.getTime())
+                    .catch(() => 0);
+                matches.push({ path: file, modTime, lineNum: i + 1, lineText: lines[i] });
+                if (matches.length >= MAX_GREP_MATCHES)
+                    break;
+            }
+        }
+        if (matches.length === 0)
+            return "No files found";
+        matches.sort((a, b) => b.modTime - a.modTime);
+        const truncated = matches.length >= MAX_GREP_MATCHES;
+        const finalMatches = truncated ? matches.slice(0, MAX_GREP_MATCHES) : matches;
+        return formatMatches(finalMatches, truncated);
+    };
+    return {
+        id: "chat_grep",
+        run,
+        tool: tool({
+            description: `Search file contents using regex.
+
+Usage:
+- Supports full regex syntax
+- Filter files by pattern with include parameter
+- Returns files sorted by modification time
+- Results truncated at 100 matches`,
+            args: {
+                pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
+                path: tool.schema.string().optional().describe("The directory to search in"),
+                include: tool.schema.string().optional().describe("File pattern to include in the search"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+export declare function createChatTools(baseDir: string, repoRoot: string, todoPath: string): {
+    tools: Record<string, {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    }>;
+    runners: Record<string, (p: Record<string, unknown>) => Promise<string>>;
+    toolIds: string[];
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tools/index.ts"],"names":[],"mappings":"AAgBA,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;gCAW/C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC;;EA6B9E"}

package/dist/tools/index.js

@@ -0,0 +1,51 @@
+/**
+ * Tool registry for the chatifier plugin.
+ * Builds chat_* tools and exposes runners for batch execution.
+ */
+import { createChatBash } from "./bash";
+import { createChatRead } from "./read";
+import { createChatPatch } from "./patch";
+import { createChatGlob } from "./glob";
+import { createChatGrep } from "./grep";
+import { createChatTodo } from "./todo";
+import { createChatBatch } from "./batch";
+import { createChatSkill } from "./skill";
+import { createChatRemember } from "./remember";
+import { createChatSemanticSearch } from "./semantic-search";
+export function createChatTools(baseDir, repoRoot, todoPath) {
+    const read = createChatRead(baseDir);
+    const patch = createChatPatch(baseDir);
+    const glob = createChatGlob(baseDir);
+    const grep = createChatGrep(baseDir);
+    const bash = createChatBash(baseDir);
+    const todo = createChatTodo(todoPath);
+    const skill = createChatSkill(baseDir);
+    const remember = createChatRemember(baseDir);
+    const semantic = createChatSemanticSearch(repoRoot);
+    const runners = {
+        [read.id]: (p) => read.run(p),
+        [patch.id]: (p) => patch.run(p),
+        [glob.id]: (p) => glob.run(p),
+        [grep.id]: (p) => grep.run(p),
+        [bash.id]: (p) => bash.run(p),
+        [todo.write.id]: (p) => todo.write.run(p),
+        [skill.id]: (p) => skill.run(p),
+        [remember.id]: (p) => remember.run(p),
+        [semantic.id]: (p) => semantic.run(p),
+    };
+    const batch = createChatBatch(runners, todo.read.run);
+    const tools = {
+        [read.id]: read.tool,
+        [patch.id]: patch.tool,
+        [glob.id]: glob.tool,
+        [grep.id]: grep.tool,
+        [bash.id]: bash.tool,
+        [todo.write.id]: todo.write.tool,
+        [todo.read.id]: todo.read.tool,
+        [skill.id]: skill.tool,
+        [remember.id]: remember.tool,
+        [semantic.id]: semantic.tool,
+        [batch.id]: batch.tool,
+    };
+    return { tools, runners, toolIds: Object.keys(tools) };
+}

package/dist/tools/patch.d.ts

@@ -0,0 +1,16 @@
+export declare function createChatPatch(baseDir: string): {
+    id: string;
+    run: (args: {
+        patchText: string;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            patchText: import("zod").ZodString;
+        };
+        execute(args: {
+            patchText: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=patch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../tools/patch.ts"],"names":[],"mappings":"AAQA,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM;;gBACpB;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;EAkF/C"}

package/dist/tools/patch.js

@@ -0,0 +1,87 @@
+/**
+ * chat_patch tool implementation.
+ * Apply patches to create, update, delete, or move files.
+ */
+import { tool } from "@opencode-ai/plugin";
+import * as path from "path";
+import { parsePatch, applyHunksToFiles } from "../util/patch";
+export function createChatPatch(baseDir) {
+    const run = async (args) => {
+        const { hunks } = parsePatch(args.patchText);
+        const resolved = hunks.map((hunk) => {
+            if (hunk.type === "update" && hunk.move_path) {
+                return { ...hunk, path: path.resolve(baseDir, hunk.path), move_path: path.resolve(baseDir, hunk.move_path) };
+            }
+            return { ...hunk, path: path.resolve(baseDir, hunk.path) };
+        });
+        const result = await applyHunksToFiles(resolved);
+        const summary = [];
+        if (result.added.length)
+            summary.push(`Added: ${result.added.join(", ")}`);
+        if (result.modified.length)
+            summary.push(`Modified: ${result.modified.join(", ")}`);
+        if (result.deleted.length)
+            summary.push(`Deleted: ${result.deleted.join(", ")}`);
+        return summary.length ? summary.join("\n") : "No changes applied";
+    };
+    return {
+        id: "chat_patch",
+        run,
+        tool: tool({
+            description: `Apply a patch to create, update, or delete files.
+
+FORMAT RULES:
+- Start with: *** Begin Patch
+- End with: *** End Patch
+- Lines starting with "-" are REMOVED from the file
+- Lines starting with "+" are ADDED to the file  
+- Lines starting with " " (space) are kept unchanged (context)
+- @@ marks a context line to LOCATE where changes happen
+
+CREATE A NEW FILE:
+*** Begin Patch
+*** Add File: path/to/new.txt
++first line of new file
++second line of new file
+*** End Patch
+
+REPLACE A LINE (must include both - and +):
+*** Begin Patch
+*** Update File: path/to/file.txt
+@@ function hello() {
+-  return "old"
++  return "new"
+*** End Patch
+
+DELETE A LINE (use - with no +):
+*** Begin Patch
+*** Update File: path/to/file.txt
+@@ const config = {
+-  debug: true,
+*** End Patch
+
+INSERT A NEW LINE (use space prefix for context, then +):
+*** Begin Patch
+*** Update File: path/to/file.txt
+@@ import React from "react"
+ import React from "react"
++import { useState } from "react"
+*** End Patch
+
+DELETE A FILE:
+*** Begin Patch
+*** Delete File: path/to/remove.txt
+*** End Patch
+
+IMPORTANT: To replace a line, you MUST use "-oldline" then "+newline". The @@ line only locates WHERE to make changes.`,
+            args: {
+                patchText: tool.schema
+                    .string()
+                    .describe("The patch text in the format shown above. Must include *** Begin Patch and *** End Patch markers."),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/read.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../tools/read.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM;;gBACnB;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;EA6D/E"}

package/dist/tools/read.js

@@ -0,0 +1,70 @@
+/**
+ * chat_read tool implementation.
+ * Reads text files with line numbers and paging hints.
+ * Blocks .env access and binary or image reads for safety.
+ */
+import * as fs from "fs/promises";
+import { tool } from "@opencode-ai/plugin";
+import { DEFAULT_READ_LIMIT } from "../util/constants";
+import { resolvePath, isBlockedEnvPath, isImageExtension, isBinaryFile } from "../util/paths";
+import { trimLine } from "../util/text";
+export function createChatRead(baseDir) {
+    const run = async (args) => {
+        const filePath = resolvePath(baseDir, args.filePath);
+        if (isBlockedEnvPath(filePath)) {
+            throw new Error(`The user has blocked you from reading ${filePath}`);
+        }
+        if (isImageExtension(filePath)) {
+            throw new Error(`Image reading is not supported: ${filePath}`);
+        }
+        if (await isBinaryFile(filePath)) {
+            throw new Error(`Cannot read binary file: ${filePath}`);
+        }
+        const stats = await fs.stat(filePath).catch(() => undefined);
+        if (!stats) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        if (stats.isDirectory()) {
+            throw new Error(`Path is a directory, not a file: ${filePath}`);
+        }
+        const offset = args.offset ?? 0;
+        const limit = args.limit ?? DEFAULT_READ_LIMIT;
+        const lines = await fs.readFile(filePath, "utf-8").then((content) => content.split("\n"));
+        const raw = lines.slice(offset, offset + limit).map(trimLine);
+        const content = raw.map((line, index) => `${(index + offset + 1).toString().padStart(5, "0")}| ${line}`);
+        let output = "<file>\n";
+        output += content.join("\n");
+        const totalLines = lines.length;
+        const lastReadLine = offset + content.length;
+        const hasMoreLines = totalLines > lastReadLine;
+        if (hasMoreLines) {
+            output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`;
+        }
+        if (!hasMoreLines) {
+            output += `\n\n(End of file - total ${totalLines} lines)`;
+        }
+        output += "\n</file>";
+        return output;
+    };
+    return {
+        id: "chat_read",
+        run,
+        tool: tool({
+            description: `Read file contents.
+
+Usage:
+- Returns line-numbered output
+- Default limit is 2000 lines
+- Use offset and limit for large files
+- Long lines (>2000 chars) are truncated`,
+            args: {
+                filePath: tool.schema.string().describe("The path to the file to read"),
+                offset: tool.schema.number().optional().describe("The line number to start reading from (0-based)"),
+                limit: tool.schema.number().optional().describe("The number of lines to read (defaults to 2000)"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/remember.d.ts

@@ -0,0 +1,16 @@
+export declare function createChatRemember(baseDir: string): {
+    id: string;
+    run: (args: {
+        memory: string;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            memory: import("zod").ZodString;
+        };
+        execute(args: {
+            memory: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=remember.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remember.d.ts","sourceRoot":"","sources":["../../tools/remember.ts"],"names":[],"mappings":"AASA,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM;;gBAGvB;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;EAqD5C"}

package/dist/tools/remember.js

@@ -0,0 +1,58 @@
+/**
+ * chat_remember tool implementation.
+ * Append a memory to AGENTS.md for long-term persistence.
+ * Since AGENTS.md is re-read on every turn, memories take effect immediately.
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { tool } from "@opencode-ai/plugin";
+export function createChatRemember(baseDir) {
+    const agentsPath = path.join(baseDir, "AGENTS.md");
+    const run = async (args) => {
+        const memory = args.memory.trim();
+        if (!memory) {
+            throw new Error("Memory cannot be empty");
+        }
+        // Check if file exists
+        let content = "";
+        try {
+            content = await fs.readFile(agentsPath, "utf-8");
+        }
+        catch {
+            // File doesn't exist, create with header
+            content = "# User Preferences & Memories\n\n";
+        }
+        // Ensure content ends with newline
+        if (!content.endsWith("\n")) {
+            content += "\n";
+        }
+        // Check for memories section, add if missing
+        if (!content.includes("## Memories")) {
+            content += "\n## Memories\n\n";
+        }
+        // Append the new memory with timestamp
+        const timestamp = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+        const memoryLine = `- ${memory} (${timestamp})\n`;
+        content += memoryLine;
+        await fs.writeFile(agentsPath, content, "utf-8");
+        return `Remembered: "${memory}"`;
+    };
+    return {
+        id: "chat_remember",
+        run,
+        tool: tool({
+            description: `Save something to long-term memory. Use this to remember:
+- User preferences (e.g., "User prefers concise responses")
+- Important facts (e.g., "User's project uses React 19")
+- Style preferences (e.g., "User likes bullet points over paragraphs")
+
+Memories persist across conversations. Keep each memory to ONE short sentence.`,
+            args: {
+                memory: tool.schema.string().describe("A single short sentence to remember. Be specific and concise."),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/semantic-search.d.ts

@@ -0,0 +1,19 @@
+export declare function createChatSemanticSearch(worktree: string): {
+    id: string;
+    run: (args: {
+        query: string;
+        limit?: number;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=semantic-search.d.ts.map

package/dist/tools/semantic-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-search.d.ts","sourceRoot":"","sources":["../../tools/semantic-search.ts"],"names":[],"mappings":"AAUA,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM;;gBAC9B;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;EA+C3D"}

package/dist/tools/semantic-search.js

@@ -0,0 +1,54 @@
+/**
+ * chat_semantic_search tool implementation.
+ * Searches repo content using local embeddings stored in SQLite.
+ */
+import * as path from "path";
+import { tool } from "@opencode-ai/plugin";
+import { semanticSearch } from "../semantic";
+const DEFAULT_LIMIT = 5;
+export function createChatSemanticSearch(worktree) {
+    const run = async (args) => {
+        const query = args.query.trim();
+        if (!query)
+            throw new Error("Query cannot be empty");
+        const dbPath = path.join(worktree, ".opencode", "chat", "semantic.sqlite");
+        const exists = await Bun.file(dbPath).exists();
+        if (!exists) {
+            return "Semantic index not found. Run chat_semantic_index first.";
+        }
+        const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, 20));
+        const results = await semanticSearch(worktree, query, limit);
+        if (results.length === 0)
+            return "No semantic matches found.";
+        return results
+            .map((item, index) => {
+            const relPath = path.relative(worktree, item.path);
+            const snippet = item.content.trim().slice(0, 400);
+            return [
+                `${index + 1}. ${relPath}:${item.start_line}-${item.end_line}`,
+                `score: ${item.score.toFixed(3)}`,
+                snippet,
+            ].join("\n");
+        })
+            .join("\n\n");
+    };
+    return {
+        id: "chat_semantic_search",
+        run,
+        tool: tool({
+            description: `Semantic search over repo files using local embeddings.
+
+Usage:
+- Best for natural language queries ("where is auth handled")
+- Returns file + line ranges + snippet
+- Indexing is incremental based on file mtime`,
+            args: {
+                query: tool.schema.string().describe("Natural language search query"),
+                limit: tool.schema.number().optional().describe("Number of results (default 5, max 20)"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/skill.d.ts

@@ -0,0 +1,17 @@
+export declare function createChatSkill(baseDir: string): {
+    id: string;
+    run: (args: {
+        name: string;
+    }) => Promise<string>;
+    buildDescription: () => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+        };
+        execute(args: {
+            name: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=skill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../tools/skill.ts"],"names":[],"mappings":"AAmCA,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM;;gBA0CpB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;EAiD1C"}