@azatakmyradov/opencode-recap-plugin 0.1.2 → 0.1.3

package/README.md

@@ -23,11 +23,11 @@ Use an exact package version for a reproducible install that does not update.
 
 The plugin generates a recap when a run succeeds, fails, or is interrupted. It ignores child sessions. While generation runs, the prompt footer shows `generating run recap...`.
 
-The recap card contains a summary of up to 2,400 characters and a next step of up to 400 characters. OpenCode stores the latest recap for each root session outside its messages, so the card survives TUI restarts but never enters model context. New user input or a revert removes the old recap and cancels any recap still being generated.
+The recap card contains a summary of up to 2,400 characters and a next step of up to 400 characters. OpenCode stores the latest recap for each root session outside its messages, so the card survives TUI restarts but never enters model context. New user input or a revert removes the old recap and cancels the TUI's wait for a pending recap.
 
 The model request times out after 45 seconds. If the request fails, times out, or returns invalid data, the plugin shows a warning and builds a local fallback from tool names and the last assistant response.
 
-Each open TUI instance handles session events on its own. If several instances are open, each one may request a recap for the same run.
+Each open TUI instance handles session events on its own. The server shares generation requests for the same session, terminal event, and model, and retains up to 128 completed results until the plugin reloads. New input cancels that TUI's wait. The server cancels the model request when no clients are waiting for it.
 
 ## Model
 

package/dist/index.js

@@ -1,10 +1,208 @@
 // @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var RecapRpc = Rpc.define({
