npm - @contextgraph/agent - Versions diffs - 0.4.0 - Mend

@contextgraph/agent 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/.claude/settings.local.json +32 -0
package/CHANGELOG.md +32 -0
package/README.md +258 -0
package/dist/index.d.ts +2 -0
package/dist/index.js +1793 -0
package/dist/index.js.map +1 -0
package/examples/completion-extraction.ts +243 -0
package/package.json +47 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1793 @@
+#!/usr/bin/env node
+// src/cli/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join4 } from "path";
+// src/callback-server.ts
+import http from "http";
+import { URL } from "url";
+var MIN_PORT = 3e3;
+var MAX_PORT = 3100;
+async function findFreePort() {
+  for (let port = MIN_PORT; port <= MAX_PORT; port++) {
+    const isAvailable = await checkPortAvailable(port);
+    if (isAvailable) {
+      return port;
+    }
+  }
+  throw new Error(`No free ports found between ${MIN_PORT} and ${MAX_PORT}`);
+}
+function checkPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+}
+async function startCallbackServer() {
+  const port = await findFreePort();
+  let callbackResolve = null;
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    if (url.pathname === "/callback") {
+      const token = url.searchParams.get("token");
+      const userId = url.searchParams.get("userId");
+      if (!token) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(getErrorPage("Missing token parameter"));
+        return;
+      }
+      if (!userId) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(getErrorPage("Missing userId parameter"));
+        return;
+      }
+      if (callbackResolve) {
+        callbackResolve({ token, userId });
+      }
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getSuccessPage());
+    } else {
+      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getNotFoundPage());
+    }
+  });
+  await new Promise((resolve) => {
+    server.listen(port, resolve);
+  });
+  return {
+    port,
+    waitForCallback: () => {
+      return new Promise((resolve) => {
+        callbackResolve = resolve;
+      });
+    },
+    close: () => {
+      return new Promise((resolve, reject) => {
+        server.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+  };
+}
+function getSuccessPage() {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Authentication Successful</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    }
+    .container {
+      background: white;
+      padding: 3rem;
+      border-radius: 1rem;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      text-align: center;
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      color: #667eea;
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      color: #666;
+      margin: 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2705</div>
+    <h1>Authentication successful!</h1>
+    <p>You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+function getErrorPage(message) {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Authentication Error</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    }
+    .container {
+      background: white;
+      padding: 3rem;
+      border-radius: 1rem;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      text-align: center;
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      color: #f5576c;
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      color: #666;
+      margin: 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u274C</div>
+    <h1>Authentication error</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+function getNotFoundPage() {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Not Found</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #f0f0f0;
+    }
+    .container {
+      background: white;
+      padding: 3rem;
+      border-radius: 1rem;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+      text-align: center;
+      max-width: 400px;
+    }
+    h1 {
+      color: #666;
+      margin: 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>404 Not Found</h1>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+// src/credentials.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+function getCredentialsDir() {
+  return process.env.CONTEXTGRAPH_CREDENTIALS_DIR || path.join(os.homedir(), ".contextgraph");
+}
+function getCredentialsPath() {
+  return path.join(getCredentialsDir(), "credentials.json");
+}
+var CREDENTIALS_DIR = getCredentialsDir();
+var CREDENTIALS_PATH = getCredentialsPath();
+async function saveCredentials(credentials) {
+  const dir = getCredentialsDir();
+  const filePath = getCredentialsPath();
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const content = JSON.stringify(credentials, null, 2);
+  await fs.writeFile(filePath, content, { mode: 384 });
+}
+async function loadCredentials() {
+  const apiToken = process.env.CONTEXTGRAPH_API_TOKEN;
+  if (apiToken) {
+    const farFuture = new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toISOString();
+    return {
+      clerkToken: apiToken,
+      userId: "api-token-user",
+      // Placeholder - server will resolve actual user
+      expiresAt: farFuture,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const filePath = getCredentialsPath();
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    console.error("Error loading credentials:", error);
+    return null;
+  }
+}
+function isExpired(credentials) {
+  return new Date(credentials.expiresAt) <= /* @__PURE__ */ new Date();
+}
+function isTokenExpired(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return false;
+    }
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const now = Math.floor(Date.now() / 1e3);
+    if (!payload.exp) {
+      return true;
+    }
+    if (payload.exp <= now) {
+      return true;
+    }
+    if (payload.nbf && payload.nbf > now) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+// src/auth-flow.ts
+var DEFAULT_TIMEOUT = 5 * 60 * 1e3;
+var DEFAULT_BASE_URL = "https://www.contextgraph.dev";
+async function defaultOpenBrowser(url) {
+  const open = (await import("open")).default;
+  await open(url);
+}
+async function authenticateAgent(options = {}) {
+  const {
+    baseUrl = DEFAULT_BASE_URL,
+    timeout = DEFAULT_TIMEOUT,
+    openBrowser = defaultOpenBrowser
+  } = options;
+  let server;
+  try {
+    server = await startCallbackServer();
+    const { port, waitForCallback, close } = server;
+    const authUrl = `${baseUrl}/auth/cli-callback?port=${port}`;
+    console.log(`Opening browser to: ${authUrl}`);
+    await openBrowser(authUrl);
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Authentication timeout")), timeout);
+    });
+    const result = await Promise.race([waitForCallback(), timeoutPromise]);
+    const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+    await saveCredentials({
+      clerkToken: result.token,
+      userId: result.userId,
+      expiresAt,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await close();
+    return {
+      success: true,
+      credentials: {
+        token: result.token,
+        userId: result.userId
+      }
+    };
+  } catch (error) {
+    if (server) {
+      await server.close();
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+// src/workflows/auth.ts
+async function runAuth() {
+  console.log("Starting authentication flow...\n");
+  const result = await authenticateAgent();
+  if (result.success) {
+    console.log("\n\u2705 Authentication successful!");
+    console.log(`User ID: ${result.credentials.userId}`);
+  } else {
+    console.error("\n\u274C Authentication failed:", result.error);
+    process.exit(1);
+  }
+}
+// src/claude-sdk.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+// src/plugin-setup.ts
+import { spawn } from "child_process";
+import { access, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var PLUGIN_REPO = "https://github.com/contextgraph/claude-code-plugin.git";
+var PLUGIN_DIR = join(homedir(), ".contextgraph", "claude-code-plugin");
+var PLUGIN_PATH = join(PLUGIN_DIR, "plugins", "contextgraph");
+async function ensurePlugin() {
+  try {
+    await access(PLUGIN_PATH);
+    console.log(`\u{1F4E6} Using plugin: ${PLUGIN_PATH}`);
+    return PLUGIN_PATH;
+  } catch {
+  }
+  let repoDirExists = false;
+  try {
+    await access(PLUGIN_DIR);
+    repoDirExists = true;
+  } catch {
+  }
+  if (repoDirExists) {
+    console.log("\u{1F4E6} Plugin directory exists but incomplete, pulling latest...");
+    await runCommand("git", ["pull"], PLUGIN_DIR);
+    try {
+      await access(PLUGIN_PATH);
+      console.log(`\u{1F4E6} Plugin ready: ${PLUGIN_PATH}`);
+      return PLUGIN_PATH;
+    } catch {
+      throw new Error(`Plugin not found at ${PLUGIN_PATH} even after git pull. Check repository structure.`);
+    }
+  }
+  console.log(`\u{1F4E6} Cloning plugin from ${PLUGIN_REPO}...`);
+  const contextgraphDir = join(homedir(), ".contextgraph");
+  try {
+    await mkdir(contextgraphDir, { recursive: true });
+  } catch {
+  }
+  await runCommand("git", ["clone", PLUGIN_REPO, PLUGIN_DIR]);
+  try {
+    await access(PLUGIN_PATH);
+    console.log(`\u{1F4E6} Plugin installed: ${PLUGIN_PATH}`);
+    return PLUGIN_PATH;
+  } catch {
+    throw new Error(`Plugin clone succeeded but plugin path not found at ${PLUGIN_PATH}`);
+  }
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, { cwd, stdio: "inherit" });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args[0]} failed with exit code ${code}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn ${command}: ${err.message}`));
+    });
+  });
+}
+// src/sdk-event-transformer.ts
+function transformSDKMessage(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  switch (message.type) {
+    case "system":
+      return transformSystemMessage(message, timestamp);
+    case "assistant":
+      return transformAssistantMessage(message, timestamp);
+    case "result":
+      return transformResultMessage(message, timestamp);
+    case "user":
+      return transformUserMessage(message, timestamp);
+    default:
+      return null;
+  }
+}
+function transformSystemMessage(message, timestamp) {
+  return {
+    eventType: "claude_message",
+    content: message.content || `System: ${message.subtype || "initialization"}`,
+    data: {
+      type: "system",
+      subtype: message.subtype,
+      content: message.content,
+      session_id: message.session_id
+    },
+    timestamp
+  };
+}
+function transformAssistantMessage(message, timestamp) {
+  const content = message.message?.content;
+  if (!content || !Array.isArray(content)) {
+    return null;
+  }
+  const contentSummary = generateContentSummary(content);
+  return {
+    eventType: "claude_message",
+    content: contentSummary,
+    data: {
+      type: "assistant",
+      message: message.message,
+      session_id: message.session_id,
+      parent_tool_use_id: message.parent_tool_use_id
+    },
+    timestamp
+  };
+}
+function transformResultMessage(message, timestamp) {
+  const isSuccess = message.subtype === "success";
+  const durationSec = message.duration_ms ? (message.duration_ms / 1e3).toFixed(1) : "unknown";
+  return {
+    eventType: "claude_message",
+    content: isSuccess ? `Completed successfully in ${durationSec}s` : `Execution ${message.subtype}: ${durationSec}s`,
+    data: {
+      type: "result",
+      subtype: message.subtype,
+      duration_ms: message.duration_ms,
+      total_cost_usd: message.total_cost_usd,
+      num_turns: message.num_turns,
+      usage: message.usage,
+      session_id: message.session_id
+    },
+    timestamp
+  };
+}
+function transformUserMessage(message, timestamp) {
+  const content = message.message?.content;
+  if (!content || !Array.isArray(content)) {
+    return null;
+  }
+  const hasToolResults = content.some(
+    (block) => block.type === "tool_result"
+  );
+  if (!hasToolResults) {
+    return null;
+  }
+  const summaries = content.filter((block) => block.type === "tool_result").map((block) => {
+    const prefix = block.is_error ? "\u274C" : "\u2713";
+    const resultText = extractToolResultText(block.content);
+    return `${prefix} ${resultText.substring(0, 100)}${resultText.length > 100 ? "..." : ""}`;
+  });
+  return {
+    eventType: "claude_message",
+    content: summaries.join("\n"),
+    data: {
+      type: "user",
+      message: message.message,
+      session_id: message.session_id
+    },
+    timestamp
+  };
+}
+function generateContentSummary(content) {
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      const text = block.text.length > 200 ? block.text.substring(0, 200) + "..." : block.text;
+      parts.push(text);
+    } else if (block.type === "tool_use") {
+      parts.push(`\u{1F527} ${block.name}`);
+    } else if (block.type === "thinking") {
+      parts.push("\u{1F4AD} [thinking]");
+    }
+  }
+  return parts.join(" | ") || "[no content]";
+}
+function extractToolResultText(content) {
+  if (!content) return "";
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.filter((block) => block.type === "text" && block.text).map((block) => block.text).join("\n");
+  }
+  return "";
+}
+// src/claude-sdk.ts
+var EXECUTION_TIMEOUT_MS = 20 * 60 * 1e3;
+var THINKING_TRUNCATE_LENGTH = 100;
+var COMMAND_TRUNCATE_LENGTH = 60;
+function formatToolUse(content) {
+  if (content.type === "tool_use") {
+    const name = content.name || "unknown";
+    const summary = formatToolInput(name, content.input);
+    return `  \u{1F527} ${name}${summary}`;
+  }
+  if (content.type === "thinking" && content.thinking) {
+    const truncated = content.thinking.length > THINKING_TRUNCATE_LENGTH ? content.thinking.substring(0, THINKING_TRUNCATE_LENGTH) + "..." : content.thinking;
+    return `  \u{1F4AD} ${truncated}`;
+  }
+  return "";
+}
+function formatToolInput(toolName, input) {
+  if (!input) return "";
+  switch (toolName) {
+    case "Read":
+      return `: ${input.file_path}`;
+    case "Edit":
+    case "Write":
+      return `: ${input.file_path}`;
+    case "Bash":
+      const cmd = input.command || "";
+      const truncated = cmd.length > COMMAND_TRUNCATE_LENGTH ? cmd.substring(0, COMMAND_TRUNCATE_LENGTH) + "..." : cmd;
+      return `: ${truncated}`;
+    case "Grep":
+      return `: "${input.pattern}"`;
+    case "Glob":
+      return `: ${input.pattern}`;
+    default:
+      return "";
+  }
+}
+function formatAssistantMessage(content) {
+  const lines = [];
+  for (const item of content) {
+    if (item.type === "text" && item.text) {
+      lines.push(`  ${item.text}`);
+    } else if (item.type === "tool_use" || item.type === "thinking") {
+      const formatted = formatToolUse(item);
+      if (formatted) lines.push(formatted);
+    }
+  }
+  return lines.join("\n");
+}
+function formatMessage(message) {
+  switch (message.type) {
+    case "system":
+      if (message.subtype === "init") {
+        return "\u{1F680} Claude session initialized";
+      }
+      return null;
+    case "assistant":
+      const assistantMsg = message;
+      if (assistantMsg.message?.content && Array.isArray(assistantMsg.message.content)) {
+        return formatAssistantMessage(assistantMsg.message.content);
+      }
+      return null;
+    case "result":
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        const duration = resultMsg.duration_ms ? `${(resultMsg.duration_ms / 1e3).toFixed(1)}s` : "unknown";
+        return `\u2705 Completed in ${duration}`;
+      } else if (resultMsg.subtype.startsWith("error_")) {
+        return "\u274C Execution failed";
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+async function executeClaude(options) {
+  let sessionId;
+  let totalCost = 0;
+  let usage;
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort();
+  }, EXECUTION_TIMEOUT_MS);
+  try {
+    const pluginPath = await ensurePlugin();
+    console.log("[Agent SDK] Loading plugin from:", pluginPath);
+    console.log("[Agent SDK] Auth token available:", !!options.authToken);
+    console.log("[Agent SDK] Anthropic API key available:", !!process.env.ANTHROPIC_API_KEY);
+    console.log("[Agent SDK] Claude OAuth token available:", !!process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    const iterator = query({
+      prompt: options.prompt,
+      options: {
+        cwd: options.cwd,
+        abortController,
+        permissionMode: "bypassPermissions",
+        // Allow MCP tools to execute automatically
+        maxTurns: 100,
+        // Reasonable limit
+        env: {
+          ...process.env,
+          // Pass auth token through environment for MCP server
+          CONTEXTGRAPH_AUTH_TOKEN: options.authToken || "",
+          // Pass Anthropic API key for SDK authentication
+          ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+          // Pass Claude OAuth token for SDK authentication (alternative to API key)
+          CLAUDE_CODE_OAUTH_TOKEN: process.env.CLAUDE_CODE_OAUTH_TOKEN || ""
+        },
+        // Load the contextgraph plugin (provides MCP server URL and other config)
+        plugins: [
+          {
+            type: "local",
+            path: pluginPath
+          }
+        ]
+        // Note: Auth is passed via CONTEXTGRAPH_AUTH_TOKEN environment variable above
+      }
+    });
+    for await (const message of iterator) {
+      if (!sessionId && message.session_id) {
+        sessionId = message.session_id;
+      }
+      const formatted = formatMessage(message);
+      if (formatted) {
+        console.log(formatted);
+      }
+      if (options.onLogEvent) {
+        try {
+          const logEvent = transformSDKMessage(message);
+          if (logEvent) {
+            options.onLogEvent(logEvent);
+          }
+        } catch (error) {
+          console.error("[Log Transform]", error instanceof Error ? error.message : String(error));
+        }
+      }
+      if (message.type === "result") {
+        const resultMsg = message;
+        totalCost = resultMsg.total_cost_usd || 0;
+        usage = resultMsg.usage;
+        if (resultMsg.subtype.startsWith("error_")) {
+          clearTimeout(timeout);
+          return {
+            exitCode: 1,
+            sessionId,
+            usage,
+            cost: totalCost
+          };
+        }
+      }
+    }
+    clearTimeout(timeout);
+    return {
+      exitCode: 0,
+      sessionId,
+      usage,
+      cost: totalCost
+    };
+  } catch (error) {
+    clearTimeout(timeout);
+    if (abortController.signal.aborted) {
+      const timeoutMinutes = EXECUTION_TIMEOUT_MS / (60 * 1e3);
+      throw new Error(`Claude SDK execution timed out after ${timeoutMinutes} minutes`);
+    }
+    throw new Error(`Failed to execute Claude SDK: ${error.message}`);
+  }
+}
+// src/fetch-with-retry.ts
+async function fetchWithRetry(url, options, retryOptions = {}) {
+  const { maxRetries = 3, baseDelayMs = 1e3, maxDelayMs = 1e4 } = retryOptions;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.ok || response.status >= 400 && response.status < 500) {
+        return response;
+      }
+      lastError = new Error(`HTTP ${response.status}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    if (attempt < maxRetries) {
+      const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+      const jitter = delay * 0.1 * Math.random();
+      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+    }
+  }
+  throw lastError ?? new Error("Request failed after retries");
+}
+// src/log-transport.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelayMs: 100,
+  backoffFactor: 2
+};
+var LogTransportService = class {
+  constructor(baseUrl, authToken, runId, retryConfig) {
+    this.baseUrl = baseUrl;
+    this.authToken = authToken;
+    this.runId = runId ?? null;
+    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+  }
+  runId = null;
+  retryConfig;
+  /**
+   * Get the current run ID
+   */
+  getRunId() {
+    return this.runId;
+  }
+  /**
+   * Create a new run for an action
+   * @param actionId - The action ID this run is executing
+   * @returns The created run ID
+   */
+  async createRun(actionId) {
+    const response = await this.makeRequest("/api/runs", {
+      method: "POST",
+      body: JSON.stringify({
+        actionId,
+        state: "queued"
+      })
+    });
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "Failed to create run");
+    }
+    this.runId = result.data.runId;
+    return this.runId;
+  }
+  /**
+   * Start the run (transition to running state)
+   * Called when execution begins
+   */
+  async startRun() {
+    if (!this.runId) {
+      throw new Error("No run ID set. Call createRun() first.");
+    }
+    const response = await this.makeRequest(`/api/runs/${this.runId}/start`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "Failed to start run");
+    }
+  }
+  /**
+   * Finish the run with an outcome
+   * @param outcome - 'success' | 'error' | 'timeout' | 'incomplete'
+   * @param metadata - Optional metadata (exitCode, errorMessage, cost, usage)
+   */
+  async finishRun(outcome, metadata) {
+    if (!this.runId) {
+      throw new Error("No run ID set. Call createRun() first.");
+    }
+    const response = await this.makeRequest(`/api/runs/${this.runId}/finish`, {
+      method: "POST",
+      body: JSON.stringify({
+        outcome,
+        exitCode: metadata?.exitCode?.toString(),
+        errorMessage: metadata?.errorMessage
+      })
+    });
+    const result = await response.json();
+    if (!result.success) {
+      const error = result.error || "Failed to finish run";
+      if (error.includes("summarizing") || error.includes("finished")) {
+        console.log("[LogTransport] Run is already being finished by server, skipping client finish");
+        return;
+      }
+      throw new Error(error);
+    }
+  }
+  /**
+   * Update the state of the current run
+   * @deprecated Use startRun() and finishRun() instead
+   * @param state - New state for the run
+   * @param metadata - Optional metadata to include with the state update
+   */
+  async updateRunState(state, metadata) {
+    if (!this.runId) {
+      throw new Error("No run ID set. Call createRun() first.");
+    }
+    if (state === "executing" || state === "preparing" || state === "running") {
+      await this.startRun();
+    } else if (state === "completed" || state === "failed") {
+      const outcome = state === "completed" ? "success" : "error";
+      await this.finishRun(outcome, {
+        exitCode: metadata?.exitCode,
+        errorMessage: metadata?.error,
+        cost: metadata?.cost,
+        usage: metadata?.usage
+      });
+    } else {
+      console.warn(`[LogTransport] Unknown state '${state}' - no API call made`);
+    }
+  }
+  /**
+   * Send a batch of log events to the platform
+   * @param events - Array of log events to send
+   * @param workerId - Optional worker ID
+   * @returns Success status and number of events received
+   */
+  async sendBatch(events, workerId) {
+    if (!this.runId) {
+      throw new Error("No run ID set. Call createRun() first.");
+    }
+    if (events.length === 0) {
+      return { success: true, eventsReceived: 0 };
+    }
+    const response = await this.makeRequest("/api/agents/log/event", {
+      method: "POST",
+      body: JSON.stringify({
+        runId: this.runId,
+        events,
+        ...workerId && { workerId }
+      })
+    });
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "Failed to send log batch");
+    }
+    return {
+      success: true,
+      eventsReceived: result.data?.eventsReceived ?? events.length
+    };
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async makeRequest(path2, options) {
+    const url = `${this.baseUrl}${path2}`;
+    const headers = {
+      "x-authorization": `Bearer ${this.authToken}`,
+      "Content-Type": "application/json"
+    };
+    let lastError = null;
+    let delay = this.retryConfig.initialDelayMs;
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            ...headers,
+            ...options.headers || {}
+          }
+        });
+        if (response.status >= 400 && response.status < 500) {
+          return response;
+        }
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.retryConfig.maxRetries) {
+          await this.sleep(delay);
+          delay *= this.retryConfig.backoffFactor;
+        }
+      }
+    }
+    throw new Error(
+      `Request failed after ${this.retryConfig.maxRetries + 1} attempts: ${lastError?.message}`
+    );
+  }
+  /**
+   * Sleep for a given number of milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+// src/log-buffer.ts
+var LOG_BUFFER_FLUSH_INTERVAL_MS = 500;
+var LOG_BUFFER_MAX_SIZE = 50;
+var LOG_BUFFER_MAX_QUEUE_SIZE = 1e3;
+var LogBuffer = class {
+  constructor(transport, flushIntervalMs = LOG_BUFFER_FLUSH_INTERVAL_MS, maxBufferSize = LOG_BUFFER_MAX_SIZE, maxQueueSize = LOG_BUFFER_MAX_QUEUE_SIZE) {
+    this.transport = transport;
+    this.flushIntervalMs = flushIntervalMs;
+    this.maxBufferSize = maxBufferSize;
+    this.maxQueueSize = maxQueueSize;
+  }
+  buffer = [];
+  flushIntervalId = null;
+  isFlushing = false;
+  /**
+   * Add an event to the buffer (fire-and-forget)
+   * Handles backpressure by dropping oldest events if queue is full.
+   */
+  push(event) {
+    if (this.buffer.length >= this.maxQueueSize) {
+      this.buffer.shift();
+    }
+    this.buffer.push(event);
+    if (this.buffer.length >= this.maxBufferSize) {
+      this.flushAsync();
+    }
+  }
+  /**
+   * Start periodic flushing
+   */
+  start() {
+    if (this.flushIntervalId !== null) return;
+    this.flushIntervalId = setInterval(() => {
+      this.flushAsync();
+    }, this.flushIntervalMs);
+  }
+  /**
+   * Stop periodic flushing and flush remaining events
+   */
+  async stop() {
+    if (this.flushIntervalId !== null) {
+      clearInterval(this.flushIntervalId);
+      this.flushIntervalId = null;
+    }
+    await this.flush();
+  }
+  /**
+   * Async flush (fire-and-forget, non-blocking)
+   */
+  flushAsync() {
+    if (this.isFlushing || this.buffer.length === 0) return;
+    this.flush().catch((error) => {
+      console.error("[LogBuffer] Flush error:", error instanceof Error ? error.message : String(error));
+    });
+  }
+  /**
+   * Flush current buffer contents to transport
+   */
+  async flush() {
+    if (this.isFlushing || this.buffer.length === 0) return;
+    this.isFlushing = true;
+    const eventsToSend = [...this.buffer];
+    this.buffer = [];
+    try {
+      await this.transport.sendBatch(eventsToSend);
+    } catch (error) {
+      console.error("[LogBuffer] Failed to send batch:", error instanceof Error ? error.message : String(error));
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+};
+// src/heartbeat-manager.ts
+var HeartbeatManager = class {
+  constructor(baseUrl, authToken, runId) {
+    this.baseUrl = baseUrl;
+    this.authToken = authToken;
+    this.runId = runId;
+  }
+  intervalId = null;
+  currentPhase = "executing";
+  currentProgress = void 0;
+  /**
+   * Start sending periodic heartbeats
+   * @param intervalMs - Time between heartbeats in milliseconds (default: 30000)
+   */
+  start(intervalMs = 3e4) {
+    this.stop();
+    this.sendHeartbeat();
+    this.intervalId = setInterval(() => {
+      this.sendHeartbeat();
+    }, intervalMs);
+  }
+  /**
+   * Stop sending heartbeats
+   */
+  stop() {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  /**
+   * Update the current phase and optional progress
+   * @param phase - Current execution phase
+   * @param progress - Optional progress percentage (0-100)
+   */
+  updatePhase(phase, progress) {
+    this.currentPhase = phase;
+    this.currentProgress = progress;
+  }
+  /**
+   * Check if heartbeat manager is currently running
+   */
+  isRunning() {
+    return this.intervalId !== null;
+  }
+  /**
+   * Send a heartbeat to the platform (internal method)
+   * Errors are logged but not thrown to avoid blocking execution.
+   * Includes one retry attempt for transient network failures.
+   */
+  async sendHeartbeat() {
+    const payload = {
+      phase: this.currentPhase,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.currentProgress !== void 0) {
+      payload.progress = this.currentProgress;
+    }
+    const url = `${this.baseUrl}/api/runs/${this.runId}/heartbeat`;
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "x-authorization": `Bearer ${this.authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const response = await fetch(url, requestOptions);
+        if (response.ok) {
+          return;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          console.error(
+            `Heartbeat failed: HTTP ${response.status} ${response.statusText}`
+          );
+          return;
+        }
+        if (attempt === 0) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      } catch (error) {
+        if (attempt === 0) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        } else {
+          console.error(
+            "Heartbeat error:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    }
+  }
+};
+// src/workflows/prepare.ts
+var API_BASE_URL = "https://www.contextgraph.dev";
+async function runPrepare(actionId, options) {
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    console.error("\u274C Not authenticated. Run authentication first.");
+    process.exit(1);
+  }
+  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+    console.error("\u274C Token expired. Re-authenticate to continue.");
+    process.exit(1);
+  }
+  console.log(`Fetching preparation instructions for action ${actionId}...
+`);
+  const response = await fetchWithRetry(
+    `${API_BASE_URL}/api/prompts/prepare`,
+    {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${credentials.clerkToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ actionId })
+    }
+  );
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch prepare prompt: ${response.statusText}
+${errorText}`);
+  }
+  const { prompt } = await response.json();
+  const logTransport = new LogTransportService(API_BASE_URL, credentials.clerkToken);
+  let runId;
+  let heartbeatManager;
+  let logBuffer;
+  try {
+    console.log("[Log Streaming] Creating run for prepare phase...");
+    runId = await logTransport.createRun(actionId);
+    console.log(`[Log Streaming] Run created: ${runId}`);
+    await logTransport.updateRunState("preparing");
+    heartbeatManager = new HeartbeatManager(API_BASE_URL, credentials.clerkToken, runId);
+    heartbeatManager.start();
+    console.log("[Log Streaming] Heartbeat started");
+    logBuffer = new LogBuffer(logTransport);
+    logBuffer.start();
+    console.log("Spawning Claude for preparation...\n");
+    const claudeResult = await executeClaude({
+      prompt,
+      cwd: options?.cwd || process.cwd(),
+      authToken: credentials.clerkToken,
+      onLogEvent: (event) => {
+        logBuffer.push(event);
+      }
+    });
+    if (claudeResult.exitCode === 0) {
+      await logTransport.finishRun("success", {
+        exitCode: claudeResult.exitCode,
+        cost: claudeResult.cost,
+        usage: claudeResult.usage
+      });
+      console.log("\n\u2705 Preparation complete");
+    } else {
+      await logTransport.finishRun("error", {
+        exitCode: claudeResult.exitCode,
+        errorMessage: `Claude preparation failed with exit code ${claudeResult.exitCode}`
+      });
+      console.error(`
+\u274C Claude preparation failed with exit code ${claudeResult.exitCode}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    if (runId) {
+      try {
+        await logTransport.finishRun("error", {
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+      } catch (stateError) {
+        console.error("[Log Streaming] Failed to update run state:", stateError);
+      }
+    }
+    throw error;
+  } finally {
+    if (heartbeatManager) {
+      heartbeatManager.stop();
+      console.log("[Log Streaming] Heartbeat stopped");
+    }
+    if (logBuffer) {
+      await logBuffer.stop();
+      console.log("[Log Streaming] Logs flushed");
+    }
+  }
+}
+// src/workflows/execute.ts
+var API_BASE_URL2 = "https://www.contextgraph.dev";
+async function runExecute(actionId, options) {
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    console.error("\u274C Not authenticated. Run authentication first.");
+    process.exit(1);
+  }
+  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+    console.error("\u274C Token expired. Re-authenticate to continue.");
+    process.exit(1);
+  }
+  console.log(`Fetching execution instructions for action ${actionId}...
+`);
+  const response = await fetchWithRetry(
+    `${API_BASE_URL2}/api/prompts/execute`,
+    {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${credentials.clerkToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ actionId })
+    }
+  );
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch execute prompt: ${response.statusText}
+${errorText}`);
+  }
+  const { prompt } = await response.json();
+  const logTransport = new LogTransportService(API_BASE_URL2, credentials.clerkToken);
+  let runId;
+  let heartbeatManager;
+  let logBuffer;
+  try {
+    console.log("[Log Streaming] Creating run...");
+    runId = await logTransport.createRun(actionId);
+    console.log(`[Log Streaming] Run created: ${runId}`);
+    await logTransport.updateRunState("executing");
+    heartbeatManager = new HeartbeatManager(API_BASE_URL2, credentials.clerkToken, runId);
+    heartbeatManager.start();
+    console.log("[Log Streaming] Heartbeat started");
+    logBuffer = new LogBuffer(logTransport);
+    logBuffer.start();
+    console.log("Spawning Claude for execution...\n");
+    const claudeResult = await executeClaude({
+      prompt,
+      cwd: options?.cwd || process.cwd(),
+      authToken: credentials.clerkToken,
+      onLogEvent: (event) => {
+        logBuffer.push(event);
+      }
+    });
+    if (claudeResult.exitCode === 0) {
+      await logTransport.finishRun("success", {
+        exitCode: claudeResult.exitCode,
+        cost: claudeResult.cost,
+        usage: claudeResult.usage
+      });
+      console.log("\n\u2705 Execution complete");
+    } else {
+      await logTransport.finishRun("error", {
+        exitCode: claudeResult.exitCode,
+        errorMessage: `Claude execution failed with exit code ${claudeResult.exitCode}`
+      });
+      throw new Error(`Claude execution failed with exit code ${claudeResult.exitCode}`);
+    }
+  } catch (error) {
+    if (runId) {
+      try {
+        await logTransport.finishRun("error", {
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+      } catch (stateError) {
+        console.error("[Log Streaming] Failed to update run state:", stateError);
+      }
+    }
+    throw error;
+  } finally {
+    if (heartbeatManager) {
+      heartbeatManager.stop();
+      console.log("[Log Streaming] Heartbeat stopped");
+    }
+    if (logBuffer) {
+      await logBuffer.stop();
+      console.log("[Log Streaming] Logs flushed");
+    }
+  }
+}
+// src/workflows/agent.ts
+import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+// src/api-client.ts
+var ApiClient = class {
+  constructor(baseUrl = "https://www.contextgraph.dev") {
+    this.baseUrl = baseUrl;
+  }
+  async getAuthToken() {
+    const credentials = await loadCredentials();
+    if (!credentials) {
+      throw new Error("Not authenticated. Run authentication first.");
+    }
+    if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+      throw new Error("Token expired. Re-authenticate to continue.");
+    }
+    return credentials.clerkToken;
+  }
+  async getActionDetail(actionId) {
+    const token = await this.getAuthToken();
+    const response = await fetchWithRetry(
+      `${this.baseUrl}/api/actions/${actionId}?token=${encodeURIComponent(token)}`,
+      {
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+    return result.data;
+  }
+  async fetchTree(rootActionId, includeCompleted = false) {
+    const token = await this.getAuthToken();
+    const response = await fetchWithRetry(
+      `${this.baseUrl}/api/tree/${rootActionId}?includeCompleted=${includeCompleted}&token=${encodeURIComponent(token)}`,
+      {
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to fetch tree: ${response.status} ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error("Failed to fetch tree: API returned unsuccessful response");
+    }
+    if (!result.data.rootActions?.[0]) {
+      return { id: rootActionId, title: "", done: true, dependencies: [], children: [] };
+    }
+    return result.data.rootActions[0];
+  }
+  async claimNextAction(workerId) {
+    const token = await this.getAuthToken();
+    const response = await fetchWithRetry(
+      `${this.baseUrl}/api/worker/next?token=${encodeURIComponent(token)}`,
+      {
+        method: "POST",
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ worker_id: workerId })
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "API returned unsuccessful response");
+    }
+    return result.data;
+  }
+  async releaseClaim(params) {
+    const token = await this.getAuthToken();
+    const response = await fetchWithRetry(
+      `${this.baseUrl}/api/worker/release?token=${encodeURIComponent(token)}`,
+      {
+        method: "POST",
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "API returned unsuccessful response");
+    }
+  }
+};
+// src/workspace-prep.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+var API_BASE_URL3 = "https://www.contextgraph.dev";
+async function fetchGitHubCredentials(authToken) {
+  const response = await fetchWithRetry(`${API_BASE_URL3}/api/cli/credentials`, {
+    headers: {
+      "x-authorization": `Bearer ${authToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status === 401) {
+    throw new Error("Authentication failed. Please re-authenticate.");
+  }
+  if (response.status === 404) {
+    throw new Error(
+      "GitHub not connected. Please connect your GitHub account at https://contextgraph.dev/settings."
+    );
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch GitHub credentials: ${response.statusText}
+${errorText}`);
+  }
+  return response.json();
+}
+function runGitCommand(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`git ${args[0]} failed (exit ${code}): ${stderr || stdout}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn git: ${err.message}`));
+    });
+  });
+}
+function buildAuthenticatedUrl(repoUrl, token) {
+  if (repoUrl.startsWith("https://github.com/")) {
+    return repoUrl.replace("https://github.com/", `https://${token}@github.com/`);
+  }
+  if (repoUrl.startsWith("https://github.com")) {
+    return repoUrl.replace("https://github.com", `https://${token}@github.com`);
+  }
+  return repoUrl;
+}
+async function prepareWorkspace(repoUrl, options) {
+  const { branch, authToken } = options;
+  const credentials = await fetchGitHubCredentials(authToken);
+  const workspacePath = await mkdtemp(join2(tmpdir(), "cg-workspace-"));
+  const cleanup = async () => {
+    try {
+      await rm(workspacePath, { recursive: true, force: true });
+    } catch (error) {
+      console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
+    }
+  };
+  try {
+    const cloneUrl = buildAuthenticatedUrl(repoUrl, credentials.githubToken);
+    console.log(`\u{1F4C2} Cloning ${repoUrl}`);
+    console.log(`   \u2192 ${workspacePath}`);
+    await runGitCommand(["clone", cloneUrl, workspacePath]);
+    console.log(`\u2705 Repository cloned`);
+    if (credentials.githubUsername) {
+      await runGitCommand(["config", "user.name", credentials.githubUsername], workspacePath);
+    }
+    if (credentials.githubEmail) {
+      await runGitCommand(["config", "user.email", credentials.githubEmail], workspacePath);
+    }
+    if (branch) {
+      const { stdout } = await runGitCommand(
+        ["ls-remote", "--heads", "origin", branch],
+        workspacePath
+      );
+      const branchExists = stdout.trim().length > 0;
+      if (branchExists) {
+        console.log(`\u{1F33F} Checking out branch: ${branch}`);
+        await runGitCommand(["checkout", branch], workspacePath);
+      } else {
+        console.log(`\u{1F331} Creating new branch: ${branch}`);
+        await runGitCommand(["checkout", "-b", branch], workspacePath);
+      }
+    }
+    return { path: workspacePath, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+// src/workflows/agent.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var packageJson = JSON.parse(
+  readFileSync(join3(__dirname2, "../package.json"), "utf-8")
+);
+var INITIAL_POLL_INTERVAL = parseInt(process.env.WORKER_INITIAL_POLL_INTERVAL || "2000", 10);
+var MAX_POLL_INTERVAL = parseInt(process.env.WORKER_MAX_POLL_INTERVAL || "5000", 10);
+var BACKOFF_MULTIPLIER = 1.5;
+var STATUS_INTERVAL_MS = 3e4;
+var INITIAL_RETRY_DELAY = 1e3;
+var MAX_RETRY_DELAY = 6e4;
+var OUTAGE_WARNING_THRESHOLD = 5;
+var running = true;
+var currentClaim = null;
+var apiClient = null;
+var stats = {
+  startTime: Date.now(),
+  prepared: 0,
+  executed: 0,
+  errors: 0
+};
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+function printStatus() {
+  const uptime = formatDuration(Date.now() - stats.startTime);
+  const total = stats.prepared + stats.executed;
+  console.log(`Status: ${total} actions (${stats.prepared} prepared, ${stats.executed} executed, ${stats.errors} errors) | Uptime: ${uptime}`);
+}
+async function cleanupAndExit() {
+  if (currentClaim && apiClient) {
+    try {
+      console.log(`
+\u{1F9F9} Releasing claim on action ${currentClaim.actionId}...`);
+      await apiClient.releaseClaim({
+        action_id: currentClaim.actionId,
+        worker_id: currentClaim.workerId,
+        claim_id: currentClaim.claimId
+      });
+      console.log("\u2705 Claim released successfully");
+    } catch (error) {
+      console.error("\u26A0\uFE0F  Failed to release claim:", error.message);
+    }
+  }
+  console.log("\u{1F44B} Shutdown complete");
+  process.exit(0);
+}
+function setupSignalHandlers() {
+  process.on("SIGINT", async () => {
+    console.log("\n\n\u26A0\uFE0F  Received SIGINT (Ctrl+C). Shutting down gracefully...");
+    running = false;
+    await cleanupAndExit();
+  });
+  process.on("SIGTERM", async () => {
+    console.log("\n\n\u26A0\uFE0F  Received SIGTERM. Shutting down gracefully...");
+    running = false;
+    await cleanupAndExit();
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableError(error) {
+  const message = error.message.toLowerCase();
+  return message.includes("api error 5") || message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504") || message.includes("network") || message.includes("timeout") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("socket hang up") || message.includes("failed query");
+}
+async function runLocalAgent() {
+  apiClient = new ApiClient();
+  setupSignalHandlers();
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    console.error("\u274C Not authenticated.");
+    console.error("   Set CONTEXTGRAPH_API_TOKEN environment variable or run `contextgraph-agent auth`");
+    process.exit(1);
+  }
+  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+    console.error("\u274C Token expired. Run `contextgraph-agent auth` to re-authenticate.");
+    process.exit(1);
+  }
+  const usingApiToken = !!process.env.CONTEXTGRAPH_API_TOKEN;
+  if (usingApiToken) {
+    console.log("\u{1F510} Authenticated via CONTEXTGRAPH_API_TOKEN");
+  }
+  const workerId = randomUUID();
+  console.log(`\u{1F916} ContextGraph Agent v${packageJson.version}`);
+  console.log(`\u{1F477} Worker ID: ${workerId}`);
+  console.log(`\u{1F504} Starting continuous worker loop...
+`);
+  console.log(`\u{1F4A1} Press Ctrl+C to gracefully shutdown and release any claimed work
+`);
+  let currentPollInterval = INITIAL_POLL_INTERVAL;
+  let lastStatusTime = Date.now();
+  let consecutiveApiErrors = 0;
+  let apiRetryDelay = INITIAL_RETRY_DELAY;
+  while (running) {
+    let actionDetail;
+    try {
+      actionDetail = await apiClient.claimNextAction(workerId);
+      consecutiveApiErrors = 0;
+      apiRetryDelay = INITIAL_RETRY_DELAY;
+    } catch (error) {
+      const err = error;
+      if (isRetryableError(err)) {
+        consecutiveApiErrors++;
+        if (consecutiveApiErrors === OUTAGE_WARNING_THRESHOLD) {
+          console.warn(`
+\u26A0\uFE0F  API appears to be experiencing an outage.`);
+          console.warn(`   Will continue retrying indefinitely (every ${MAX_RETRY_DELAY / 1e3}s max).`);
+          console.warn(`   Press Ctrl+C to stop.
+`);
+        }
+        if (consecutiveApiErrors < OUTAGE_WARNING_THRESHOLD) {
+          console.warn(`\u26A0\uFE0F  API error (attempt ${consecutiveApiErrors}): ${err.message}`);
+        } else if (consecutiveApiErrors % 10 === 0) {
+          console.warn(`\u26A0\uFE0F  Still retrying... (attempt ${consecutiveApiErrors}, last error: ${err.message})`);
+        }
+        const delaySeconds = Math.round(apiRetryDelay / 1e3);
+        if (consecutiveApiErrors < OUTAGE_WARNING_THRESHOLD) {
+          console.warn(`   Retrying in ${delaySeconds}s...`);
+        }
+        await sleep(apiRetryDelay);
+        apiRetryDelay = Math.min(apiRetryDelay * 2, MAX_RETRY_DELAY);
+        continue;
+      }
+      throw err;
+    }
+    if (!actionDetail) {
+      if (Date.now() - lastStatusTime >= STATUS_INTERVAL_MS) {
+        printStatus();
+        lastStatusTime = Date.now();
+      }
+      await sleep(currentPollInterval);
+      currentPollInterval = Math.min(currentPollInterval * BACKOFF_MULTIPLIER, MAX_POLL_INTERVAL);
+      continue;
+    }
+    currentPollInterval = INITIAL_POLL_INTERVAL;
+    console.log(`Working: ${actionDetail.title}`);
+    if (actionDetail.claim_id) {
+      currentClaim = {
+        actionId: actionDetail.id,
+        claimId: actionDetail.claim_id,
+        workerId
+      };
+    }
+    const isPrepared = actionDetail.prepared !== false;
+    const repoUrl = actionDetail.resolved_repository_url || actionDetail.repository_url;
+    const branch = actionDetail.resolved_branch || actionDetail.branch;
+    if (!repoUrl) {
+      console.error(`
+\u274C Action "${actionDetail.title}" has no repository_url set.`);
+      console.error(`   Actions must have a repository_url (directly or inherited from parent).`);
+      console.error(`   Action ID: ${actionDetail.id}`);
+      console.error(`   resolved_repository_url: ${actionDetail.resolved_repository_url}`);
+      console.error(`   repository_url: ${actionDetail.repository_url}`);
+      process.exit(1);
+    }
+    let workspacePath;
+    let cleanup;
+    try {
+      const workspace = await prepareWorkspace(repoUrl, {
+        branch: branch || void 0,
+        authToken: credentials.clerkToken
+      });
+      workspacePath = workspace.path;
+      cleanup = workspace.cleanup;
+      if (!isPrepared) {
+        await runPrepare(actionDetail.id, { cwd: workspacePath });
+        stats.prepared++;
+        if (currentClaim && apiClient) {
+          try {
+            await apiClient.releaseClaim({
+              action_id: currentClaim.actionId,
+              worker_id: currentClaim.workerId,
+              claim_id: currentClaim.claimId
+            });
+          } catch (releaseError) {
+            console.error("\u26A0\uFE0F  Failed to release claim after preparation:", releaseError.message);
+          }
+        }
+        currentClaim = null;
+        continue;
+      }
+      try {
+        await runExecute(actionDetail.id, { cwd: workspacePath });
+        stats.executed++;
+        console.log(`Completed: ${actionDetail.title}`);
+      } catch (executeError) {
+        stats.errors++;
+        console.error(`Error: ${executeError.message}. Continuing...`);
+      } finally {
+        if (currentClaim && apiClient) {
+          try {
+            await apiClient.releaseClaim({
+              action_id: currentClaim.actionId,
+              worker_id: currentClaim.workerId,
+              claim_id: currentClaim.claimId
+            });
+          } catch (releaseError) {
+            console.error("\u26A0\uFE0F  Failed to release claim:", releaseError.message);
+          }
+        }
+        currentClaim = null;
+      }
+    } catch (workspaceError) {
+      stats.errors++;
+      console.error(`Error preparing workspace: ${workspaceError.message}. Continuing...`);
+      if (currentClaim && apiClient) {
+        try {
+          console.log(`\u{1F9F9} Releasing claim due to workspace error...`);
+          await apiClient.releaseClaim({
+            action_id: currentClaim.actionId,
+            worker_id: currentClaim.workerId,
+            claim_id: currentClaim.claimId
+          });
+          console.log("\u2705 Claim released");
+        } catch (releaseError) {
+          console.error("\u26A0\uFE0F  Failed to release claim:", releaseError.message);
+        }
+      }
+      currentClaim = null;
+    } finally {
+      if (cleanup) {
+        await cleanup();
+      }
+    }
+  }
+}
+// src/cli/index.ts
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+var packageJson2 = JSON.parse(
+  readFileSync2(join4(__dirname3, "../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("contextgraph-agent").description("Autonomous agent for contextgraph action execution").version(packageJson2.version);
+program.command("run").description("Run continuous worker loop (claims and executes actions until Ctrl+C)").action(async () => {
+  try {
+    await runLocalAgent();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Error running agent:", error.message || "(no message)");
+      if (error.stack) {
+        console.error("\nStack trace:");
+        console.error(error.stack);
+      }
+    } else {
+      console.error("Error running agent:", error);
+    }
+    process.exit(1);
+  }
+});
+program.command("auth").description("Authenticate with contextgraph.dev").action(async () => {
+  try {
+    await runAuth();
+  } catch (error) {
+    console.error("Error during authentication:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("prepare").argument("<action-id>", "Action ID to prepare").description("Prepare a single action").action(async (actionId) => {
+  try {
+    await runPrepare(actionId);
+  } catch (error) {
+    console.error("Error preparing action:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("execute").argument("<action-id>", "Action ID to execute").description("Execute a single action").action(async (actionId) => {
+  try {
+    await runExecute(actionId);
+  } catch (error) {
+    console.error("Error executing action:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("whoami").description("Show current authentication status").action(async () => {
+  try {
+    const credentials = await loadCredentials();
+    if (!credentials) {
+      console.log("Not authenticated. Run `contextgraph-agent auth` to authenticate.");
+      process.exit(1);
+    }
+    if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+      console.log("\u26A0\uFE0F  Token expired. Run `contextgraph-agent auth` to re-authenticate.");
+      console.log(`User ID: ${credentials.userId}`);
+      console.log(`Expired at: ${credentials.expiresAt}`);
+      process.exit(1);
+    }
+    console.log("\u2705 Authenticated");
+    console.log(`User ID: ${credentials.userId}`);
+    console.log(`Expires at: ${credentials.expiresAt}`);
+  } catch (error) {
+    console.error("Error checking authentication:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map