@contextgraph/agent 0.4.24 → 0.4.26

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 
 // src/callback-server.ts
 import http from "http";
@@ -42,6 +42,7 @@ async function startCallbackServer() {
     if (url.pathname === "/callback") {
       const token = url.searchParams.get("token");
       const userId = url.searchParams.get("userId");
+      const email = url.searchParams.get("email");
       if (!token) {
         res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
         res.end(getErrorPage("Missing token parameter"));
@@ -53,7 +54,7 @@ async function startCallbackServer() {
         return;
       }
       if (callbackResolve) {
-        callbackResolve({ token, userId });
+        callbackResolve({ token, userId, ...email ? { email } : {} });
       }
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(getSuccessPage());
@@ -542,6 +543,7 @@ async function authenticateAgent(options = {}) {
     await saveCredentials({
       clerkToken: result.token,
       userId: result.userId,
+      ...result.email ? { email: result.email } : {},
       expiresAt,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -550,7 +552,8 @@ async function authenticateAgent(options = {}) {
       success: true,
       credentials: {
         token: result.token,
-        userId: result.userId
+        userId: result.userId,
+        email: result.email
       }
     };
   } catch (error) {
@@ -581,69 +584,6 @@ async function runAuth() {
 // 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();
@@ -850,8 +790,6 @@ async function executeClaude(options) {
     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] Auth token prefix:", options.authToken?.substring(0, 20) + "...");
     console.log("[Agent SDK] Anthropic API key available:", !!process.env.ANTHROPIC_API_KEY);
@@ -1356,25 +1294,25 @@ var HeartbeatManager = class {
 // src/workspace-setup.ts
 import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 
 // src/workspace-prep.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { mkdtemp, rm, appendFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 
 // src/skill-injection.ts
-import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { join as join2 } from "path";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
 async function injectSkills(workspacePath, skills) {
   if (skills.length === 0) {
     return;
   }
   for (const skill of skills) {
     try {
-      const skillDir = join2(workspacePath, ".claude", "skills", skill.name);
-      await mkdir2(skillDir, { recursive: true });
+      const skillDir = join(workspacePath, ".claude", "skills", skill.name);
+      await mkdir(skillDir, { recursive: true });
       const triggerSection = skill.trigger ? `trigger: |
 ${skill.trigger.split("\n").map((line) => `  ${line}`).join("\n")}
 ` : "";
@@ -1385,7 +1323,7 @@ ${triggerSection}---
 
 ${skill.content}
 `;
-      const skillFilePath = join2(skillDir, "SKILL.md");
+      const skillFilePath = join(skillDir, "SKILL.md");
       await writeFile(skillFilePath, skillContent, "utf-8");
     } catch (error) {
       console.error(`\u274C Failed to inject skill "${skill.name}":`, error);
@@ -1442,6 +1380,7 @@ async function fetchSkillsLibrary(options) {
 }
 
 // src/workspace-prep.ts
+import chalk from "chalk";
 var API_BASE_URL2 = "https://www.contextgraph.dev";
 async function fetchGitHubCredentials(authToken) {
   const response = await fetchWithRetry(`${API_BASE_URL2}/api/cli/credentials`, {
@@ -1467,7 +1406,7 @@ ${errorText}`);
 }
 function runGitCommand(args, cwd) {
   return new Promise((resolve, reject) => {
-    const proc = spawn2("git", args, { cwd });
+    const proc = spawn("git", args, { cwd });
     let stdout = "";
     let stderr = "";
     proc.stdout.on("data", (data) => {
@@ -1501,27 +1440,27 @@ function buildAuthenticatedUrl(repoUrl, token, username) {
 async function prepareWorkspace(repoUrl, options) {
   const { branch, authToken, runId, skipSkills } = options;
   const credentials = await fetchGitHubCredentials(authToken);
-  const workspacePath = await mkdtemp(join3(tmpdir(), "cg-workspace-"));
+  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);
+      console.error(chalk.yellow(`Warning: Failed to cleanup workspace at ${workspacePath}:`), error);
     }
   };
   try {
     const cloneUrl = buildAuthenticatedUrl(repoUrl, credentials.githubToken, credentials.gitCredentialsUsername);
-    console.log(`\u{1F4C2} Cloning ${repoUrl}`);
-    console.log(`   \u2192 ${workspacePath}`);
+    console.log(`Cloning ${chalk.cyan(repoUrl)}`);
+    console.log(chalk.dim(`   ${workspacePath}`));
     await runGitCommand(["clone", cloneUrl, workspacePath]);
-    console.log(`\u2705 Repository cloned`);
+    console.log(chalk.green("Repository cloned"));
     if (credentials.githubUsername) {
       await runGitCommand(["config", "user.name", credentials.githubUsername], workspacePath);
     }
     if (credentials.githubEmail) {
       await runGitCommand(["config", "user.email", credentials.githubEmail], workspacePath);
     }
-    await appendFile(join3(workspacePath, ".git", "info", "exclude"), "\n.claude/skills/\n");
+    await appendFile(join2(workspacePath, ".git", "info", "exclude"), "\n.claude/skills/\n");
     if (branch) {
       const { stdout } = await runGitCommand(
         ["ls-remote", "--heads", "origin", branch],
@@ -1529,10 +1468,10 @@ async function prepareWorkspace(repoUrl, options) {
       );
       const branchExists = stdout.trim().length > 0;
       if (branchExists) {
-        console.log(`\u{1F33F} Checking out branch: ${branch}`);
+        console.log(`Checking out branch: ${chalk.cyan(branch)}`);
         await runGitCommand(["checkout", branch], workspacePath);
       } else {
-        console.log(`\u{1F331} Creating new branch: ${branch}`);
+        console.log(`Creating new branch: ${chalk.cyan(branch)}`);
         await runGitCommand(["checkout", "-b", branch], workspacePath);
       }
     }
@@ -1540,17 +1479,17 @@ async function prepareWorkspace(repoUrl, options) {
     const startingCommit = commitHash.trim();
     console.log("");
     if (skipSkills) {
-      console.log("\u{1F4DA} Skipping skill injection (--no-skills flag)");
+      console.log(chalk.dim("Skipping skill injection (--no-skills flag)"));
     } else {
       try {
         const librarySkills = await fetchSkillsLibrary({ authToken, runId });
         if (librarySkills.length > 0) {
           await injectSkills(workspacePath, librarySkills);
         } else {
-          console.log("\u{1F4DA} No skills to inject (empty library)");
+          console.log(chalk.dim("No skills to inject (empty library)"));
         }
       } catch (skillError) {
-        console.warn("\u26A0\uFE0F  Skill injection failed (agent will continue):", skillError);
+        console.warn(chalk.yellow("Skill injection failed (agent will continue):"), skillError);
       }
     }
     return { path: workspacePath, startingCommit, cleanup };
@@ -1563,7 +1502,7 @@ async function prepareWorkspace(repoUrl, options) {
 // package.json
 var package_default = {
   name: "@contextgraph/agent",
-  version: "0.4.24",
+  version: "0.4.25",
   description: "Autonomous agent for contextgraph action execution",
   type: "module",
   bin: {
@@ -1592,7 +1531,9 @@ var package_default = {
   },
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "^0.1.50",
+    chalk: "^5.6.2",
     commander: "^11.0.0",
+    listr2: "^9.0.5",
     open: "^10.0.0"
   },
   devDependencies: {
@@ -1719,21 +1660,22 @@ var ApiClient = class {
 };
 
 // src/workspace-setup.ts
+import chalk2 from "chalk";
 var API_BASE_URL3 = "https://www.contextgraph.dev";
 async function setupWorkspaceForAction(actionId, options) {
   const { authToken, phase, startingCommit: startingCommitOverride, skipSkills } = options;
   let actionDetail = options.actionDetail;
   if (!actionDetail) {
     const apiClient2 = new ApiClient();
-    console.log(`Fetching action details for ${actionId}...`);
+    console.log(chalk2.dim(`Fetching action details for ${actionId}...`));
     actionDetail = await apiClient2.getActionDetail(actionId);
   }
   const logTransport = new LogTransportService(API_BASE_URL3, authToken);
-  console.log(`[Log Streaming] Creating run for ${phase} phase...`);
+  console.log(chalk2.dim(`[Log Streaming] Creating run for ${phase} phase...`));
   const runId = await logTransport.createRun(actionId, phase, {
     startingCommit: startingCommitOverride
   });
-  console.log(`[Log Streaming] Run created: ${runId}`);
+  console.log(chalk2.dim(`[Log Streaming] Run created: ${runId}`));
   const repoUrl = actionDetail.resolved_repository_url || actionDetail.repository_url;
   const branch = actionDetail.resolved_branch || actionDetail.branch;
   let workspacePath;
@@ -1750,14 +1692,14 @@ async function setupWorkspaceForAction(actionId, options) {
     cleanup = workspace.cleanup;
     startingCommit = workspace.startingCommit;
   } else {
-    console.log(`\u{1F4C2} No repository configured - creating blank workspace`);
-    workspacePath = await mkdtemp2(join4(tmpdir2(), "cg-workspace-"));
-    console.log(`   \u2192 ${workspacePath}`);
+    console.log(chalk2.dim("No repository configured - creating blank workspace"));
+    workspacePath = await mkdtemp2(join3(tmpdir2(), "cg-workspace-"));
+    console.log(chalk2.dim(`   ${workspacePath}`));
     cleanup = async () => {
       try {
         await rm2(workspacePath, { recursive: true, force: true });
       } catch (error) {
-        console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
+        console.error(chalk2.yellow(`Warning: Failed to cleanup workspace at ${workspacePath}:`), error);
       }
     };
   }
@@ -1771,15 +1713,16 @@ async function setupWorkspaceForAction(actionId, options) {
 }
 
 // src/workflows/prepare.ts
+import chalk3 from "chalk";
 var API_BASE_URL4 = "https://www.contextgraph.dev";
 async function runPrepare(actionId, options) {
   const credentials = await loadCredentials();
   if (!credentials) {
-    console.error("\u274C Not authenticated. Run authentication first.");
+    console.error(chalk3.red("Not authenticated."), "Run authentication first.");
     process.exit(1);
   }
   if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
-    console.error("\u274C Token expired. Re-authenticate to continue.");
+    console.error(chalk3.red("Token expired."), "Re-authenticate to continue.");
     process.exit(1);
   }
   let runId = options?.runId;
@@ -1801,12 +1744,12 @@ async function runPrepare(actionId, options) {
       runId = setup.runId;
       logTransport = setup.logTransport;
     } else {
-      console.log(`[Log Streaming] Using pre-created run: ${runId}`);
+      console.log(chalk3.dim(`[Log Streaming] Using pre-created run: ${runId}`));
       workspacePath = options?.cwd || process.cwd();
       logTransport = new LogTransportService(API_BASE_URL4, credentials.clerkToken, runId);
     }
-    console.log(`Fetching preparation instructions for action ${actionId}...
-`);
+    console.log(chalk3.dim(`Fetching preparation instructions for action ${actionId}...
+`));
     const response = await fetchWithRetry(
       `${API_BASE_URL4}/api/prompts/prepare`,
       {
@@ -1827,7 +1770,7 @@ ${errorText}`);
     await logTransport.updateRunState("preparing");
     heartbeatManager = new HeartbeatManager(API_BASE_URL4, credentials.clerkToken, runId);
     heartbeatManager.start();
-    console.log("[Log Streaming] Heartbeat started");
+    console.log(chalk3.dim("[Log Streaming] Heartbeat started"));
     logBuffer = new LogBuffer(logTransport);
     logBuffer.start();
     console.log("Spawning Claude for preparation...\n");
@@ -1846,14 +1789,13 @@ ${errorText}`);
         cost: claudeResult.cost,
         usage: claudeResult.usage
       });
-      console.log("\n\u2705 Preparation complete");
+      console.log("\n" + chalk3.green("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}`);
+      console.error("\n" + chalk3.red(`Claude preparation failed with exit code ${claudeResult.exitCode}`));
       process.exit(1);
     }
   } catch (error) {
@@ -1863,18 +1805,18 @@ ${errorText}`);
           errorMessage: error instanceof Error ? error.message : String(error)
         });
       } catch (stateError) {
-        console.error("[Log Streaming] Failed to update run state:", stateError);
+        console.error(chalk3.dim("[Log Streaming] Failed to update run state:"), stateError);
       }
     }
     throw error;
   } finally {
     if (heartbeatManager) {
       heartbeatManager.stop();
-      console.log("[Log Streaming] Heartbeat stopped");
+      console.log(chalk3.dim("[Log Streaming] Heartbeat stopped"));
     }
     if (logBuffer) {
       await logBuffer.stop();
-      console.log("[Log Streaming] Logs flushed");
+      console.log(chalk3.dim("[Log Streaming] Logs flushed"));
     }
     if (cleanup) {
       await cleanup();
@@ -1883,15 +1825,16 @@ ${errorText}`);
 }
 
 // src/workflows/execute.ts
+import chalk4 from "chalk";
 var API_BASE_URL5 = "https://www.contextgraph.dev";
 async function runExecute(actionId, options) {
   const credentials = await loadCredentials();
   if (!credentials) {
-    console.error("\u274C Not authenticated. Run authentication first.");
+    console.error(chalk4.red("Not authenticated."), "Run authentication first.");
     process.exit(1);
   }
   if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
-    console.error("\u274C Token expired. Re-authenticate to continue.");
+    console.error(chalk4.red("Token expired."), "Re-authenticate to continue.");
     process.exit(1);
   }
   let runId = options?.runId;
@@ -1913,12 +1856,12 @@ async function runExecute(actionId, options) {
       runId = setup.runId;
       logTransport = setup.logTransport;
     } else {
-      console.log(`[Log Streaming] Using pre-created run: ${runId}`);
+      console.log(chalk4.dim(`[Log Streaming] Using pre-created run: ${runId}`));
       workspacePath = options?.cwd || process.cwd();
       logTransport = new LogTransportService(API_BASE_URL5, credentials.clerkToken, runId);
     }
-    console.log(`Fetching execution instructions for action ${actionId}...
-`);
+    console.log(chalk4.dim(`Fetching execution instructions for action ${actionId}...
+`));
     const response = await fetchWithRetry(
       `${API_BASE_URL5}/api/prompts/execute`,
       {
@@ -1939,7 +1882,7 @@ ${errorText}`);
     await logTransport.updateRunState("executing");
     heartbeatManager = new HeartbeatManager(API_BASE_URL5, credentials.clerkToken, runId);
     heartbeatManager.start();
-    console.log("[Log Streaming] Heartbeat started");
+    console.log(chalk4.dim("[Log Streaming] Heartbeat started"));
     logBuffer = new LogBuffer(logTransport);
     logBuffer.start();
     console.log("Spawning Claude for execution...\n");
@@ -1958,7 +1901,7 @@ ${errorText}`);
         cost: claudeResult.cost,
         usage: claudeResult.usage
       });
-      console.log("\n\u2705 Execution complete");
+      console.log("\n" + chalk4.green("Execution complete"));
     } else {
       await logTransport.finishRun("error", {
         exitCode: claudeResult.exitCode,
@@ -1973,18 +1916,18 @@ ${errorText}`);
           errorMessage: error instanceof Error ? error.message : String(error)
         });
       } catch (stateError) {
-        console.error("[Log Streaming] Failed to update run state:", stateError);
+        console.error(chalk4.dim("[Log Streaming] Failed to update run state:"), stateError);
       }
     }
     throw error;
   } finally {
     if (heartbeatManager) {
       heartbeatManager.stop();
-      console.log("[Log Streaming] Heartbeat stopped");
+      console.log(chalk4.dim("[Log Streaming] Heartbeat stopped"));
     }
     if (logBuffer) {
       await logBuffer.stop();
-      console.log("[Log Streaming] Logs flushed");
+      console.log(chalk4.dim("[Log Streaming] Logs flushed"));
     }
     if (cleanup) {
       await cleanup();
@@ -1996,11 +1939,12 @@ ${errorText}`);
 import { randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, join as join5 } from "path";
+import { dirname, join as join4 } from "path";
+import chalk5 from "chalk";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
 var packageJson = JSON.parse(
-  readFileSync(join5(__dirname2, "../package.json"), "utf-8")
+  readFileSync(join4(__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);
@@ -2032,34 +1976,34 @@ function formatDuration(ms) {
 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}`);
+  console.log(chalk5.dim(`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}...`);
+      console.log(chalk5.dim(`
+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");
+      console.log(chalk5.dim("Claim released successfully"));
     } catch (error) {
-      console.error("\u26A0\uFE0F  Failed to release claim:", error.message);
+      console.error(chalk5.yellow("Failed to release claim:"), error.message);
     }
   }
-  console.log("\u{1F44B} Shutdown complete");
+  console.log("Shutdown complete");
   process.exit(0);
 }
 function setupSignalHandlers() {
   process.on("SIGINT", async () => {
-    console.log("\n\n\u26A0\uFE0F  Received SIGINT (Ctrl+C). Shutting down gracefully...");
+    console.log(chalk5.yellow("\n\nReceived 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...");
+    console.log(chalk5.yellow("\n\nReceived SIGTERM. Shutting down gracefully..."));
     running = false;
     await cleanupAndExit();
   });
@@ -2076,25 +2020,23 @@ async function runLocalAgent(options) {
   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`");
+    console.error(chalk5.red("Not authenticated."));
+    console.error(`   Set CONTEXTGRAPH_API_TOKEN environment variable or run ${chalk5.cyan("contextgraph-agent auth")}`);
     process.exit(1);
   }
   if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
-    console.error("\u274C Token expired. Run `contextgraph-agent auth` to re-authenticate.");
+    console.error(chalk5.red("Token expired."), `Run ${chalk5.cyan("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");
+    console.log(chalk5.dim("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
-`);
+  console.log(`${chalk5.bold("ContextGraph Agent")} ${chalk5.dim(`v${packageJson.version}`)}`);
+  console.log(chalk5.dim(`Worker ID: ${workerId}`));
+  console.log("Starting continuous worker loop...\n");
+  console.log(chalk5.dim("Press Ctrl+C to gracefully shutdown and release any claimed work\n"));
   let currentPollInterval = INITIAL_POLL_INTERVAL;
   let lastStatusTime = Date.now();
   let consecutiveApiErrors = 0;
@@ -2110,20 +2052,20 @@ async function runLocalAgent(options) {
       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.
-`);
+          console.warn(chalk5.yellow(`
+API appears to be experiencing an outage.`));
+          console.warn(chalk5.yellow(`   Will continue retrying indefinitely (every ${MAX_RETRY_DELAY / 1e3}s max).`));
+          console.warn(chalk5.yellow(`   Press Ctrl+C to stop.
+`));
         }
         if (consecutiveApiErrors < OUTAGE_WARNING_THRESHOLD) {
-          console.warn(`\u26A0\uFE0F  API error (attempt ${consecutiveApiErrors}): ${err.message}`);
+          console.warn(chalk5.yellow(`API error (attempt ${consecutiveApiErrors}):`), err.message);
         } else if (consecutiveApiErrors % 10 === 0) {
-          console.warn(`\u26A0\uFE0F  Still retrying... (attempt ${consecutiveApiErrors}, last error: ${err.message})`);
+          console.warn(chalk5.yellow(`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...`);
+          console.warn(chalk5.dim(`   Retrying in ${delaySeconds}s...`));
         }
         await sleep(apiRetryDelay);
         apiRetryDelay = Math.min(apiRetryDelay * 2, MAX_RETRY_DELAY);
@@ -2154,7 +2096,7 @@ async function runLocalAgent(options) {
     } else if (!actionDetail.done) {
       phase = "execute";
     } else {
-      console.log(`\u23ED\uFE0F  Skipping action "${actionDetail.title}" - already completed`);
+      console.log(chalk5.dim(`Skipping action "${actionDetail.title}" - already completed`));
       if (currentClaim && apiClient) {
         try {
           await apiClient.releaseClaim({
@@ -2163,13 +2105,13 @@ async function runLocalAgent(options) {
             claim_id: currentClaim.claimId
           });
         } catch (releaseError) {
-          console.error("\u26A0\uFE0F  Failed to release claim:", releaseError.message);
+          console.error(chalk5.yellow("Failed to release claim:"), releaseError.message);
         }
       }
       currentClaim = null;
       continue;
     }
-    console.log(`Working: ${actionDetail.title}`);
+    console.log(`${chalk5.bold("Working:")} ${chalk5.cyan(actionDetail.title)}`);
     let workspacePath;
     let cleanup;
     let startingCommit;
@@ -2197,7 +2139,7 @@ async function runLocalAgent(options) {
               claim_id: currentClaim.claimId
             });
           } catch (releaseError) {
-            console.error("\u26A0\uFE0F  Failed to release claim after preparation:", releaseError.message);
+            console.error(chalk5.yellow("Failed to release claim after preparation:"), releaseError.message);
           }
         }
         currentClaim = null;
@@ -2206,10 +2148,10 @@ async function runLocalAgent(options) {
       try {
         await runExecute(actionDetail.id, { cwd: workspacePath, startingCommit, model: options?.forceModel, runId });
         stats.executed++;
-        console.log(`Completed: ${actionDetail.title}`);
+        console.log(`${chalk5.bold.green("Completed:")} ${chalk5.cyan(actionDetail.title)}`);
       } catch (executeError) {
         stats.errors++;
-        console.error(`Error: ${executeError.message}. Continuing...`);
+        console.error(chalk5.red("Error:"), `${executeError.message}. Continuing...`);
       } finally {
         if (currentClaim && apiClient) {
           try {
@@ -2219,25 +2161,25 @@ async function runLocalAgent(options) {
               claim_id: currentClaim.claimId
             });
           } catch (releaseError) {
-            console.error("\u26A0\uFE0F  Failed to release claim:", releaseError.message);
+            console.error(chalk5.yellow("Failed to release claim:"), releaseError.message);
           }
         }
         currentClaim = null;
       }
     } catch (workspaceError) {
       stats.errors++;
-      console.error(`Error preparing workspace: ${workspaceError.message}. Continuing...`);
+      console.error(chalk5.red("Error preparing workspace:"), `${workspaceError.message}. Continuing...`);
       if (currentClaim && apiClient) {
         try {
-          console.log(`\u{1F9F9} Releasing claim due to workspace error...`);
+          console.log(chalk5.dim("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");
+          console.log(chalk5.dim("Claim released"));
         } catch (releaseError) {
-          console.error("\u26A0\uFE0F  Failed to release claim:", releaseError.message);
+          console.error(chalk5.yellow("Failed to release claim:"), releaseError.message);
         }
       }
       currentClaim = null;
@@ -2249,14 +2191,223 @@ async function runLocalAgent(options) {
   }
 }
 
+// src/workflows/setup.ts
+import chalk6 from "chalk";
+import { Listr } from "listr2";
+
+// src/plugin-setup.ts
+import { spawn as spawn2 } from "child_process";
+var MARKETPLACE_SOURCE = "contextgraph/claude-code-plugin";
+var MARKETPLACE_NAME = "contextgraph";
+var PLUGIN_NAME = "contextgraph";
+function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({ stdout, exitCode: code ?? 1 });
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn ${command}: ${err.message}`));
+    });
+  });
+}
+async function isClaudeCodeAvailable() {
+  try {
+    const { exitCode } = await runCommand("claude", ["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function isMarketplaceConfigured() {
+  try {
+    const { stdout, exitCode } = await runCommand("claude", ["plugin", "marketplace", "list"]);
+    return exitCode === 0 && stdout.includes(MARKETPLACE_NAME);
+  } catch {
+    return false;
+  }
+}
+async function addMarketplace() {
+  console.log("Adding ContextGraph marketplace...");
+  const { exitCode } = await runCommand("claude", ["plugin", "marketplace", "add", MARKETPLACE_SOURCE]);
+  if (exitCode !== 0) {
+    throw new Error(`Failed to add marketplace (exit code ${exitCode})`);
+  }
+}
+async function isPluginInstalled() {
+  try {
+    const { stdout, exitCode } = await runCommand("claude", ["plugin", "list"]);
+    return exitCode === 0 && stdout.includes(PLUGIN_NAME);
+  } catch {
+    return false;
+  }
+}
+async function ensurePluginInstalled() {
+  if (await isPluginInstalled()) {
+    return;
+  }
+  if (!await isMarketplaceConfigured()) {
+    await addMarketplace();
+  }
+  console.log("Installing ContextGraph plugin for Claude Code...");
+  const { exitCode } = await runCommand("claude", ["plugin", "install", PLUGIN_NAME]);
+  if (exitCode !== 0) {
+    throw new Error(`Failed to install plugin (exit code ${exitCode})`);
+  }
+  console.log("ContextGraph plugin installed (includes MCP server)");
+}
+
+// src/workflows/setup.ts
+async function runSetup() {
+  console.log(`
+${chalk6.bold("Welcome to ContextGraph!")}`);
+  console.log("This setup wizard will help you get started.\n");
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking authentication",
+        task: async (ctx2, task) => {
+          const creds = await loadCredentials();
+          if (!creds) {
+            ctx2.needsAuth = true;
+          } else if (isExpired(creds) || isTokenExpired(creds.clerkToken)) {
+            ctx2.needsAuth = true;
+          } else {
+            ctx2.needsAuth = false;
+            ctx2.userId = creds.userId;
+            ctx2.displayName = creds.email ?? creds.userId;
+            task.title = `Checking authentication \u2014 logged in as ${chalk6.cyan(ctx2.displayName)}`;
+          }
+        }
+      },
+      {
+        title: "Authenticating with ContextGraph",
+        skip: (ctx2) => !ctx2.needsAuth ? "Already authenticated" : false,
+        task: async (ctx2, task) => {
+          task.output = "Waiting for browser...";
+          const result = await authenticateAgent();
+          if (!result.success) {
+            throw new Error("Authentication failed: " + result.error);
+          }
+          ctx2.userId = result.credentials.userId;
+          ctx2.displayName = result.credentials.email ?? result.credentials.userId;
+          task.title = `Authenticated as ${chalk6.cyan(ctx2.displayName)}`;
+        },
+        options: { bottomBar: Infinity }
+      },
+      {
+        title: "Checking for Claude Code",
+        task: async (ctx2, task) => {
+          ctx2.hasClaudeCode = await isClaudeCodeAvailable();
+          task.title = ctx2.hasClaudeCode ? "Checking for Claude Code \u2014 detected" : "Checking for Claude Code \u2014 not found";
+        }
+      },
+      {
+        title: "Installing ContextGraph plugin",
+        skip: (ctx2) => !ctx2.hasClaudeCode ? "Claude Code not detected" : false,
+        task: async (ctx2, task) => {
+          try {
+            if (await isPluginInstalled()) {
+              ctx2.pluginInstalled = true;
+              task.title = "ContextGraph plugin already installed";
+            } else {
+              await ensurePluginInstalled();
+              ctx2.pluginInstalled = true;
+              task.title = "ContextGraph plugin installed";
+            }
+          } catch {
+            ctx2.pluginInstalled = false;
+            task.skip("Could not install automatically \u2014 see manual instructions below");
+          }
+        }
+      }
+    ],
+    {
+      ctx: { needsAuth: false, userId: null, displayName: null, hasClaudeCode: false, pluginInstalled: false },
+      rendererOptions: { collapseErrors: false }
+    }
+  );
+  const ctx = await tasks.run();
+  console.log("");
+  if (ctx.hasClaudeCode) {
+    if (!ctx.pluginInstalled) {
+      console.log(chalk6.yellow("Plugin could not be installed automatically."));
+      console.log("You can install it manually with:\n");
+      console.log(`  ${chalk6.dim("$")} claude plugin marketplace add contextgraph/claude-code-plugin`);
+      console.log(`  ${chalk6.dim("$")} claude plugin install contextgraph
+`);
+    }
+    console.log(chalk6.bold.green("Setup complete!") + " You're ready to go.\n");
+    console.log(`There are three ways to work with ContextGraph:
+`);
+    console.log(chalk6.bold("1. Run the ContextGraph agent"));
+    console.log("   Wraps Claude Code and automatically prepares and executes");
+    console.log("   actions for you in your codebase.\n");
+    console.log(`   ${chalk6.cyan("npx @contextgraph/agent run")}
+`);
+    console.log(chalk6.bold("2. Use ContextGraph directly via Claude Code"));
+    console.log("   Open Claude Code (or restart if already running) and interact");
+    console.log("   with your action graph through the MCP tools.\n");
+    console.log(chalk6.dim("   Examples:"));
+    console.log(chalk6.dim('     "Create an action plan for implementing user auth"'));
+    console.log(chalk6.dim('     "Show me my action tree"'));
+    console.log(chalk6.dim('     "What should I work on next?"'));
+    console.log(chalk6.dim('     "Capture this discussion as an action with sub-tasks"'));
+    console.log("");
+    console.log(chalk6.bold("3. Integrate the MCP server into other platforms"));
+    console.log("   Add the ContextGraph MCP server to any compatible tool.\n");
+    console.log(`   MCP Server URL: ${chalk6.cyan("https://mcp.contextgraph.dev")}
+`);
+    console.log(chalk6.dim("   Works with: Cursor, Claude.ai, ChatGPT, Codex CLI, Windsurf,"));
+    console.log(chalk6.dim("   and any other MCP-compatible client."));
+    console.log("");
+    console.log(`  Web dashboard:  ${chalk6.cyan("https://contextgraph.dev")}`);
+  } else {
+    console.log("You have a few options:\n");
+    console.log(chalk6.bold("Option 1: Install Claude Code"));
+    console.log(`   Visit: ${chalk6.cyan("https://claude.ai/download")}`);
+    console.log(`   Then run this setup again: ${chalk6.cyan("npx @contextgraph/agent@latest setup")}
+`);
+    console.log(chalk6.bold("Option 2: Use ContextGraph MCP server with other editors"));
+    console.log("   ContextGraph works with any MCP-compatible editor!\n");
+    console.log("   To add the ContextGraph MCP server to your editor:");
+    console.log(`   - Cursor: See ${chalk6.cyan("https://docs.cursor.com/advanced/mcp")}`);
+    console.log(`   - Windsurf: See ${chalk6.cyan("https://docs.windsurf.ai/mcp")}`);
+    console.log(`   - Other: See ${chalk6.cyan("https://modelcontextprotocol.io/clients")}
+`);
+    console.log("   MCP Server URL:");
+    console.log(`   ${chalk6.cyan("https://mcp.contextgraph.dev")}
+`);
+    console.log(chalk6.bold("Option 3: Use the agent CLI directly"));
+    console.log(`   Run autonomous agent: ${chalk6.cyan("npx @contextgraph/agent run")}`);
+    console.log(`   Execute specific action: ${chalk6.cyan("npx @contextgraph/agent execute <action-id>")}`);
+    console.log(`   Prepare an action: ${chalk6.cyan("npx @contextgraph/agent prepare <action-id>")}
+`);
+    console.log(`Authentication complete! Visit ${chalk6.cyan("https://contextgraph.dev")} to get started!`);
+  }
+  console.log("");
+}
+
 // src/cli/index.ts
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname2(__filename3);
 var packageJson2 = JSON.parse(
-  readFileSync2(join6(__dirname3, "../package.json"), "utf-8")
+  readFileSync2(join5(__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("setup").description("Interactive setup wizard for new users").action(async () => {
+  try {
+    await runSetup();
+  } catch (error) {
+    console.error("Error during setup:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
 program.command("run").description("Run continuous worker loop (claims and executes actions until Ctrl+C)").option("--force-haiku", "Force all workflows to use claude-haiku-4-5 instead of default models").option("--skip-skills", "Skip skill injection (for testing)").action(async (options) => {
   try {
     await runLocalAgent({