@otto-assistant/bridge 0.4.100 → 0.4.102

package/dist/commands/login.js

@@ -39,6 +39,8 @@ const PROVIDER_POPULARITY_ORDER = [
     'xai',
     'groq',
     'deepseek',
+    'opencode',
+    'opencode-go',
     'mistral',
     'openrouter',
     'fireworks-ai',
@@ -47,12 +49,12 @@ const PROVIDER_POPULARITY_ORDER = [
     'azure',
     'google-vertex',
     'google-vertex-anthropic',
-    'cohere',
+    // 'cohere',
     'cerebras',
-    'perplexity',
+    // 'perplexity',
     'cloudflare-workers-ai',
-    'novita-ai',
-    'huggingface',
+    // 'novita-ai',
+    // 'huggingface',
     'deepinfra',
     'github-models',
     'lmstudio',

package/dist/context-awareness-plugin.js

@@ -1,7 +1,6 @@
 // OpenCode plugin that injects synthetic message parts for context awareness:
 // - Git branch / detached HEAD changes
 // - Working directory (pwd) changes (e.g. after /new-worktree mid-session)
-// - MEMORY.md table of contents on first message
 // - MEMORY.md reminder after a large assistant reply
 // - Onboarding tutorial instructions (when TUTORIAL_WELCOME_TEXT detected)
 //
@@ -16,26 +15,13 @@
 // Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
 // plugin by OpenCode's plugin loader.
 import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
 import * as errore from 'errore';
 import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
 import { setDataDir } from './config.js';
 import { initSentry, notifyError } from './sentry.js';
 import { execAsync } from './exec-async.js';
-import { condenseMemoryMd } from './condense-memory.js';
 import { ONBOARDING_TUTORIAL_INSTRUCTIONS, TUTORIAL_WELCOME_TEXT, } from './onboarding-tutorial.js';
 const logger = createPluginLogger('OPENCODE');
-function createSessionState() {
-    return {
-        gitState: undefined,
-        memoryInjected: false,
-        lastMemoryReminderAssistantMessageId: undefined,
-        tutorialInjected: false,
-        resolvedDirectory: undefined,
-        announcedDirectory: undefined,
-    };
-}
 // ── Pure derivation functions ────────────────────────────────────
 // These take state + fresh input and return whether to inject.
 // No side effects, no mutations — easy to test with fixtures.
@@ -66,9 +52,6 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
     };
 }
 const MEMORY_REMINDER_OUTPUT_TOKENS = 12_000;
-function getOutputTokenTotal(tokens) {
-    return Math.max(0, tokens.output + tokens.reasoning);
-}
 export function shouldInjectMemoryReminderFromLatestAssistant({ lastMemoryReminderAssistantMessageId, latestAssistantMessage, threshold = MEMORY_REMINDER_OUTPUT_TOKENS, }) {
     if (!latestAssistantMessage) {
         return { inject: false };
@@ -85,7 +68,7 @@ export function shouldInjectMemoryReminderFromLatestAssistant({ lastMemoryRemind
     if (lastMemoryReminderAssistantMessageId === latestAssistantMessage.id) {
         return { inject: false };
     }
-    const outputTokens = getOutputTokenTotal(latestAssistantMessage.tokens);
+    const outputTokens = Math.max(0, latestAssistantMessage.tokens.output + latestAssistantMessage.tokens.reasoning);
     if (outputTokens < threshold) {
         return { inject: false };
     }
@@ -184,7 +167,13 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
         if (existing) {
             return existing;
         }
-        const state = createSessionState();
+        const state = {
+            gitState: undefined,
+            lastMemoryReminderAssistantMessageId: undefined,
+            tutorialInjected: false,
+            resolvedDirectory: undefined,
+            announcedDirectory: undefined,
+        };
         sessions.set(sessionID, state);
         return state;
     }
@@ -274,25 +263,6 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                             synthetic: true,
                         });
                     }
