opencode-empirical-plan 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-empirical-plan",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "OpenCode lifecycle plugin for empirical plan orchestration.",
   "author": "chuck",
   "license": "MIT",

package/src/hooks/skill-reminder.ts

@@ -0,0 +1,124 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+const KEY = Symbol.for("opencode-empirical-plan.skillReminder");
+
+interface SkillReminderStore {
+  notifiedMessageIds: Map<string, number>;
+}
+
+if (!(globalThis as Record<symbol, unknown>)[KEY]) {
+  (globalThis as Record<symbol, unknown>)[KEY] = {
+    notifiedMessageIds: new Map<string, number>(),
+  } satisfies SkillReminderStore;
+}
+
+const store = (globalThis as Record<symbol, unknown>)[KEY] as SkillReminderStore;
+
+const ENGLISH_KEYWORD_REGEX = /\b(plan|planning)\b/i;
+const CHINESE_KEYWORDS = ["计划", "规划", "制定计划", "做计划"];
+const MAX_DEDUP_ENTRIES = 200;
+
+const PLUGIN_VARIANT = "empirical-plan-reminder";
+const REMINDER_PREFIX = "## [Empirical Plan Reminder]";
+
+const REMINDER_TEXT = `## [Empirical Plan Reminder]
+
+检测到规划类关键词（plan / 计划 / 规划）。
+
+**在回答前，请先执行：**
+\`\`\`
+skill(name="empirical-plan")
+\`\`\`
+
+**重要**：执行 empirical-plan 时，必须通过 \`task()\` 启动独立子 session，禁止在当前 session 内联执行：
+\`\`\`
+task(load_skills=["empirical-plan"], run_in_background=false, prompt="使用 empirical-plan skill 完成 Phase 1-3，产出 plan.md。目标：<描述>")
+\`\`\`
+
+如果这只是一个澄清问题（非任务），或本 session 已加载过 empirical-plan，可跳过。`;
+
+interface TextPartLike {
+  type?: string;
+  text?: unknown;
+}
+
+function extractText(parts: unknown[]): string {
+  const texts: string[] = [];
+  for (const part of parts) {
+    const candidate = part as TextPartLike;
+    if (candidate.type === "text" && typeof candidate.text === "string") {
+      texts.push(candidate.text);
+    }
+  }
+  return texts.join("\n");
+}
+
+function containsPlanningKeywords(text: string): boolean {
+  if (ENGLISH_KEYWORD_REGEX.test(text)) return true;
+  return CHINESE_KEYWORDS.some((kw) => text.includes(kw));
+}
+
+function normalizeTextKey(text: string): string {
+  return text.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+function buildMessageKey(sessionID: string, messageID: string | undefined, text: string): string {
+  if (messageID) return `id:${sessionID}:${messageID}`;
+  return `text:${sessionID}:${normalizeTextKey(text)}`;
+}
+
+function markNotified(messageKey: string): void {
+  store.notifiedMessageIds.set(messageKey, Date.now());
+  while (store.notifiedMessageIds.size > MAX_DEDUP_ENTRIES) {
+    const oldestKey = store.notifiedMessageIds.keys().next().value;
+    if (!oldestKey) break;
+    store.notifiedMessageIds.delete(oldestKey);
+  }
+}
+
+export async function handleSkillReminderChatMessage(
+  sessionID: string,
+  options: { variant?: string; messageID?: string; role?: string },
+  parts: unknown[],
+  client: PluginInput["client"],
+): Promise<void> {
+  let messageKey: string | undefined;
+  try {
+    if (options.variant === PLUGIN_VARIANT) return;
+    if (options.role !== "user") return;
+
+    const text = extractText(parts);
+    if (!text) return;
+    if (text.trimStart().startsWith(REMINDER_PREFIX)) return;
+    if (!containsPlanningKeywords(text)) return;
+    messageKey = buildMessageKey(sessionID, options.messageID, text);
+    if (store.notifiedMessageIds.has(messageKey)) return;
+
+    markNotified(messageKey);
+
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: REMINDER_TEXT }],
+      },
+    });
+  } catch (err) {
+    console.error("[empirical-plan] skill-reminder error:", err);
+    if (messageKey) {
+      store.notifiedMessageIds.delete(messageKey);
+    }
+  }
+}
+
+export function cleanupSkillReminderSession(sessionID: string): void {
+  const keysToDelete: string[] = [];
+  for (const key of store.notifiedMessageIds.keys()) {
+    if (key.includes(`:${sessionID}:`)) {
+      keysToDelete.push(key);
+    }
+  }
+  for (const key of keysToDelete) {
+    store.notifiedMessageIds.delete(key);
+  }
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import { handleToolAfter } from "./hooks/tool-after.ts";
 import { recordCallStart } from "./hooks/tool-before.ts";
 import { handleSessionIdle } from "./hooks/session-idle.ts";
 import { cleanup, cleanupChild } from "./state/active-lifecycles.ts";
+import { handleSkillReminderChatMessage, cleanupSkillReminderSession } from "./hooks/skill-reminder.ts";
 
 export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
   return {
@@ -15,6 +16,19 @@ export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
       lifecycle_record_reflection: lifecycleRecordReflectionTool,
     },
 
+    "chat.message": async (input, output) => {
+      try {
+        await handleSkillReminderChatMessage(
+          input.sessionID,
+          { variant: input.variant, messageID: input.messageID, role: output.message?.role },
+          output.parts,
+          client,
+        );
+      } catch (err) {
+        console.error("[empirical-plan] chat.message error:", err);
+      }
+    },
+
     "tool.execute.before": async (input) => {
       try {
         recordCallStart(input.callID);
@@ -49,6 +63,7 @@ export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
           if (sessionID) {
             cleanup(sessionID);
             cleanupChild(sessionID);
+            cleanupSkillReminderSession(sessionID);
           }
         }
       } catch (err) {

package/src/tools/lifecycle-start.ts

@@ -58,7 +58,7 @@ advances lifecycle-state.json to the next phase (plan→execute→reflect→done
           next_action: "Wait for the current lifecycle to complete before starting a new one.",
         });
       }
-      console.log(`[empirical-plan] lifecycle_start: stale map entry for session ${ctx.sessionID} (phase=${existingState?.phase ?? "missing"}), proceeding with new lifecycle`);
+
     }
 
     await fs.mkdir(runDir, { recursive: true });