claude-smart 0.2.45 → 0.2.47

package/plugin/opencode/server.mts

@@ -0,0 +1,251 @@
+import { spawn } from "node:child_process"
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { homedir } from "node:os"
+import { dirname, isAbsolute, join, relative, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import { AssistantBuffer } from "./assistant-buffer.js"
+import { sessionIDFrom } from "./internal.js"
+import { chatMessagePayload, eventPayload, stopPayload, toolAfterPayload } from "./payload.js"
+
+type HookResult = Record<string, unknown>
+
+type PluginInput = {
+  directory: string
+}
+
+type EventInput = {
+  event: {
+    type?: string
+    properties?: Record<string, unknown>
+  }
+}
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url))
+
+function homeDir(): string {
+  return process.env.HOME || homedir()
+}
+
+function textFilePluginRoot(): string | undefined {
+  try {
+    return readFileSync(join(homeDir(), ".reflexio", "plugin-root.txt"), "utf8").trim() || undefined
+  } catch {
+    return undefined
+  }
+}
+
+function isPluginRoot(candidate: string | undefined): candidate is string {
+  return !!candidate
+    && existsSync(join(candidate, "pyproject.toml"))
+    && existsSync(join(candidate, "uv.lock"))
+    && existsSync(join(candidate, "scripts", "hook_entry.sh"))
+}
+
+function canonicalPluginRoot(candidate: string | undefined): string | undefined {
+  if (!isPluginRoot(candidate)) return undefined
+  try {
+    return realpathSync(candidate)
+  } catch {
+    return undefined
+  }
+}
+
+function pathParts(candidate: string): string[] {
+  return candidate.split(/[\\/]+/).filter(Boolean)
+}
+
+function isDescendantOrSame(child: string, parent: string): boolean {
+  const path = relative(parent, child)
+  return path === "" || (!path.startsWith("..") && !isAbsolute(path))
+}
+
+function isReflexioSessionCopy(candidate: string): boolean {
+  try {
+    const reflexioRoot = realpathSync(join(homeDir(), ".reflexio"))
+    return isDescendantOrSame(candidate, reflexioRoot)
+  } catch {
+    return false
+  }
+}
+
+function isTransientPackageRoot(candidate: string): boolean {
+  return pathParts(candidate).includes("_npx") || isReflexioSessionCopy(candidate)
+}
+
+function resolvePluginRoot(): string {
+  const current = resolve(MODULE_DIR, "../..")
+  const explicit = canonicalPluginRoot(process.env.CLAUDE_SMART_PLUGIN_ROOT)
+  if (explicit) return explicit
+
+  const currentRoot = canonicalPluginRoot(current)
+  if (currentRoot && !isTransientPackageRoot(currentRoot)) return currentRoot
+
+  const candidates = [
+    join(homeDir(), ".reflexio", "plugin-root"),
+    textFilePluginRoot(),
+  ]
+  for (const candidate of candidates) {
+    const root = canonicalPluginRoot(candidate)
+    if (root) return root
+  }
+  if (currentRoot) return currentRoot
+  try {
+    return realpathSync(current)
+  } catch {
+    return current
+  }
+}
+
+const PLUGIN_ROOT = resolvePluginRoot()
+const SCRIPTS_DIR = resolve(PLUGIN_ROOT, "scripts")
+const HOOK_ENTRY = resolve(SCRIPTS_DIR, "hook_entry.sh")
+const BACKEND_SERVICE = resolve(SCRIPTS_DIR, "backend-service.sh")
+const DASHBOARD_SERVICE = resolve(SCRIPTS_DIR, "dashboard-service.sh")
+
+function contextFrom(result: HookResult): string {
+  const hookOutput = result.hookSpecificOutput
+  if (!hookOutput || typeof hookOutput !== "object") return ""
+  const additional = (hookOutput as Record<string, unknown>).additionalContext
+  return typeof additional === "string" ? additional : ""
+}
+
+function parseFirstJsonObject(text: string): HookResult {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith("{")) continue
+    try {
+      const parsed = JSON.parse(trimmed)
+      if (parsed && typeof parsed === "object") return parsed as HookResult
+    } catch {
+      continue
+    }
+  }
+  return {}
+}
+
+function runScript(script: string, args: string[], payload?: Record<string, unknown>): Promise<HookResult> {
+  return new Promise((resolvePromise) => {
+    const child = spawn("bash", [script, ...args], {
+      cwd: PLUGIN_ROOT,
+      env: {
+        ...process.env,
+        CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
+        CLAUDE_SMART_HOST: "opencode",
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+    let stdout = ""
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString()
+    })
+    child.stderr.on("data", (chunk) => {
+      process.stderr.write(chunk)
+    })
+    child.stdin.on("error", () => {
+      // Hooks can exit before reading stdin on marker-gated setup failures.
+    })
+    child.on("error", () => resolvePromise({}))
+    child.on("close", () => resolvePromise(parseFirstJsonObject(stdout)))
+    try {
+      if (payload) child.stdin.write(JSON.stringify(payload))
+      child.stdin.end()
+    } catch {
+      resolvePromise({})
+    }
+  })
+}
+
+function runService(script: string, subcommand: string): Promise<void> {
+  return runScript(script, [subcommand]).then(() => undefined)
+}
+
+function cacheContext(cache: Map<string, string[]>, sessionID: string, result: HookResult): void {
+  const context = contextFrom(result)
+  if (!sessionID || !context) return
+  const pending = cache.get(sessionID) ?? []
+  pending.push(context)
+  cache.set(sessionID, pending)
+}
+
+async function server(input: PluginInput) {
+  const pendingContext = new Map<string, string[]>()
+  const activeSessions = new Set<string>()
+  const completedAssistantText = new Map<string, string>()
+  const assistant = new AssistantBuffer()
+  const cwd = input.directory
+
+  async function flushStop(sessionID: string): Promise<void> {
+    if (!sessionID || !activeSessions.has(sessionID)) return
+    activeSessions.delete(sessionID)
+    const text = assistant.text(sessionID) || completedAssistantText.get(sessionID) || ""
+    completedAssistantText.delete(sessionID)
+    await runScript(
+      HOOK_ENTRY,
+      ["opencode", "stop"],
+      stopPayload({ properties: { sessionID, info: { directory: cwd } } }, cwd, text),
+    )
+    assistant.clear(sessionID)
+  }
+
+  return {
+    event: async ({ event }: EventInput) => {
+      const type = event.type
+      assistant.update(event)
+      if (type === "session.created") {
+        const payload = eventPayload(event, cwd)
+        const sessionID = String(payload.session_id || "")
+        if (!sessionID) return
+        activeSessions.add(sessionID)
+        await runService(BACKEND_SERVICE, "start")
+        await runService(DASHBOARD_SERVICE, "start")
+        const result = await runScript(HOOK_ENTRY, ["opencode", "session-start"], payload)
+        cacheContext(pendingContext, sessionID, result)
+        return
+      }
+      if (type === "session.idle") {
+        const payload = eventPayload(event, cwd)
+        const sessionID = String(payload.session_id || "")
+        if (!sessionID) return
+        await flushStop(sessionID)
+      }
+    },
+    "chat.message": async (hookInput: Record<string, unknown>, output: Record<string, unknown>) => {
+      const payload = chatMessagePayload(hookInput, output, cwd)
+      if (!payload.session_id || !payload.prompt) return
+      activeSessions.add(String(payload.session_id || ""))
+      const result = await runScript(HOOK_ENTRY, ["opencode", "user-prompt"], payload)
+      cacheContext(pendingContext, String(payload.session_id || ""), result)
+    },
+    "experimental.chat.system.transform": async (hookInput: Record<string, unknown>, output: { system: string[] }) => {
+      const sessionID = sessionIDFrom(hookInput)
+      const pending = pendingContext.get(sessionID)
+      if (!pending?.length) return
+      output.system.push(...pending)
+      pendingContext.delete(sessionID)
+    },
+    "tool.execute.after": async (hookInput: Record<string, unknown>, output: Record<string, unknown>) => {
+      const payload = toolAfterPayload(hookInput, output, cwd)
+      if (!payload.session_id || !payload.tool_name) return
+      await runScript(HOOK_ENTRY, ["opencode", "post-tool"], payload)
+    },
+    "experimental.text.complete": async (
+      hookInput: { sessionID?: string },
+      output: { text?: string },
+    ) => {
+      const sessionID = typeof hookInput.sessionID === "string" ? hookInput.sessionID : ""
+      if (!sessionID) return
+      if (typeof output.text === "string") completedAssistantText.set(sessionID, output.text)
+    },
+    dispose: async () => {
+      await Promise.all([...activeSessions].map((sessionID) => flushStop(sessionID)))
+      await runService(DASHBOARD_SERVICE, "session-end")
+      await runService(BACKEND_SERVICE, "session-end")
+    },
+  }
+}
+
+export default {
+  id: "claude-smart",
+  server,
+}

package/plugin/opencode/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["*.ts", "*.mts"]
+}

