claude-smart 0.2.45 → 0.2.47

package/plugin/opencode/assistant-buffer.ts

@@ -0,0 +1,108 @@
+import { eventProperties, type EventLike, sessionIDFrom } from "./internal.js"
+
+type PartLike = {
+  id?: string
+  type?: string
+  text?: string
+  messageID?: string
+}
+
+type SessionText = {
+  messageID?: string
+  parts: Map<string, string>
+  textPartIDs: Set<string>
+  ignoredPartIDs: Set<string>
+}
+
+function textFromPart(part: unknown): { id: string; text: string; messageID?: string } | undefined {
+  if (!part || typeof part !== "object") return undefined
+  const item = part as PartLike
+  if (item.type !== "text") return undefined
+  if (typeof item.text !== "string") return undefined
+  return {
+    id: item.id || `${item.messageID || "message"}:${item.type}`,
+    text: item.text,
+    messageID: item.messageID,
+  }
+}
+
+function partIDFrom(part: unknown): string | undefined {
+  if (!part || typeof part !== "object") return undefined
+  const item = part as PartLike
+  return item.id || (item.messageID && item.type ? `${item.messageID}:${item.type}` : undefined)
+}
+
+function emptySession(messageID?: string): SessionText {
+  return { messageID, parts: new Map(), textPartIDs: new Set(), ignoredPartIDs: new Set() }
+}
+
+export class AssistantBuffer {
+  private readonly sessions = new Map<string, SessionText>()
+
+  update(event: EventLike): void {
+    const type = event.type
+    const properties = eventProperties(event)
+    const sessionID = sessionIDFrom(properties)
+    if (!sessionID || !type) return
+
+    if (type === "message.updated") {
+      const info = properties.info
+      if (!info || typeof info !== "object") return
+      const message = info as { id?: string; role?: string }
+      if (message.role !== "assistant") return
+      const current = this.sessions.get(sessionID)
+      if (!current || current.messageID !== message.id) {
+        this.sessions.set(sessionID, emptySession(message.id))
+      }
+      return
+    }
+
+    if (type === "message.part.updated") {
+      const hit = textFromPart(properties.part)
+      if (!hit) {
+        const ignoredID = partIDFrom(properties.part)
+        if (!ignoredID) return
+        const current: SessionText = this.sessions.get(sessionID) ?? emptySession()
+        current.ignoredPartIDs.add(ignoredID)
+        current.textPartIDs.delete(ignoredID)
+        current.parts.delete(ignoredID)
+        this.sessions.set(sessionID, current)
+        return
+      }
+      const current: SessionText = this.sessions.get(sessionID) ?? emptySession()
+      if (hit.messageID && current.messageID && hit.messageID !== current.messageID) {
+        current.messageID = hit.messageID
+        current.parts.clear()
+        current.textPartIDs.clear()
+        current.ignoredPartIDs.clear()
+      } else if (hit.messageID) {
+        current.messageID = hit.messageID
+      }
+      current.ignoredPartIDs.delete(hit.id)
+      current.textPartIDs.add(hit.id)
+      current.parts.set(hit.id, hit.text)
+      this.sessions.set(sessionID, current)
+      return
+    }
+
+    if (type === "message.part.delta") {
+      const partID = typeof properties.partID === "string" ? properties.partID : undefined
+      const delta = typeof properties.delta === "string" ? properties.delta : undefined
+      if (!partID || !delta) return
+      const current: SessionText = this.sessions.get(sessionID) ?? emptySession()
+      if (current.ignoredPartIDs.has(partID) || !current.textPartIDs.has(partID)) return
+      current.parts.set(partID, `${current.parts.get(partID) || ""}${delta}`)
+      this.sessions.set(sessionID, current)
+    }
+  }
+
+  text(sessionID: string): string {
+    const current = this.sessions.get(sessionID)
+    if (!current) return ""
+    return Array.from(current.parts.values()).filter(Boolean).join("\n\n")
+  }
+
+  clear(sessionID: string): void {
+    this.sessions.delete(sessionID)
+  }
+}

package/plugin/opencode/dist/assistant-buffer.js

