@mojoaar/opencode-mimir 0.24.0 → 0.26.0

package/dist/index.js

@@ -18,6 +18,11 @@ 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 = [];
@@ -82,9 +87,15 @@ 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)
@@ -102,19 +113,57 @@ export default Plugin.define({
             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);
+            const sent = await callTool('memory_learn', {
+                repo: repo ?? undefined,
+                transcript: text,
+                hint: LEARN_HINT,
+                client: 'opencode',
+                session: event.sessionID,
+            }, { ...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,
+                            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;
+                        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/dist/tools.js

@@ -80,8 +80,16 @@ function rememberTool(repo) {
             required: ['path', 'body'],
             additionalProperties: false,
         },
-        async execute(input) {
-            const result = await callTool('memory_write', { path: input.path, body: input.body, kind: input.kind, repo: repo ?? undefined }, { timeoutMs: 8000 });
+        // `client` and `session` are provenance, so history can say who wrote it.
+        async execute(input, context) {
+            const result = await callTool('memory_write', {
+                path: input.path,
+                body: input.body,
+                kind: input.kind,
+                repo: repo ?? undefined,
+                client: 'opencode',
+                session: context?.sessionID,
+            }, { timeoutMs: 8000 });
             if (!result.ok)
                 return { content: `Could not store that (${result.error}).` };
             const written = result.result;
@@ -130,8 +138,14 @@ function learnTool(repo) {
             required: ['transcript'],
             additionalProperties: false,
         },
-        async execute(input) {
-            const result = await callTool('memory_learn', { transcript: input?.transcript, hint: input?.hint, repo: repo ?? undefined }, { timeoutMs: 8000 });
+        async execute(input, context) {
+            const result = await callTool('memory_learn', {
+                transcript: input?.transcript,
+                hint: input?.hint,
+                repo: repo ?? undefined,
+                client: 'opencode',
+                session: context?.sessionID,
+            }, { 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.24.0",
+  "version": "0.26.0",
   "description": "Mimir long-term memory for OpenCode sessions",
   "type": "module",
   "main": "src/index.ts",

package/src/index.ts

@@ -23,6 +23,12 @@ export const MAX_TRANSCRIPT = 32_000
 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 {
@@ -91,9 +97,14 @@ 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 })
 
@@ -113,7 +124,13 @@ export default Plugin.define({
 
       const sent = await callTool(
         'memory_learn',
-        { repo: repo ?? undefined, transcript: text, hint: LEARN_HINT },
+        {
+          repo: repo ?? undefined,
+          transcript: text,
+          hint: LEARN_HINT,
+          client: 'opencode',
+          session: event.sessionID,
+        },
         { ...config, timeoutMs: 4000 },
       ).catch(() => null)
 
@@ -123,6 +140,40 @@ export default Plugin.define({
       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,
+                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)
+            }
+          }
+          await ctx.session.synthetic({ sessionID, text: notice }).catch(() => null)
+        },
+      })
+    })
+
     const tools = await registerTools(ctx, config, repo)
 
     return async () => {
@@ -130,6 +181,7 @@ export default Plugin.define({
       await session.dispose()
       await nudge.dispose()
       await compaction.dispose()
+      await command.dispose()
     }
   },
 })

package/src/tools.ts

@@ -114,10 +114,18 @@ function rememberTool(repo: string | null): ToolDefinition {
       required: ['path', 'body'],
       additionalProperties: false,
     },
-    async execute(input) {
+    // `client` and `session` are provenance, so history can say who wrote it.
+    async execute(input, context) {
       const result = await callTool(
         'memory_write',
-        { path: input.path, body: input.body, kind: input.kind, repo: repo ?? undefined },
+        {
+          path: input.path,
+          body: input.body,
+          kind: input.kind,
+          repo: repo ?? undefined,
+          client: 'opencode',
+          session: context?.sessionID,
+        },
         { timeoutMs: 8000 },
       )
       if (!result.ok) return { content: `Could not store that (${result.error}).` }
@@ -173,10 +181,16 @@ function learnTool(repo: string | null): ToolDefinition {
       required: ['transcript'],
       additionalProperties: false,
     },
-    async execute(input) {
+    async execute(input, context) {
       const result = await callTool(
         'memory_learn',
-        { transcript: input?.transcript, hint: input?.hint, repo: repo ?? undefined },
+        {
+          transcript: input?.transcript,
+          hint: input?.hint,
+          repo: repo ?? undefined,
+          client: 'opencode',
+          session: context?.sessionID,
+        },
         { timeoutMs: 8000 },
       )
       if (!result.ok) return { content: `Could not hand that over (${result.error}).` }