@rcrsr/rill-ext-claude-code 0.8.6 → 0.11.0

package/dist/index.js

@@ -1,20 +1,647 @@
-/**
- * @rcrsr/rill-ext-claude-code
- *
- * Extension for executing Claude Code toolkit operations from rill scripts.
- */
-// ============================================================
-// VERSION
-// ============================================================
-export const VERSION = '0.1.0';
-export { createStreamParser } from './stream-parser.js';
-// ============================================================
-// RESULT EXTRACTION
-// ============================================================
-export { extractResult } from './result.js';
-export { spawnClaudeCli } from './process.js';
-// ============================================================
-// EXTENSION FACTORY
-// ============================================================
-export { createClaudeCodeExtension } from './factory.js';
-//# sourceMappingURL=index.js.map
+// src/stream-parser.ts
+var ANSI_ESCAPE_PATTERN = new RegExp(
+  [
+    // CSI sequences: ESC [ ... letter
+    `${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`,
+    // OSC sequences: ESC ] ... BEL
+    `${String.fromCharCode(27)}\\][^${String.fromCharCode(7)}]*${String.fromCharCode(7)}`,
+    // ESC = and ESC >
+    `${String.fromCharCode(27)}[=>]`,
+    // Character set selection: ESC ( or ESC ) followed by code
+    `${String.fromCharCode(27)}[()][AB012]`
+  ].join("|"),
+  "g"
+);
+function stripAnsi(text) {
+  return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function createStreamParser() {
+  let buffer = "";
+  function processLine(line, onMessage) {
+    if (line.trim().length === 0) {
+      return;
+    }
+    const cleaned = line.trim().replace(/\[<u/g, "");
+    if (cleaned.length === 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(cleaned);
+      if (typeof parsed !== "object" || parsed === null || !("type" in parsed)) {
+        return;
+      }
+      onMessage(parsed);
+    } catch {
+    }
+  }
+  return {
+    processChunk(chunk, onMessage) {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      buffer += text;
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+        const rawLine = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        const cleanLine = stripAnsi(rawLine);
+        processLine(cleanLine, onMessage);
+      }
+    },
+    flush(onMessage) {
+      if (buffer.trim().length > 0) {
+        const cleanLine = stripAnsi(buffer);
+        processLine(cleanLine, onMessage);
+        buffer = "";
+      }
+    }
+  };
+}
+
+// src/result.ts
+function extractResult(messages) {
+  const tokens = {
+    prompt: 0,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheRead: 0,
+    output: 0
+  };
+  const textParts = [];
+  let cost = 0;
+  let duration = 0;
+  let exitCode = 0;
+  for (const msg of messages) {
+    if (msg.type === "assistant") {
+      if (msg.message.usage) {
+        accumulateTokens(tokens, msg.message.usage);
+      }
+      for (const block of msg.message.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        }
+      }
+    } else if (msg.type === "result") {
+      cost = msg.cost_usd;
+      duration = msg.duration_ms;
+      exitCode = msg.is_error ? 1 : 0;
+      accumulateTokens(tokens, msg.usage);
+    }
+  }
+  return {
+    result: textParts.join(""),
+    tokens,
+    cost,
+    exitCode,
+    duration
+  };
+}
+function accumulateTokens(tokens, usage) {
+  if (usage.input_tokens !== void 0) {
+    tokens.prompt += usage.input_tokens;
+  }
+  if (usage.output_tokens !== void 0) {
+    tokens.output += usage.output_tokens;
+  }
+  if (usage.cache_creation?.ephemeral_5m_input_tokens !== void 0) {
+    tokens.cacheWrite5m += usage.cache_creation.ephemeral_5m_input_tokens;
+  }
+  if (usage.cache_creation?.ephemeral_1h_input_tokens !== void 0) {
+    tokens.cacheWrite1h += usage.cache_creation.ephemeral_1h_input_tokens;
+  }
+  if (usage.cache_read_input_tokens !== void 0) {
+    tokens.cacheRead += usage.cache_read_input_tokens;
+  }
+}
+
+// src/process.ts
+import * as pty from "node-pty";
+import { RuntimeError } from "@rcrsr/rill";
+function spawnClaudeCli(prompt, options = {}) {
+  const {
+    binaryPath = "claude",
+    timeoutMs,
+    cwd = process.cwd(),
+    env = process.env,
+    dangerouslySkipPermissions = true,
+    settingSources = ""
+  } = options;
+  const args = [
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--no-session-persistence",
+    "--setting-sources",
+    settingSources
+  ];
+  if (dangerouslySkipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  let timeoutId;
+  let disposed = false;
+  let resolveExit;
+  let rejectExit;
+  const exitCode = new Promise((resolve, reject) => {
+    resolveExit = resolve;
+    rejectExit = reject;
+  });
+  let ptyProcess;
+  try {
+    ptyProcess = pty.spawn(binaryPath, args, {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 30,
+      cwd,
+      env
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      const code = error.code;
+      if (code === "ENOENT") {
+        throw new RuntimeError(
+          "RILL-R004",
+          "claude binary not found",
+          void 0,
+          { binaryPath }
+        );
+      }
+      if (code === "EACCES") {
+        throw new RuntimeError(
+          "RILL-R004",
+          "Permission denied: claude",
+          void 0,
+          { binaryPath }
+        );
+      }
+      throw new RuntimeError(
+        "RILL-R004",
+        `Failed to spawn claude binary: ${error.message}`,
+        void 0,
+        { binaryPath, originalError: error.message }
+      );
+    }
+    throw new RuntimeError(
+      "RILL-R004",
+      `Failed to spawn claude binary: Unknown error`,
+      void 0,
+      { binaryPath }
+    );
+  }
+  if (timeoutMs !== void 0 && timeoutMs > 0) {
+    timeoutId = setTimeout(() => {
+      if (!disposed) {
+        disposed = true;
+        ptyProcess.kill();
+        rejectExit(
+          new RuntimeError(
+            "RILL-R004",
+            `Claude CLI timeout after ${timeoutMs}ms`,
+            void 0,
+            { timeoutMs }
+          )
+        );
+      }
+    }, timeoutMs);
+  }
+  ptyProcess.onExit((event) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    if (!disposed) {
+      disposed = true;
+      const { exitCode: code } = event;
+      if (code !== 0) {
+        rejectExit(
+          new RuntimeError(
+            "RILL-R004",
+            `Claude CLI exited with code ${code}`,
+            void 0,
+            { exitCode: code }
+          )
+        );
+      } else {
+        resolveExit(code);
+      }
+    }
+  });
+  const dispose = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    try {
+      ptyProcess.kill();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Failed to kill claude process during cleanup: ${message}`);
+    }
+  };
+  return {
+    ptyProcess,
+    exitCode,
+    dispose
+  };
+}
+
+// src/factory.ts
+import which from "which";
+import {
+  RuntimeError as RuntimeError3,
+  emitExtensionEvent
+} from "@rcrsr/rill";
+
+// ../../shared/ext-param/dist/param.js
+import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
+function validateParamName(name) {
+  if (name === "") {
+    throw new RuntimeError2("RILL-R001", "param name must not be empty");
+  }
+  if (/\s/.test(name)) {
+    throw new RuntimeError2("RILL-R001", "param name must be a valid identifier");
+  }
+}
+function buildAnnotations(desc) {
+  if (desc !== void 0) {
+    return { description: desc };
+  }
+  return {};
+}
+var p = {
+  /**
+   * IR-1: Creates a string parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param desc - Optional description
+   * @returns RillParam with type 'string'
+   */
+  str(name, desc) {
+    validateParamName(name);
+    return {
+      name,
+      type: { type: "string" },
+      defaultValue: void 0,
+      annotations: buildAnnotations(desc)
+    };
+  },
+  /**
+   * IR-2: Creates a number parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param desc - Optional description
+   * @param def - Optional default value
+   * @returns RillParam with type 'number'
+   */
+  num(name, desc, def) {
+    validateParamName(name);
+    return {
+      name,
+      type: { type: "number" },
+      defaultValue: def,
+      annotations: buildAnnotations(desc)
+    };
+  },
+  /**
+   * IR-3: Creates a boolean parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param desc - Optional description
+   * @param def - Optional default value
+   * @returns RillParam with type 'bool'
+   */
+  bool(name, desc, def) {
+    validateParamName(name);
+    return {
+      name,
+      type: { type: "bool" },
+      defaultValue: def,
+      annotations: buildAnnotations(desc)
+    };
+  },
+  /**
+   * IR-4: Creates a dict parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param desc - Optional description
+   * @param def - Optional default value
+   * @returns RillParam with type 'dict'
+   */
+  dict(name, desc, def) {
+    validateParamName(name);
+    return {
+      name,
+      type: { type: "dict" },
+      defaultValue: def,
+      annotations: buildAnnotations(desc)
+    };
+  },
+  /**
+   * IR-5: Creates a list parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param itemType - Optional element type; omitted when not provided
+   * @param desc - Optional description
+   * @returns RillParam with type 'list' (with element if itemType provided)
+   */
+  list(name, itemType, desc) {
+    validateParamName(name);
+    const type = itemType !== void 0 ? { type: "list", element: itemType } : { type: "list" };
+    return {
+      name,
+      type,
+      defaultValue: void 0,
+      annotations: buildAnnotations(desc)
+    };
+  },
+  /**
+   * IR-6: Creates a callable parameter descriptor.
+   *
+   * @param name - Parameter name (must be a valid identifier)
+   * @param desc - Optional description
+   * @returns RillParam with type 'closure'
+   */
+  callable(name, desc) {
+    validateParamName(name);
+    return {
+      name,
+      type: { type: "closure" },
+      defaultValue: void 0,
+      annotations: buildAnnotations(desc)
+    };
+  }
+};
+
+// src/factory.ts
+var DEFAULT_BINARY_PATH = "claude";
+var DEFAULT_TIMEOUT = 18e5;
+var MAX_TIMEOUT = 36e5;
+function serializeArgsToFlags(args) {
+  const flags = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (value === true) {
+      flags.push(`--${key}`);
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const nested = value;
+      for (const [nestedKey, nestedValue] of Object.entries(nested)) {
+        flags.push(`--${key}.${nestedKey}`, String(nestedValue));
+      }
+    } else {
+      flags.push(`--${key}`, String(value));
+    }
+  }
+  return flags;
+}
+function truncateText(text, maxLength = 100) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength) + "...";
+}
+function validateTimeout(timeout) {
+  if (!Number.isInteger(timeout)) {
+    throw new Error("Invalid timeout: must be positive integer, max 3600000");
+  }
+  if (timeout <= 0) {
+    throw new Error("Invalid timeout: must be positive integer, max 3600000");
+  }
+  if (timeout > MAX_TIMEOUT) {
+    throw new Error("Invalid timeout: must be positive integer, max 3600000");
+  }
+}
+function createClaudeCodeExtension(config = {}) {
+  const binaryPath = config.binaryPath ?? DEFAULT_BINARY_PATH;
+  const defaultTimeout = config.defaultTimeout ?? DEFAULT_TIMEOUT;
+  const dangerouslySkipPermissions = config.dangerouslySkipPermissions ?? true;
+  const settingSources = config.settingSources ?? "";
+  validateTimeout(defaultTimeout);
+  try {
+    which.sync(binaryPath);
+  } catch {
+    throw new Error(`Binary not found: ${binaryPath}`);
+  }
+  const tracker = {
+    disposers: /* @__PURE__ */ new Set()
+  };
+  const dispose = () => {
+    for (const disposer of tracker.disposers) {
+      try {
+        disposer();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.warn(`Failed to cleanup process: ${message}`);
+      }
+    }
+    tracker.disposers.clear();
+  };
+  const result = {
+    // IR-2: claude-code::prompt
+    prompt: {
+      params: [
+        p.str("text"),
+        p.dict("options", void 0, {})
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const text = args[0];
+          const options = args[1] ?? {};
+          if (text.trim().length === 0) {
+            throw new RuntimeError3("RILL-R004", "prompt text cannot be empty");
+          }
+          const timeout = typeof options["timeout"] === "number" ? options["timeout"] : defaultTimeout;
+          const spawn2 = spawnClaudeCli(text, {
+            binaryPath,
+            timeoutMs: timeout,
+            dangerouslySkipPermissions,
+            settingSources
+          });
+          tracker.disposers.add(spawn2.dispose);
+          const parser = createStreamParser();
+          const messages = [];
+          spawn2.ptyProcess.onData((chunk) => {
+            parser.processChunk(chunk, (msg) => messages.push(msg));
+          });
+          try {
+            await spawn2.exitCode;
+            parser.flush((msg) => messages.push(msg));
+          } finally {
+            tracker.disposers.delete(spawn2.dispose);
+            spawn2.dispose();
+          }
+          const result2 = extractResult(messages);
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:prompt",
+            subsystem: "extension:claude-code",
+            prompt: truncateText(text),
+            duration
+          });
+          return {
+            ...result2,
+            tokens: { ...result2.tokens }
+          };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:error",
+            subsystem: "extension:claude-code",
+            error: error instanceof Error ? error.message : "Unknown error",
+            duration
+          });
+          throw error;
+        }
+      },
+      description: "Execute Claude Code prompt and return result text and token usage",
+      returnType: { type: "dict" }
+    },
+    // IR-3: claude-code::skill
+    skill: {
+      params: [
+        p.str("name"),
+        p.dict("args", void 0, {})
+      ],
+      fn: async (fnArgs, ctx) => {
+        const startTime = Date.now();
+        try {
+          const name = fnArgs[0];
+          const args = fnArgs[1] ?? {};
+          if (name.trim().length === 0) {
+            throw new RuntimeError3("RILL-R004", "skill name cannot be empty");
+          }
+          const flags = serializeArgsToFlags(args);
+          const flagsText = flags.length > 0 ? " " + flags.join(" ") : "";
+          const prompt = `/${name}${flagsText}`;
+          const timeout = typeof args["timeout"] === "number" ? args["timeout"] : defaultTimeout;
+          const spawn2 = spawnClaudeCli(prompt, {
+            binaryPath,
+            timeoutMs: timeout,
+            dangerouslySkipPermissions,
+            settingSources
+          });
+          tracker.disposers.add(spawn2.dispose);
+          const parser = createStreamParser();
+          const messages = [];
+          spawn2.ptyProcess.onData((chunk) => {
+            parser.processChunk(chunk, (msg) => messages.push(msg));
+          });
+          try {
+            await spawn2.exitCode;
+            parser.flush((msg) => messages.push(msg));
+          } finally {
+            tracker.disposers.delete(spawn2.dispose);
+            spawn2.dispose();
+          }
+          const result2 = extractResult(messages);
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:skill",
+            subsystem: "extension:claude-code",
+            name,
+            args,
+            duration
+          });
+          return {
+            ...result2,
+            tokens: { ...result2.tokens }
+          };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:error",
+            subsystem: "extension:claude-code",
+            error: error instanceof Error ? error.message : "Unknown error",
+            duration
+          });
+          throw error;
+        }
+      },
+      description: "Execute Claude Code skill with instruction and return structured result",
+      returnType: { type: "dict" }
+    },
+    // IR-4: claude-code::command
+    command: {
+      params: [
+        p.str("name"),
+        p.dict("args", void 0, {})
+      ],
+      fn: async (fnArgs, ctx) => {
+        const startTime = Date.now();
+        try {
+          const name = fnArgs[0];
+          const args = fnArgs[1] ?? {};
+          if (name.trim().length === 0) {
+            throw new RuntimeError3("RILL-R004", "command name cannot be empty");
+          }
+          const flags = serializeArgsToFlags(args);
+          const flagsText = flags.length > 0 ? " " + flags.join(" ") : "";
+          const prompt = `/${name}${flagsText}`;
+          const timeout = typeof args["timeout"] === "number" ? args["timeout"] : defaultTimeout;
+          const spawn2 = spawnClaudeCli(prompt, {
+            binaryPath,
+            timeoutMs: timeout,
+            dangerouslySkipPermissions,
+            settingSources
+          });
+          tracker.disposers.add(spawn2.dispose);
+          const parser = createStreamParser();
+          const messages = [];
+          spawn2.ptyProcess.onData((chunk) => {
+            parser.processChunk(chunk, (msg) => messages.push(msg));
+          });
+          try {
+            await spawn2.exitCode;
+            parser.flush((msg) => messages.push(msg));
+          } finally {
+            tracker.disposers.delete(spawn2.dispose);
+            spawn2.dispose();
+          }
+          const result2 = extractResult(messages);
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:command",
+            subsystem: "extension:claude-code",
+            name,
+            args,
+            duration
+          });
+          return {
+            ...result2,
+            tokens: { ...result2.tokens }
+          };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "claude-code:error",
+            subsystem: "extension:claude-code",
+            error: error instanceof Error ? error.message : "Unknown error",
+            duration
+          });
+          throw error;
+        }
+      },
+      description: "Execute Claude Code command with task description and return execution summary",
+      returnType: { type: "dict" }
+    }
+  };
+  result.dispose = dispose;
+  return result;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var configSchema = {
+  binaryPath: { type: "string" },
+  defaultTimeout: { type: "number" },
+  dangerouslySkipPermissions: { type: "boolean" },
+  settingSources: { type: "string" }
+};
+export {
+  VERSION,
+  configSchema,
+  createClaudeCodeExtension,
+  createStreamParser,
+  extractResult,
+  spawnClaudeCli
+};