@meetopenbot/claude-code 0.1.12 → 0.1.13

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@meetopenbot/plugin-sdk';
+declare const plugin: Plugin;
+export { plugin };
+export default plugin;

package/dist/index.js

@@ -43,7 +43,7 @@ async function resolveModelConfigField() {
 import { execSync } from "node:child_process";
 import { existsSync as existsSync2, readlinkSync as readlinkSync2, statSync as statSync2 } from "node:fs";
 
-// node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
+// ../../node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.2.141_@cfworker+json-schema@4.1.1_zod@4.4.3/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as $S } from "node:module";
 import { execFile as E6$ } from "child_process";
 import { randomUUID as rz } from "crypto";
@@ -19370,15 +19370,15 @@ function Z_($, Q) {
   return null;
 }
 
-// node_modules/@meetopenbot/plugin-sdk/dist/index.js
+// ../plugin-sdk/dist/index.js
 import { z } from "zod";
 
-// node_modules/@meetopenbot/plugin-sdk/dist/plugin.js
+// ../plugin-sdk/dist/plugin.js
 function definePlugin(definition) {
   return definition;
 }
 
-// node_modules/@meetopenbot/plugin-sdk/dist/helpers.js
+// ../plugin-sdk/dist/helpers.js
 function shouldHandleInvoke(event, agentId) {
   const routedTo = event.data?.agentId;
   return !(typeof routedTo === "string" && routedTo && routedTo !== agentId);
@@ -19394,6 +19394,17 @@ function agentOutput(args) {
     }
   };
 }
