@howaboua/opencode-chat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Igor Wiedler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# OpenCode Chatifier
+
+A conversational coding assistant plugin for OpenCode with semantic code search.
+
+## What It Does
+
+**Chatifier** transforms OpenCode into a more conversational experience with two specialized agents and local semantic search.
+
+![opencode-chat](https://github.com/user-attachments/assets/d489422c-a5a6-4003-b955-adf9b17260c2)
+
+### Chat Agents
+
+| Agent         | Purpose                                              |
+| ------------- | ---------------------------------------------------- |
+| **Just Chat** | Quick questions, web research, remembering context   |
+| **Tool Chat** | Full coding toolkit with semantic search and editing |
+
+### Features
+
+- **Semantic Search** - Ask "where is auth handled?" and find code by meaning, not keywords
+- **Memory** - Tell it to remember preferences and they persist across sessions
+- **Task Tracking** - Built-in todo list for multi-step work
+- **Skills** - Load project-specific guidance from `.opencode/skill/`
+- **Streamlined Prompts** - Concise, direct responses without filler
+
+## Installation
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["@howaboua/opencode-chat"]
+}
+```
+
+OpenCode automatically installs the plugin on next launch.
+
+### Pin a version (optional)
+
+```json
+{
+  "plugin": ["@howaboua/opencode-chat@0.1.0"]
+}
+```
+
+## Setup
+
+### New or Small Projects
+
+For new projects or directories with fewer than 100 files, just launch OpenCode. The plugin automatically:
+
+1. Downloads the embedding model (~90MB, cached in `.opencode/chat/models/`)
+2. Indexes your codebase for semantic search
+
+### Existing Large Projects (IMPORTANT)
+
+**For directories with 100+ files (Obsidian vaults, large codebases, etc.), you MUST run setup manually before launching OpenCode.** Otherwise, the plugin will skip indexing to avoid blocking startup.
+
+```bash
+cd your-project
+
+# Download the embedding model first
+npx opencode-chat-download-model
+
+# Index your files (may take several minutes for large directories)
+npx opencode-chat-semantic-index --mode full
+```
+
+After this one-time setup, OpenCode will launch normally and only re-index changed files.
+
+## Usage
+
+### Switch Agents
+
+Use the agent selector in OpenCode to switch between:
+
+- **Just Chat** - Conversational, minimal tools, web access
+- **Tool Chat** - Full toolkit including semantic search
+
+### Semantic Search
+
+Ask natural language questions:
+
+- "Where is the database connection configured?"
+- "Find error handling for API requests"
+- "Show me the authentication flow"
+
+The assistant searches by meaning using local embeddings - no API calls, fully private.
+
+### Memory
+
+Tell the assistant to remember things:
+
+- "Remember that I prefer TypeScript over JavaScript"
+- "Remember this project uses React 19"
+
+Memories persist in `AGENTS.md` and apply to future sessions.
+
+### Task Tracking
+
+For multi-step tasks, the assistant creates and tracks a todo list automatically. The list persists in `todo.md` and is removed when all tasks complete.
+
+## Requirements
+
+- [OpenCode](https://opencode.ai) v1.0.201+
+- [Bun](https://bun.sh) runtime (for semantic indexing)
+
+## How It Works
+
+- **Embeddings**: Uses [fastembed](https://github.com/Anush008/fastembed-js) with the AllMiniLML6V2 model
+- **Storage**: SQLite database in `.opencode/chat/semantic.sqlite`
+- **Indexing**: Incremental - only re-indexes changed files
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+type AgentConfig = {
+    tools?: Record<string, boolean>;
+    prompt?: string;
+    [key: string]: unknown;
+};
+type ConfigWithTools = {
+    tools?: Record<string, boolean>;
+    agent?: Record<string, AgentConfig>;
+    default_agent?: string;
+};
+export declare function configureChatAgents(config: ConfigWithTools, toolIds: string[]): void;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../config.ts"],"names":[],"mappings":"AAUA,KAAK,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAA;AAC/F,KAAK,eAAe,GAAG;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACnC,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAgCD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,QA+B7E"}

package/dist/config.js

@@ -0,0 +1,65 @@
+/**
+ * Configuration helpers for the chatifier plugin.
+ * Disables chat_* tools globally via config.tools, then enables them for chatified agents.
+ *
+ * Agents:
+ *   - Just Chat: Minimal tools for conversation and web research
+ *   - Tool Chat: Full toolkit for files, code, and web
+ */
+import { CHATIFIER_PROMPT } from "./system";
+const NATIVE_TOOLS = [
+    "bash",
+    "read",
+    "write",
+    "edit",
+    "glob",
+    "grep",
+    "webfetch",
+    "websearch",
+    "codesearch",
+    "task",
+    "todowrite",
+    "todoread",
+    "patch",
+    "multiedit",
+    "lsp",
+    "lsp_hover",
+    "lsp_diagnostics",
+    "batch",
+    "skill",
+];
+// Tools for Just Chat: web research and conversation
+// Uses native tools directly (no chat_* wrappers needed)
+const JUST_CHAT_NATIVE = ["webfetch", "websearch"];
+const JUST_CHAT_TOOLS = ["chat_remember", "chat_todowrite", "chat_todoread"];
+// Native tools to enable for Tool Chat (in addition to chat_* tools)
+const TOOL_CHAT_NATIVE = ["websearch", "webfetch"];
+export function configureChatAgents(config, toolIds) {
+    // Disable chat_* tools globally - this affects all built-in agents
+    config.tools = config.tools ?? {};
+    for (const id of toolIds) {
+        config.tools[id] = false;
+    }
+    config.agent = config.agent ?? {};
+    // Just Chat: minimal tools for conversation and web research
+    config.agent["Just Chat"] = {
+        description: "Conversational agent with web access",
+        mode: "primary",
+        prompt: CHATIFIER_PROMPT,
+        tools: {
+            ...Object.fromEntries(NATIVE_TOOLS.map((id) => [id, false])),
+            ...Object.fromEntries(JUST_CHAT_NATIVE.map((id) => [id, true])),
+            ...Object.fromEntries(JUST_CHAT_TOOLS.map((id) => [id, true])),
+        },
+    };
+    // Tool Chat: full toolkit for files, code, and web
+    config.agent["Tool Chat"] = {
+        description: "Full toolkit agent for files and code",
+        prompt: CHATIFIER_PROMPT,
+        tools: {
+            ...Object.fromEntries(NATIVE_TOOLS.map((id) => [id, false])),
+            ...Object.fromEntries(TOOL_CHAT_NATIVE.map((id) => [id, true])),
+            ...Object.fromEntries(toolIds.map((id) => [id, true])),
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Chatifier plugin entrypoint.
+ * Wires chat_* tools, config mutations, and system prompt updates.
+ * Keeps orchestration minimal and delegates logic to modules.
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const ChatifierPlugin: Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAQjD,eAAO,MAAM,eAAe,EAAE,MAyC7B,CAAA"}

package/dist/index.js

@@ -0,0 +1,44 @@
+import path from "path";
+import { TODO_FILENAME } from "./util/constants";
+import { configureChatAgents } from "./config";
+import { replaceSystemPrompt } from "./system";
+import { createChatTools } from "./tools";
+import { ensureSemanticIndex, ensureModel } from "./semantic";
+export const ChatifierPlugin = async ({ directory, worktree }) => {
+    const todoPath = path.join(worktree, TODO_FILENAME);
+    await ensureModel(worktree);
+    const result = await ensureSemanticIndex(worktree, {
+        mode: "changed",
+        maxTargets: 100,
+        onProgress: (progress) => {
+            if (progress.total === 0)
+                return;
+            const percent = Math.floor((progress.processed / progress.total) * 100);
+            const filled = Math.round((percent / 100) * 20);
+            const bar = "=".repeat(filled) + "-".repeat(20 - filled);
+            const current = progress.currentPath ? `\n  ${progress.currentPath}` : "";
+            console.log(`[semantic] [${bar}] ${percent}% ${progress.processed}/${progress.total} files, chunks: ${progress.chunks}${current}`);
+        },
+    });
+    if (result.skippedReason) {
+        console.log(`\n[semantic] ⚠️  indexing skipped: ${result.skippedReason} (${result.total} files)`);
+        console.log(`[semantic]    Run \`bun run semantic-index\` to index all files.\n`);
+        await Bun.sleep(10000);
+    }
+    else if (result.indexed > 0) {
+        console.log(`[semantic] indexed ${result.indexed} files (${result.chunks} chunks)`);
+    }
+    else if (result.total === 0 && result.skipped > 0) {
+        console.log(`[semantic] index up to date (${result.skipped} files unchanged)`);
+    }
+    const chatTools = createChatTools(directory, worktree, todoPath);
+    return {
+        config: async (config) => {
+            configureChatAgents(config, chatTools.toolIds);
+        },
+        "experimental.chat.system.transform": async (_input, output) => {
+            replaceSystemPrompt(output.system);
+        },
+        tool: chatTools.tools,
+    };
+};

