@mojoaar/opencode-mimir 0.29.2 → 0.29.4

package/dist/index.d.ts

@@ -6,6 +6,12 @@ export declare const MAX_TRANSCRIPT = 32000;
 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;
+/**
+ * The session API hands back message records, not the provider shapes the
+ * context hook uses: a user turn keeps its words in `text`, an assistant turn
+ * in `content`. System and synthetic records are instructions, not conversation.
+ */
+export declare function sessionTranscript(messages: readonly 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

@@ -20,6 +20,8 @@ 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 ALREADY = 'This session was already handed over.';
+const UNREADABLE = 'Mimir could not read this session, so nothing was sent.';
 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.';
@@ -52,6 +54,41 @@ function textOf(value) {
         .join('\n')
         .trim();
 }
+/**
+ * The session API hands back message records, not the provider shapes the
+ * context hook uses: a user turn keeps its words in `text`, an assistant turn
+ * in `content`. System and synthetic records are instructions, not conversation.
+ */
+export function sessionTranscript(messages) {
+    const lines = [];
+    for (const message of messages) {
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const record = message;
+        if (record.type === 'user') {
+            const body = textOf(record.text);
+            if (body)
+                lines.push(`user: ${body}`);
+        }
+        else if (record.type === 'assistant') {
+            const body = assistantText(record.content);
+            if (body)
+                lines.push(`assistant: ${body}`);
+        }
+    }
+    return lines.join('\n\n').slice(-MAX_TRANSCRIPT);
+}
+/** Reasoning and tool parts are not conversation, and they are the bulk of it. */
+function assistantText(content) {
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((part) => part?.type === 'text')
+        .map((part) => part.text)
+        .filter((part) => typeof part === 'string')
+        .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
@@ -91,15 +128,9 @@ export default Plugin.define({
         // 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)
@@ -131,30 +162,51 @@ export default Plugin.define({
                 compacted.delete(event.sessionID);
         });
         // A manual handover, for the sessions that end before they ever compact.
+        // One process hands a session over once, so a second command does not
+        // queue the same transcript again.
+        const sent = new Set();
         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,
-                            client: 'opencode',
-                            session: sessionID,
-                        }, { ...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;
+                    if (sent.has(sessionID)) {
+                        notice = ALREADY;
+                    }
+                    else {
+                        let history = null;
+                        try {
+                            history = await ctx.session.context({ sessionID });
+                        }
+                        catch {
+                            history = null;
+                        }
+                        // The manual command is explicit, so any real text is worth a
+                        // model call. The 500 character floor is for automatic compaction.
+                        if (!Array.isArray(history)) {
+                            notice = UNREADABLE;
+                        }
                         else {
-                            notice = SENT;
-                            // Kept on failure above, so a retry has something to send.
-                            snapshots.delete(sessionID);
+                            const text = sessionTranscript(history);
+                            if (text.trim() !== '') {
+                                const result = await callTool('memory_learn', {
+                                    repo: repo ?? undefined,
+                                    transcript: text,
+                                    hint: LEARN_NOW_HINT,
+                                    client: 'opencode',
+                                    session: sessionID,
+                                }, { ...config, timeoutMs: 4000 }).catch(() => null);
+                                const queued = result?.ok ? result.result.queued : undefined;
+                                if (!result?.ok)
+                                    notice = UNREACHABLE;
+                                else if (queued === false)
+                                    notice = QUEUE_OFF;
+                                else {
+                                    notice = SENT;
+                                    sent.add(sessionID);
+                                }
+                            }
                         }
                     }
                     await ctx.session.synthetic({ sessionID, text: notice }).catch(() => null);

package/package.json

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

package/src/index.ts

@@ -26,6 +26,8 @@ const LEARN_HINT =
 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 ALREADY = 'This session was already handed over.'
+const UNREADABLE = 'Mimir could not read this session, so nothing was sent.'
 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.'
@@ -56,6 +58,38 @@ function textOf(value: unknown): string {
     .trim()
 }
 
+/**
+ * The session API hands back message records, not the provider shapes the
+ * context hook uses: a user turn keeps its words in `text`, an assistant turn
+ * in `content`. System and synthetic records are instructions, not conversation.
+ */
+export function sessionTranscript(messages: readonly unknown[]): string {
+  const lines: string[] = []
+  for (const message of messages) {
+    if (typeof message !== 'object' || message === null) continue
+    const record = message as { type?: unknown; text?: unknown; content?: unknown }
+    if (record.type === 'user') {
+      const body = textOf(record.text)
+      if (body) lines.push(`user: ${body}`)
+    } else if (record.type === 'assistant') {
+      const body = assistantText(record.content)
+      if (body) lines.push(`assistant: ${body}`)
+    }
+  }
+  return lines.join('\n\n').slice(-MAX_TRANSCRIPT)
+}
+
+/** Reasoning and tool parts are not conversation, and they are the bulk of it. */
+function assistantText(content: unknown): string {
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((part) => (part as { type?: unknown })?.type === 'text')
+    .map((part) => (part as { text?: unknown }).text)
+    .filter((part): part is string => typeof part === 'string')
+    .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
@@ -104,14 +138,9 @@ export default Plugin.define({
     // 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 })
 
@@ -148,32 +177,51 @@ export default Plugin.define({
     })
 
     // A manual handover, for the sessions that end before they ever compact.
+    // One process hands a session over once, so a second command does not
+    // queue the same transcript again.
+    const sent = new Set<string>()
     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,
-                client: 'opencode',
-                session: sessionID,
-              },
-              { ...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)
+          if (sent.has(sessionID)) {
+            notice = ALREADY
+          } else {
+            let history: readonly unknown[] | null = null
+            try {
+              history = await ctx.session.context({ sessionID })
+            } catch {
+              history = null
+            }
+
+            // The manual command is explicit, so any real text is worth a
+            // model call. The 500 character floor is for automatic compaction.
+            if (!Array.isArray(history)) {
+              notice = UNREADABLE
+            } else {
+              const text = sessionTranscript(history)
+              if (text.trim() !== '') {
+                const result = await callTool(
+                  'memory_learn',
+                  {
+                    repo: repo ?? undefined,
+                    transcript: text,
+                    hint: LEARN_NOW_HINT,
+                    client: 'opencode',
+                    session: sessionID,
+                  },
+                  { ...config, timeoutMs: 4000 },
+                ).catch(() => null)
+                const queued = result?.ok ? (result.result as { queued?: boolean }).queued : undefined
+                if (!result?.ok) notice = UNREACHABLE
+                else if (queued === false) notice = QUEUE_OFF
+                else {
+                  notice = SENT
+                  sent.add(sessionID)
+                }
+              }
             }
           }
           await ctx.session.synthetic({ sessionID, text: notice }).catch(() => null)