+function toolTraceWidget(args) {
+  return {
+    kind: "message",
+    display: "collapsed",
+    widgetId: args.widgetId,
+    groupId: args.groupId,
+    title: args.title,
+    ...args.body ? { body: args.body } : {},
+    ...args.state ? { state: args.state } : {}
+  };
+}
 function uiWidget(args) {
   return {
     type: "client:ui:widget",
@@ -19406,6 +19417,275 @@ function uiWidget(args) {
   };
 }
 
+// ../plugin-sdk/dist/diff.js
+import { spawnSync } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+var MAX_DIFF_FILES = 40;
+var MAX_DIFF_PATCH_CHARS = 48e3;
+var LANG_BY_EXT = {
+  ts: "typescript",
+  tsx: "tsx",
+  js: "javascript",
+  jsx: "jsx",
+  mjs: "javascript",
+  cjs: "javascript",
+  py: "python",
+  go: "go",
+  rs: "rust",
+  rb: "ruby",
+  java: "java",
+  kt: "kotlin",
+  swift: "swift",
+  cs: "csharp",
+  cpp: "cpp",
+  cc: "cpp",
+  cxx: "cpp",
+  c: "c",
+  h: "c",
+  hpp: "cpp",
+  md: "markdown",
+  json: "json",
+  css: "css",
+  scss: "scss",
+  html: "html",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  sql: "sql"
+};
+var WRITE_TOOLS = /^(write|write_file|notebookedit|notebook_edit)$/i;
+var EDIT_TOOLS = /^(edit|strreplace|str_replace|edit_file|replace)$/i;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function languageFromPath(path) {
+  const base = path.split("/").pop() ?? path;
+  const ext = base.includes(".") ? base.slice(base.lastIndexOf(".") + 1).toLowerCase() : "";
+  return LANG_BY_EXT[ext];
+}
+function countPatchStats(patch) {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      additions += 1;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      deletions += 1;
+  }
+  return { additions, deletions };
+}
+function capPatch(patch) {
+  if (patch.length <= MAX_DIFF_PATCH_CHARS)
+    return { patch };
+  return { patch: patch.slice(0, MAX_DIFF_PATCH_CHARS), truncated: true };
+}
+function summarizeDiffFiles(files) {
+  const additions = files.reduce((sum, file) => sum + (file.additions ?? 0), 0);
+  const deletions = files.reduce((sum, file) => sum + (file.deletions ?? 0), 0);
+  const fileLabel = files.length === 1 ? "1 file" : `${files.length} files`;
+  if (!additions && !deletions)
+    return fileLabel;
+  if (!deletions)
+    return `${fileLabel} \xB7 +${additions}`;
+  if (!additions)
+    return `${fileLabel} \xB7 \u2212${deletions}`;
+  return `${fileLabel} \xB7 +${additions} \u2212${deletions}`;
+}
+function withLanguage(path) {
+  const language = languageFromPath(path);
+  return language ? { language } : {};
+}
+function diffFileFromPatch(path, patch, status = "modified") {
+  const stats = countPatchStats(patch);
+  return {
+    path,
+    status,
+    ...withLanguage(path),
+    additions: stats.additions || void 0,
+    deletions: stats.deletions || void 0,
+    ...capPatch(patch)
+  };
+}
+function diffFileFromWrite(path, content) {
+  const capped = capPatch(content);
+  return {
+    path,
+    status: "added",
+    ...withLanguage(path),
+    additions: content.split("\n").length,
+    before: "",
+    after: capped.patch,
+    ...capped.truncated ? { truncated: true } : {}
+  };
+}
+function splitUnifiedDiff(raw) {
+  const text = raw.replace(/\r\n/g, "\n");
+  const starts = [];
+  const header = /^diff --git /gm;
+  let match;
+  while (match = header.exec(text))
+    starts.push(match.index);
+  if (starts.length === 0) {
+    if (!text.trim())
+      return [];
+    return [diffFileFromPatch("diff", text)];
+  }
+  return starts.map((start, index) => {
+    const chunk = text.slice(start, starts[index + 1]);
+    const names = /^diff --git a\/(.+?) b\/(.+)$/m.exec(chunk);
+    const oldPath = names?.[1] ?? "unknown";
+    const path = names?.[2] ?? oldPath;
+    let status = "modified";
+    if (/^new file mode /m.test(chunk) || oldPath === "/dev/null")
+      status = "added";
+    else if (/^deleted file mode /m.test(chunk) || path === "/dev/null")
+      status = "deleted";
+    else if (/^rename from /m.test(chunk) || oldPath !== path)
+      status = "renamed";
+    const resolvedPath = path === "/dev/null" ? oldPath : path;
+    return {
+      ...diffFileFromPatch(resolvedPath, chunk, status),
+      ...status === "renamed" && oldPath !== path ? { oldPath } : {}
+    };
+  }).slice(0, MAX_DIFF_FILES);
+}
+function pathFromArgs(input) {
+  if (!isRecord(input))
+    return void 0;
+  return asString(input.path) ?? asString(input.file_path) ?? asString(input.target_file) ?? asString(input.notebook_path);
+}
+function writeContent(input) {
+  if (!isRecord(input))
+    return void 0;
+  if (typeof input.content === "string")
+    return input.content;
+  if (typeof input.contents === "string")
+    return input.contents;
+  if (typeof input.new_source === "string")
+    return input.new_source;
+  return void 0;
+}
+function editPatchFromResult(result) {
+  if (!isRecord(result))
+    return void 0;
+  const details = isRecord(result.details) ? result.details : void 0;
+  return asString(details?.patch) ?? asString(result.patch);
+}
+function patchFromReplace(input) {
+  if (!isRecord(input))
+    return void 0;
+  const oldText = asString(input.old_string) ?? asString(input.oldText) ?? asString(input.old_str);
+  const newText = asString(input.new_string) ?? asString(input.newText) ?? asString(input.new_str);
+  if (oldText == null || newText == null)
+    return void 0;
+  return `--- a
++++ b
+@@
+${oldText.split("\n").map((line) => `-${line}`).join("\n")}
+${newText.split("\n").map((line) => `+${line}`).join("\n")}
+`;
+}
+function diffFileFromMutationTool(args) {
+  const path = pathFromArgs(args.input);
+  if (!path)
+    return null;
+  const patch = editPatchFromResult(args.result);
+  if (patch)
+    return diffFileFromPatch(path, patch);
+  const toolName = args.toolName.replace(/[:/]/g, "_");
+  if (WRITE_TOOLS.test(toolName)) {
+    const content = writeContent(args.input);
+    if (content === void 0)
+      return null;
+    return diffFileFromWrite(path, content);
+  }
+  if (EDIT_TOOLS.test(toolName)) {
+    const replacePatch = patchFromReplace(args.input);
+    if (!replacePatch)
+      return null;
+    return diffFileFromPatch(path, replacePatch);
+  }
+  return null;
+}
+function buildDiffWidget(args) {
+  const files = args.files.slice(0, MAX_DIFF_FILES);
+  if (files.length === 0)
+    return null;
+  return {
+    kind: "diff",
+    widgetId: args.widgetId,
+    title: args.title ?? "Changes",
+    description: summarizeDiffFiles(files),
+    files,
+    size: "full",
+    display: "expanded"
+  };
+}
+function git(cwd, args) {
+  try {
+    const result = spawnSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      timeout: 15e3,
+      maxBuffer: 8e6,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.status !== 0)
+      return null;
+    return result.stdout ?? "";
+  } catch {
+    return null;
+  }
+}
+function snapshotWorkspace(cwd) {
+  if (!cwd)
+    return null;
+  const inside = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside?.trim() !== "true")
+    return null;
+  const stashSha = git(cwd, ["stash", "create"])?.trim() || void 0;
+  const untracked = git(cwd, ["ls-files", "--others", "--exclude-standard"])?.split("\n").map((line) => line.trim()).filter(Boolean) ?? [];
+  return { cwd, stashSha, untracked };
+}
+function mergeDiffFiles(existing, extra) {
+  const byPath = new Map(existing.map((file) => [file.path, file]));
+  for (const file of extra)
+    byPath.set(file.path, file);
+  return [...byPath.values()].slice(0, MAX_DIFF_FILES);
+}
+function diffFromSnapshot(snapshot) {
+  if (!snapshot)
+    return [];
+  const { cwd, stashSha, untracked: beforeUntracked } = snapshot;
+  const diffRaw = stashSha ? git(cwd, ["diff", stashSha]) : git(cwd, ["diff", "HEAD"]);
+  const files = diffRaw ? splitUnifiedDiff(diffRaw) : [];
+  const afterUntracked = git(cwd, ["ls-files", "--others", "--exclude-standard"])?.split("\n").map((line) => line.trim()).filter(Boolean) ?? [];
+  const beforeSet = new Set(beforeUntracked);
+  const extras = [];
+  for (const path of afterUntracked) {
+    if (beforeSet.has(path))
+      continue;
+    try {
+      extras.push(diffFileFromWrite(path, readFileSync2(join(cwd, path), "utf8")));
+    } catch {
+      extras.push({ path, status: "added", ...withLanguage(path) });
+    }
+  }
+  return mergeDiffFiles(files, extras);
+}
+function resolveRunDiffFiles(args) {
+  const fromGit = diffFromSnapshot(args.snapshot ?? null);
+  if (fromGit.length > 0)
+    return fromGit;
+  return [...args.fallback ?? []].slice(0, MAX_DIFF_FILES);
+}
+
 // credits-auth.ts
 var INTEGRATIONS_TOKEN_HEADER = "x-openbot-integrations-token";
 var CREDITS_API_KEY_PLACEHOLDER = "openbot-credits";
