@mojoaar/opencode-mimir 0.23.0 → 0.24.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
@@ -62,10 +67,10 @@ unreachable, slow, or unconfigured - a session never waits on memory.
 
 ## Import an existing project
 
-Until the package is published, run the CLI from a checkout:
+The package ships the importer as its `mimir` binary:
 
 ```sh
-node packages/opencode-plugin/dist/bin.js ingest .
+npx @mojoaar/opencode-mimir ingest .
 ```
 
 Walks the folder and loads its **documentation and configuration** - READMEs,

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,39 @@ 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.';
+/** 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,6 +79,8 @@ 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();
         const nudge = await ctx.session.hook('context', async (event) => {
             const state = counts.get(event.sessionID) ?? { turns: 0, nudgedAt: 0 };
@@ -55,11 +90,31 @@ export default Plugin.define({
             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);
+        });
         const tools = await registerTools(ctx, config, repo);
         return async () => {
             await tools.dispose();
             await session.dispose();
             await nudge.dispose();
+            await compaction.dispose();
         };
     },
 });

package/package.json

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

package/src/index.ts

@@ -18,6 +18,38 @@ 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.'
+
+/** 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 +88,48 @@ 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 }>()
     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
       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)
+    })
+
     const tools = await registerTools(ctx, config, repo)
 
     return async () => {
       await tools.dispose()
       await session.dispose()
       await nudge.dispose()
+      await compaction.dispose()
     }
   },
 })