@michaelxwb/code-flow 0.6.4 → 0.8.1

package/src/adapters/opencode/plugins/code-flow/index.js

@@ -1,213 +1,162 @@
-import { execFile } from "child_process";
-import { join } from "path";
-import { appendFileSync, mkdirSync } from "fs";
+import { execFile } from "node:child_process";
+import { join, isAbsolute, resolve, dirname } from "node:path";
+import { existsSync } from "node:fs";
 
-// Note: intentionally no `import { Plugin } from "@opencode/plugin"`.
-// The server does not auto-provide that package for local plugins, and
-// `Plugin.define` is only an identity wrapper — a plain default export
-// with `id` + `setup` satisfies the v2 plugin schema dependency-free,
-// so `code-flow init` works offline without npm install.
-
-const SCRIPT_DIR = ".code-flow/scripts";
-const STOP_CHECK_TIMEOUT = 35000;
 const HOOK_TIMEOUT = 5000;
-
-// Per-session queued feedback. Single map, append-only: idle/stop-check and
-// post-check feedback accumulate here and are consumed by the next context
-// hook. Never overwrite — a prompt hook arriving between idle and context
-// must not drop queued stop-check feedback.
-const sessionContext = new Map();
-
-export function mergePending(existing, incoming) {
-  if (!existing) return incoming;
-  if (!incoming) return existing;
-  return existing + "\n\n" + incoming;
-}
-
-function debugLog(projectRoot, msg) {
-  if (process.env.CF_DEBUG !== "1") return;
-  try {
-    const dir = join(projectRoot, ".code-flow");
-    mkdirSync(dir, { recursive: true });
-    const ts = new Date().toISOString().replace("T", " ").slice(0, 19);
-    appendFileSync(join(dir, ".debug.log"), `${ts} [opencode] ${msg}\n`);
-  } catch {}
+const IDLE_TIMEOUT = 35000;
+
+function runtimeScript(directory) {
+  let root = resolve(directory);
+  while (!existsSync(join(root, ".code-flow/config.yml"))) {
+    const parent = dirname(root);
+    if (parent === root) throw new Error(`No code-flow runtime for OpenCode session at ${directory}`);
+    root = parent;
+  }
+  return join(root, ".code-flow/scripts/cf_opencode_event.py");
 }
 
-function pythonPath(projectRoot, script) {
-  return join(projectRoot, SCRIPT_DIR, script);
+/** Combine model-visible feedback without dropping earlier gate failures. */
+export function mergePending(existing, incoming) {
+  return [existing, incoming].filter(Boolean).join("\n\n");
 }
 
-function callHook(projectRoot, script, input, timeout = HOOK_TIMEOUT) {
-  // Async child process: never block the plugin event thread. opencode's
-  // idle event cannot interrupt a turn, so stop-check failures queue into
-  // sessionContext for the next context hook (documented platform gap
-  // vs. blocking Stop hooks).
-  return new Promise((resolve) => {
-    const child = execFile(
-      "python3",
-      [pythonPath(projectRoot, script)],
-      { cwd: projectRoot, timeout, maxBuffer: 1024 * 1024 },
-      (error, stdout, stderr) => {
-        if (error) {
-          debugLog(projectRoot, `callHook ${script} failed: ${error.message || stderr}`);
-          resolve(null);
-          return;
-        }
-        const text = (stdout || "").trim();
-        if (!text) {
-          resolve(null);
-          return;
-        }
+function callRuntime(directory, kind, event, signal) {
+  return new Promise((accept, reject) => {
+    const child = execFile(process.platform === "win32" ? "py" : "python3",
+      [...(process.platform === "win32" ? ["-3"] : []), runtimeScript(directory)],
+      { cwd: directory, timeout: kind === "session.idle" ? IDLE_TIMEOUT : HOOK_TIMEOUT,
+        maxBuffer: 1024 * 1024, signal }, (error, stdout, stderr) => {
+        if (error) return reject(new Error(`code-flow native runtime: ${error.message}; ${stderr.trim()}`));
+        if (stderr.trim()) console.error(stderr.trim());
         try {
-          resolve(JSON.parse(text));
-        } catch (e) {
-          debugLog(projectRoot, `callHook ${script} bad JSON: ${e.message}`);
-          resolve(null);
-        }
-      }
-    );
-    if (input !== undefined && child.stdin) {
-      child.stdin.write(JSON.stringify(input));
-      child.stdin.end();
-    }
+          const result = JSON.parse(stdout);
+          if (result.error) throw new Error(result.error);
+          if (typeof result.context !== "string" || typeof result.blocked !== "boolean") {
+            throw new Error("Invalid code-flow native RPC response");
+          }
+          accept(result);
+        } catch (failure) { reject(failure); }
+      });
+    child.stdin.on("error", reject);
+    child.stdin.end(JSON.stringify({ directory, kind, event }));
   });
 }
 
-function queueFeedback(sessionID, text) {
-  if (!sessionID || !text) return;
-  sessionContext.set(sessionID, mergePending(sessionContext.get(sessionID), text));
-}
-
-function consumeFeedback(sessionID) {
-  const pending = sessionContext.get(sessionID);
-  if (pending) sessionContext.delete(sessionID);
-  return pending;
-}
-
-function toolInputFilePath(input) {
-  if (!input || typeof input !== "object") return "";
-  const args = input;
-  return args.filePath || args.file_path || args.path || "";
+function createState() {
+  const pending = new Map();
+  const jobs = new Map();
+  let disposed = false;
+  return {
+    fault: "",
+    queue(sid, text) { if (!disposed && text) pending.set(sid, mergePending(pending.get(sid), text)); },
+    consume(sid) { const text = pending.get(sid); pending.delete(sid); return text; },
+    async wait(sid) { await jobs.get(sid); },
+    run(sid, operation) {
+      const job = (jobs.get(sid) || Promise.resolve()).then(operation, operation);
+      jobs.set(sid, job);
+      return job.finally(() => { if (jobs.get(sid) === job) jobs.delete(sid); });
+    },
+    clear(sid) { pending.delete(sid); },
+    dispose() { disposed = true; pending.clear(); jobs.clear(); },
+  };
 }
 
-async function runStopCheck(projectRoot, sessionID) {
-  const result = await callHook(projectRoot, "cf_stop_hook.py", { session_id: sessionID }, STOP_CHECK_TIMEOUT);
-  if (result?.reason) {
-    // idle 无法阻断，校验失败排队到下一轮 context hook
-    queueFeedback(sessionID, result.reason);
-    debugLog(projectRoot, `stop-check feedback queued`);
+async function sessionInfo(ctx, sid) {
+  if (typeof sid !== "string" || !sid) throw new Error("OpenCode native event requires sessionID");
+  const info = await ctx.session.get({ sessionID: sid });
+  if (typeof info?.location?.directory !== "string" || !isAbsolute(info.location.directory)) {
+    throw new Error(`OpenCode session ${sid} has no absolute location.directory`);
   }
+  return info;
 }
 
-async function registerPromptHook(ctx, projectRoot) {
-  await ctx.session.hook("prompt", async (event) => {
-    const promptText = event.prompt?.text || "";
-    if (!promptText) return;
-    debugLog(projectRoot, `prompt sid=${event.sessionID} prompt_len=${promptText.length}`);
-    const result = await callHook(projectRoot, "cf_user_prompt_hook.py", {
-      prompt: promptText,
-      session_id: event.sessionID,
-    });
-    const additional = result?.hookSpecificOutput?.additionalContext;
-    if (additional) {
-      // Append, never overwrite: queued stop-check feedback survives.
-      queueFeedback(event.sessionID, additional);
-      debugLog(projectRoot, `hook matched — context ${additional.length} chars cached`);
-    } else {
-      debugLog(projectRoot, `hook returned no context`);
+async function invoke(ctx, state, kind, event, signal) {
+  let result;
+  try {
+    const info = await sessionInfo(ctx, event.sessionID);
+    result = await callRuntime(info.location.directory, kind, event, signal);
+  } catch (error) {
+    if (!signal.aborted) {
+      const message = `code-flow OpenCode: ${error.message}`;
+      // The event subscriber owns idle error feedback, including lookup errors.
+      if (kind !== "session.idle") state.queue(event.sessionID, message);
+      console.error(message);
     }
-  });
+    throw error;
+  }
+  state.queue(event.sessionID, result.context);
+  if (result.blocked && ["tool.before", "session.prompt"].includes(kind)) throw new Error(result.context);
 }
 
-async function registerToolHook(ctx, projectRoot) {
-  await ctx.tool.hook("execute.after", async (event) => {
-    const tool = String(event.tool || "").toLowerCase();
-    if (!["edit", "write", "multiedit", "patch"].includes(tool)) return;
-    const filePath = toolInputFilePath(event.input);
-    if (!filePath) return;
-    const result = await callHook(projectRoot, "cf_post_hook.py", {
-      tool_name: tool === "write" ? "Write" : "Edit",
-      tool_input: { file_path: filePath },
-      session_id: event.sessionID || "",
-    });
-    const additional = result?.hookSpecificOutput?.additionalContext;
-    if (additional) {
-      // 反馈排队，下一轮 context hook 注入（opencode 无法当轮插话）
-      queueFeedback(event.sessionID, additional);
-      debugLog(projectRoot, `post-check feedback queued ${additional.length} chars`);
+async function registerHooks(ctx, state, signal) {
+  await ctx.session.hook("prompt", event => {
+    if (!event.prompt?.text?.trim()) return;
+    return state.run(event.sessionID, () => invoke(ctx, state, "session.prompt", event, signal));
+  });
+  await ctx.session.hook("context", async event => {
+    try { await state.wait(event.sessionID); } catch (error) {
+      console.error(`code-flow pending event failed: ${error.message}`);
     }
+    const text = mergePending(state.consume(event.sessionID), state.fault);
+    state.fault = "";
+    if (text) event.system.push({ type: "text", text });
   });
-}
-
-async function registerContextHook(ctx) {
-  await ctx.session.hook("context", (event) => {
-    const pending = consumeFeedback(event.sessionID);
-    if (pending) {
-      event.system.push({ type: "text", text: pending });
-      debugLog(ctx.location.directory, `context — injected ${pending.length} chars`);
+  await ctx.tool.hook("execute.before", event => {
+    if (!["edit", "write", "patch"].includes(event.tool)) return;
+    return state.run(event.sessionID, () => invoke(ctx, state, "tool.before", event, signal));
+  });
+  await ctx.tool.hook("execute.after", async event => {
+    if (!["edit", "write", "patch"].includes(event.tool)) return;
+    try {
+      await state.run(event.sessionID, () => invoke(ctx, state, "tool.after", event, signal));
+    } catch (error) {
+      // The mutation has already happened. Preserve its result and expose the
+      // runtime error through the next native context hook.
+      if (!signal.aborted) console.error(`code-flow post-edit check failed: ${error.message}`);
     }
   });
 }
 
-// 子会话（子 agent / worktree 并行任务）的 idle 不得触发主工作区 stop-check：
-// 子会话的编辑发生在自己的工作区，主区既无 active marker 也没有对应文件，
-// 触发只会重复执行主区 validators（全量测试）。用 session.created.parentID 标记子会话。
-export function createSessionRegistry() {
-  const children = new Set();
-  return {
-    observe(event) {
-      if (!event || typeof event.type !== "string") return null;
-      const sid = event.data?.sessionID || "";
-      if (!sid) return null;
-      if (event.type === "session.created") {
-        if (event.data?.parentID) children.add(sid);
-        return { type: "created", sid };
-      }
-      if (event.type === "session.idle") {
-        return { type: "idle", sid, child: children.has(sid) };
-      }
-      return null;
-    },
-  };
+async function observeIdle(ctx, state, event, signal) {
+  const sid = event.data?.sessionID;
+  if (!sid) throw new Error("OpenCode session.idle requires data.sessionID");
+  const info = await sessionInfo(ctx, sid);
+  if (resolve(info.location.directory) !== resolve(ctx.location.directory)) return;
+  if (info.parentID) {
+    const parent = await sessionInfo(ctx, info.parentID);
+    if (resolve(parent.location.directory) === resolve(info.location.directory)) return;
+  }
+  await state.run(sid, () => invoke(ctx, state, "session.idle", { sessionID: sid }, signal));
 }
 
-function startEventSubscription(ctx, projectRoot) {
-  const controller = new AbortController();
-  const registry = createSessionRegistry();
-  void (async () => {
-    try {
-      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
-        const observed = registry.observe(event);
-        if (!observed) continue;
-        if (observed.type === "created") {
-          debugLog(projectRoot, `session.created sid=${observed.sid}`);
-          sessionContext.delete(observed.sid);
-        } else if (observed.child) {
-          debugLog(projectRoot, `session.idle sid=${observed.sid} (child) — stop-check skipped`);
-        } else {
-          await runStopCheck(projectRoot, observed.sid);
-        }
-      }
-    } catch (err) {
-      if (err?.name !== "AbortError") {
-        debugLog(projectRoot, `event subscription ended: ${err?.message || err}`);
+async function subscribe(ctx, state, signal) {
+  try {
+    for await (const event of ctx.event.subscribe({ signal })) {
+      try {
+        if (event.type === "session.deleted") state.clear(event.data.sessionID);
+        if (event.type === "session.idle") await observeIdle(ctx, state, event, signal);
+      } catch (error) {
+        if (signal.aborted) return;
+        state.queue(event.data?.sessionID, `code-flow idle check failed: ${error.message}`);
+        console.error(`code-flow idle check failed: ${error.message}`);
       }
     }
-  })();
-  return () => controller.abort();
+  } catch (error) {
+    if (!signal.aborted) {
+      state.fault = `code-flow OpenCode event subscription failed: ${error.message}`;
+      console.error(state.fault);
+    }
+  }
 }
 
-const CodeFlowPlugin = {
+// V2's native definition shape. No v1 server() entry or protocol adapter.
+export default {
   id: "code-flow",
   async setup(ctx) {
-    const projectRoot = ctx.location.directory;
-    await registerPromptHook(ctx, projectRoot);
-    await registerToolHook(ctx, projectRoot);
-    await registerContextHook(ctx);
-    const stopSubscription = startEventSubscription(ctx, projectRoot);
-    return () => stopSubscription();
+    const state = createState();
+    const controller = new AbortController();
+    await registerHooks(ctx, state, controller.signal);
+    void subscribe(ctx, state, controller.signal);
+    return () => { controller.abort(); state.dispose(); };
   },
 };
-
-export default CodeFlowPlugin;