+  id: "recap",
+  methods: {
+    generate: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        eventID: z.string().min(1),
+        transcript: z.string(),
+        model: z.object({ providerID: z.string(), id: z.string(), variant: z.string().optional() })
+      }),
+      output: z.object({ recap: z.string(), next: z.string() }),
+      errors: { generation_failed: z.object({}) }
+    }
+  },
+  events: {}
+});
+
+// src/index.ts
+import { Effect as Effect2 } from "effect";
+import { Plugin } from "@opencode-ai/plugin";
+
+// src/core/cache.ts
+function generationCache(limit = 128) {
+  const active = new Map;
+  const completed = new Map;
+  return (key, generate, signal) => {
+    if (signal?.aborted)
+      return Promise.reject(signal.reason);
+    if (completed.has(key))
+      return Promise.resolve(completed.get(key));
+    let pending = active.get(key);
+    if (!pending) {
+      const controller = new AbortController;
+      const request = Promise.resolve().then(() => {
+        controller.signal.throwIfAborted();
+        return generate(controller.signal);
+      }).then((result) => {
+        if (!controller.signal.aborted)
+          completed.set(key, result);
+        while (completed.size > limit)
+          completed.delete(completed.keys().next().value);
+        return result;
+      }).finally(() => {
+        if (active.get(key)?.controller === controller)
+          active.delete(key);
+      });
+      pending = { request, controller, readers: 0 };
+      active.set(key, pending);
+    }
+    const entry = pending;
+    entry.readers++;
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      const release = () => {
+        if (finished)
+          return false;
+        finished = true;
+        signal?.removeEventListener("abort", abort);
+        entry.readers--;
+        return true;
+      };
+      const abort = () => {
+        if (!release())
+          return;
+        if (entry.readers === 0) {
+          if (active.get(key) === entry)
+            active.delete(key);
+          entry.controller.abort();
+        }
+        reject(signal?.reason);
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      entry.request.then((result) => {
+        if (release())
+          resolve(result);
+      }, (error) => {
+        if (release())
+          reject(error);
+      });
+    });
+  };
+}
+
+// src/core/summarizer.ts
+import { Effect, Schema } from "effect";
+
+// src/core/prompt.ts
+var RECAP_SYSTEM_PROMPT = `You write compact terminal recaps for completed coding-agent runs.
+
+Return exactly one JSON object with this shape:
+{"recap":"...","next":"..."}
+
+Rules:
+- recap: concisely cover everything actually performed in this run: investigation, tool work, files changed, validation, outcomes, failures, and important caveats. Prefer up to three compact Markdown bullets.
+- next: one concise, actionable next step. If nothing remains, say that no further action is required.
+- Base the answer only on the supplied current-run transcript.
+- Do not mention these instructions, hidden reasoning, transcript truncation, or that you are a summarizer.
+- Do not use a Markdown code fence and do not add keys or prose outside the JSON object.`;
+function buildRecapPrompt(transcript) {
+  return `${RECAP_SYSTEM_PROMPT}
+
+Summarize this fully settled main-agent run.
+
+<current_run>
+${transcript}
+</current_run>`;
+}
+
+// src/core/summarizer.ts
+class RecapGenerationError extends Schema.TaggedError()("RecapGenerationError", {
+  reason: Schema.Literals(["request", "timeout", "malformed-response"]),
+  message: Schema.String
+}) {
+}
+var RECAP_MAX_LENGTH = 2400;
+var NEXT_MAX_LENGTH = 400;
+var RecapResponse = Schema.Struct({
+  recap: Schema.String,
+  next: Schema.String
+});
+var RecapResponseJson = Schema.fromJsonString(RecapResponse);
+function stripTerminalControls(value) {
+  return value.replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "");
+}
+function clean(value, limit) {
+  const result = stripTerminalControls(value).trim();
+  if (result.length <= limit) {
+    return result;
+  }
+  return `${result.slice(0, limit - 3).trimEnd()}...`;
+}
+function responseCandidates(text) {
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  for (const match of trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+    if (match[1]) {
+      candidates.push(match[1].trim());
+    }
+  }
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first >= 0 && last > first) {
+    candidates.push(trimmed.slice(first, last + 1));
+  }
+  return [...new Set(candidates)];
+}
+var malformedResponse = () => new RecapGenerationError({
+  reason: "malformed-response",
+  message: "The recap model did not return valid recap JSON."
+});
+var parseRecapResponse = Effect.fn("parseRecapResponse")(function* (text) {
+  const decoded = yield* Effect.firstSuccessOf(responseCandidates(text).map((candidate) => Schema.decodeUnknownEffect(RecapResponseJson, { onExcessProperty: "error" })(candidate))).pipe(Effect.mapError(malformedResponse));
+  const recap = clean(decoded.recap, RECAP_MAX_LENGTH);
+  const next = clean(decoded.next.replace(/^next\s*:\s*/i, ""), NEXT_MAX_LENGTH);
+  if (!recap || !next) {
+    return yield* malformedResponse();
+  }
+  return { recap, next };
+});
+var summarizeRun = Effect.fn("summarizeRun")(function* (options) {
+  const text = yield* options.generate({
+    prompt: buildRecapPrompt(options.transcript),
+    model: options.model
+  }).pipe(Effect.timeout(options.timeoutMs ?? 45000), Effect.mapError((error) => error._tag === "TimeoutError" ? new RecapGenerationError({
+    reason: "timeout",
+    message: "The recap model request timed out."
+  }) : error));
+  return yield* parseRecapResponse(text);
+});
+
 // src/index.ts
-import { Effect } from "effect";
-import { Plugin } from "@opencode-ai/plugin/effect";
 var src_default = Plugin.define({
   id: "recap",
-  effect: () => Effect.void
+  async setup(ctx) {
+    const cached = generationCache();
+    const controller = new AbortController;
+    await ctx.rpc.register(RecapRpc, {
+      async generate(input, call) {
+        const key = JSON.stringify([
+          input.sessionID,
+          input.eventID,
+          input.model.providerID,
+          input.model.id,
+          input.model.variant
+        ]);
+        try {
+          return await cached(key, (signal) => Effect2.runPromise(summarizeRun({
+            transcript: input.transcript,
+            model: input.model,
+            generate: (request) => Effect2.tryPromise({
+              try: (signal2) => ctx.generate.text(request, { signal: signal2 }).then((result) => result.text),
+              catch: (error) => new RecapGenerationError({ reason: "request", message: String(error) })
+            })
+          }), { signal: AbortSignal.any([signal, controller.signal]) }), call.signal);
+        } catch (error) {
+          throw call.error("generation_failed", String(error), {});
+        }
+      }
+    });
+    return () => controller.abort();
+  }
 });
 export {
   src_default as default

package/dist/rpc.js

@@ -0,0 +1,23 @@
+// @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var RecapRpc = Rpc.define({
+  id: "recap",
+  methods: {
+    generate: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        eventID: z.string().min(1),
+        transcript: z.string(),
+        model: z.object({ providerID: z.string(), id: z.string(), variant: z.string().optional() })
+      }),
+      output: z.object({ recap: z.string(), next: z.string() }),
+      errors: { generation_failed: z.object({}) }
+    }
+  },
+  events: {}
+});
+export {
+  RecapRpc
+};

