@vibetasks/cli 0.2.0 → 0.3.0

package/dist/{vibetasks.js → bin/vibetasks.js}

@@ -1,7 +1,17 @@
 #!/usr/bin/env node
+import {
+  checkClipboardForError,
+  createClipboardMonitor,
+  detectError,
+  formatErrorForNotes,
+  getErrorSummary
+} from "../chunk-PZF4VRDG.js";
+import {
+  daemonConfigManager
+} from "../chunk-2KRLRG4G.js";
 
 // bin/vibetasks.ts
-import { Command as Command13 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/commands/login.ts
 import { Command } from "commander";
@@ -1055,7 +1065,13 @@ import chalk11 from "chalk";
 import ora8 from "ora";
 import fs from "fs/promises";
 import path from "path";
-var hooksCommand = new Command10("hooks").description("Manage git hooks integration").command("install").description("Install git hooks in current repository").action(async () => {
+function getVibetasksHooksPath() {
+  const cliRoot = path.dirname(path.dirname(path.dirname(new URL(import.meta.url).pathname)));
+  const normalizedPath = process.platform === "win32" && cliRoot.startsWith("/") ? cliRoot.slice(1) : cliRoot;
+  return path.join(normalizedPath, "hooks");
+}
+var hooksCommand = new Command10("hooks").description("Manage hooks integration (git and Claude Code)");
+hooksCommand.command("install").description("Install git hooks in current repository").action(async () => {
   const spinner = ora8("Installing git hooks...").start();
   try {
     const gitDir = path.join(process.cwd(), ".git");
@@ -1070,7 +1086,7 @@ var hooksCommand = new Command10("hooks").description("Manage git hooks integrat
     await fs.mkdir(hooksDir, { recursive: true });
     const postCommitPath = path.join(hooksDir, "post-commit");
     const hookScript = `#!/bin/sh
-# TaskFlow post-commit hook
+# VibeTasks post-commit hook
 # Automatically updates tasks based on commit messages
 
 # Get the commit message
@@ -1085,14 +1101,14 @@ if [ -n "$TASK_ID" ]; then
 
   if [ -n "$IS_COMPLETE" ]; then
     # Mark task as complete
-    taskflow done "$TASK_ID" 2>/dev/null || true
+    vibetasks done "$TASK_ID" 2>/dev/null || true
   else
     # Add commit info to task notes
     COMMIT_HASH=$(git log -1 --pretty=%h)
     COMMIT_TYPE=$(echo "$COMMIT_MSG" | grep -oP '^\\w+(?=:)' || echo "update")
 
     # Update task with commit reference (silently, don't block commit)
-    taskflow update "$TASK_ID" --notes "Commit $COMMIT_HASH: $COMMIT_TYPE" 2>/dev/null || true
+    vibetasks update "$TASK_ID" --notes "Commit $COMMIT_HASH: $COMMIT_TYPE" 2>/dev/null || true
   fi
 fi
 
@@ -1100,13 +1116,13 @@ exit 0
 `;
     await fs.writeFile(postCommitPath, hookScript, { mode: 493 });
     spinner.succeed(chalk11.green("Git hooks installed!"));
-    console.log(chalk11.gray("\n\u{1F4CC} Post-commit hook created"));
-    console.log(chalk11.gray("Location:"), postCommitPath);
-    console.log(chalk11.blue.bold("\n\u2728 How to use:\n"));
-    console.log(chalk11.white("1. Link commits to tasks:"));
-    console.log(chalk11.gray('   git commit -m "feat: Add login [TASK-abc123]"'));
-    console.log(chalk11.white("\n2. Auto-complete tasks:"));
-    console.log(chalk11.gray('   git commit -m "feat: Complete feature [TASK-abc123] [COMPLETE]"'));
+    console.log(chalk11.gray("\n  Post-commit hook created"));
+    console.log(chalk11.gray("  Location:"), postCommitPath);
+    console.log(chalk11.blue.bold("\n  How to use:\n"));
+    console.log(chalk11.white("  1. Link commits to tasks:"));
+    console.log(chalk11.gray('     git commit -m "feat: Add login [TASK-abc123]"'));
+    console.log(chalk11.white("\n  2. Auto-complete tasks:"));
+    console.log(chalk11.gray('     git commit -m "feat: Complete feature [TASK-abc123] [COMPLETE]"'));
     console.log();
     process.exit(0);
   } catch (error) {
@@ -1117,6 +1133,106 @@ Error: ${error.message}
     process.exit(1);
   }
 });
+hooksCommand.command("claude").description("Generate Claude Code hook configuration for TodoWrite sync").option("--project <path>", "Project path (defaults to current directory)").option("--output", "Output config to stdout instead of installing").action(async (options) => {
+  const spinner = ora8("Generating Claude Code hook configuration...").start();
+  try {
+    const projectPath = options.project || process.cwd();
+    const hooksPath = getVibetasksHooksPath();
+    const syncScriptPath = path.join(hooksPath, "sync-todos.js");
+    const hookConfig = {
+      hooks: {
+        SubagentStop: [
+          {
+            command: `node "${syncScriptPath.replace(/\\/g, "/")}"`,
+            timeout: 1e4,
+            input: {
+              todoState: true
+            }
+          }
+        ]
+      }
+    };
+    if (options.output) {
+      spinner.stop();
+      console.log(JSON.stringify(hookConfig, null, 2));
+      process.exit(0);
+    }
+    const claudeDir = path.join(projectPath, ".claude");
+    await fs.mkdir(claudeDir, { recursive: true });
+    const settingsPath = path.join(claudeDir, "settings.json");
+    let existingSettings = {};
+    try {
+      const data = await fs.readFile(settingsPath, "utf-8");
+      existingSettings = JSON.parse(data);
+    } catch {
+    }
+    existingSettings.hooks = existingSettings.hooks || {};
+    existingSettings.hooks.SubagentStop = existingSettings.hooks.SubagentStop || [];
+    const existingHookIndex = existingSettings.hooks.SubagentStop.findIndex(
+      (h) => h.command?.includes("sync-todos.js")
+    );
+    if (existingHookIndex >= 0) {
+      existingSettings.hooks.SubagentStop[existingHookIndex] = hookConfig.hooks.SubagentStop[0];
+      spinner.text = "Updating existing Claude Code hook...";
+    } else {
+      existingSettings.hooks.SubagentStop.push(hookConfig.hooks.SubagentStop[0]);
+    }
+    await fs.writeFile(settingsPath, JSON.stringify(existingSettings, null, 2), "utf-8");
+    spinner.succeed(chalk11.green("Claude Code hooks configured!"));
+    console.log(chalk11.gray("\n  Configuration written to:"));
+    console.log(chalk11.white(`  ${settingsPath}`));
+    console.log(chalk11.gray("\n  Hook script location:"));
+    console.log(chalk11.white(`  ${syncScriptPath}`));
+    console.log(chalk11.blue.bold("\n  How it works:\n"));
+    console.log(chalk11.white("  1. When Claude marks a TodoWrite item as completed"));
+    console.log(chalk11.white("  2. The SubagentStop hook triggers"));
+    console.log(chalk11.white("  3. sync-todos.js syncs status to vibetasks"));
+    console.log(chalk11.gray("\n  Status mapping:"));
+    console.log(chalk11.gray("    pending     -> todo"));
+    console.log(chalk11.gray("    in_progress -> vibing"));
+    console.log(chalk11.gray("    completed   -> done"));
+    console.log(chalk11.yellow.bold("\n  Note: Ensure vibetasks MCP is configured in Claude Code."));
+    console.log(chalk11.gray("  Run: vibetasks setup claude\n"));
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk11.red("Failed to configure Claude Code hooks"));
+    console.error(chalk11.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+hooksCommand.command("status").description("Show status of installed hooks").action(async () => {
+  console.log(chalk11.blue.bold("\n  VibeTasks Hooks Status\n"));
+  const gitHooksDir = path.join(process.cwd(), ".git", "hooks");
+  const postCommitPath = path.join(gitHooksDir, "post-commit");
+  try {
+    const content = await fs.readFile(postCommitPath, "utf-8");
+    if (content.includes("vibetasks") || content.includes("VibeTasks")) {
+      console.log(chalk11.green("  [x] Git post-commit hook installed"));
+    } else {
+      console.log(chalk11.yellow("  [ ] Git post-commit hook (exists but not vibetasks)"));
+    }
+  } catch {
+    console.log(chalk11.gray("  [ ] Git post-commit hook not installed"));
+  }
+  const claudeSettingsPath = path.join(process.cwd(), ".claude", "settings.json");
+  try {
+    const content = await fs.readFile(claudeSettingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    if (settings.hooks?.SubagentStop?.some((h) => h.command?.includes("sync-todos"))) {
+      console.log(chalk11.green("  [x] Claude Code SubagentStop hook configured"));
+    } else {
+      console.log(chalk11.gray("  [ ] Claude Code SubagentStop hook not configured"));
+    }
+  } catch {
+    console.log(chalk11.gray("  [ ] Claude Code hooks not configured"));
+  }
+  console.log(chalk11.gray("\n  To install hooks:"));
+  console.log(chalk11.gray("    Git:    vibetasks hooks install"));
+  console.log(chalk11.gray("    Claude: vibetasks hooks claude\n"));
+  process.exit(0);
+});
 
 // src/commands/init.ts
 import { Command as Command11 } from "commander";
@@ -1723,8 +1839,801 @@ var setupCommand = new Command12("setup").description("Interactive setup wizard
   process.exit(0);
 });
 
+// src/commands/watch.ts
+import { Command as Command13 } from "commander";
+import chalk14 from "chalk";
+import ora11 from "ora";
+import inquirer6 from "inquirer";
+import { AuthManager as AuthManager13, TaskOperations as TaskOperations9 } from "@vibetasks/core";
+import { detectProject as detectProject4 } from "@vibetasks/shared/utils/project-detector";
+var watchCommand = new Command13("watch").description("Monitor clipboard for errors and offer to capture them as tasks").option("-i, --interval <ms>", "Polling interval in milliseconds", "1000").option("-a, --auto", "Auto-create tasks without prompting").option("-q, --quiet", "Minimal output (only show errors)").option("--project <name>", "Override auto-detected project").action(async (options) => {
+  const interval = parseInt(options.interval || "1000", 10);
+  if (!options.quiet) {
+    console.log();
+    console.log(chalk14.cyan.bold("VibeTasks Clipboard Monitor"));
+    console.log(chalk14.gray("Watching for errors in your clipboard..."));
+    console.log();
+  }
+  let authManager;
+  let taskOps;
+  try {
+    authManager = new AuthManager13();
+    taskOps = await TaskOperations9.fromAuthManager(authManager);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk14.yellow("\nYou need to login first"));
+      console.error(chalk14.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk14.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+  let projectTag = options.project;
+  if (!projectTag) {
+    try {
+      const detected = await detectProject4(process.cwd());
+      projectTag = detected.name;
+      if (!options.quiet) {
+        console.log(chalk14.gray(`Project: ${chalk14.white(projectTag)}`));
+      }
+    } catch {
+    }
+  }
+  const recentErrors = /* @__PURE__ */ new Set();
+  const handleError = async (error) => {
+    const errorHash = `${error.type}:${error.message.substring(0, 50)}`;
+    if (recentErrors.has(errorHash)) {
+      return;
+    }
+    console.log();
+    console.log(chalk14.red.bold("Error detected in clipboard!"));
+    console.log(chalk14.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk14.yellow(getErrorSummary(error)));
+    console.log();
+    if (error.suggestion) {
+      console.log(chalk14.cyan("Suggestion: ") + error.suggestion);
+      console.log();
+    }
+    if (options.auto) {
+      await createTaskFromError(error, taskOps, projectTag);
+      recentErrors.add(errorHash);
+      return;
+    }
+    const { action } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { name: "Create task from this error", value: "create" },
+          { name: "Show full error", value: "show" },
+          { name: "Ignore", value: "ignore" },
+          { name: "Stop watching", value: "stop" }
+        ]
+      }
+    ]);
+    switch (action) {
+      case "create":
+        await createTaskFromError(error, taskOps, projectTag);
+        recentErrors.add(errorHash);
+        break;
+      case "show":
+        console.log();
+        console.log(chalk14.gray("\u2500".repeat(50)));
+        console.log(error.rawText);
+        console.log(chalk14.gray("\u2500".repeat(50)));
+        console.log();
+        const { afterShow } = await inquirer6.prompt([
+          {
+            type: "list",
+            name: "afterShow",
+            message: "Now what?",
+            choices: [
+              { name: "Create task from this error", value: "create" },
+              { name: "Ignore", value: "ignore" }
+            ]
+          }
+        ]);
+        if (afterShow === "create") {
+          await createTaskFromError(error, taskOps, projectTag);
+          recentErrors.add(errorHash);
+        }
+        break;
+      case "stop":
+        monitor.stop();
+        process.exit(0);
+        break;
+      case "ignore":
+      default:
+        if (!options.quiet) {
+          console.log(chalk14.gray("Error ignored, continuing to watch..."));
+        }
+        break;
+    }
+    console.log();
+  };
+  const monitor = createClipboardMonitor({
+    interval,
+    onError: handleError,
+    onStart: () => {
+      if (!options.quiet) {
+        console.log(chalk14.green("Started watching clipboard"));
+        console.log(chalk14.gray(`Interval: ${interval}ms`));
+        if (options.auto) {
+          console.log(chalk14.yellow("Auto-create mode: ON"));
+        }
+        console.log();
+        console.log(chalk14.gray("Press Ctrl+C to stop"));
+        console.log();
+      }
+    },
+    onStop: () => {
+      if (!options.quiet) {
+        console.log();
+        console.log(chalk14.yellow("Stopped watching clipboard"));
+      }
+    }
+  });
+  process.on("SIGINT", () => {
+    monitor.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    monitor.stop();
+    process.exit(0);
+  });
+  await monitor.start();
+  await new Promise(() => {
+  });
+});
+async function createTaskFromError(error, taskOps, projectTag) {
+  const spinner = ora11("Creating task...").start();
+  try {
+    const title = generateTaskTitle(error);
+    const task = await taskOps.createTask({
+      title,
+      notes: formatErrorForNotes(error),
+      notes_format: "markdown",
+      priority: error.category === "typescript" ? "medium" : "high",
+      project_tag: projectTag,
+      created_by: "human",
+      // User triggered this
+      status: "todo"
+    });
+    const tagName = `error-${error.category}`;
+    try {
+      const tag = await taskOps.findOrCreateTag(tagName, getTagColor(error.category));
+      await taskOps.linkTaskTags(task.id, [tag.id]);
+    } catch {
+    }
+    spinner.succeed(chalk14.green("Task created!"));
+    console.log(chalk14.gray(`ID: ${task.id.substring(0, 8)}...`));
+    console.log(chalk14.white.bold(title));
+  } catch (err) {
+    spinner.fail(chalk14.red("Failed to create task"));
+    console.error(chalk14.red(`Error: ${err.message}`));
+  }
+}
+function generateTaskTitle(error) {
+  const prefix = getCategoryPrefix(error.category);
+  let title = `${prefix} ${error.type}`;
+  if (error.message && error.message.length < 60) {
+    title += `: ${error.message}`;
+  } else if (error.message) {
+    const shortMessage = error.message.split(/[.!?\n]/)[0].trim();
+    if (shortMessage.length < 60) {
+      title += `: ${shortMessage}`;
+    }
+  }
+  if (error.file) {
+    const fileName = error.file.split(/[/\\]/).pop();
+    if (fileName && title.length + fileName.length < 100) {
+      title += ` in ${fileName}`;
+    }
+  }
+  if (title.length > 120) {
+    title = title.substring(0, 117) + "...";
+  }
+  return title;
+}
+function getCategoryPrefix(category) {
+  const prefixes = {
+    nodejs: "Fix",
+    npm: "Resolve npm",
+    expo: "Fix Expo",
+    "react-native": "Fix RN",
+    webpack: "Fix build",
+    typescript: "Fix TS",
+    python: "Fix Python",
+    generic: "Fix"
+  };
+  return prefixes[category] || "Fix";
+}
+function getTagColor(category) {
+  const colors = {
+    nodejs: "#68A063",
+    // Node green
+    npm: "#CB3837",
+    // npm red
+    expo: "#000020",
+    // Expo dark
+    "react-native": "#61DAFB",
+    // React blue
+    webpack: "#8DD6F9",
+    // Webpack blue
+    typescript: "#3178C6",
+    // TS blue
+    python: "#3776AB",
+    // Python blue
+    generic: "#FF6B6B"
+    // Generic red
+  };
+  return colors[category] || "#FF6B6B";
+}
+var checkCommand = new Command13("check-clipboard").description("Check clipboard once for errors").action(async () => {
+  console.log(chalk14.gray("Checking clipboard..."));
+  const error = await checkClipboardForError();
+  if (!error) {
+    console.log(chalk14.green("No errors detected in clipboard."));
+    process.exit(0);
+  }
+  console.log();
+  console.log(chalk14.red.bold("Error detected!"));
+  console.log(chalk14.gray("\u2500".repeat(50)));
+  console.log();
+  console.log(chalk14.yellow(getErrorSummary(error)));
+  console.log();
+  if (error.suggestion) {
+    console.log(chalk14.cyan("Suggestion: ") + error.suggestion);
+  }
+  console.log();
+  console.log(chalk14.gray("Use `vibetasks watch` to monitor continuously."));
+  process.exit(0);
+});
+
+// src/commands/archive.ts
+import { Command as Command14 } from "commander";
+import chalk15 from "chalk";
+import ora12 from "ora";
+import inquirer7 from "inquirer";
+import { AuthManager as AuthManager14, TaskOperations as TaskOperations10 } from "@vibetasks/core";
+var archiveCommand = new Command14("archive").description("Archive a task or manage archived tasks").argument("[task-id]", "Task ID to archive (full or first 8 characters)").option("-l, --list", "List all archived tasks").option("-u, --unarchive <id>", "Unarchive a task by ID").option("--pick", "Pick from completed tasks to archive").action(async (taskId, options) => {
+  const spinner = ora12();
+  try {
+    const authManager = new AuthManager14();
+    const taskOps = await TaskOperations10.fromAuthManager(authManager);
+    if (options.list) {
+      spinner.start("Fetching archived tasks...");
+      const archivedTasks = await taskOps.getArchivedTasks();
+      spinner.stop();
+      if (archivedTasks.length === 0) {
+        console.log(chalk15.yellow("\nNo archived tasks found.\n"));
+        process.exit(0);
+      }
+      console.log(chalk15.white("\nArchived Tasks:\n"));
+      archivedTasks.forEach((task2, index) => {
+        const archivedDate = task2.archived_at ? new Date(task2.archived_at).toLocaleDateString() : "Unknown";
+        console.log(
+          chalk15.gray(`${index + 1}. `) + chalk15.white(task2.title) + chalk15.gray(` [${task2.id.slice(0, 8)}]`) + chalk15.gray(` - Archived: ${archivedDate}`)
+        );
+      });
+      console.log(chalk15.gray(`
+Total: ${archivedTasks.length} archived tasks
+`));
+      console.log(chalk15.gray("To restore a task: vibetasks archive --unarchive <id>\n"));
+      process.exit(0);
+    }
+    if (options.unarchive) {
+      spinner.start("Restoring task...");
+      let targetId2 = options.unarchive;
+      if (targetId2.length < 32) {
+        const archivedTasks = await taskOps.getArchivedTasks();
+        const matchingTask = archivedTasks.find((t) => t.id.startsWith(targetId2));
+        if (!matchingTask) {
+          spinner.fail(chalk15.red("Archived task not found"));
+          console.error(chalk15.gray(`
+No archived task found with ID starting with: ${targetId2}
+`));
+          process.exit(1);
+        }
+        targetId2 = matchingTask.id;
+      }
+      const task2 = await taskOps.unarchiveTask(targetId2);
+      spinner.succeed(chalk15.green("Task restored!"));
+      console.log(chalk15.gray(`
+Restored: ${task2.title}`));
+      console.log(chalk15.gray(`Status set to: done
+`));
+      process.exit(0);
+    }
+    if (options.pick || !taskId) {
+      const allTasks = await taskOps.getTasks("completed");
+      if (allTasks.length === 0) {
+        console.log(chalk15.yellow("\nNo completed tasks to archive. Complete some tasks first!\n"));
+        process.exit(0);
+      }
+      const { selectedTask } = await inquirer7.prompt([{
+        type: "list",
+        name: "selectedTask",
+        message: "Pick a completed task to archive:",
+        choices: allTasks.map((t) => ({
+          name: `${t.title}${t.completed_at ? chalk15.gray(` - Completed: ${new Date(t.completed_at).toLocaleDateString()}`) : ""}`,
+          value: t.id
+        }))
+      }]);
+      taskId = selectedTask;
+    }
+    if (!taskId) {
+      console.log(chalk15.yellow("\nUsage: vibetasks archive <task-id>"));
+      console.log(chalk15.gray("  or: vibetasks archive --pick"));
+      console.log(chalk15.gray("  or: vibetasks archive --list"));
+      console.log(chalk15.gray("  or: vibetasks archive --unarchive <id>\n"));
+      process.exit(1);
+    }
+    spinner.start("Archiving task...");
+    let targetId = taskId;
+    if (taskId.length < 32) {
+      const allTasks = await taskOps.getTasks("all", true);
+      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
+      if (!matchingTask) {
+        spinner.fail(chalk15.red("Task not found"));
+        console.error(chalk15.gray(`
+No task found with ID starting with: ${taskId}
+`));
+        process.exit(1);
+      }
+      targetId = matchingTask.id;
+    }
+    const task = await taskOps.archiveTask(targetId);
+    spinner.succeed(chalk15.green("Task archived!"));
+    console.log(chalk15.gray(`
+Archived: ${task.title}`));
+    console.log(chalk15.gray(`Archived at: ${(/* @__PURE__ */ new Date()).toLocaleString()}`));
+    console.log(chalk15.gray("\nTo view archived tasks: vibetasks archive --list"));
+    console.log(chalk15.gray(`To restore: vibetasks archive --unarchive ${targetId.slice(0, 8)}
+`));
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk15.red("Operation failed"));
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk15.yellow("\nYou need to login first"));
+      console.error(chalk15.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk15.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/daemon.ts
+import { Command as Command15 } from "commander";
+import chalk16 from "chalk";
+import ora13 from "ora";
+import { spawn } from "child_process";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { AuthManager as AuthManager15, TaskOperations as TaskOperations11 } from "@vibetasks/core";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var daemonCommand = new Command15("daemon").description("Manage the VibeTasks error capture daemon").addCommand(createStartCommand()).addCommand(createStopCommand()).addCommand(createStatusCommand()).addCommand(createConfigureCommand()).addCommand(createCaptureCommand());
+function createStartCommand() {
+  return new Command15("start").description("Start the error capture daemon").option("-f, --foreground", "Run in foreground (useful for debugging)").option("--no-notify", "Disable startup notification").action(async (options) => {
+    const spinner = ora13("Starting VibeTasks daemon...").start();
+    try {
+      if (await daemonConfigManager.isDaemonRunning()) {
+        spinner.warn(chalk16.yellow("Daemon is already running"));
+        const pid = await daemonConfigManager.getPid();
+        console.log(chalk16.gray(`PID: ${pid}`));
+        process.exit(0);
+      }
+      const config = await daemonConfigManager.getConfig();
+      if (!config.enabled) {
+        spinner.fail(chalk16.red("Daemon is disabled in configuration"));
+        console.log(chalk16.gray("Run: vibetasks daemon configure --enable"));
+        process.exit(1);
+      }
+      if (options.foreground) {
+        spinner.succeed(chalk16.green("Starting daemon in foreground mode"));
+        console.log(chalk16.gray("Press Ctrl+C to stop\n"));
+        await runDaemonForeground(config);
+      } else {
+        const daemonProcess = await startDaemonBackground(config);
+        if (daemonProcess && daemonProcess.pid) {
+          await daemonConfigManager.savePid(daemonProcess.pid);
+          spinner.succeed(chalk16.green("VibeTasks daemon started"));
+          console.log(chalk16.gray(`PID: ${daemonProcess.pid}`));
+          console.log(chalk16.cyan(`Keyboard shortcut: ${config.keyboard_shortcut}`));
+          console.log(chalk16.gray("\nThe daemon is now running in the background."));
+          console.log(chalk16.gray('Use "vibetasks daemon stop" to stop it.'));
+        } else {
+          throw new Error("Failed to start daemon process");
+        }
+      }
+      process.exit(0);
+    } catch (error) {
+      spinner.fail(chalk16.red("Failed to start daemon"));
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+function createStopCommand() {
+  return new Command15("stop").description("Stop the error capture daemon").action(async () => {
+    const spinner = ora13("Stopping VibeTasks daemon...").start();
+    try {
+      const pid = await daemonConfigManager.getPid();
+      if (!pid) {
+        spinner.warn(chalk16.yellow("Daemon is not running"));
+        process.exit(0);
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        try {
+          process.kill(pid, 0);
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+        await daemonConfigManager.removePid();
+        spinner.succeed(chalk16.green("VibeTasks daemon stopped"));
+      } catch (error) {
+        if (error.code === "ESRCH") {
+          await daemonConfigManager.removePid();
+          spinner.warn(chalk16.yellow("Daemon was not running (stale PID file removed)"));
+        } else {
+          throw error;
+        }
+      }
+      process.exit(0);
+    } catch (error) {
+      spinner.fail(chalk16.red("Failed to stop daemon"));
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+function createStatusCommand() {
+  return new Command15("status").description("Check daemon status").action(async () => {
+    try {
+      const isRunning = await daemonConfigManager.isDaemonRunning();
+      const config = await daemonConfigManager.getConfig();
+      const pid = await daemonConfigManager.getPid();
+      console.log(chalk16.blue.bold("\nVibeTasks Daemon Status\n"));
+      if (isRunning) {
+        console.log(chalk16.green("  Status: Running"));
+        console.log(chalk16.gray(`  PID: ${pid}`));
+      } else {
+        console.log(chalk16.yellow("  Status: Stopped"));
+      }
+      console.log(chalk16.gray(`  Enabled: ${config.enabled ? "Yes" : "No"}`));
+      console.log(chalk16.gray(`  Keyboard Shortcut: ${config.keyboard_shortcut}`));
+      console.log(chalk16.gray(`  Auto-start: ${config.auto_start ? "Yes" : "No"}`));
+      console.log(chalk16.gray(`  Auto-create tasks: ${config.auto_create_task ? "Yes" : "No"}`));
+      console.log(chalk16.gray(`  Config path: ${daemonConfigManager.getConfigDir()}`));
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+function createConfigureCommand() {
+  return new Command15("configure").description("Configure daemon settings").option("--enable", "Enable the daemon").option("--disable", "Disable the daemon").option("--shortcut <keys>", 'Set keyboard shortcut (e.g., "Ctrl+Alt+E")').option("--auto-start <bool>", "Enable/disable auto-start on login").option("--auto-task <bool>", "Automatically create tasks from errors").option("--notification-duration <ms>", "Notification display duration in ms").option("--reset", "Reset to default configuration").action(async (options) => {
+    try {
+      if (options.reset) {
+        const { DEFAULT_DAEMON_CONFIG } = await import("../daemon-config-EUSBQA4E.js");
+        await daemonConfigManager.saveConfig(DEFAULT_DAEMON_CONFIG);
+        console.log(chalk16.green("\nConfiguration reset to defaults\n"));
+        process.exit(0);
+      }
+      const updates = {};
+      if (options.enable) updates.enabled = true;
+      if (options.disable) updates.enabled = false;
+      if (options.shortcut) updates.keyboard_shortcut = options.shortcut;
+      if (options.autoStart !== void 0) updates.auto_start = options.autoStart === "true";
+      if (options.autoTask !== void 0) updates.auto_create_task = options.autoTask === "true";
+      if (options.notificationDuration) updates.notification_duration = parseInt(options.notificationDuration, 10);
+      if (Object.keys(updates).length === 0) {
+        const config = await daemonConfigManager.getConfig();
+        console.log(chalk16.blue.bold("\nDaemon Configuration\n"));
+        console.log(JSON.stringify(config, null, 2));
+        console.log();
+      } else {
+        await daemonConfigManager.saveConfig(updates);
+        console.log(chalk16.green("\nConfiguration updated\n"));
+        if (await daemonConfigManager.isDaemonRunning()) {
+          console.log(chalk16.yellow("Note: Restart the daemon for changes to take effect"));
+          console.log(chalk16.gray("Run: vibetasks daemon stop && vibetasks daemon start\n"));
+        }
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+function createCaptureCommand() {
+  return new Command15("capture").description("Manually capture clipboard and check for errors").option("--create-task", "Create a task from the captured error").option("--raw", "Show raw clipboard content").action(async (options) => {
+    const spinner = ora13("Capturing clipboard...").start();
+    try {
+      const clipboard = await import("clipboardy");
+      const content = await clipboard.default.read();
+      spinner.stop();
+      if (!content || content.trim().length === 0) {
+        console.log(chalk16.yellow("\nClipboard is empty\n"));
+        process.exit(0);
+      }
+      if (options.raw) {
+        console.log(chalk16.blue.bold("\nClipboard Content:\n"));
+        console.log(content);
+        console.log();
+      }
+      const error = detectError(content);
+      if (!error) {
+        console.log(chalk16.yellow("\nNo error detected in clipboard content\n"));
+        if (!options.raw) {
+          console.log(chalk16.gray("First 200 characters:"));
+          console.log(chalk16.gray(content.substring(0, 200) + (content.length > 200 ? "..." : "")));
+          console.log();
+        }
+        process.exit(0);
+      }
+      console.log(chalk16.red.bold("\nError Detected!\n"));
+      console.log(chalk16.cyan("Type: ") + chalk16.white(error.type));
+      console.log(chalk16.cyan("Category: ") + chalk16.white(error.category));
+      console.log(chalk16.cyan("Message: ") + chalk16.white(error.message));
+      if (error.file) {
+        console.log(chalk16.cyan("File: ") + chalk16.white(error.file));
+        if (error.line) {
+          console.log(chalk16.cyan("Line: ") + chalk16.white(error.line.toString()) + (error.column ? chalk16.gray(`:${error.column}`) : ""));
+        }
+      }
+      if (error.suggestion) {
+        console.log(chalk16.green("\nSuggestion: ") + chalk16.white(error.suggestion));
+      }
+      if (error.stack) {
+        console.log(chalk16.cyan("\nStack Trace (first 5 lines):"));
+        const stackLines = error.stack.split("\n").slice(0, 5);
+        stackLines.forEach((line) => {
+          console.log(chalk16.gray("  " + line));
+        });
+      }
+      if (options.createTask) {
+        console.log();
+        await createTaskFromError2(error);
+      }
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      spinner.fail(chalk16.red("Failed to capture clipboard"));
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+async function startDaemonBackground(config) {
+  const workerPath = path3.resolve(__dirname2, "..", "daemon-worker.js");
+  const child = spawn(process.execPath, [workerPath], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      VIBETASKS_DAEMON: "true",
+      VIBETASKS_SHORTCUT: config.keyboard_shortcut
+    }
+  });
+  child.unref();
+  return child;
+}
+async function runDaemonForeground(config) {
+  console.log(chalk16.blue.bold("VibeTasks Error Capture Daemon"));
+  console.log(chalk16.gray(`Keyboard shortcut: ${config.keyboard_shortcut}`));
+  console.log(chalk16.gray("Listening for keyboard shortcut...\n"));
+  let keyListener;
+  try {
+    const { GlobalKeyboardListener } = await import("node-global-key-listener");
+    keyListener = new GlobalKeyboardListener();
+    console.log(chalk16.green("Using node-global-key-listener"));
+    const shortcut = daemonConfigManager.parseShortcut(config.keyboard_shortcut);
+    let modifiersPressed = { ctrl: false, alt: false, shift: false };
+    keyListener.addListener((event, down) => {
+      const keyName = event.name?.toUpperCase() || "";
+      if (event.name === "LEFT CTRL" || event.name === "RIGHT CTRL") {
+        modifiersPressed.ctrl = event.state === "DOWN";
+      }
+      if (event.name === "LEFT ALT" || event.name === "RIGHT ALT") {
+        modifiersPressed.alt = event.state === "DOWN";
+      }
+      if (event.name === "LEFT SHIFT" || event.name === "RIGHT SHIFT") {
+        modifiersPressed.shift = event.state === "DOWN";
+      }
+      if (event.state === "DOWN" && keyName === shortcut.key.toUpperCase() && modifiersPressed.ctrl === shortcut.ctrl && modifiersPressed.alt === shortcut.alt && modifiersPressed.shift === shortcut.shift) {
+        console.log(chalk16.cyan(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Shortcut triggered!`));
+        handleShortcutTriggered(config).catch((err) => {
+          console.error(chalk16.red(`Error handling shortcut: ${err.message}`));
+        });
+      }
+    });
+  } catch (error) {
+    console.log(chalk16.yellow(`Note: node-global-key-listener not available: ${error.message}`));
+    console.log(chalk16.gray("Install with: npm install node-global-key-listener"));
+    console.log(chalk16.gray("\nFalling back to manual capture mode."));
+    console.log(chalk16.gray('Use "vibetasks daemon capture" to manually capture clipboard.\n'));
+    await new Promise(() => {
+    });
+  }
+  process.on("SIGINT", () => {
+    console.log(chalk16.yellow("\nShutting down daemon..."));
+    if (keyListener && keyListener.kill) {
+      keyListener.kill();
+    }
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.log(chalk16.yellow("\nReceived SIGTERM, shutting down..."));
+    if (keyListener && keyListener.kill) {
+      keyListener.kill();
+    }
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+async function handleShortcutTriggered(config) {
+  try {
+    const clipboard = await import("clipboardy");
+    const content = await clipboard.default.read();
+    if (!content || content.trim().length === 0) {
+      await showNotification("VibeTasks", "Clipboard is empty", "info");
+      return;
+    }
+    const error = detectError(content);
+    if (!error) {
+      await showNotification("VibeTasks", "No error detected in clipboard", "info");
+      console.log(chalk16.gray("Clipboard content did not match error patterns"));
+      return;
+    }
+    const summary = getErrorSummary(error);
+    console.log(chalk16.red("Error detected:"));
+    console.log(chalk16.white(summary));
+    await showNotification(
+      "VibeTasks: Error Detected",
+      summary,
+      "error",
+      config.notification_duration
+    );
+    if (config.auto_create_task) {
+      console.log(chalk16.cyan("Creating task..."));
+      await createTaskFromError2(error);
+    }
+  } catch (err) {
+    console.error(chalk16.red(`Error: ${err.message}`));
+    await showNotification("VibeTasks Error", err.message, "error");
+  }
+}
+async function showNotification(title, message, type = "info", duration) {
+  try {
+    const notifier = await import("node-notifier");
+    const options = {
+      title,
+      message: message.substring(0, 256),
+      // Windows limits notification length
+      sound: type === "error",
+      wait: false
+    };
+    if (process.platform === "win32") {
+      options.appID = "VibeTasks";
+    }
+    notifier.default.notify(options);
+  } catch (error) {
+    console.log(chalk16.blue(`[Notification] ${title}: ${message}`));
+  }
+}
+function generateTaskTitle2(error) {
+  const prefix = getCategoryPrefix2(error.category);
+  let title = `${prefix} ${error.type}`;
+  if (error.message && error.message.length < 60) {
+    title += `: ${error.message}`;
+  } else if (error.message) {
+    const shortMessage = error.message.split(/[.!?\n]/)[0].trim();
+    if (shortMessage.length < 60) {
+      title += `: ${shortMessage}`;
+    }
+  }
+  if (error.file) {
+    const fileName = error.file.split(/[/\\]/).pop();
+    if (fileName && title.length + fileName.length < 100) {
+      title += ` in ${fileName}`;
+    }
+  }
+  if (title.length > 120) {
+    title = title.substring(0, 117) + "...";
+  }
+  return title;
+}
+function getCategoryPrefix2(category) {
+  const prefixes = {
+    nodejs: "Fix",
+    npm: "Resolve npm",
+    expo: "Fix Expo",
+    "react-native": "Fix RN",
+    webpack: "Fix build",
+    typescript: "Fix TS",
+    python: "Fix Python",
+    generic: "Fix"
+  };
+  return prefixes[category] || "Fix";
+}
+async function createTaskFromError2(error) {
+  const spinner = ora13("Creating task from error...").start();
+  try {
+    const authManager = new AuthManager15();
+    const taskOps = await TaskOperations11.fromAuthManager(authManager);
+    const title = generateTaskTitle2(error);
+    const notes = formatErrorForNotes(error);
+    const task = await taskOps.createTask({
+      title,
+      notes,
+      notes_format: "markdown",
+      priority: error.category === "typescript" ? "medium" : "high",
+      created_by: "ai",
+      status: "todo"
+    });
+    const tagName = `error-${error.category}`;
+    try {
+      const tag = await taskOps.findOrCreateTag(tagName, getTagColor2(error.category));
+      await taskOps.linkTaskTags(task.id, [tag.id]);
+    } catch {
+    }
+    spinner.succeed(chalk16.green("Task created!"));
+    console.log(chalk16.gray(`ID: ${task.id.substring(0, 8)}...`));
+    console.log(chalk16.white.bold(task.title));
+    await showNotification(
+      "VibeTasks: Task Created",
+      `Created: ${title.substring(0, 100)}`,
+      "success"
+    );
+  } catch (err) {
+    spinner.fail(chalk16.red("Failed to create task"));
+    if (err.message.includes("Not authenticated")) {
+      console.log(chalk16.yellow("You need to login first: vibetasks login"));
+    } else {
+      console.log(chalk16.red(`Error: ${err.message}`));
+    }
+  }
+}
+function getTagColor2(category) {
+  const colors = {
+    nodejs: "#68A063",
+    // Node green
+    npm: "#CB3837",
+    // npm red
+    expo: "#000020",
+    // Expo dark
+    "react-native": "#61DAFB",
+    // React blue
+    webpack: "#8DD6F9",
+    // Webpack blue
+    typescript: "#3178C6",
+    // TS blue
+    python: "#3776AB",
+    // Python blue
+    generic: "#FF6B6B"
+    // Generic red
+  };
+  return colors[category] || "#FF6B6B";
+}
+
 // bin/vibetasks.ts
-var program = new Command13();
+var program = new Command16();
 program.name("vibetasks").description("VibeTasks CLI - Fast task management for vibers").version("0.2.0");
 program.addCommand(setupCommand);
 program.addCommand(loginCommand);
@@ -1738,4 +2647,8 @@ program.addCommand(deleteCommand);
 program.addCommand(configCommand);
 program.addCommand(hooksCommand);
 program.addCommand(initCommand);
+program.addCommand(watchCommand);
+program.addCommand(checkCommand);
+program.addCommand(archiveCommand);
+program.addCommand(daemonCommand);
 program.parse();