@ryanfw/prompt-orchestration-pipeline 0.16.3 → 0.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server.js",

package/src/config/models.js

@@ -41,6 +41,11 @@ export const ModelAlias = Object.freeze({
   ANTHROPIC_SONNET_4_5: "anthropic:sonnet-4-5",
   ANTHROPIC_HAIKU_4_5: "anthropic:haiku-4-5",
   ANTHROPIC_OPUS_4_1: "anthropic:opus-4-1", // Legacy, still available
+
+  // Claude Code (subscription-based, uses CLI)
+  CLAUDE_CODE_SONNET: "claudecode:sonnet",
+  CLAUDE_CODE_OPUS: "claudecode:opus",
+  CLAUDE_CODE_HAIKU: "claudecode:haiku",
 });
 
 // Consolidated model configuration with pricing metadata
@@ -199,6 +204,27 @@ export const MODEL_CONFIG = Object.freeze({
     tokenCostInPerMillion: 15.0,
     tokenCostOutPerMillion: 75.0,
   },
+
+  // ─── Claude Code (Subscription) ───
+  // Uses existing Claude subscription via CLI, costs show $0.00
+  [ModelAlias.CLAUDE_CODE_SONNET]: {
+    provider: "claudecode",
+    model: "sonnet",
+    tokenCostInPerMillion: 0,
+    tokenCostOutPerMillion: 0,
+  },
+  [ModelAlias.CLAUDE_CODE_OPUS]: {
+    provider: "claudecode",
+    model: "opus",
+    tokenCostInPerMillion: 0,
+    tokenCostOutPerMillion: 0,
+  },
+  [ModelAlias.CLAUDE_CODE_HAIKU]: {
+    provider: "claudecode",
+    model: "haiku",
+    tokenCostInPerMillion: 0,
+    tokenCostOutPerMillion: 0,
+  },
 });
 
 // Validation set of all valid model aliases
