@mojoaar/opencode-mimir 0.29.1 → 0.29.3

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
@@ -62,8 +99,12 @@ export default Plugin.define({
     id: 'mimir',
     async setup(ctx) {
         const config = resolveConfig(ctx.options);
-        if (!config)
+        if (!config) {
+            // This API has no logger, and an inert plugin is otherwise invisible:
+            // the digest, the tools and /mimir-learn simply never appear.
+            console.warn('mimir: no url, so no digest, tools or /mimir-learn. Set MIMIR_URL and MIMIR_TOKEN, or add options.url and options.tokenFile to the plugin entry.');
             return;
+        }
         // A folder without a git remote still needs a stable key, or every write
         // lands in a fresh project. The server maps absolute paths to `local:<hash>`.
         const repo = detectRepo(ctx.location.directory) ?? ctx.location.directory;
@@ -87,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)
@@ -127,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/dist/tools.js

@@ -10,11 +10,11 @@ export async function registerTools(ctx, config, repo) {
     if (config.tools === 'auto' && (await servedByMcp(ctx, config.url)))
         return IDLE;
     return ctx.tool.transform((editor) => {
-        editor.add(digestTool(repo));
-        editor.add(rememberTool(repo));
-        editor.add(searchTool(repo));
-        editor.add(readTool(repo));
-        editor.add(learnTool(repo));
+        editor.add(digestTool(repo, config));
+        editor.add(rememberTool(repo, config));
+        editor.add(searchTool(repo, config));
+        editor.add(readTool(repo, config));
+        editor.add(learnTool(repo, config));
     });
 }
 const IDLE = { dispose: async () => { } };
@@ -40,7 +40,7 @@ function sameEndpoint(actual, expected) {
 function strip(value) {
     return (value ?? '').replace(/\/+$/, '');
 }
-function digestTool(repo) {
+function digestTool(repo, config) {
     return {
         name: 'mimir_digest',
         description: 'Load what this project already knows from Mimir. Call once at the start of a session, before searching for anything.',
@@ -57,7 +57,7 @@ function digestTool(repo) {
         },
         async execute(input) {
             const args = input;
-            const result = await callTool('memory_digest', { budget_tokens: Number(args.budget_tokens ?? 800), repo: repo ?? undefined }, { timeoutMs: 5000 });
+            const result = await callTool('memory_digest', { budget_tokens: Number(args.budget_tokens ?? 800), repo: repo ?? undefined }, { url: config.url, token: config.token, timeoutMs: 5000 });
             if (!result.ok)
                 return { content: `Mimir is unavailable (${result.error}). Carry on without it.` };
             const digest = result.result;
@@ -68,7 +68,7 @@ function digestTool(repo) {
 // A project created from a repo a teammate already knows about splits the
 // knowledge in two until someone asks the owner for a grant.
 const NEW_PROJECT = ' Started a new project. If a teammate already uses this repository, request access at /app/requests on your Mimir install.';
-function rememberTool(repo) {
+function rememberTool(repo, config) {
     return {
         name: 'mimir_remember',
         description: 'Store one durable fact in Mimir. Use a path like "deploy/rollback" or "auth/token-rotation"; rewriting the same path replaces what was there.',
@@ -97,7 +97,7 @@ function rememberTool(repo) {
                 repo: repo ?? undefined,
                 client: 'opencode',
                 session: context?.sessionID,
-            }, { timeoutMs: 8000 });
+            }, { url: config.url, token: config.token, timeoutMs: 8000 });
             if (!result.ok)
                 return { content: `Could not store that (${result.error}).` };
             const written = result.result;
@@ -108,7 +108,7 @@ function rememberTool(repo) {
         },
     };
 }
-function searchTool(repo) {
+function searchTool(repo, config) {
     return {
         name: 'mimir_search',
         description: 'Search what this project has already settled in Mimir. Returns paths, titles and summaries; read a path with the MCP server if you need the body.',
@@ -123,7 +123,7 @@ function searchTool(repo) {
         },
         async execute(input) {
             const args = input;
-            const result = await callTool('memory_search', { query: typeof args.query === 'string' ? args.query : '', path_prefix: typeof args.path_prefix === 'string' ? args.path_prefix : undefined, repo: repo ?? undefined }, { timeoutMs: 8000 });
+            const result = await callTool('memory_search', { query: typeof args.query === 'string' ? args.query : '', path_prefix: typeof args.path_prefix === 'string' ? args.path_prefix : undefined, repo: repo ?? undefined }, { url: config.url, token: config.token, timeoutMs: 8000 });
             if (!result.ok)
                 return { content: `Mimir is unavailable (${result.error}). Carry on without it.` };
             const hits = result.result;
@@ -143,7 +143,7 @@ function renderMemory(memory) {
     const head = day ? `${memory.path ?? ''} · updated ${day}` : (memory.path ?? '');
     return `${head}\n# ${memory.title ?? ''}\n\n${memory.body ?? ''}`;
 }
-function readTool(repo) {
+function readTool(repo, config) {
     return {
         name: 'mimir_read',
         description: 'Read one memory in full by its path. Search returns paths and summaries; this is the body behind one.',
@@ -155,14 +155,14 @@ function readTool(repo) {
         },
         async execute(input) {
             const args = input;
-            const result = await callTool('memory_read', { path: String(args.path ?? ''), repo: repo ?? undefined }, { timeoutMs: 8000 });
+            const result = await callTool('memory_read', { path: String(args.path ?? ''), repo: repo ?? undefined }, { url: config.url, token: config.token, timeoutMs: 8000 });
             if (!result.ok)
                 return { content: 'Nothing is stored at that path.' };
             return { content: renderMemory(result.result) };
         },
     };
 }
-function learnTool(repo) {
+function learnTool(repo, config) {
     return {
         name: 'mimir_learn',
         description: 'Hand the part of this conversation worth keeping to Mimir. The project model writes at most three memories, in the background, so this answers at once.',
@@ -183,7 +183,7 @@ function learnTool(repo) {
                 repo: repo ?? undefined,
                 client: 'opencode',
                 session: context?.sessionID,
-            }, { timeoutMs: 8000 });
+            }, { url: config.url, token: config.token, timeoutMs: 8000 });
             if (!result.ok)
                 return { content: `Could not hand that over (${result.error}).` };
             const queued = result.result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojoaar/opencode-mimir",
-  "version": "0.29.1",
+  "version": "0.29.3",
   "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
@@ -66,7 +100,14 @@ export default Plugin.define({
   id: 'mimir',
   async setup(ctx) {
     const config = resolveConfig(ctx.options)
-    if (!config) return
+    if (!config) {
+      // This API has no logger, and an inert plugin is otherwise invisible:
+      // the digest, the tools and /mimir-learn simply never appear.
+      console.warn(
+        'mimir: no url, so no digest, tools or /mimir-learn. Set MIMIR_URL and MIMIR_TOKEN, or add options.url and options.tokenFile to the plugin entry.',
+      )
+      return
+    }
 
     // A folder without a git remote still needs a stable key, or every write
     // lands in a fresh project. The server maps absolute paths to `local:<hash>`.
@@ -97,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 })
 
@@ -141,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)

package/src/tools.ts

@@ -36,11 +36,11 @@ export async function registerTools(
   if (config.tools === 'auto' && (await servedByMcp(ctx, config.url))) return IDLE
 
   return ctx.tool.transform((editor) => {
-    editor.add(digestTool(repo))
-    editor.add(rememberTool(repo))
-    editor.add(searchTool(repo))
-    editor.add(readTool(repo))
-    editor.add(learnTool(repo))
+    editor.add(digestTool(repo, config))
+    editor.add(rememberTool(repo, config))
+    editor.add(searchTool(repo, config))
+    editor.add(readTool(repo, config))
+    editor.add(learnTool(repo, config))
   })
 }
 
@@ -70,7 +70,7 @@ function strip(value: string | undefined): string {
   return (value ?? '').replace(/\/+$/, '')
 }
 
-function digestTool(repo: string | null): ToolDefinition {
+function digestTool(repo: string | null, config: MimirConfig): ToolDefinition {
   return {
     name: 'mimir_digest',
     description:
@@ -91,7 +91,7 @@ function digestTool(repo: string | null): ToolDefinition {
       const result = await callTool(
         'memory_digest',
         { budget_tokens: Number(args.budget_tokens ?? 800), repo: repo ?? undefined },
-        { timeoutMs: 5000 },
+        { url: config.url, token: config.token, timeoutMs: 5000 },
       )
       if (!result.ok) return { content: `Mimir is unavailable (${result.error}). Carry on without it.` }
       const digest = result.result as { text?: string }
@@ -104,7 +104,7 @@ function digestTool(repo: string | null): ToolDefinition {
 // knowledge in two until someone asks the owner for a grant.
 const NEW_PROJECT = ' Started a new project. If a teammate already uses this repository, request access at /app/requests on your Mimir install.'
 
-function rememberTool(repo: string | null): ToolDefinition {
+function rememberTool(repo: string | null, config: MimirConfig): ToolDefinition {
   return {
     name: 'mimir_remember',
     description:
@@ -137,7 +137,7 @@ function rememberTool(repo: string | null): ToolDefinition {
           client: 'opencode',
           session: context?.sessionID,
         },
-        { timeoutMs: 8000 },
+        { url: config.url, token: config.token, timeoutMs: 8000 },
       )
       if (!result.ok) return { content: `Could not store that (${result.error}).` }
       const written = result.result as { path?: string; created?: boolean; projectCreated?: boolean }
@@ -149,7 +149,7 @@ function rememberTool(repo: string | null): ToolDefinition {
   }
 }
 
-function searchTool(repo: string | null): ToolDefinition {
+function searchTool(repo: string | null, config: MimirConfig): ToolDefinition {
   return {
     name: 'mimir_search',
     description:
@@ -168,7 +168,7 @@ function searchTool(repo: string | null): ToolDefinition {
       const result = await callTool(
         'memory_search',
         { query: typeof args.query === 'string' ? args.query : '', path_prefix: typeof args.path_prefix === 'string' ? args.path_prefix : undefined, repo: repo ?? undefined },
-        { timeoutMs: 8000 },
+        { url: config.url, token: config.token, timeoutMs: 8000 },
       )
       if (!result.ok) return { content: `Mimir is unavailable (${result.error}). Carry on without it.` }
       const hits = result.result as { path: string; title: string; summary: string | null }[]
@@ -189,7 +189,7 @@ function renderMemory(memory: { path?: string; title?: string; body?: string; up
   return `${head}\n# ${memory.title ?? ''}\n\n${memory.body ?? ''}`
 }
 
-function readTool(repo: string | null): ToolDefinition {
+function readTool(repo: string | null, config: MimirConfig): ToolDefinition {
   return {
     name: 'mimir_read',
     description:
@@ -205,7 +205,7 @@ function readTool(repo: string | null): ToolDefinition {
       const result = await callTool(
         'memory_read',
         { path: String(args.path ?? ''), repo: repo ?? undefined },
-        { timeoutMs: 8000 },
+        { url: config.url, token: config.token, timeoutMs: 8000 },
       )
       if (!result.ok) return { content: 'Nothing is stored at that path.' }
       return { content: renderMemory(result.result as { path?: string; title?: string; body?: string; updatedAt?: string }) }
@@ -213,7 +213,7 @@ function readTool(repo: string | null): ToolDefinition {
   }
 }
 
-function learnTool(repo: string | null): ToolDefinition {
+function learnTool(repo: string | null, config: MimirConfig): ToolDefinition {
   return {
     name: 'mimir_learn',
     description:
@@ -238,7 +238,7 @@ function learnTool(repo: string | null): ToolDefinition {
           client: 'opencode',
           session: context?.sessionID,
         },
-        { timeoutMs: 8000 },
+        { url: config.url, token: config.token, timeoutMs: 8000 },
       )
       if (!result.ok) return { content: `Could not hand that over (${result.error}).` }
       const queued = result.result as { queued?: boolean; reason?: string; projectCreated?: boolean }