package/plugin/pyproject.toml

@@ -1,7 +1,24 @@
 [project]
 name = "claude-smart"
-version = "0.2.45"
-description = "Self-improving Claude Code and Codex plugin that turns corrections into Preferences, Project-specific skills, and Shared skills"
+version = "0.2.47"
+description = "Self-improving Claude Code, Codex, and OpenCode plugin that turns corrections into Preferences, Project-specific skills, and Shared skills"
+keywords = [
+    "claude",
+    "claude-code",
+    "claude-code-plugin",
+    "codex",
+    "codex-plugin",
+    "opencode",
+    "opencode-plugin",
+    "memory",
+    "agent-memory",
+    "plugin",
+    "reflexio",
+    "self-improvement",
+    "self-improving-agents",
+    "skills",
+    "learning",
+]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
@@ -9,7 +26,7 @@ dependencies = [
     # normal installs; vendor releases may override it after uv sync by
     # installing plugin/vendor/reflexio. Keep in sync via
     # scripts/sync-reflexio-dep.py.
-    "reflexio-ai>=0.2.25",
+    "reflexio-ai>=0.2.27",
     # Needed when Reflexio runs the local embedding provider (ONNXMiniLM_L6_V2).
     # Pulls in onnxruntime + tokenizers; the ~80 MB ONNX model itself is
     # downloaded on first use, not at install time.
@@ -21,9 +38,13 @@ dependencies = [
     "sqlite-vec>=0.1.6",
 ]
 
+# claude-smart is distributed via npm only (see bin/claude-smart.js); it is not
+# published to PyPI, so there is no `claude-smart` console script / uvx entry
+# point. These two scripts are resolved by the runtime from the plugin venv
+# (session_start.py locates claude-smart-optimizer-assistant; the hook is invoked
+# via `python -m claude_smart.hook`), so they stay.
 [project.scripts]
 claude-smart-hook = "claude_smart.hook:main"
-claude-smart = "claude_smart.cli:main"
 claude-smart-optimizer-assistant = "claude_smart.optimizer_assistant:main"
 
 [build-system]

package/plugin/scripts/_lib.sh

@@ -87,8 +87,12 @@ claude_smart_env_unquote() {
 }
 
 claude_smart_source_reflexio_env() {
+  # claude-smart's env lives at ~/.claude-smart/.env (kept separate from the OSS
+  # reflexio default ~/.reflexio/.env). Stays in sync with
+  # env_config.REFLEXIO_ENV_PATH and the REFLEXIO_ENV_FILE export in
+  # backend-service.sh.
   local env_file line key value
-  env_file="$HOME/.reflexio/.env"
+  env_file="$HOME/.claude-smart/.env"
   [ -f "$env_file" ] || return 0
   while IFS= read -r line || [ -n "$line" ]; do
     line="${line#"${line%%[![:space:]]*}"}"

package/plugin/scripts/backend-service.sh

@@ -34,6 +34,21 @@ EMBEDDING_PORT="${EMBEDDING_PORT:-8072}"
 export BACKEND_PORT="$PORT"
 export EMBEDDING_PORT
 
+# Run claude-smart's backend under its own org id. The reflexio no-auth resolver
+# reads REFLEXIO_DEFAULT_ORG_ID, which scopes the request org -> config file
+# name (config_<org>.json) and SQLite data. Hard-set (not :-defaulted) so a
+# value in the shared ~/.reflexio/.env can't drag claude-smart back onto
+# "self-host-org" and collide with the enterprise self-host backend over
+# config_self-host-org.json. Must stay in sync with cli.py's config path.
+export REFLEXIO_DEFAULT_ORG_ID="claude-smart"
+
+# Load claude-smart's env from ~/.claude-smart/.env instead of the reflexio
+# default ~/.reflexio/.env, so an OSS reflexio backend's .env on this machine
+# can't leak in. The data dir is independent (LOCAL_STORAGE_PATH), so both still
+# share ~/.reflexio/data. Must stay in sync with env_config.REFLEXIO_ENV_PATH and
+# the source path in _lib.sh (claude_smart_source_reflexio_env).
+export REFLEXIO_ENV_FILE="$HOME/.claude-smart/.env"
+
 # Default: route extraction through the active host CLI + ONNX embedder
 # so claude-smart works without any LLM API key. Users can opt out by
 # pre-exporting these to 0.
@@ -50,7 +65,12 @@ PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "backend-service.sh" "$@"
 
 if [ -z "${CLAUDE_SMART_CLI_PATH:-}" ]; then
-  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
+  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "opencode" ] && command -v opencode >/dev/null 2>&1; then
+    # Preserve Reflexio's Claude CLI provider contract while routing
+    # generation through the user's authenticated OpenCode setup.
+    claude_smart_prepend_node_bins
+    export CLAUDE_SMART_CLI_PATH="$PLUGIN_ROOT/scripts/opencode-claude-compat"
+  elif [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
     # Reflexio's provider still calls CLAUDE_SMART_CLI_PATH with Claude CLI
     # flags. Use a small compatibility executable that translates that narrow
     # contract to `codex exec`.
@@ -286,7 +306,7 @@ case "$CMD" in
     # Keep plugin runtime data in ~/.reflexio even when the backend imports
     # Reflexio from an editable checkout inside a larger repo with its own
     # .env. python-dotenv respects pre-existing env vars, so this prevents a
-    # parent REFLEXIO_LOG_DIR from sending claude-smart to enterprise configs.
+    # parent REFLEXIO_LOG_DIR from sending claude-smart to unrelated configs.
     export REFLEXIO_LOG_DIR="${REFLEXIO_LOG_DIR:-$HOME}"
 
     # Force sqlite: the plugin venv ships only the open-source reflexio

package/plugin/scripts/ensure-plugin-root.sh

@@ -32,12 +32,12 @@ if [ "$FORCE" = "--force" ]; then
 fi
 
 # Opt-in: when CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=1 (set in the
-# environment or in ~/.reflexio/.env), always relink to $TARGET so the
+# environment or in ~/.claude-smart/.env), always relink to $TARGET so the
 # symlink tracks the currently loaded plugin.
 FOLLOW="${CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION:-}"
-if [ -z "$FOLLOW" ] && [ -f "$HOME/.reflexio/.env" ]; then
-    FOLLOW="$(grep -E '^CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.reflexio/.env" \
-        | tail -n1 | cut -d= -f2-)"
+if [ -z "$FOLLOW" ] && [ -f "$HOME/.claude-smart/.env" ]; then
+    FOLLOW="$(grep -E '^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.claude-smart/.env" \
+        | tail -n1 | sed -E 's/^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=//')"
     # Strip a single pair of surrounding double or single quotes, if present.
     FOLLOW="${FOLLOW#\"}"; FOLLOW="${FOLLOW%\"}"
     FOLLOW="${FOLLOW#\'}"; FOLLOW="${FOLLOW%\'}"