@@ -211,6 +237,7 @@ export const DEFAULT_MODEL_BY_PROVIDER = Object.freeze({
   gemini: ModelAlias.GEMINI_3_FLASH, // Updated: Gemini 3 Flash is new default
   zhipu: ModelAlias.ZAI_GLM_4_6,
   anthropic: ModelAlias.ANTHROPIC_OPUS_4_5, // Updated: Opus 4.5 available at better price
+  claudecode: ModelAlias.CLAUDE_CODE_SONNET,
 });
 
 /**
@@ -351,4 +378,4 @@ if (
   throw new Error(
     "VALID_MODEL_ALIASES does not exactly match MODEL_CONFIG keys"
   );
-}
+}

package/src/llm/index.js

@@ -3,6 +3,10 @@ import { deepseekChat } from "../providers/deepseek.js";
 import { anthropicChat } from "../providers/anthropic.js";
 import { geminiChat } from "../providers/gemini.js";
 import { zhipuChat } from "../providers/zhipu.js";
+import {
+  claudeCodeChat,
+  isClaudeCodeAvailable,
+} from "../providers/claude-code.js";
 import { EventEmitter } from "node:events";
 import { getConfig } from "../core/config.js";
 import {
@@ -57,6 +61,7 @@ export function getAvailableProviders() {
     anthropic: !!process.env.ANTHROPIC_API_KEY,
     gemini: !!process.env.GEMINI_API_KEY,
     zhipu: !!process.env.ZHIPU_API_KEY,
+    claudecode: isClaudeCodeAvailable(),
     mock: !!mockProviderInstance,
   };
 }
@@ -524,6 +529,59 @@ export async function chat(options) {
           totalTokens: promptTokens + completionTokens,
         };
       }
+    } else if (provider === "claudecode") {
+      logger.log("Using Claude Code provider");
+      const defaultAlias = DEFAULT_MODEL_BY_PROVIDER["claudecode"];
+      const defaultModelConfig = MODEL_CONFIG[defaultAlias];
+      const defaultModel = defaultModelConfig?.model;
+
+      const claudeCodeArgs = {
+        messages,
+        model: model || defaultModel,
+        maxTokens,
+        ...rest,
+      };
+      logger.log("Claude Code call parameters:", {
+        model: claudeCodeArgs.model,
+        hasMessages: !!claudeCodeArgs.messages,
+        messageCount: claudeCodeArgs.messages?.length,
+      });
+      if (responseFormat !== undefined) {
+        claudeCodeArgs.responseFormat = responseFormat;
+      }
+
+      logger.log("Calling claudeCodeChat()...");
+      const result = await claudeCodeChat(claudeCodeArgs);
+      logger.log("claudeCodeChat() returned:", {
+        hasResult: !!result,
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
+
+      response = {
+        content: result.content,
+        raw: result.raw,
+      };
+
+      // Claude Code returns $0 for subscription users
+      if (result?.usage) {
+        const { prompt_tokens, completion_tokens, total_tokens } = result.usage;
+        usage = {
+          promptTokens: prompt_tokens,
+          completionTokens: completion_tokens,
+          totalTokens: total_tokens,
+        };
+      } else {
+        const promptTokens = estimateTokens(systemMsg + userMsg);
+        const completionTokens = estimateTokens(
+          typeof result === "string" ? result : JSON.stringify(result)
+        );
+        usage = {
+          promptTokens,
+          completionTokens,
+          totalTokens: promptTokens + completionTokens,
+        };
+      }
     } else {
       logger.error("Unknown provider:", provider);
       throw new Error(`Provider ${provider} not yet implemented`);
@@ -804,4 +862,4 @@ export function createHighLevelLLM(options = {}) {
     // Include provider-grouped functions for backward compatibility
     ...providerFunctions,
   };
-}
+}

package/src/providers/claude-code.js

@@ -0,0 +1,156 @@
+import { spawn, spawnSync } from "child_process";
+import {
+  extractMessages,
+  isRetryableError,
+  sleep,
+  stripMarkdownFences,
+  tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
+} from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("ClaudeCode");
+
+/**
+ * Check if Claude Code CLI is available
+ * @returns {boolean}
+ */
+export function isClaudeCodeAvailable() {
+  try {
+    const result = spawnSync("claude", ["--version"], {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Chat with Claude via the Claude Code CLI
+ * @param {Object} options
+ * @param {Array} options.messages - Array of message objects with role and content
+ * @param {string} [options.model="sonnet"] - Model name: sonnet, opus, or haiku
+ * @param {number} [options.maxTokens] - Maximum tokens in response
+ * @param {number} [options.maxTurns=1] - Maximum conversation turns
+ * @param {string} [options.responseFormat="json"] - Response format
+ * @param {number} [options.maxRetries=3] - Maximum retry attempts
+ * @returns {Promise<{content: any, text: string, usage: Object, raw: any}>}
+ */
+export async function claudeCodeChat({
+  messages,
+  model = "sonnet",
+  maxTokens,
+  maxTurns = 1,
+  responseFormat = "json",
+  maxRetries = 3,
+}) {
+  ensureJsonResponseFormat(responseFormat, "ClaudeCode");
+
+  const { systemMsg, userMsg } = extractMessages(messages);
+
+  const args = [
+    "-p",
+    userMsg,
+    "--output-format",
+    "json",
+    "--model",
+    model,
+    "--max-turns",
+    String(maxTurns),
+  ];
+
+  if (systemMsg) {
+    args.push("--system-prompt", systemMsg);
+  }
+
+  if (maxTokens) {
+    args.push("--max-tokens", String(maxTokens));
+  }
+
+  logger.log("Spawning claude CLI", { model, argsCount: args.length });
+
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await spawnClaude(args);
+      return parseClaudeResponse(result, model);
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries && isRetryableError(err)) {
+        const delay = Math.pow(2, attempt) * 1000;
+        logger.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+        await sleep(delay);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError;
+}
+
+/**
+ * Spawn the claude CLI and collect output
+ * @param {string[]} args - CLI arguments
+ * @returns {Promise<string>} - stdout content
+ */
+function spawnClaude(args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn claude CLI: ${err.message}`));
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout);
+      } else {
+        reject(new Error(`claude CLI exited with code ${code}: ${stderr}`));
+      }
+    });
+  });
+}
+
+/**
+ * Parse the JSON response from Claude CLI
+ * @param {string} stdout - Raw stdout from CLI
+ * @param {string} model - Model name for error reporting
+ * @returns {{content: any, text: string, usage: Object, raw: any}}
+ */
+function parseClaudeResponse(stdout, model) {
+  const jsonResponse = tryParseJSON(stdout);
+  if (!jsonResponse) {
+    throw new ProviderJsonParseError(
+      "claudecode",
+      model,
+      stdout.slice(0, 200),
+      "Failed to parse Claude CLI JSON response"
+    );
+  }
+
+  // Extract text content from response
+  const rawText = jsonResponse.result ?? jsonResponse.text ?? "";
+  const cleanedText = stripMarkdownFences(rawText);
+  const parsed = tryParseJSON(cleanedText) ?? cleanedText;
+
+  return {
+    content: parsed,
+    text: rawText,
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    raw: jsonResponse,
+  };
+}

package/src/ui/endpoints/task-save-endpoint.js

@@ -76,27 +76,62 @@ export async function handleTaskSave(req, res) {
     const indexPath = taskRegistryPath;
     let indexContent = await fs.readFile(indexPath, "utf8");
 
-    // Check if task name already exists in the index
-    const taskNamePattern = new RegExp(`^\\s*${taskName}\\s*:`, "m");
+    // Check if task name already exists in the index (handles both quoted and unquoted)
+    const taskNamePattern = new RegExp(`^\\s*"?${taskName}"?\\s*:`, "m");
     if (taskNamePattern.test(indexContent)) {
       return sendJson(res, 400, {
         error: `Task "${taskName}" already exists in the registry`,
       });
     }
 
-    // Find the line containing "export default {"
-    const exportLine = "export default {";
-    const exportLineIndex = indexContent.indexOf(exportLine);
-
-    if (exportLineIndex === -1) {
+    // Detect module format: ESM (export default {) or CommonJS (module.exports = {)
+    const esmPattern = /export\s+default\s+\{/;
+    const cjsPattern = /module\.exports\s*=\s*\{/;
+    const cjsTasksPattern = /module\.exports\s*=\s*\{\s*tasks\s*:\s*\{/;
+
+    let insertPosition;
+    let exportMatch;
+    let isNestedCjs = false;
+
+    if (esmPattern.test(indexContent)) {
+      // ESM format: export default { ... }
+      exportMatch = indexContent.match(esmPattern);
+      insertPosition = indexContent.indexOf("\n", exportMatch.index) + 1;
+    } else if (cjsTasksPattern.test(indexContent)) {
+      // CommonJS with nested tasks: module.exports = { tasks: { ... } }
+      exportMatch = indexContent.match(cjsTasksPattern);
+      insertPosition = exportMatch.index + exportMatch[0].length;
+      isNestedCjs = true;
+    } else if (cjsPattern.test(indexContent)) {
+      // CommonJS flat: module.exports = { ... }
+      exportMatch = indexContent.match(cjsPattern);
+      insertPosition = indexContent.indexOf("\n", exportMatch.index) + 1;
+    } else {
       return sendJson(res, 500, {
-        error: "Failed to find export default line in index.js",
+        error:
+          "Failed to find export pattern in index.js (expected 'export default {' or 'module.exports = {')",
       });
     }
 
-    // Insert new task entry after the export line
-    const insertPosition = indexContent.indexOf("\n", exportLineIndex) + 1;
-    const newEntry = `  ${taskName}: "./${filename}",\n`;
+    // Insert new task entry after the opening brace line
+    // For nested CommonJS, check if we need to add newline to expand single-line format
+    let newEntry;
+    if (isNestedCjs) {
+      // Check if the tasks object already spans multiple lines
+      // (i.e., has whitespace and a newline after "tasks: {")
+      const remainingContent = indexContent.slice(insertPosition);
+      const whitespaceMatch = remainingContent.match(/^\s*\n/);
+      if (whitespaceMatch) {
+        // Multi-line format: skip whitespace and newline, insert at next position
+        insertPosition += whitespaceMatch[0].length;
+        newEntry = `  ${taskName}: "./${filename}",\n`;
+      } else {
+        // Single-line format: add newline to expand it
+        newEntry = `\n  ${taskName}: "./${filename}",\n`;
+      }
+    } else {
+      newEntry = `  ${taskName}: "./${filename}",\n`;
+    }
 
     indexContent =
       indexContent.slice(0, insertPosition) +
@@ -116,4 +151,4 @@ export async function handleTaskSave(req, res) {
       error: error.message || "Failed to create task",
     });
   }
-}
+}