@mojoaar/opencode-mimir 0.23.1 → 0.25.0

package/README.md

@@ -44,6 +44,11 @@ one the MCP header can use.
 |---|---|
 | `mimir_digest` | Returns what this project already knows: paths, titles, and a summary of the newest memories. |
 | `mimir_remember` | Stores one durable fact at a path like `deploy/rollback`. Writing the same path again replaces it. |
+| `mimir_search` | Hybrid search over this project's memories. |
+| `mimir_learn` | Hands a transcript over; the project's own model writes at most three memories from it. |
+
+When OpenCode compacts the conversation it also hands those messages to Mimir,
+which distils at most three memories from them.
 
 `tools` decides whether they are added: `auto` (default) leaves them out when an
 MCP server already points at the same `/mcp` endpoint, `always` adds them

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 import { Plugin } from '@opencode/plugin';
 export declare const DIGEST_HEADER = "## What this project already knows (Mimir)\n\n";
 export declare const NUDGE_HEADER = "## Memory check (Mimir)\n\n";
+export declare const MAX_TRANSCRIPT = 32000;
+/** A compaction of nothing is not worth a model call. */
+export declare const MIN_TRANSCRIPT = 500;
+/** Message text is shaped differently by each provider, so read what we can and skip the rest. */
+export declare function transcript(messages: unknown[]): string;
 /**
  * One injection point and two tools. The hook is what puts the project's
  * digest in front of the model before the first turn, so a session starts

package/dist/index.js

@@ -14,6 +14,44 @@ const NUDGE_EVERY = 20;
 const NUDGE = 'If this session settled a decision, a convention or a gotcha that is not in Mimir yet, ' +
     'call memory_write now at one clear path, or hand the conversation over with mimir_learn, ' +
     'before the detail is compacted away.';
+export const MAX_TRANSCRIPT = 32_000;
+/** A compaction of nothing is not worth a model call. */
+export const MIN_TRANSCRIPT = 500;
+const LEARN_HINT = 'This session was just compacted. Keep what was decided, what broke and any convention, and skip what Mimir already has.';
+const LEARN_NOW_HINT = 'The user asked for this session to be kept now. Keep what was decided, what broke and any convention, and skip what Mimir already has.';
+const NOTHING_TO_SEND = 'Nothing worth handing over yet.';
+const SENT = 'Mimir is writing what this session settled.';
+const QUEUE_OFF = 'Mimir took it, but its queue is not running.';
+const UNREACHABLE = 'Mimir is unreachable, so nothing was sent.';
+/** Message text is shaped differently by each provider, so read what we can and skip the rest. */
+export function transcript(messages) {
+    const lines = [];
+    for (const message of messages) {
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const record = message;
+        const role = typeof record.role === 'string' ? record.role : 'message';
+        const body = textOf(record.content) || textOf(record.parts);
+        if (body)
+            lines.push(`${role}: ${body}`);
+    }
+    return lines.join('\n\n').slice(-MAX_TRANSCRIPT);
+}
+function textOf(value) {
+    if (typeof value === 'string')
+        return value.trim();
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        const text = part?.text;
+        return typeof text === 'string' ? text : '';
+    })
+        .join('\n')
+        .trim();
+}
 /**
  * One injection point and two tools. The hook is what puts the project's
  * digest in front of the model before the first turn, so a session starts
@@ -46,20 +84,74 @@ export default Plugin.define({
                 return;
             event.system.push({ type: 'text', text: `${DIGEST_HEADER}${text}` });
         });
+        // The reminder rides the message count. A shrink means a compaction just
+        // happened, which is the worst moment to lose a detail, so it nudges early.
         const counts = new Map();
+        // The command below is handed no messages, only a session id, so the hook
+        // keeps the newest transcript for it. One string per live session, at most
+        // 32 KB, dropped once it has been sent.
+        const snapshots = new Map();
         const nudge = await ctx.session.hook('context', async (event) => {
             const state = counts.get(event.sessionID) ?? { turns: 0, nudgedAt: 0 };
             const turns = event.messages?.length ?? 0;
+            if (turns > state.turns)
+                snapshots.set(event.sessionID, transcript(event.messages ?? []));
             const due = turns < state.turns || turns - state.nudgedAt >= NUDGE_EVERY;
             counts.set(event.sessionID, { turns, nudgedAt: due ? turns : state.nudgedAt });
             if (due)
                 event.system.push({ type: 'text', text: `${NUDGE_HEADER}${NUDGE}` });
         });
+        // OpenCode fires this for its own compaction and hands over the messages
+        // being replaced. A compressed view swapped in by another plugin never
+        // reaches it, which is why the message count is not a signal.
+        const compacted = new Set();
+        const compaction = await ctx.session.hook('compaction', async (event) => {
+            // One compaction can ask twice. The second call must not write again.
+            if (compacted.has(event.sessionID))
+                return;
+            const text = transcript(event.messages ?? []);
+            if (text.length < MIN_TRANSCRIPT)
+                return;
+            compacted.add(event.sessionID);
+            const sent = await callTool('memory_learn', { repo: repo ?? undefined, transcript: text, hint: LEARN_HINT }, { ...config, timeoutMs: 4000 }).catch(() => null);
+            // Nothing is written to event.system here: this request's prompt becomes
+            // the summary that replaces the conversation. A failure gives the session
+            // its one chance back, so an outage does not use the compaction up.
+            if (!sent?.ok)
+                compacted.delete(event.sessionID);
+        });
+        // A manual handover, for the sessions that end before they ever compact.
+        const command = await ctx.command.transform((editor) => {
+            editor.add({
+                name: 'mimir-learn',
+                description: 'Hand this session to Mimir now.',
+                execute: async ({ sessionID }) => {
+                    const text = snapshots.get(sessionID) ?? '';
+                    let notice = NOTHING_TO_SEND;
+                    if (text.length >= MIN_TRANSCRIPT) {
+                        const sent = await callTool('memory_learn', { repo: repo ?? undefined, transcript: text, hint: LEARN_NOW_HINT }, { ...config, timeoutMs: 4000 }).catch(() => null);
+                        const queued = sent?.ok ? sent.result.queued : undefined;
+                        if (!sent?.ok)
+                            notice = UNREACHABLE;
+                        else if (queued === false)
+                            notice = QUEUE_OFF;
+                        else {
+                            notice = SENT;
+                            // Kept on failure above, so a retry has something to send.
+                            snapshots.delete(sessionID);
+                        }
+                    }
+                    await ctx.session.synthetic({ sessionID, text: notice }).catch(() => null);
+                },
+            });
+        });
         const tools = await registerTools(ctx, config, repo);
         return async () => {
             await tools.dispose();
             await session.dispose();
             await nudge.dispose();
+            await compaction.dispose();
+            await command.dispose();
         };
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojoaar/opencode-mimir",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "Mimir long-term memory for OpenCode sessions",
   "type": "module",
   "main": "src/index.ts",

package/src/index.ts

@@ -18,6 +18,44 @@ const NUDGE =
   'call memory_write now at one clear path, or hand the conversation over with mimir_learn, ' +
   'before the detail is compacted away.'
 
+export const MAX_TRANSCRIPT = 32_000
+/** A compaction of nothing is not worth a model call. */
+export const MIN_TRANSCRIPT = 500
+const LEARN_HINT =
+  'This session was just compacted. Keep what was decided, what broke and any convention, and skip what Mimir already has.'
+const LEARN_NOW_HINT =
+  'The user asked for this session to be kept now. Keep what was decided, what broke and any convention, and skip what Mimir already has.'
+const NOTHING_TO_SEND = 'Nothing worth handing over yet.'
+const SENT = 'Mimir is writing what this session settled.'
+const QUEUE_OFF = 'Mimir took it, but its queue is not running.'
+const UNREACHABLE = 'Mimir is unreachable, so nothing was sent.'
+
+/** Message text is shaped differently by each provider, so read what we can and skip the rest. */
+export function transcript(messages: unknown[]): string {
+  const lines: string[] = []
+  for (const message of messages) {
+    if (typeof message !== 'object' || message === null) continue
+    const record = message as { role?: unknown; content?: unknown; parts?: unknown }
+    const role = typeof record.role === 'string' ? record.role : 'message'
+    const body = textOf(record.content) || textOf(record.parts)
+    if (body) lines.push(`${role}: ${body}`)
+  }
+  return lines.join('\n\n').slice(-MAX_TRANSCRIPT)
+}
+
+function textOf(value: unknown): string {
+  if (typeof value === 'string') return value.trim()
+  if (!Array.isArray(value)) return ''
+  return value
+    .map((part) => {
+      if (typeof part === 'string') return part
+      const text = (part as { text?: unknown })?.text
+      return typeof text === 'string' ? text : ''
+    })
+    .join('\n')
+    .trim()
+}
+
 /**
  * One injection point and two tools. The hook is what puts the project's
  * digest in front of the model before the first turn, so a session starts
@@ -56,21 +94,82 @@ export default Plugin.define({
       event.system.push({ type: 'text', text: `${DIGEST_HEADER}${text}` })
     })
 
+    // The reminder rides the message count. A shrink means a compaction just
+    // happened, which is the worst moment to lose a detail, so it nudges early.
     const counts = new Map<string, { turns: number; nudgedAt: number }>()
+    // The command below is handed no messages, only a session id, so the hook
+    // keeps the newest transcript for it. One string per live session, at most
+    // 32 KB, dropped once it has been sent.
+    const snapshots = new Map<string, string>()
     const nudge = await ctx.session.hook('context', async (event) => {
       const state = counts.get(event.sessionID) ?? { turns: 0, nudgedAt: 0 }
       const turns = event.messages?.length ?? 0
+      if (turns > state.turns) snapshots.set(event.sessionID, transcript(event.messages ?? []))
       const due = turns < state.turns || turns - state.nudgedAt >= NUDGE_EVERY
       counts.set(event.sessionID, { turns, nudgedAt: due ? turns : state.nudgedAt })
+
       if (due) event.system.push({ type: 'text', text: `${NUDGE_HEADER}${NUDGE}` })
     })
 
+    // OpenCode fires this for its own compaction and hands over the messages
+    // being replaced. A compressed view swapped in by another plugin never
+    // reaches it, which is why the message count is not a signal.
+    const compacted = new Set<string>()
+    const compaction = await ctx.session.hook('compaction', async (event) => {
+      // One compaction can ask twice. The second call must not write again.
+      if (compacted.has(event.sessionID)) return
+      const text = transcript(event.messages ?? [])
+      if (text.length < MIN_TRANSCRIPT) return
+      compacted.add(event.sessionID)
+
+      const sent = await callTool(
+        'memory_learn',
+        { repo: repo ?? undefined, transcript: text, hint: LEARN_HINT },
+        { ...config, timeoutMs: 4000 },
+      ).catch(() => null)
+
+      // Nothing is written to event.system here: this request's prompt becomes
+      // the summary that replaces the conversation. A failure gives the session
+      // its one chance back, so an outage does not use the compaction up.
+      if (!sent?.ok) compacted.delete(event.sessionID)
+    })
+
+    // A manual handover, for the sessions that end before they ever compact.
+    const command = await ctx.command.transform((editor) => {
+      editor.add({
+        name: 'mimir-learn',
+        description: 'Hand this session to Mimir now.',
+        execute: async ({ sessionID }) => {
+          const text = snapshots.get(sessionID) ?? ''
+          let notice = NOTHING_TO_SEND
+          if (text.length >= MIN_TRANSCRIPT) {
+            const sent = await callTool(
+              'memory_learn',
+              { repo: repo ?? undefined, transcript: text, hint: LEARN_NOW_HINT },
+              { ...config, timeoutMs: 4000 },
+            ).catch(() => null)
+            const queued = sent?.ok ? (sent.result as { queued?: boolean }).queued : undefined
+            if (!sent?.ok) notice = UNREACHABLE
+            else if (queued === false) notice = QUEUE_OFF
+            else {
+              notice = SENT
+              // Kept on failure above, so a retry has something to send.
+              snapshots.delete(sessionID)
+            }
+          }
+          await ctx.session.synthetic({ sessionID, text: notice }).catch(() => null)
+        },
+      })
+    })
+
     const tools = await registerTools(ctx, config, repo)
 
     return async () => {
       await tools.dispose()
       await session.dispose()
       await nudge.dispose()
+      await compaction.dispose()
+      await command.dispose()
     }
   },
 })