greprag 0.7.0 → 0.7.3

package/dist/opencode-plugin.d.ts

@@ -0,0 +1,182 @@
+/** GrepRAG memory plugin for opencode.
+ *
+ * Two responsibilities:
+ *   1. Inject a recap of recent memory + unread inbox count into the system
+ *      prompt at the start of each session.
+ *   2. Capture every completed (user, assistant) turn pair to /v1/memory/turn
+ *      for episodic compaction.
+ *
+ * Loaded by opencode from ~/.config/opencode/plugins/greprag-memory.js
+ * (installed by `greprag init --opencode`). All types are declared inline so
+ * the file has zero external runtime imports — the package source must remain
+ * self-contained because opencode's loader hands the compiled module straight
+ * to Bun, with no resolution step against our dependency tree.
+ *
+ * Hook surface used (verified against sst/opencode dev branch):
+ *   - experimental.chat.system.transform — fires before each LLM call. We
+ *     push recap text on the FIRST fire per sessionID and ignore later fires.
+ *   - event — receives every bus event. We listen for "message.updated" with
+ *     role="assistant" and info.time.completed set (assistant message
+ *     finalized), then fetch the session's full message list via the supplied
+ *     client and capture the (parent user, this assistant) pair.
+ *
+ * The bus surface (event hook + message.updated) is the stable signal for
+ * "turn complete". experimental.chat.messages.transform fires BEFORE each
+ * LLM call — mid-turn during tool loops — so it cannot deliver finalized
+ * assistant content and is wrong for episodic capture.
+ */
+interface OpenCodeProject {
+    name?: string;
+    path?: string;
+}
+interface OpenCodeClient {
+    session: {
+        messages: (args: {
+            path: {
+                id: string;
+            };
+        }) => Promise<WithParts[]>;
+    };
+}
+interface OpenCodePluginContext {
+    client: OpenCodeClient;
+    project: OpenCodeProject;
+    directory: string;
+    worktree: string;
+    serverUrl: URL;
+    $: unknown;
+}
+interface UserInfo {
+    id: string;
+    sessionID: string;
+    role: 'user';
+    time: {
+        created: number;
+    };
+}
+interface AssistantInfo {
+    id: string;
+    sessionID: string;
+    role: 'assistant';
+    parentID: string;
+    modelID: string;
+    providerID: string;
+    time: {
+        created: number;
+        completed?: number;
+    };
+    agent: string;
+    path: {
+        cwd: string;
+        root: string;
+    };
+    cost: number;
+    error?: unknown;
+}
+type MessageInfo = UserInfo | AssistantInfo;
+interface WithParts {
+    info: MessageInfo;
+    parts: Part[];
+}
+interface TextPart {
+    type: 'text';
+    text: string;
+    synthetic?: boolean;
+    ignored?: boolean;
+}
+type ToolState = {
+    status: 'pending';
+    input: Record<string, unknown>;
+} | {
+    status: 'running';
+    input: Record<string, unknown>;
+    title?: string;
+} | {
+    status: 'completed';
+    input: Record<string, unknown>;
+    output: string;
+    title: string;
+} | {
+    status: 'error';
+    input: Record<string, unknown>;
+    error: string;
+};
+interface ToolPart {
+    type: 'tool';
+    callID: string;
+    tool: string;
+    state: ToolState;
+}
+interface GenericPart {
+    type: string;
+    [key: string]: unknown;
+}
+type Part = TextPart | ToolPart | GenericPart;
+interface BusEvent {
+    id?: string;
+    type: string;
+    properties: Record<string, unknown>;
+}
+type Hooks = {
+    'experimental.chat.system.transform'?: (input: {
+        sessionID: string;
+        model: unknown;
+    }, output: {
+        system: string[];
+    }) => Promise<void> | void;
+    event?: (input: {
+        event: BusEvent;
+    }) => Promise<void> | void;
+};
+interface ProjectAnchor {
+    projectId: string;
+    projectName: string;
+    memoryCapture: boolean;
+    sessionStartRecap: boolean;
+    inboxNotify: 'every_turn' | 'session_start_only' | 'off';
+}
+/** Resolve the project anchor for `worktree` using the same 4-level cascade
+ *  the Claude Code CLI uses (packages/cli/src/project-anchor.ts). Settings
+ *  always come from the nearest repo-level file when one exists, regardless
+ *  of which identity level resolved.
+ *
+ *    1. Anchor file with explicit `project_id` → file-based identity
+ *    2. Git repo with at least one commit → root-commit-derived UUID
+ *    3. Ephemeral cwd + ~/.claude/project.json exists → global anchor
+ *    4. Path-hash fallback (never returns null; lets capture flow until
+ *       `greprag init` runs and `greprag doctor` consolidates) */
+declare function readAnchor(worktree: string): ProjectAnchor;
+declare function extractText(parts: Part[]): string;
+interface ToolCallSummary {
+    name: string;
+    target?: string;
+    brief?: string;
+}
+/** Pull a one-line summary out of each tool call: name + a target string + an
+ *  optional brief for shell commands. Mirrors the shape the Claude Code hook
+ *  posts so server-side compaction sees identical structure regardless of
+ *  client origin. */
+declare function extractToolCalls(parts: Part[]): ToolCallSummary[];
+declare function extractFilesTouched(parts: Part[]): string[];
+interface Envelope {
+    userPrompt: string;
+    agentResponse: string;
+    toolCalls: ToolCallSummary[];
+    filesTouched: string[];
+    status: 'completed' | 'errored';
+}
+declare function buildEnvelope(userParts: Part[], assistantParts: Part[], errored: boolean): Envelope;
+declare const GrepRAGMemoryPlugin: (ctx: OpenCodePluginContext) => Promise<Hooks>;
+declare const _default: {
+    server: (ctx: OpenCodePluginContext) => Promise<Hooks>;
+    id: string;
+};
+export default _default;
+export { GrepRAGMemoryPlugin };
+export declare const __test: {
+    extractText: typeof extractText;
+    extractToolCalls: typeof extractToolCalls;
+    extractFilesTouched: typeof extractFilesTouched;
+    buildEnvelope: typeof buildEnvelope;
+    readAnchor: typeof readAnchor;
+};