@@ -0,0 +1,96 @@
+import { eventProperties, sessionIDFrom } from "./internal.js";
+function textFromPart(part) {
+    if (!part || typeof part !== "object")
+        return undefined;
+    const item = part;
+    if (item.type !== "text")
+        return undefined;
+    if (typeof item.text !== "string")
+        return undefined;
+    return {
+        id: item.id || `${item.messageID || "message"}:${item.type}`,
+        text: item.text,
+        messageID: item.messageID,
+    };
+}
+function partIDFrom(part) {
+    if (!part || typeof part !== "object")
+        return undefined;
+    const item = part;
+    return item.id || (item.messageID && item.type ? `${item.messageID}:${item.type}` : undefined);
+}
+function emptySession(messageID) {
+    return { messageID, parts: new Map(), textPartIDs: new Set(), ignoredPartIDs: new Set() };
+}
+export class AssistantBuffer {
+    sessions = new Map();
+    update(event) {
+        const type = event.type;
+        const properties = eventProperties(event);
+        const sessionID = sessionIDFrom(properties);
+        if (!sessionID || !type)
+            return;
+        if (type === "message.updated") {
+            const info = properties.info;
+            if (!info || typeof info !== "object")
+                return;
+            const message = info;
+            if (message.role !== "assistant")
+                return;
+            const current = this.sessions.get(sessionID);
+            if (!current || current.messageID !== message.id) {
+                this.sessions.set(sessionID, emptySession(message.id));
+            }
+            return;
+        }
+        if (type === "message.part.updated") {
+            const hit = textFromPart(properties.part);
+            if (!hit) {
+                const ignoredID = partIDFrom(properties.part);
+                if (!ignoredID)
+                    return;
+                const current = this.sessions.get(sessionID) ?? emptySession();
+                current.ignoredPartIDs.add(ignoredID);
+                current.textPartIDs.delete(ignoredID);
+                current.parts.delete(ignoredID);
+                this.sessions.set(sessionID, current);
+                return;
+            }
+            const current = this.sessions.get(sessionID) ?? emptySession();
+            if (hit.messageID && current.messageID && hit.messageID !== current.messageID) {
+                current.messageID = hit.messageID;
+                current.parts.clear();
+                current.textPartIDs.clear();
+                current.ignoredPartIDs.clear();
+            }
+            else if (hit.messageID) {
+                current.messageID = hit.messageID;
+            }
+            current.ignoredPartIDs.delete(hit.id);
+            current.textPartIDs.add(hit.id);
+            current.parts.set(hit.id, hit.text);
+            this.sessions.set(sessionID, current);
+            return;
+        }
+        if (type === "message.part.delta") {
+            const partID = typeof properties.partID === "string" ? properties.partID : undefined;
+            const delta = typeof properties.delta === "string" ? properties.delta : undefined;
+            if (!partID || !delta)
+                return;
+            const current = this.sessions.get(sessionID) ?? emptySession();
+            if (current.ignoredPartIDs.has(partID) || !current.textPartIDs.has(partID))
+                return;
+            current.parts.set(partID, `${current.parts.get(partID) || ""}${delta}`);
+            this.sessions.set(sessionID, current);
+        }
+    }
+    text(sessionID) {
+        const current = this.sessions.get(sessionID);
+        if (!current)
+            return "";
+        return Array.from(current.parts.values()).filter(Boolean).join("\n\n");
+    }
+    clear(sessionID) {
+        this.sessions.delete(sessionID);
+    }
+}

package/plugin/opencode/dist/internal.js

@@ -0,0 +1,12 @@
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function eventProperties(event) {
+    return isRecord(event.properties) ? event.properties : event;
+}
+export function sessionIDFrom(value) {
+    if (!isRecord(value))
+        return "";
+    const raw = value.sessionID ?? value.session_id;
+    return typeof raw === "string" ? raw : "";
+}

package/plugin/opencode/dist/payload.js