@@ -19774,6 +20054,8 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
       const emittedToolCallIds = /* @__PURE__ */ new Set();
       const emittedToolResultIds = /* @__PURE__ */ new Set();
       const toolTitleByUseId = /* @__PURE__ */ new Map();
+      const changedFiles = /* @__PURE__ */ new Map();
+      const snapshot = snapshotWorkspace(workingDir);
       const emitAssistantText = function* (text) {
         if (!text) return;
         if (authMode === "credits") {
@@ -19837,20 +20119,12 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
                   yield uiWidget({
                     agentId: context.state.agentId,
                     threadId,
-                    widget: {
-                      kind: "message",
+                    widget: toolTraceWidget({
                       widgetId: toolCallWidgetId(tool.toolUseId),
+                      groupId: "claude-code:tools",
                       title: toolTitleByUseId.get(tool.toolUseId)?.title ?? "",
-                      body: formatToolInputBody(tool.input),
-                      display: "collapsed",
-                      metadata: {
-                        type: "claude_tool",
-                        phase: "call",
-                        toolName: tool.title,
-                        toolUseId: tool.toolUseId,
-                        source: "claude-code"
-                      }
-                    }
+                      body: formatToolInputBody(tool.input)
+                    })
                   });
                 }
                 continue;
@@ -19876,24 +20150,25 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
               yield uiWidget({
                 agentId: context.state.agentId,
                 threadId,
-                widget: {
-                  kind: "message",
+                widget: toolTraceWidget({
                   widgetId: toolCallWidgetId(res.toolUseId),
+                  groupId: "claude-code:tools",
                   title: toolTitleByUseId.get(res.toolUseId)?.title ?? "",
                   body: formatToolResultBody(
                     toolTitleByUseId.get(res.toolUseId)?.input,
                     body
                   ),
-                  display: "collapsed",
-                  ...state ? { state } : {},
-                  metadata: {
-                    type: "claude_tool",
-                    phase: "result",
-                    toolUseId: res.toolUseId,
-                    source: "claude-code"
-                  }
-                }
+                  state
+                })
               });
+              if (!res.isError) {
+                const file = diffFileFromMutationTool({
+                  toolName: toolTitleByUseId.get(res.toolUseId)?.title ?? "",
+                  input: toolTitleByUseId.get(res.toolUseId)?.input,
+                  result: res.content
+                });
+                if (file) changedFiles.set(file.path, file);
+              }
             }
           }
         }