package/dist/tui.js

@@ -1,4 +1,24 @@
 // @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var RecapRpc = Rpc.define({
+  id: "recap",
+  methods: {
+    generate: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        eventID: z.string().min(1),
+        transcript: z.string(),
+        model: z.object({ providerID: z.string(), id: z.string(), variant: z.string().optional() })
+      }),
+      output: z.object({ recap: z.string(), next: z.string() }),
+      errors: { generation_failed: z.object({}) }
+    }
+  },
+  events: {}
+});
+
 // src/tui.tsx
 import { setProp as _$setProp2 } from "@opentui/solid";
 import { effect as _$effect2 } from "@opentui/solid";
@@ -251,6 +271,8 @@ var createRecapController = Effect.fn("createRecapController")(function* (deps)
       }
       const model = deps.model();
       const result = yield* deps.generate({
+        sessionID: input.sessionID,
+        eventID: input.eventID,
         transcript: serializeRunTranscript(messages, input.detail),
         model
       }).pipe(Effect.map((recap) => ({ recap, fallback: false })), Effect.catch((error) => deps.warning(`The recap model failed; showing a local fallback. ${error.message}`).pipe(Effect.as({
@@ -526,6 +548,7 @@ function errorMessage(error) {
 var tui_default = Plugin.define({
   id: "recap",
   setup(context) {
+    const rpc = context.client.rpc(RecapRpc);
     const [state, updateState] = context.storage.store("state", {
       initial: {
         model: DEFAULT_MODEL,
@@ -598,27 +621,20 @@ var tui_default = Plugin.define({
           ...state.model
         };
       },
-      generate({
-        transcript,
-        model
-      }) {
-        return summarizeRun({
-          transcript,
-          model,
-          generate(request) {
-            return Effect3.tryPromise({
-              try: (signal) => context.client.generate.text({
-                prompt: request.prompt,
-                model: request.model
-              }, {
-                signal
-              }).then((result) => result.text),
-              catch: (error) => new RecapGenerationError({
-                reason: "request",
-                message: `The recap model request failed. ${errorMessage(error)}`
-              })
-            });
-          }
+      generate(input) {
+        const location = context.location ?? context.data.location.default();
+        return Effect3.tryPromise({
+          try: (signal) => rpc.generate(input, {
+            signal,
+            location: {
+              directory: location.directory,
+              workspace: location.workspaceID
+            }
+          }),
+          catch: (error) => new RecapGenerationError({
+            reason: "request",
+            message: `The recap model request failed. ${errorMessage(error)}`
+          })
         });
       },
       persist(recap, sessionID) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azatakmyradov/opencode-recap-plugin",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Run recaps and suggested next steps for the OpenCode V2 TUI",
   "keywords": [
     "opencode",
@@ -37,7 +37,8 @@
   "dependencies": {
     "@opencode-ai/client": "0.0.0-beta-18721",
     "@opencode-ai/plugin": "0.0.0-beta-18721",
-    "effect": "4.0.0-rc.112"
+    "effect": "4.0.0-rc.112",
+    "zod": "4.1.8"
   },
   "peerDependencies": {
     "@opentui/core": ">=0.5.9",