package/dist/script/download-model.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=download-model.d.ts.map

package/dist/script/download-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-model.d.ts","sourceRoot":"","sources":["../../script/download-model.ts"],"names":[],"mappings":""}

package/dist/script/download-model.js

@@ -0,0 +1,39 @@
+/**
+ * Download embedding model for semantic search.
+ * Usage: bun script/download-model.ts
+ * Automatically finds repo root by walking up to .opencode/
+ */
+import * as path from "path";
+import * as fs from "fs/promises";
+import { EmbeddingModel, ExecutionProvider, FlagEmbedding } from "fastembed";
+const MODEL_DIRNAME = "models";
+async function findRepoRoot(start) {
+    let dir = start;
+    while (dir !== "/") {
+        const opencodePath = path.join(dir, ".opencode");
+        const exists = await fs
+            .stat(opencodePath)
+            .then((s) => s.isDirectory())
+            .catch(() => false);
+        if (exists)
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return start;
+}
+async function main() {
+    const worktree = await findRepoRoot(path.resolve(process.cwd()));
+    const cacheDir = path.join(worktree, ".opencode", "chat", MODEL_DIRNAME);
+    console.log(`[model] worktree: ${worktree}`);
+    console.log(`[model] cache dir: ${cacheDir}`);
+    console.log(`[model] downloading AllMiniLML6V2...`);
+    await fs.mkdir(cacheDir, { recursive: true });
+    await FlagEmbedding.init({
+        model: EmbeddingModel.AllMiniLML6V2,
+        executionProviders: [ExecutionProvider.CPU],
+        cacheDir,
+        showDownloadProgress: true,
+    });
+    console.log(`[model] download complete!`);
+}
+await main();

package/dist/script/semantic-index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=semantic-index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-index.d.ts","sourceRoot":"","sources":["../../script/semantic-index.ts"],"names":[],"mappings":""}

package/dist/script/semantic-index.js

@@ -0,0 +1,63 @@
+/**
+ * Manual semantic indexer.
+ * Usage: bun script/semantic-index.ts --mode changed|full
+ * Automatically finds repo root by walking up to .opencode/
+ */
+import * as path from "path";
+import * as fs from "fs/promises";
+import { ensureSemanticIndex } from "../semantic";
+async function findRepoRoot(start) {
+    let dir = start;
+    while (dir !== "/") {
+        const opencodePath = path.join(dir, ".opencode");
+        const exists = await fs
+            .stat(opencodePath)
+            .then((s) => s.isDirectory())
+            .catch(() => false);
+        if (exists)
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return start;
+}
+function parseMode(argv) {
+    const idx = argv.indexOf("--mode");
+    if (idx === -1)
+        return "changed";
+    const value = argv[idx + 1];
+    if (value === "full")
+        return "full";
+    return "changed";
+}
+function formatProgress(progress) {
+    if (progress.total === 0)
+        return "[semantic] no files to index";
+    const percent = Math.floor((progress.processed / progress.total) * 100);
+    const width = 24;
+    const filled = Math.round((percent / 100) * width);
+    const bar = "=".repeat(filled) + "-".repeat(width - filled);
+    const current = progress.currentPath ? `\n  ${progress.currentPath}` : "";
+    return `[semantic] [${bar}] ${percent}% ${progress.processed}/${progress.total} files, chunks: ${progress.chunks}${current}`;
+}
+async function main() {
+    const mode = parseMode(process.argv);
+    const worktree = await findRepoRoot(path.resolve(process.cwd()));
+    console.log(`[semantic] worktree: ${worktree}`);
+    let lastShown = "";
+    const result = await ensureSemanticIndex(worktree, {
+        mode,
+        onProgress: (progress) => {
+            const line = formatProgress(progress);
+            if (line === lastShown)
+                return;
+            lastShown = line;
+            console.log(line);
+        },
+    });
+    console.log("Semantic index complete.");
+    console.log(`mode: ${result.mode}`);
+    console.log(`files indexed: ${result.indexed}`);
+    console.log(`files skipped: ${result.skipped}`);
+    console.log(`chunks: ${result.chunks}`);
+}
+await main();

package/dist/semantic/chunker.d.ts

@@ -0,0 +1,8 @@
+export type Chunk = {
+    path: string;
+    startLine: number;
+    endLine: number;
+    content: string;
+};
+export declare function chunkFile(filePath: string, text: string): Chunk[];
+//# sourceMappingURL=chunker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../semantic/chunker.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AA+KD,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE,CAIjE"}

package/dist/semantic/chunker.js

@@ -0,0 +1,163 @@
+/**
+ * Text chunking strategies for semantic indexing.
+ * Splits files into embeddable chunks respecting content boundaries.
+ */
+import * as path from "path";
+const MAX_CHUNK_CHARS = 6000;
+function linesToText(lines) {
+    return lines.join("\n");
+}
+function splitByParagraphs(lines, startLine, maxChars) {
+    const paragraphs = [];
+    let current = [];
+    let currentStart = startLine;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (current.length === 0)
+            currentStart = startLine + i;
+        current.push(line);
+        if (line.trim() === "") {
+            paragraphs.push({ start: currentStart, end: startLine + i, lines: current });
+            current = [];
+        }
+    }
+    if (current.length > 0) {
+        paragraphs.push({ start: currentStart, end: startLine + lines.length - 1, lines: current });
+    }
+    const chunks = [];
+    let acc = [];
+    let accStart = startLine;
+    let accLen = 0;
+    for (const para of paragraphs) {
+        const text = linesToText(para.lines);
+        const nextLen = accLen + text.length;
+        if (accLen > 0 && nextLen > maxChars) {
+            chunks.push({ start: accStart, end: accStart + acc.length - 1, lines: acc });
+            acc = [];
+            accLen = 0;
+        }
+        if (text.length > maxChars) {
+            if (acc.length > 0) {
+                chunks.push({ start: accStart, end: accStart + acc.length - 1, lines: acc });
+                acc = [];
+                accLen = 0;
+            }
+            let slice = [];
+            let sliceStart = para.start;
+            let sliceLen = 0;
+            for (let i = 0; i < para.lines.length; i++) {
+                const line = para.lines[i];
+                const lineLen = line.length + 1;
+                if (sliceLen > 0 && sliceLen + lineLen > maxChars) {
+                    chunks.push({ start: sliceStart, end: sliceStart + slice.length - 1, lines: slice });
+                    slice = [];
+                    sliceLen = 0;
+                    sliceStart = para.start + i;
+                }
+                slice.push(line);
+                sliceLen += lineLen;
+            }
+            if (slice.length > 0) {
+                chunks.push({ start: sliceStart, end: sliceStart + slice.length - 1, lines: slice });
+            }
+            continue;
+        }
+        if (acc.length === 0)
+            accStart = para.start;
+        acc.push(...para.lines);
+        accLen += text.length;
+    }
+    if (acc.length > 0) {
+        chunks.push({ start: accStart, end: accStart + acc.length - 1, lines: acc });
+    }
+    return chunks;
+}
+function chunkMarkdown(filePath, text) {
+    const lines = text.split("\n");
+    const chunks = [];
+    let index = 0;
+    if (lines[0] === "---") {
+        let end = -1;
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i] === "---") {
+                end = i;
+                break;
+            }
+        }
+        if (end > 0) {
+            chunks.push({ path: filePath, startLine: 1, endLine: end + 1, content: linesToText(lines.slice(0, end + 1)) });
+            index = end + 1;
+        }
+    }
+    let sectionStart = index;
+    let sectionLines = [];
+    const flushSection = (startLine, linesToFlush) => {
+        if (linesToFlush.length === 0)
+            return;
+        const textContent = linesToText(linesToFlush);
+        if (textContent.length <= MAX_CHUNK_CHARS) {
+            chunks.push({
+                path: filePath,
+                startLine: startLine + 1,
+                endLine: startLine + linesToFlush.length,
+                content: textContent,
+            });
+            return;
+        }
+        for (const chunk of splitByParagraphs(linesToFlush, startLine + 1, MAX_CHUNK_CHARS)) {
+            chunks.push({ path: filePath, startLine: chunk.start, endLine: chunk.end, content: linesToText(chunk.lines) });
+        }
+    };
+    for (let i = index; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("#")) {
+            flushSection(sectionStart, sectionLines);
+            sectionStart = i;
+            sectionLines = [line];
+            continue;
+        }
+        sectionLines.push(line);
+    }
+    flushSection(sectionStart, sectionLines);
+    return chunks;
+}
+function chunkText(filePath, text) {
+    const lines = text.split("\n");
+    const chunks = [];
+    let current = [];
+    let currentStart = 1;
+    let currentLen = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const nextLen = currentLen + line.length + 1;
+        if (currentLen > 0 && nextLen > MAX_CHUNK_CHARS) {
+            chunks.push({
+                path: filePath,
+                startLine: currentStart,
+                endLine: currentStart + current.length - 1,
+                content: linesToText(current),
+            });
+            current = [];
+            currentLen = 0;
+        }
+        if (current.length === 0)
+            currentStart = i + 1;
+        current.push(line);
+        currentLen += line.length + 1;
+    }
+    if (current.length > 0) {
+        chunks.push({
+            path: filePath,
+            startLine: currentStart,
+            endLine: currentStart + current.length - 1,
+            content: linesToText(current),
+        });
+    }
+    return chunks;
+}
+export function chunkFile(filePath, text) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".md" || ext === ".mdx")
+        return chunkMarkdown(filePath, text);
+    return chunkText(filePath, text);
+}