@@ -19943,6 +20218,20 @@ ${details}` : `[claude-code] run ended with error: ${subtype}`
       if (lastSessionId && lastSessionId !== resumeId) {
         await persistSessionId(context.state, storage, lastSessionId);
       }
+      const diff = buildDiffWidget({
+        widgetId: `claude-code-diff:${threadId ?? "run"}:${Date.now()}`,
+        files: resolveRunDiffFiles({
+          snapshot,
+          fallback: changedFiles.values()
+        })
+      });
+      if (diff) {
+        yield uiWidget({
+          agentId: context.state.agentId,
+          threadId,
+          widget: diff
+        });
+      }
     } catch (error) {
       const errorMessage = formatClaudeCodeError(error, launchContext, stderrChunks);
       if (authMode === "credits") {
@@ -20085,7 +20374,7 @@ var claudeCodePlugin = {
     });
   }
 };
-var claude_code_default = definePlugin(claudeCodePlugin);
+var plugin_claude_code_default = definePlugin(claudeCodePlugin);
 export {
-  claude_code_default as default
+  plugin_claude_code_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/claude-code",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "description": "Claude Code plugin for OpenBot",
   "main": "./dist/index.js",
@@ -8,22 +8,28 @@
     "access": "public"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:melony --external:zod",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",
-    "@meetopenbot/plugin-sdk": "^0.1.4"
+    "@meetopenbot/plugin-sdk": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",
     "esbuild": "^0.21.0",
     "zod": "^4.3.5"
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:melony --external:zod && node ../../scripts/write-plugin-declaration.mjs",
+    "dev": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:melony --external:zod --watch",
+    "typecheck": "tsc --noEmit --allowImportingTsExtensions --module ESNext --moduleResolution Bundler --target ES2022 --skipLibCheck index.ts"
   }
-}
+}