@@ -0,0 +1,85 @@
+import { eventProperties, isRecord, sessionIDFrom } from "./internal.js";
+function textFromParts(parts) {
+    if (!Array.isArray(parts))
+        return "";
+    return parts
+        .map((part) => (part && part.type === "text" && typeof part.text === "string" ? part.text : ""))
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function eventPayload(event, cwd) {
+    const properties = eventProperties(event);
+    const info = isRecord(properties.info) ? properties.info : {};
+    return {
+        session_id: sessionIDFrom(properties) || sessionIDFrom(info),
+        cwd: typeof info.directory === "string" ? info.directory : cwd,
+    };
+}
+export function chatMessagePayload(input, output, cwd) {
+    const message = isRecord(output.message) ? output.message : {};
+    const prompt = textFromParts(output.parts) ||
+        (typeof message.content === "string" ? message.content : "") ||
+        textFromParts(message.parts);
+    return {
+        session_id: sessionIDFrom(input),
+        cwd,
+        prompt,
+    };
+}
+export function normalizeToolName(tool) {
+    const lowered = tool.toLowerCase();
+    if (lowered === "edit")
+        return "Edit";
+    if (lowered === "write")
+        return "Write";
+    if (lowered === "apply_patch")
+        return "apply_patch";
+    if (["bash", "shell", "terminal", "exec", "command"].includes(lowered))
+        return "Bash";
+    return tool;
+}
+export function normalizeToolInput(tool, args) {
+    if (!isRecord(args))
+        return {};
+    const out = { ...args };
+    const copy = (from, to) => {
+        if (from in args && !(to in out))
+            out[to] = args[from];
+    };
+    copy("filePath", "file_path");
+    copy("oldString", "old_string");
+    copy("newString", "new_string");
+    copy("patchText", "command");
+    if (normalizeToolName(tool) === "Bash") {
+        copy("cmd", "command");
+        copy("script", "command");
+    }
+    return out;
+}
+export function toolAfterPayload(input, output, cwd) {
+    const tool = typeof input.tool === "string" ? input.tool : "";
+    const text = typeof output.output === "string" ? output.output : "";
+    const response = {
+        output: text,
+        stdout: text,
+    };
+    if (typeof output.title === "string")
+        response.title = output.title;
+    if (isRecord(output.metadata))
+        response.metadata = output.metadata;
+    if (isRecord(output.metadata) && output.metadata.error)
+        response.error = output.metadata.error;
+    return {
+        session_id: sessionIDFrom(input),
+        cwd,
+        tool_name: normalizeToolName(tool),
+        tool_input: normalizeToolInput(tool, input.args),
+        tool_response: response,
+    };
+}
+export function stopPayload(event, cwd, lastAssistantMessage) {
+    return {
+        ...eventPayload(event, cwd),
+        last_assistant_message: lastAssistantMessage,
+    };
+}

package/plugin/opencode/dist/server.mjs

@@ -0,0 +1,232 @@
+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";
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+function homeDir() {
+    return process.env.HOME || homedir();
+}
+function textFilePluginRoot() {
+    try {
+        return readFileSync(join(homeDir(), ".reflexio", "plugin-root.txt"), "utf8").trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPluginRoot(candidate) {
+    return !!candidate
+        && existsSync(join(candidate, "pyproject.toml"))
+        && existsSync(join(candidate, "uv.lock"))
+        && existsSync(join(candidate, "scripts", "hook_entry.sh"));
+}
+function canonicalPluginRoot(candidate) {
+    if (!isPluginRoot(candidate))
+        return undefined;
+    try {
+        return realpathSync(candidate);
+    }
+    catch {
+        return undefined;
+    }
+}
+function pathParts(candidate) {
+    return candidate.split(/[\\/]+/).filter(Boolean);
+}
+function isDescendantOrSame(child, parent) {
+    const path = relative(parent, child);
+    return path === "" || (!path.startsWith("..") && !isAbsolute(path));
+}
+function isReflexioSessionCopy(candidate) {
+    try {
+        const reflexioRoot = realpathSync(join(homeDir(), ".reflexio"));
+        return isDescendantOrSame(candidate, reflexioRoot);
+    }
+    catch {
+        return false;
+    }
+}
+function isTransientPackageRoot(candidate) {
+    return pathParts(candidate).includes("_npx") || isReflexioSessionCopy(candidate);
+}
+function resolvePluginRoot() {
+    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) {
+    const hookOutput = result.hookSpecificOutput;
+    if (!hookOutput || typeof hookOutput !== "object")
+        return "";
+    const additional = hookOutput.additionalContext;
+    return typeof additional === "string" ? additional : "";
+}
+function parseFirstJsonObject(text) {
+    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;
+        }
+        catch {
+            continue;
+        }
+    }
+    return {};
+}
+function runScript(script, args, payload) {
+    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, subcommand) {
+    return runScript(script, [subcommand]).then(() => undefined);
+}
+function cacheContext(cache, sessionID, result) {
+    const context = contextFrom(result);
+    if (!sessionID || !context)
+        return;
+    const pending = cache.get(sessionID) ?? [];
+    pending.push(context);
+    cache.set(sessionID, pending);
+}
+async function server(input) {
+    const pendingContext = new Map();
+    const activeSessions = new Set();
+    const completedAssistantText = new Map();
+    const assistant = new AssistantBuffer();
+    const cwd = input.directory;
+    async function flushStop(sessionID) {
+        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 }) => {
+            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, output) => {
+            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, output) => {
+            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, output) => {
+            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, output) => {
+            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/internal.ts

@@ -0,0 +1,18 @@
+export type EventLike = {
+  type?: string
+  properties?: Record<string, unknown>
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value)
+}
+
+export function eventProperties(event: EventLike): Record<string, unknown> {
+  return isRecord(event.properties) ? event.properties : (event as Record<string, unknown>)
+}
+
+export function sessionIDFrom(value: unknown): string {
+  if (!isRecord(value)) return ""
+  const raw = value.sessionID ?? value.session_id
+  return typeof raw === "string" ? raw : ""
+}

package/plugin/opencode/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/plugin/opencode/payload.ts

@@ -0,0 +1,90 @@
+import { eventProperties, type EventLike, isRecord, sessionIDFrom } from "./internal.js"
+
+type PartLike = {
+  type?: string
+  text?: string
+}
+
+export type PythonPayload = Record<string, unknown>
+
+function textFromParts(parts: unknown): string {
+  if (!Array.isArray(parts)) return ""
+  return parts
+    .map((part: PartLike) => (part && part.type === "text" && typeof part.text === "string" ? part.text : ""))
+    .filter(Boolean)
+    .join("\n\n")
+}
+
+export function eventPayload(event: EventLike, cwd: string): PythonPayload {
+  const properties = eventProperties(event)
+  const info = isRecord(properties.info) ? properties.info : {}
+  return {
+    session_id: sessionIDFrom(properties) || sessionIDFrom(info),
+    cwd: typeof info.directory === "string" ? info.directory : cwd,
+  }
+}
+
+export function chatMessagePayload(input: Record<string, unknown>, output: Record<string, unknown>, cwd: string): PythonPayload {
+  const message = isRecord(output.message) ? output.message : {}
+  const prompt =
+    textFromParts(output.parts) ||
+    (typeof message.content === "string" ? message.content : "") ||
+    textFromParts(message.parts)
+  return {
+    session_id: sessionIDFrom(input),
+    cwd,
+    prompt,
+  }
+}
+
+export function normalizeToolName(tool: string): string {
+  const lowered = tool.toLowerCase()
+  if (lowered === "edit") return "Edit"
+  if (lowered === "write") return "Write"
+  if (lowered === "apply_patch") return "apply_patch"
+  if (["bash", "shell", "terminal", "exec", "command"].includes(lowered)) return "Bash"
+  return tool
+}
+
+export function normalizeToolInput(tool: string, args: unknown): Record<string, unknown> {
+  if (!isRecord(args)) return {}
+  const out: Record<string, unknown> = { ...args }
+  const copy = (from: string, to: string) => {
+    if (from in args && !(to in out)) out[to] = args[from]
+  }
+  copy("filePath", "file_path")
+  copy("oldString", "old_string")
+  copy("newString", "new_string")
+  copy("patchText", "command")
+  if (normalizeToolName(tool) === "Bash") {
+    copy("cmd", "command")
+    copy("script", "command")
+  }
+  return out
+}
+
+export function toolAfterPayload(input: Record<string, unknown>, output: Record<string, unknown>, cwd: string): PythonPayload {
+  const tool = typeof input.tool === "string" ? input.tool : ""
+  const text = typeof output.output === "string" ? output.output : ""
+  const response: Record<string, unknown> = {
+    output: text,
+    stdout: text,
+  }
+  if (typeof output.title === "string") response.title = output.title
+  if (isRecord(output.metadata)) response.metadata = output.metadata
+  if (isRecord(output.metadata) && output.metadata.error) response.error = output.metadata.error
+  return {
+    session_id: sessionIDFrom(input),
+    cwd,
+    tool_name: normalizeToolName(tool),
+    tool_input: normalizeToolInput(tool, input.args),
+    tool_response: response,
+  }
+}
+
+export function stopPayload(event: EventLike, cwd: string, lastAssistantMessage: string): PythonPayload {
+  return {
+    ...eventPayload(event, cwd),
+    last_assistant_message: lastAssistantMessage,
+  }
+}