package/plugin/scripts/hook_entry.sh

@@ -15,7 +15,7 @@ set -eu
 HOST="claude-code"
 EVENT="${1:-}"
 case "$EVENT" in
-  claude-code|codex)
+  claude-code|codex|opencode)
     HOST="$EVENT"
     EVENT="${2:-}"
     ;;

package/plugin/scripts/opencode-claude-compat

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)/"
+exec node "$SCRIPT_DIR/opencode-claude-compat.js" "$@"

package/plugin/scripts/opencode-claude-compat.cmd

@@ -0,0 +1,3 @@
+@echo off
+set SCRIPT_DIR=%~dp0
+node "%SCRIPT_DIR%opencode-claude-compat.js" %*

package/plugin/scripts/opencode-claude-compat.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+"use strict";
+
+/*
+ * Translate Reflexio's Claude CLI provider contract to `opencode run`.
+ *
+ * Reflexio shells out to CLAUDE_SMART_CLI_PATH as if it were Claude Code:
+ *
+ *   <path> -p --output-format stream-json --model <model> ...
+ *
+ * Under OpenCode, this bridge preserves that executable contract while routing
+ * generation through the user's authenticated OpenCode CLI/provider setup.
+ */
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const AGENT_NAME = "claude-smart-extractor";
+
+function main(argv) {
+  let workDir = null;
+  try {
+    const { outputFormat, systemPrompt, model } = parseSupportedArgs(argv);
+    const prompt = fs.readFileSync(0, "utf8");
+    workDir = prepareWorkDir();
+    const content = runOpenCode({
+      prompt: combinedPrompt({ prompt, systemPrompt }),
+      model,
+      workDir,
+    });
+    const payload =
+      outputFormat === "stream-json"
+        ? { type: "result", subtype: "success", result: content }
+        : { result: content };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`opencode-claude-compat: ${message}\n`);
+    return 1;
+  } finally {
+    if (workDir) {
+      try {
+        fs.rmSync(workDir, { recursive: true, force: true });
+      } catch {
+        // Best effort cleanup only.
+      }
+    }
+  }
+}
+
+function parseSupportedArgs(argv) {
+  let outputFormat = "json";
+  let systemPrompt = "";
+  let model = "";
+  let idx = 0;
+  while (idx < argv.length) {
+    const arg = argv[idx];
+    if (arg === "-p") {
+      idx += 1;
+    } else if (arg === "--output-format") {
+      outputFormat = requireValue(argv, idx, arg);
+      idx += 2;
+    } else if (arg === "--model") {
+      model = requireValue(argv, idx, arg);
+      idx += 2;
+    } else if (arg === "--verbose" || arg === "--include-partial-messages") {
+      idx += 1;
+    } else if (arg === "--append-system-prompt") {
+      systemPrompt = requireValue(argv, idx, arg);
+      idx += 2;
+    } else {
+      throw new Error(`unsupported Claude CLI argument: ${arg}`);
+    }
+  }
+  if (outputFormat !== "json" && outputFormat !== "stream-json") {
+    throw new Error(`unsupported --output-format: ${outputFormat}`);
+  }
+  return { outputFormat, systemPrompt, model };
+}
+
+function requireValue(argv, idx, name) {
+  if (idx + 1 >= argv.length) {
+    throw new Error(`${name} requires a value`);
+  }
+  return argv[idx + 1];
+}
+
+function prepareWorkDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-smart-opencode-"));
+  const config = {
+    agent: {
+      [AGENT_NAME]: {
+        description: "Internal claude-smart learning extraction",
+        prompt:
+          "You are running as an internal claude-smart extraction subprocess. " +
+          "Return only the requested text or JSON. Do not use tools, edit files, " +
+          "search the workspace, or ask follow-up questions.",
+        steps: 2,
+        permission: "deny",
+      },
+    },
+  };
+  const opencodeDir = path.join(dir, ".opencode");
+  fs.mkdirSync(opencodeDir, { recursive: true });
+  fs.writeFileSync(path.join(opencodeDir, "opencode.json"), `${JSON.stringify(config, null, 2)}\n`);
+  return dir;
+}
+
+function runOpenCode({ prompt, model, workDir }) {
+  const opencodePath = process.env.CLAUDE_SMART_OPENCODE_PATH || commandPath(opencodeNames());
+  if (!opencodePath) {
+    throw new Error("opencode CLI not found on PATH");
+  }
+
+  const args = [
+    "run",
+    "--pure",
+    "--format",
+    "json",
+    "--agent",
+    AGENT_NAME,
+    "--dir",
+    workDir,
+  ];
+  const selectedModel = opencodeModel(model);
+  if (selectedModel) {
+    args.push("--model", selectedModel);
+  }
+  const variant = (process.env.CLAUDE_SMART_OPENCODE_VARIANT || "").trim();
+  if (variant) {
+    args.push("--variant", variant);
+  }
+
+  const proc = spawnSync(opencodePath, args, {
+    input: prompt,
+    cwd: workDir,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      CLAUDE_SMART_HOST: "opencode",
+      CLAUDE_SMART_INTERNAL: "1",
+      CLAUDE_CODE_ENTRYPOINT: "optimizer",
+    },
+    timeout: timeoutMs(),
+    windowsHide: true,
+    shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(opencodePath),
+  });
+  if (proc.error) {
+    if (proc.error.code === "ETIMEDOUT") {
+      throw new Error(`opencode CLI timed out after ${timeoutMs() / 1000}s`);
+    }
+    throw proc.error;
+  }
+  if (proc.status !== 0) {
+    const stderr = String(proc.stderr || "").trim().slice(0, 500);
+    throw new Error(`opencode CLI exited ${proc.status}: ${stderr}`);
+  }
+  const content = parseOpenCodeJson(proc.stdout);
+  if (!content) {
+    throw new Error("opencode CLI returned empty output");
+  }
+  return content;
+}
+
+function opencodeModel(modelFromArgs) {
+  const explicit = (process.env.CLAUDE_SMART_OPENCODE_MODEL || "").trim();
+  if (explicit) return explicit;
+  const candidate = (modelFromArgs || "").trim();
+  return candidate.includes("/") ? candidate : "";
+}
+
+function parseOpenCodeJson(stdout) {
+  const chunks = [];
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const part = event && typeof event === "object" ? event.part : null;
+    if (part && part.type === "text" && typeof part.text === "string") {
+      chunks.push(part.text);
+    } else if (event.type === "text" && typeof event.text === "string") {
+      chunks.push(event.text);
+    } else if (event.type === "result" && typeof event.result === "string") {
+      chunks.push(event.result);
+    }
+  }
+  return chunks.join("").trim();
+}
+
+function timeoutMs() {
+  const raw = Number(process.env.CLAUDE_SMART_CLI_TIMEOUT || "");
+  if (Number.isFinite(raw) && raw > 0) return raw * 1000;
+  return DEFAULT_TIMEOUT_MS;
+}
+
+function opencodeNames() {
+  return process.platform === "win32" ? ["opencode.cmd", "opencode.exe", "opencode"] : ["opencode"];
+}
+
+function commandPath(names) {
+  const pathParts = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  for (const dir of pathParts) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function combinedPrompt({ prompt, systemPrompt }) {
+  if (!systemPrompt) return prompt;
+  return `${systemPrompt}\n\n## Task\n${prompt}`;
+}
+
+process.exitCode = main(process.argv.slice(2));