package/dist/semantic/embedder.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Embedding model management and vector operations.
+ * Handles model initialization and similarity scoring.
+ */
+import { FlagEmbedding } from "fastembed";
+export declare function getEmbedder(cacheDir: string): Promise<FlagEmbedding>;
+export declare function ensureModel(worktree: string): Promise<void>;
+export declare function encodeEmbedding(vec: number[]): Buffer<ArrayBuffer>;
+export declare function decodeEmbedding(blob: Uint8Array): Float32Array<ArrayBufferLike>;
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+export declare function getModelDir(dbDir: string): string;
+//# sourceMappingURL=embedder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embedder.d.ts","sourceRoot":"","sources":["../../semantic/embedder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAqC,aAAa,EAAE,MAAM,WAAW,CAAA;AAO5E,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,0BASjD;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,iBAUjD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,uBAE5C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,iCAE/C;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,UAWhE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,UAExC"}

package/dist/semantic/embedder.js

@@ -0,0 +1,54 @@
+/**
+ * Embedding model management and vector operations.
+ * Handles model initialization and similarity scoring.
+ */
+import { EmbeddingModel, ExecutionProvider, FlagEmbedding } from "fastembed";
+import * as path from "path";
+import * as fs from "fs/promises";
+const MODEL_DIRNAME = "models";
+let embedder = null;
+export async function getEmbedder(cacheDir) {
+    if (embedder)
+        return embedder;
+    embedder = await FlagEmbedding.init({
+        model: EmbeddingModel.AllMiniLML6V2,
+        executionProviders: [ExecutionProvider.CPU],
+        cacheDir,
+        showDownloadProgress: true,
+    });
+    return embedder;
+}
+export async function ensureModel(worktree) {
+    const cacheDir = path.join(worktree, ".opencode", "chat", MODEL_DIRNAME);
+    const modelPath = path.join(cacheDir, "fast-all-MiniLM-L6-v2", "model.onnx");
+    const exists = await fs
+        .stat(modelPath)
+        .then(() => true)
+        .catch(() => false);
+    if (exists)
+        return;
+    await fs.mkdir(cacheDir, { recursive: true });
+    await getEmbedder(cacheDir);
+}
+export function encodeEmbedding(vec) {
+    return Buffer.from(new Float32Array(vec).buffer);
+}
+export function decodeEmbedding(blob) {
+    return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+}
+export function cosineSimilarity(a, b) {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export function getModelDir(dbDir) {
+    return path.join(dbDir, MODEL_DIRNAME);
+}