-                    // -- MEMORY.md injection --
-                    if (!state.memoryInjected) {
-                        state.memoryInjected = true;
-                        const memoryPath = path.join(effectiveDirectory, 'MEMORY.md');
-                        const memoryContent = await fs.promises
-                            .readFile(memoryPath, 'utf-8')
-                            .catch(() => null);
-                        if (memoryContent) {
-                            const condensed = condenseMemoryMd(memoryContent);
-                            output.parts.push({
-                                id: `prt_${crypto.randomUUID()}`,
-                                sessionID,
-                                messageID,
-                                type: 'text',
-                                text: `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>`,
-                                synthetic: true,
-                            });
-                        }
-                    }
                     const memoryReminder = shouldInjectMemoryReminderFromLatestAssistant({
                         lastMemoryReminderAssistantMessageId: state.lastMemoryReminderAssistantMessageId,
                         latestAssistantMessage,

package/dist/kimaki-opencode-plugin.js

@@ -5,11 +5,13 @@
 //
 // Plugins are split into focused modules:
 // - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
-// - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
+// - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
+// - memory-overview-plugin: frozen MEMORY.md heading overview per session
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
+export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';

package/dist/memory-overview-plugin.js

@@ -0,0 +1,126 @@
+// OpenCode plugin that snapshots the MEMORY.md heading overview once per
+// session and injects that frozen snapshot on the first real user message.
+// The snapshot is cached by session ID so later MEMORY.md edits do not change
+// the prompt for the same session and do not invalidate OpenCode's cache.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
+import { condenseMemoryMd } from './condense-memory.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('OPENCODE');
+function createSessionState() {
+    return {
+        hasFrozenOverview: false,
+        frozenOverviewText: null,
+        injected: false,
+    };
+}
+function buildMemoryOverviewReminder({ condensed }) {
+    return `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>`;
+}
+async function freezeMemoryOverview({ directory, state, }) {
+    if (state.hasFrozenOverview) {
+        return state.frozenOverviewText;
+    }
+    const memoryPath = path.join(directory, 'MEMORY.md');
+    const memoryContentResult = await fs.promises.readFile(memoryPath, 'utf-8').catch(() => {
+        return null;
+    });
+    if (!memoryContentResult) {
+        state.hasFrozenOverview = true;
+        state.frozenOverviewText = null;
+        return null;
+    }
+    const condensed = condenseMemoryMd(memoryContentResult);
+    state.hasFrozenOverview = true;
+    state.frozenOverviewText = buildMemoryOverviewReminder({ condensed });
+    return state.frozenOverviewText;
+}
+const memoryOverviewPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    function getOrCreateSessionState({ sessionID }) {
+        const existing = sessions.get(sessionID);
+        if (existing) {
+            return existing;
+        }
+        const state = createSessionState();
+        sessions.set(sessionID, state);
+        return state;
+    }
+    return {
+        'chat.message': async (input, output) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    const state = getOrCreateSessionState({ sessionID: input.sessionID });
+                    if (state.injected) {
+                        return;
+                    }
+                    const firstPart = output.parts.find((part) => {
+                        if (part.type !== 'text') {
+                            return true;
+                        }
+                        return part.synthetic !== true;
+                    });
+                    if (!firstPart || firstPart.type !== 'text' || firstPart.text.trim().length === 0) {
+                        return;
+                    }
+                    const overviewText = await freezeMemoryOverview({ directory, state });
+                    state.injected = true;
+                    if (!overviewText) {
+                        return;
+                    }
+                    output.parts.push({
+                        id: `prt_${crypto.randomUUID()}`,
+                        sessionID: input.sessionID,
+                        messageID: firstPart.messageID,
+                        type: 'text',
+                        text: overviewText,
+                        synthetic: true,
+                    });
+                },
+                catch: (error) => {
+                    return new Error('memory overview chat.message hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin chat.message hook failed');
+        },
+        event: async ({ event }) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    if (event.type !== 'session.deleted') {
+                        return;
+                    }
+                    const id = event.properties?.info?.id;
+                    if (!id) {
+                        return;
+                    }
+                    sessions.delete(id);
+                },
+                catch: (error) => {
+                    return new Error('memory overview event hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin event hook failed');
+        },
+    };
+};
+export { memoryOverviewPlugin };

package/dist/opencode.js

@@ -335,6 +335,9 @@ async function startSingleServer() {
     const opencodeConfigDir = path
         .join(os.homedir(), '.config', 'opencode')
         .replaceAll('\\', '/');
+    const opensrcDir = path
+        .join(os.homedir(), '.opensrc')
+        .replaceAll('\\', '/');
     const kimakiDataDir = path
         .join(os.homedir(), '.kimaki')
         .replaceAll('\\', '/');
@@ -349,6 +352,8 @@ async function startSingleServer() {
         [`${tmpdir}/*`]: 'allow',
         [opencodeConfigDir]: 'allow',
         [`${opencodeConfigDir}/*`]: 'allow',
+        [opensrcDir]: 'allow',
+        [`${opensrcDir}/*`]: 'allow',
         [kimakiDataDir]: 'allow',
         [`${kimakiDataDir}/*`]: 'allow',
     };
@@ -388,11 +393,14 @@ async function startSingleServer() {
     // priority chain, so project-level opencode.json can override kimaki defaults.
     // OPENCODE_CONFIG_CONTENT was loaded last and overrode user project configs,
     // causing issue #90 (project permissions not being respected).
+    const isDev = import.meta.url.endsWith('.ts') || import.meta.url.endsWith('.tsx');
     const opencodeConfig = {
         $schema: 'https://opencode.ai/config.json',
         lsp: false,
         formatter: false,
-        plugin: [new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href],
+        plugin: [
+            new URL(isDev ? './kimaki-opencode-plugin.ts' : './kimaki-opencode-plugin.js', import.meta.url).href,
+        ],
         permission: {
             edit: 'allow',
             bash: 'allow',
@@ -668,6 +676,12 @@ export function buildSessionPermissions({ directory, originalRepoDirectory, }) {
         .join(os.homedir(), '.config', 'opencode')
         .replaceAll('\\', '/');
     rules.push({ permission: 'external_directory', pattern: opencodeConfigDir, action: 'allow' }, { permission: 'external_directory', pattern: `${opencodeConfigDir}/*`, action: 'allow' });
+    // Allow ~/.opensrc so agents can inspect cached opensrc checkouts without
+    // permission prompts.
+    const opensrcDir = path
+        .join(os.homedir(), '.opensrc')
+        .replaceAll('\\', '/');
+    rules.push({ permission: 'external_directory', pattern: opensrcDir, action: 'allow' }, { permission: 'external_directory', pattern: `${opensrcDir}/*`, action: 'allow' });
     // Allow ~/.kimaki so the agent can access kimaki data dir (logs, db, etc.)
     // without permission prompts.
     const kimakiDataDir = path

package/package.json

@@ -2,7 +2,7 @@
   "name": "@otto-assistant/bridge",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.100",
+  "version": "0.4.102",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm generate && pnpm tsc",