cueclaw 0.0.3 → 0.1.0

package/dist/chunk-WE5J7GMR.js

@@ -0,0 +1,409 @@
+import {
+  createAnthropicClient
+} from "./chunk-DVQFSFIZ.js";
+import {
+  getConfiguredSecretKeys
+} from "./chunk-ZCK3IFLC.js";
+import {
+  PlannerError
+} from "./chunk-BVQG3WYO.js";
+import {
+  logger
+} from "./chunk-QBOYMF4A.js";
+
+// src/planner.ts
+import { z } from "zod/v4";
+import { nanoid } from "nanoid";
+
+// src/workflow.ts
+function validateDAG(steps) {
+  const errors = [];
+  const stepIds = new Set(steps.map((s) => s.id));
+  for (const step of steps) {
+    for (const dep of step.depends_on) {
+      if (!stepIds.has(dep)) {
+        errors.push(`Step "${step.id}" depends on unknown step "${dep}"`);
+      }
+    }
+  }
+  for (const step of steps) {
+    const refs = extractStepRefs(step.inputs);
+    for (const ref of refs) {
+      if (!stepIds.has(ref)) {
+        errors.push(`Step "${step.id}" references unknown step "${ref}" in inputs`);
+      }
+      if (stepIds.has(ref) && !step.depends_on.includes(ref)) {
+        errors.push(`Step "${step.id}" references "$steps.${ref}.output" but does not list "${ref}" in depends_on`);
+      }
+    }
+  }
+  if (hasCycle(steps)) {
+    errors.push("DAG contains a cycle");
+  }
+  return errors;
+}
+function extractStepRefs(obj) {
+  const refs = [];
+  const pattern = /\$steps\.([a-z0-9-]+)\.output/g;
+  function walk(value) {
+    if (typeof value === "string") {
+      let match;
+      while ((match = pattern.exec(value)) !== null) {
+        refs.push(match[1]);
+      }
+      pattern.lastIndex = 0;
+    } else if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+    } else if (value !== null && typeof value === "object") {
+      for (const v of Object.values(value)) walk(v);
+    }
+  }
+  walk(obj);
+  return refs;
+}
+function hasCycle(steps) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    inDegree.set(step.id, 0);
+    adjacency.set(step.id, []);
+  }
+  for (const step of steps) {
+    for (const dep of step.depends_on) {
+      if (adjacency.has(dep)) {
+        adjacency.get(dep).push(step.id);
+        inDegree.set(step.id, (inDegree.get(step.id) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) queue.push(id);
+  }
+  let processed = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    processed++;
+    for (const neighbor of adjacency.get(current) ?? []) {
+      const newDeg = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDeg);
+      if (newDeg === 0) queue.push(neighbor);
+    }
+  }
+  return processed !== steps.length;
+}
+
+// src/planner.ts
+var PlanStepSchema = z.object({
+  id: z.string(),
+  description: z.string(),
+  expected_output: z.string().optional(),
+  agent: z.literal("claude"),
+  inputs: z.record(z.string(), z.any()),
+  depends_on: z.array(z.string())
+});
+var TriggerConfigSchema = z.union([
+  z.object({
+    type: z.literal("poll"),
+    interval_seconds: z.number(),
+    check_script: z.string(),
+    diff_mode: z.enum(["new_items", "any_change"])
+  }),
+  z.object({
+    type: z.literal("cron"),
+    expression: z.string(),
+    timezone: z.string().optional()
+  }),
+  z.object({ type: z.literal("manual") })
+]);
+var FailurePolicySchema = z.object({
+  on_step_failure: z.enum(["stop", "skip_dependents", "ask_user"]),
+  max_retries: z.number(),
+  retry_delay_ms: z.number()
+});
+var PlannerOutputSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  trigger: TriggerConfigSchema,
+  steps: z.array(PlanStepSchema).min(1),
+  failure_policy: FailurePolicySchema
+});
+var plannerOutputJsonSchema = {
+  type: "object",
+  required: ["name", "description", "trigger", "steps", "failure_policy"],
+  properties: {
+    name: { type: "string", description: "Short workflow name" },
+    description: { type: "string", description: "User's original natural language description" },
+    trigger: {
+      type: "object",
+      description: "Trigger configuration",
+      properties: {
+        type: { type: "string", enum: ["poll", "cron", "manual"] },
+        interval_seconds: { type: "number" },
+        check_script: { type: "string" },
+        diff_mode: { type: "string", enum: ["new_items", "any_change"] },
+        expression: { type: "string" },
+        timezone: { type: "string" }
+      },
+      required: ["type"]
+    },
+    steps: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["id", "description", "agent", "inputs", "depends_on"],
+        properties: {
+          id: { type: "string", description: "kebab-case step ID" },
+          description: { type: "string", description: "Detailed step description for the agent" },
+          expected_output: { type: "string" },
+          agent: { type: "string", enum: ["claude"] },
+          inputs: { type: "object", description: "Step inputs, may use $steps.{id}.output or $trigger_data" },
+          depends_on: { type: "array", items: { type: "string" }, description: "Step IDs this step depends on" }
+        }
+      },
+      minItems: 1
+    },
+    failure_policy: {
+      type: "object",
+      required: ["on_step_failure", "max_retries", "retry_delay_ms"],
+      properties: {
+        on_step_failure: { type: "string", enum: ["stop", "skip_dependents", "ask_user"] },
+        max_retries: { type: "number" },
+        retry_delay_ms: { type: "number" }
+      }
+    }
+  }
+};
+var plannerTool = {
+  name: "create_workflow",
+  description: "Create a workflow definition from the user description. Generate steps as a DAG with proper dependencies.",
+  input_schema: plannerOutputJsonSchema
+};
+var askQuestionTool = {
+  name: "ask_question",
+  description: "Ask the user a clarifying question to gather more information before creating a workflow. Use this when the user description is ambiguous or missing key details such as trigger frequency, specific repositories, filters, output format, etc.",
+  input_schema: {
+    type: "object",
+    required: ["question"],
+    properties: {
+      question: { type: "string", description: "The question to ask the user" }
+    }
+  }
+};
+var setSecretTool = {
+  name: "set_secret",
+  description: "Store a secret/credential provided by the user (e.g., API token, webhook URL). The value will be saved to the environment for use by workflow steps. Only call this after the user explicitly provides the secret value.",
+  input_schema: {
+    type: "object",
+    required: ["key", "value"],
+    properties: {
+      key: { type: "string", description: "Environment variable name in UPPER_SNAKE_CASE (e.g., GITHUB_TOKEN)" },
+      value: { type: "string", description: "The secret value provided by the user" }
+    }
+  }
+};
+function parsePlannerToolResponse(response) {
+  if (!response.content || !Array.isArray(response.content)) {
+    return { type: "error", error: "Unexpected API response: no content array" };
+  }
+  const askBlock = response.content.find((b) => b.type === "tool_use" && b.name === "ask_question");
+  if (askBlock && askBlock.type === "tool_use") {
+    const question = askBlock.input?.question;
+    return { type: "question", question: question ?? "Could you provide more details?" };
+  }
+  const secretBlock = response.content.find((b) => b.type === "tool_use" && b.name === "set_secret");
+  if (secretBlock && secretBlock.type === "tool_use") {
+    const input = secretBlock.input;
+    return { type: "set_secret", key: input.key, value: input.value };
+  }
+  const toolBlock = response.content.find((b) => b.type === "tool_use" && b.name === "create_workflow");
+  if (toolBlock && toolBlock.type === "tool_use") {
+    const parseResult = PlannerOutputSchema.safeParse(toolBlock.input);
+    if (!parseResult.success) {
+      const errMsg = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { type: "error", error: `Invalid plan: ${errMsg}` };
+    }
+    const dagErrors = validateDAG(parseResult.data.steps);
+    if (dagErrors.length > 0) {
+      return { type: "error", error: `DAG validation failed: ${dagErrors.join(", ")}` };
+    }
+    return { type: "plan", plannerOutput: parseResult.data };
+  }
+  const textBlocks = response.content.filter((b) => b.type === "text");
+  if (textBlocks.length > 0) {
+    const text = textBlocks.map((b) => b.type === "text" ? b.text : "").join("\n");
+    return { type: "text", text };
+  }
+  return { type: "error", error: "Unexpected planner response format" };
+}
+function buildPlannerSystemPrompt(config) {
+  const identity = config.identity?.name ? `
+User identity: ${config.identity.name}` : "";
+  return `You are CueClaw Planner. Convert user's natural language into a structured Workflow.
+
+## Execution Environment
+
+All steps are executed by the Claude Agent SDK. The agent has Bash and can use
+any CLI tool installed locally. It auto-loads .claude/skills/.
+You don't need to verify tool availability \u2014 the agent detects at runtime.
+
+## Rules
+
+1. Every step's agent field is "claude" (Claude Agent SDK execution)
+2. Step description uses natural language \u2014 the agent decides which tools to use
+3. depends_on must reference defined step IDs, forming a valid DAG (no cycles)
+4. Step IDs use kebab-case: "fetch-issues", "create-branch"
+5. Use $steps.{id}.output in inputs to reference prior step results
+6. Use $trigger_data in inputs to reference the trigger's output data
+7. Do NOT generate position, phase, schema_version, status, or timestamp fields (framework auto-fills). You MUST generate step id fields.
+8. Trigger check_script can use any shell commands
+9. Step description should be detailed enough for the agent to execute independently \u2014 not just a one-line summary
+10. Input keys use snake_case (e.g., issue_number, repo_path)
+11. Steps must NOT include a status field \u2014 the framework sets all steps to pending automatically
+12. Step output is a plain text string \u2014 downstream agents parse structure themselves
+
+## Available Credentials
+
+${(() => {
+    const keys = getConfiguredSecretKeys();
+    if (keys.length > 0) {
+      return `The following credentials are configured: ${keys.join(", ")}
+You can reference these in workflow steps \u2014 they are available as environment variables.`;
+    }
+    return "No credentials are currently configured.";
+  })()}
+
+If a workflow needs credentials not listed above, use the set_secret tool to store them after the user provides the value. Never invent or guess secret values.
+
+## User Identity
+${identity}`;
+}
+async function generatePlan(userDescription, config) {
+  const anthropic = createAnthropicClient(config);
+  const MAX_RETRIES = 2;
+  let retryContext = "";
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const prompt = retryContext ? `${userDescription}
+
+${retryContext}` : userDescription;
+    logger.debug({ attempt, hasRetryContext: !!retryContext }, "Planner attempt");
+    let response;
+    try {
+      response = await anthropic.messages.create({
+        model: config.claude.planner.model,
+        max_tokens: 4096,
+        system: buildPlannerSystemPrompt(config),
+        messages: [{ role: "user", content: prompt }],
+        tools: [plannerTool],
+        tool_choice: { type: "tool", name: "create_workflow" }
+      });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new PlannerError(
+        `API request failed: ${detail}. Check your API key and base_url in ~/.cueclaw/config.yaml`
+      );
+    }
+    const rawResponse = response;
+    if (rawResponse.type === "error" || rawResponse.error) {
+      const errMsg = rawResponse.error?.message ?? JSON.stringify(rawResponse.error ?? rawResponse);
+      throw new PlannerError(`API error: ${errMsg}`);
+    }
+    if (!response.content || !Array.isArray(response.content)) {
+      logger.debug({ response: JSON.stringify(response).slice(0, 500) }, "Unexpected API response shape");
+      throw new PlannerError(
+        `Unexpected API response (no content array). This may indicate an issue with your API provider. Response: ${JSON.stringify(response).slice(0, 200)}`
+      );
+    }
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (!toolBlock || toolBlock.type !== "tool_use") {
+      throw new PlannerError("Unexpected planner response format: no tool_use block");
+    }
+    const parseResult = PlannerOutputSchema.safeParse(toolBlock.input);
+    if (!parseResult.success) {
+      const errMsg = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      if (attempt < MAX_RETRIES) {
+        retryContext = `[System] Previous plan had validation issues:
+${errMsg}
+Please fix and try again.`;
+        continue;
+      }
+      throw new PlannerError(`Invalid plan after ${MAX_RETRIES + 1} attempts: ${errMsg}`);
+    }
+    const dagErrors = validateDAG(parseResult.data.steps);
+    if (dagErrors.length > 0) {
+      if (attempt < MAX_RETRIES) {
+        retryContext = `[System] DAG dependency issues:
+${dagErrors.join("\n")}
+Please fix the step dependencies.`;
+        continue;
+      }
+      throw new PlannerError(`DAG validation failed after ${MAX_RETRIES + 1} attempts: ${dagErrors.join(", ")}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      ...parseResult.data,
+      schema_version: "1.0",
+      id: `wf_${nanoid()}`,
+      phase: "awaiting_confirmation",
+      created_at: now,
+      updated_at: now
+    };
+  }
+  throw new PlannerError("Failed to generate valid plan after retries");
+}
+async function modifyPlan(originalWorkflow, modificationDescription, config) {
+  const plannerOutput = {
+    name: originalWorkflow.name,
+    description: originalWorkflow.description,
+    trigger: originalWorkflow.trigger,
+    steps: originalWorkflow.steps,
+    failure_policy: originalWorkflow.failure_policy
+  };
+  const combinedPrompt = `Here is the current workflow plan:
+\`\`\`json
+${JSON.stringify(plannerOutput, null, 2)}
+\`\`\`
+
+The user wants to modify it as follows:
+${modificationDescription}
+
+Preserve unmodified steps' IDs, descriptions, and dependencies \u2014 only change what the user specified.
+Return the complete modified workflow using the create_workflow tool.`;
+  const result = await generatePlan(combinedPrompt, config);
+  return {
+    ...result,
+    id: originalWorkflow.id,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function confirmPlan(workflow) {
+  if (workflow.phase !== "awaiting_confirmation") {
+    throw new PlannerError(`Cannot confirm workflow in phase "${workflow.phase}"`);
+  }
+  const nextPhase = workflow.trigger.type === "manual" ? "executing" : "active";
+  return {
+    ...workflow,
+    phase: nextPhase,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function rejectPlan(workflow) {
+  return {
+    ...workflow,
+    phase: "planning",
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+export {
+  PlannerOutputSchema,
+  plannerTool,
+  askQuestionTool,
+  setSecretTool,
+  parsePlannerToolResponse,
+  buildPlannerSystemPrompt,
+  generatePlan,
+  modifyPlan,
+  confirmPlan,
+  rejectPlan
+};

package/dist/chunk-ZCK3IFLC.js

@@ -0,0 +1,59 @@
+// src/env.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parse } from "dotenv";
+var secrets = {};
+var isDev = !import.meta.url.includes("/dist/");
+function loadSecrets() {
+  if (!isDev) return;
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const envPath = resolve(thisDir, "..", ".env");
+  if (!existsSync(envPath)) return;
+  const content = readFileSync(envPath, "utf-8");
+  secrets = parse(content);
+  for (const [key, value] of Object.entries(secrets)) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function getSecret(key) {
+  return secrets[key] ?? process.env[key];
+}
+function hasSecret(key) {
+  return getSecret(key) !== void 0;
+}
+function getConfiguredSecretKeys() {
+  const patterns = [/_TOKEN$/, /_API_KEY$/, /_SECRET$/, /_WEBHOOK/, /_PASSWORD$/];
+  return Object.keys(process.env).filter((k) => patterns.some((p) => p.test(k)) && process.env[k]).sort();
+}
+function writeEnvVar(key, value) {
+  if (!isDev) throw new Error("writeEnvVar should only be called in dev mode");
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const envPath = resolve(thisDir, "..", ".env");
+  let lines = [];
+  if (existsSync(envPath)) {
+    lines = readFileSync(envPath, "utf-8").split("\n");
+  }
+  const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+  const entry = `${key}=${value}`;
+  if (idx >= 0) {
+    lines[idx] = entry;
+  } else {
+    lines.push(entry);
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  writeFileSync(envPath, lines.join("\n") + "\n", "utf-8");
+  process.env[key] = value;
+  secrets[key] = value;
+}
+
+export {
+  isDev,
+  loadSecrets,
+  getSecret,
+  hasSecret,
+  getConfiguredSecretKeys,
+  writeEnvVar
+};