package/dist/opencode-plugin.js

@@ -0,0 +1,490 @@
+"use strict";
+/** GrepRAG memory plugin for opencode.
+ *
+ * Two responsibilities:
+ *   1. Inject a recap of recent memory + unread inbox count into the system
+ *      prompt at the start of each session.
+ *   2. Capture every completed (user, assistant) turn pair to /v1/memory/turn
+ *      for episodic compaction.
+ *
+ * Loaded by opencode from ~/.config/opencode/plugins/greprag-memory.js
+ * (installed by `greprag init --opencode`). All types are declared inline so
+ * the file has zero external runtime imports — the package source must remain
+ * self-contained because opencode's loader hands the compiled module straight
+ * to Bun, with no resolution step against our dependency tree.
+ *
+ * Hook surface used (verified against sst/opencode dev branch):
+ *   - experimental.chat.system.transform — fires before each LLM call. We
+ *     push recap text on the FIRST fire per sessionID and ignore later fires.
+ *   - event — receives every bus event. We listen for "message.updated" with
+ *     role="assistant" and info.time.completed set (assistant message
+ *     finalized), then fetch the session's full message list via the supplied
+ *     client and capture the (parent user, this assistant) pair.
+ *
+ * The bus surface (event hook + message.updated) is the stable signal for
+ * "turn complete". experimental.chat.messages.transform fires BEFORE each
+ * LLM call — mid-turn during tool loops — so it cannot deliver finalized
+ * assistant content and is wrong for episodic capture.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__test = exports.GrepRAGMemoryPlugin = void 0;
+// ============================================================================
+// Module-level setup: env + anchor (loaded once per opencode process)
+// ============================================================================
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const API_URL = 'https://api.greprag.com';
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+/** Load env vars from ~/.claude/settings.json so the plugin sees the same
+ *  GREPRAG_API_KEY + MEMORY_HOOK_ENABLED that the Claude Code hook sees,
+ *  without forcing the user to set them in opencode's own env. */
+function loadClaudeEnv() {
+    try {
+        const p = path.join(HOME, '.claude', 'settings.json');
+        if (!fs.existsSync(p))
+            return;
+        const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (data && data.env && typeof data.env === 'object') {
+            for (const [key, val] of Object.entries(data.env)) {
+                if (!process.env[key] && typeof val === 'string') {
+                    process.env[key] = val;
+                }
+            }
+        }
+    }
+    catch {
+        // settings.json absent or malformed — silently fall through
+    }
+}
+loadClaudeEnv();
+function getEnv(key) {
+    return process.env[key] || '';
+}
+function readAnchorFile(filePath) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (!raw || typeof raw !== 'object')
+            return null;
+        const notify = raw.inbox_notify;
+        const inboxNotify = notify === 'off' || notify === 'session_start_only' ? notify : 'every_turn';
+        return {
+            projectId: typeof raw.project_id === 'string' ? raw.project_id : undefined,
+            projectName: typeof raw.project_name === 'string' ? raw.project_name : undefined,
+            memoryCapture: raw.memory_capture !== false,
+            sessionStartRecap: raw.session_start_recap !== false,
+            inboxNotify,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Walk up from cwd looking for an anchor file. Checks both `.claude/` and
+ *  `.opencode/` at each level. Returns the first hit. Skips `~/.claude/` (the
+ *  global anchor is reserved for the ephemeral-cwd path of the cascade). */
+function findExistingAnchorFile(startDir) {
+    const globalAnchorPath = path.join(HOME, '.claude', 'project.json');
+    let dir = path.resolve(startDir);
+    while (true) {
+        for (const subdir of ['.claude', '.opencode']) {
+            const candidate = path.join(dir, subdir, 'project.json');
+            if (candidate !== globalAnchorPath && fs.existsSync(candidate))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Format the SHA-256 of an input string into a deterministic UUID v4-shape
+ *  string. Must match the algorithm in packages/cli/src/project-anchor.ts so
+ *  the plugin resolves identical IDs to the Claude Code CLI. */
+function formatUuid(hashHex) {
+    return [
+        hashHex.slice(0, 8),
+        hashHex.slice(8, 12),
+        '4' + hashHex.slice(13, 16),
+        '8' + hashHex.slice(17, 20),
+        hashHex.slice(20, 32),
+    ].join('-');
+}
+/** Derive a stable project_id from the repo's root commit SHA. Sorted +
+ *  hashed so disjoint-history merges produce one deterministic id everywhere.
+ *  Returns null when cwd isn't a git repo or has no commits yet. */
+function computeGitDerivedProjectId(cwd) {
+    try {
+        const out = (0, child_process_1.execSync)('git rev-list --max-parents=0 HEAD', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const roots = out.trim().split(/\s+/).filter(Boolean).sort();
+        if (roots.length === 0)
+            return null;
+        const hash = crypto.createHash('sha256').update(roots.join('\n')).digest('hex');
+        return formatUuid(hash);
+    }
+    catch {
+        return null;
+    }
+}
+/** Hash the cwd path into a stable UUID. Last-resort fallback — when no git
+ *  history and no anchor file exist, this keeps capture flowing under a
+ *  per-path identity that `greprag doctor` can later consolidate. */
+function deterministicProjectId(cwd) {
+    const normalized = path.resolve(cwd).toLowerCase();
+    const hash = crypto.createHash('sha256').update(normalized).digest('hex');
+    return formatUuid(hash);
+}
+/** True when cwd is an ephemeral session path (Cowork, tmp dirs). The
+ *  deterministic-hash fallback would mint a fresh id every session in those
+ *  paths, so we prefer the global anchor instead. */
+function isEphemeralCwd(cwd) {
+    const norm = path.resolve(cwd).replace(/\\/g, '/').toLowerCase();
+    if (norm.includes('/appdata/roaming/claude/local-agent-mode-sessions/'))
+        return true;
+    if (norm.includes('/appdata/local/claude/local-agent-mode-sessions/'))
+        return true;
+    if (norm.startsWith('/tmp/'))
+        return true;
+    if (norm.startsWith('/var/tmp/'))
+        return true;
+    if (norm.startsWith('/private/tmp/'))
+        return true;
+    return false;
+}
+/** Resolve the project anchor for `worktree` using the same 4-level cascade
+ *  the Claude Code CLI uses (packages/cli/src/project-anchor.ts). Settings
+ *  always come from the nearest repo-level file when one exists, regardless
+ *  of which identity level resolved.
+ *
+ *    1. Anchor file with explicit `project_id` → file-based identity
+ *    2. Git repo with at least one commit → root-commit-derived UUID
+ *    3. Ephemeral cwd + ~/.claude/project.json exists → global anchor
+ *    4. Path-hash fallback (never returns null; lets capture flow until
+ *       `greprag init` runs and `greprag doctor` consolidates) */
+function readAnchor(worktree) {
+    const filePath = findExistingAnchorFile(worktree);
+    const file = filePath ? readAnchorFile(filePath) : null;
+    const root = path.resolve(worktree);
+    // 1. File with explicit project_id
+    if (file && file.projectId && file.projectName) {
+        return {
+            projectId: file.projectId,
+            projectName: file.projectName,
+            memoryCapture: file.memoryCapture,
+            sessionStartRecap: file.sessionStartRecap,
+            inboxNotify: file.inboxNotify,
+        };
+    }
+    // 2. Git-derived identity. Settings layer in from the settings-only file
+    // when one exists; otherwise defaults apply.
+    const gitId = computeGitDerivedProjectId(worktree);
+    if (gitId) {
+        return {
+            projectId: gitId,
+            projectName: file?.projectName || path.basename(root).toLowerCase(),
+            memoryCapture: file?.memoryCapture ?? true,
+            sessionStartRecap: file?.sessionStartRecap ?? true,
+            inboxNotify: file?.inboxNotify ?? 'every_turn',
+        };
+    }
+    // 3. Ephemeral cwd + global anchor
+    if (isEphemeralCwd(worktree)) {
+        const globalPath = path.join(HOME, '.claude', 'project.json');
+        const globalFile = fs.existsSync(globalPath) ? readAnchorFile(globalPath) : null;
+        if (globalFile && globalFile.projectId && globalFile.projectName) {
+            return {
+                projectId: globalFile.projectId,
+                projectName: globalFile.projectName,
+                memoryCapture: globalFile.memoryCapture,
+                sessionStartRecap: globalFile.sessionStartRecap,
+                inboxNotify: globalFile.inboxNotify,
+            };
+        }
+    }
+    // 4. Path-hash fallback — keep capture flowing for uninitialized repos.
+    return {
+        projectId: deterministicProjectId(worktree),
+        projectName: file?.projectName || path.basename(root).toLowerCase(),
+        memoryCapture: file?.memoryCapture ?? true,
+        sessionStartRecap: file?.sessionStartRecap ?? true,
+        inboxNotify: file?.inboxNotify ?? 'every_turn',
+    };
+}
+// ============================================================================
+// Envelope construction (real opencode Part schema)
+// ============================================================================
+function extractText(parts) {
+    const out = [];
+    for (const p of parts) {
+        if (p.type !== 'text')
+            continue;
+        const tp = p;
+        if (tp.synthetic || tp.ignored)
+            continue;
+        if (tp.text)
+            out.push(tp.text);
+    }
+    return out.join('\n').trim();
+}
+/** Pull a one-line summary out of each tool call: name + a target string + an
+ *  optional brief for shell commands. Mirrors the shape the Claude Code hook
+ *  posts so server-side compaction sees identical structure regardless of
+ *  client origin. */
+function extractToolCalls(parts) {
+    const calls = [];
+    for (const p of parts) {
+        if (p.type !== 'tool')
+            continue;
+        const tp = p;
+        const name = tp.tool || 'unknown';
+        const input = (tp.state && tp.state.input) || {};
+        const call = { name };
+        if (input.command !== undefined) {
+            const desc = input.description;
+            call.target =
+                typeof desc === 'string' && desc
+                    ? desc
+                    : String(input.command).split(/\s+/)[0] || '';
+            const cmd = String(input.command);
+            call.brief = cmd.length > 800 ? cmd.slice(0, 800) + '…' : cmd;
+        }
+        else if (typeof input.file_path === 'string') {
+            call.target = input.file_path;
+        }
+        else if (typeof input.filePath === 'string') {
+            call.target = input.filePath;
+        }
+        else if (typeof input.pattern === 'string') {
+            call.target = input.pattern;
+        }
+        else if (typeof input.url === 'string') {
+            call.target = input.url;
+        }
+        else if (typeof input.query === 'string') {
+            call.target = input.query;
+        }
+        calls.push(call);
+    }
+    return calls;
+}
+function extractFilesTouched(parts) {
+    const files = new Set();
+    for (const p of parts) {
+        if (p.type !== 'tool')
+            continue;
+        const tp = p;
+        const input = (tp.state && tp.state.input) || {};
+        if (typeof input.file_path === 'string')
+            files.add(input.file_path);
+        if (typeof input.filePath === 'string')
+            files.add(input.filePath);
+    }
+    return Array.from(files).sort();
+}
+function buildEnvelope(userParts, assistantParts, errored) {
+    return {
+        userPrompt: extractText(userParts),
+        agentResponse: extractText(assistantParts),
+        toolCalls: extractToolCalls(assistantParts),
+        filesTouched: extractFilesTouched(assistantParts),
+        status: errored ? 'errored' : 'completed',
+    };
+}
+// ============================================================================
+// API calls (fire-and-forget; never block the LLM)
+// ============================================================================
+async function storeTurn(anchor, sessionID, envelope, workingDir) {
+    const apiKey = getEnv('GREPRAG_API_KEY');
+    if (!apiKey)
+        return;
+    const body = JSON.stringify({
+        projectId: anchor.projectId,
+        projectName: anchor.projectName,
+        branch: null,
+        workingDir,
+        sessionIdExternal: sessionID,
+        turnId: crypto.randomUUID(),
+        model: null,
+        status: envelope.status,
+        userPrompt: envelope.userPrompt,
+        agentResponse: envelope.agentResponse,
+        toolCalls: envelope.toolCalls,
+        filesTouched: envelope.filesTouched,
+        artifacts: [],
+        source: 'opencode',
+    });
+    try {
+        await fetch(`${API_URL}/v1/memory/turn`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body,
+        });
+    }
+    catch {
+        // Silent — fire-and-forget
+    }
+}
+async function fetchRecapInbox(anchor) {
+    const apiKey = getEnv('GREPRAG_API_KEY');
+    if (!apiKey)
+        return [];
+    const lines = [];
+    const now = new Date();
+    const weekAgo = new Date(now.getTime() - 7 * 86400000).toISOString();
+    const toIso = now.toISOString();
+    if (anchor.sessionStartRecap) {
+        try {
+            const res = await fetch(`${API_URL}/v1/memory/by-period?projectId=${anchor.projectId}&from=${encodeURIComponent(weekAgo)}&to=${encodeURIComponent(toIso)}&type=episodic-daily&limit=7`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (res.ok) {
+                const data = (await res.json());
+                if (data.memories && data.memories.length > 0) {
+                    lines.push(`[GrepRAG memory: ${anchor.projectName}]`);
+                    for (const m of data.memories) {
+                        const date = m.windowStart ? m.windowStart.slice(0, 10) : '';
+                        lines.push(`[${date}] ${m.content}`);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    if (anchor.inboxNotify !== 'off') {
+        try {
+            const res = await fetch(`${API_URL}/v1/inbox?count_only=1&projectId=${anchor.projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (res.ok) {
+                const data = (await res.json());
+                if (typeof data.unread_count === 'number' && data.unread_count > 0) {
+                    lines.push(`[${data.unread_count} unread in inbox]`);
+                }
+            }
+        }
+        catch { }
+    }
+    return lines;
+}
+// ============================================================================
+// Per-session state. Plugin function runs once at opencode boot, so this state
+// lives for the lifetime of the opencode process and is shared across every
+// session that process handles. Both sets key on opencode's canonical IDs
+// (sessionID and assistant-message id) so they're correct across sessions.
+// ============================================================================
+const recapInjectedBySession = new Set();
+const storedAssistantMessageIds = new Set();
+// ============================================================================
+// Plugin entry point
+// ============================================================================
+const GrepRAGMemoryPlugin = async (ctx) => {
+    const apiKey = getEnv('GREPRAG_API_KEY');
+    const enabled = getEnv('MEMORY_HOOK_ENABLED') === 'true';
+    if (!enabled || !apiKey)
+        return {};
+    const anchor = readAnchor(ctx.worktree);
+    const client = ctx.client;
+    const workingDir = ctx.directory || ctx.worktree;
+    return {
+        'experimental.chat.system.transform': async (input, output) => {
+            const sid = input && input.sessionID;
+            if (!sid)
+                return;
+            if (recapInjectedBySession.has(sid))
+                return;
+            recapInjectedBySession.add(sid);
+            const recap = await fetchRecapInbox(anchor);
+            if (recap.length > 0) {
+                output.system.push(recap.join('\n'));
+            }
+        },
+        event: async ({ event }) => {
+            if (!anchor.memoryCapture)
+                return;
+            if (!event || event.type !== 'message.updated')
+                return;
+            const info = event.properties && event.properties.info;
+            if (!info || info.role !== 'assistant')
+                return;
+            const completed = info.time && typeof info.time.completed === 'number';
+            if (!completed)
+                return;
+            if (storedAssistantMessageIds.has(info.id))
+                return;
+            storedAssistantMessageIds.add(info.id);
+            let allMessages;
+            try {
+                allMessages = await client.session.messages({
+                    path: { id: info.sessionID },
+                });
+            }
+            catch {
+                return;
+            }
+            const assistantWithParts = allMessages.find((m) => m.info.id === info.id);
+            if (!assistantWithParts)
+                return;
+            const userWithParts = allMessages.find((m) => m.info.id === info.parentID);
+            if (!userWithParts)
+                return;
+            const errored = !!info.error;
+            const envelope = buildEnvelope(userWithParts.parts, assistantWithParts.parts, errored);
+            if (!envelope.userPrompt &&
+                !envelope.agentResponse &&
+                envelope.toolCalls.length === 0) {
+                return;
+            }
+            await storeTurn(anchor, info.sessionID, envelope, workingDir);
+        },
+    };
+};
+exports.GrepRAGMemoryPlugin = GrepRAGMemoryPlugin;
+// V1 plugin export shape (preferred by opencode's loader). The legacy named
+// export is kept as a fallback for older loader code paths.
+exports.default = { server: GrepRAGMemoryPlugin, id: 'greprag-memory' };
+// Exposed for unit tests — never imported by opencode at runtime.
+exports.__test = {
+    extractText,
+    extractToolCalls,
+    extractFilesTouched,
+    buildEnvelope,
+    readAnchor,
+};
+//# sourceMappingURL=opencode-plugin.js.map