@vibetasks/cli 0.1.0 → 0.3.0

package/dist/chunk-2KRLRG4G.js

@@ -0,0 +1,161 @@
+// src/utils/daemon-config.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var DEFAULT_DAEMON_CONFIG = {
+  enabled: true,
+  keyboard_shortcut: "Ctrl+Alt+E",
+  auto_start: false,
+  notification_duration: 5e3,
+  auto_create_task: false,
+  capture_clipboard: true,
+  capture_screen: false,
+  // Screen capture requires additional setup
+  error_patterns: [
+    "Error:",
+    "Exception:",
+    "TypeError:",
+    "ReferenceError:",
+    "SyntaxError:",
+    "FATAL:",
+    "FAILED:",
+    "error\\[",
+    "panic:",
+    "Traceback",
+    "at Object\\.",
+    "at Module\\.",
+    "at async",
+    "npm ERR!",
+    "yarn error",
+    "pnpm ERR!"
+  ]
+};
+var DaemonConfigManager = class {
+  configDir;
+  configPath;
+  pidFilePath;
+  constructor() {
+    const configHome = process.env.XDG_CONFIG_HOME || (process.platform === "win32" ? process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming") : path.join(os.homedir(), ".config"));
+    this.configDir = path.join(configHome, "taskflow");
+    this.configPath = path.join(this.configDir, "daemon.json");
+    this.pidFilePath = path.join(this.configDir, "daemon.pid");
+  }
+  /**
+   * Ensure the config directory exists
+   */
+  async ensureConfigDir() {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw new Error(`Failed to create config directory: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Get daemon configuration
+   */
+  async getConfig() {
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      const config = JSON.parse(data);
+      return { ...DEFAULT_DAEMON_CONFIG, ...config };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { ...DEFAULT_DAEMON_CONFIG };
+      }
+      throw new Error(`Failed to read daemon config: ${error.message}`);
+    }
+  }
+  /**
+   * Save daemon configuration
+   */
+  async saveConfig(config) {
+    await this.ensureConfigDir();
+    const currentConfig = await this.getConfig();
+    const newConfig = { ...currentConfig, ...config };
+    try {
+      await fs.writeFile(this.configPath, JSON.stringify(newConfig, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write daemon config: ${error.message}`);
+    }
+  }
+  /**
+   * Get PID file path
+   */
+  getPidFilePath() {
+    return this.pidFilePath;
+  }
+  /**
+   * Get config directory path
+   */
+  getConfigDir() {
+    return this.configDir;
+  }
+  /**
+   * Save daemon PID
+   */
+  async savePid(pid) {
+    await this.ensureConfigDir();
+    await fs.writeFile(this.pidFilePath, pid.toString(), "utf-8");
+  }
+  /**
+   * Get daemon PID
+   */
+  async getPid() {
+    try {
+      const data = await fs.readFile(this.pidFilePath, "utf-8");
+      return parseInt(data.trim(), 10);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Remove PID file
+   */
+  async removePid() {
+    try {
+      await fs.unlink(this.pidFilePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Check if daemon is running
+   */
+  async isDaemonRunning() {
+    const pid = await this.getPid();
+    if (!pid) return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      await this.removePid();
+      return false;
+    }
+  }
+  /**
+   * Parse keyboard shortcut string to key combination
+   */
+  parseShortcut(shortcut) {
+    const parts = shortcut.toLowerCase().split("+").map((p) => p.trim());
+    return {
+      ctrl: parts.includes("ctrl") || parts.includes("control"),
+      alt: parts.includes("alt"),
+      shift: parts.includes("shift"),
+      key: parts.find((p) => !["ctrl", "control", "alt", "shift"].includes(p)) || ""
+    };
+  }
+};
+var daemonConfigManager = new DaemonConfigManager();
+
+export {
+  DEFAULT_DAEMON_CONFIG,
+  DaemonConfigManager,
+  daemonConfigManager
+};

package/dist/chunk-PZF4VRDG.js

@@ -0,0 +1,430 @@
+// src/utils/clipboard-monitor.ts
+var clipboardy = null;
+async function getClipboardy() {
+  if (!clipboardy) {
+    clipboardy = await import("clipboardy");
+  }
+  return clipboardy;
+}
+var nodeJsPatterns = {
+  name: "Node.js Errors",
+  category: "nodejs",
+  patterns: [
+    /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|EvalError|URIError):\s*.+/m,
+    /^\s+at\s+.+\(.+:\d+:\d+\)/m,
+    /^Uncaught\s+(Error|TypeError|ReferenceError):/m,
+    /^UnhandledPromiseRejectionWarning:/m,
+    /^node:internal\//m
+  ],
+  extractInfo: (text) => {
+    const errorMatch = text.match(
+      /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|EvalError|URIError):\s*(.+)/m
+    );
+    if (!errorMatch) return null;
+    const stackMatch = text.match(/at\s+(?:.+\s+)?\((.+):(\d+):(\d+)\)/);
+    const file = stackMatch?.[1];
+    const line = stackMatch ? parseInt(stackMatch[2], 10) : void 0;
+    const column = stackMatch ? parseInt(stackMatch[3], 10) : void 0;
+    const stackLines = text.split("\n").filter((l) => l.trim().startsWith("at "));
+    const stack = stackLines.length > 0 ? stackLines.join("\n") : void 0;
+    return {
+      type: errorMatch[1],
+      category: "nodejs",
+      message: errorMatch[2].trim(),
+      stack,
+      file,
+      line,
+      column,
+      rawText: text
+    };
+  }
+};
+var npmPatterns = {
+  name: "npm Errors",
+  category: "npm",
+  patterns: [
+    /npm ERR!/,
+    /npm WARN/,
+    /ERESOLVE/,
+    /E404/,
+    /ENOENT/,
+    /EPERM/,
+    /EACCES/,
+    /peer dep missing/i,
+    /Could not resolve dependency/
+  ],
+  extractInfo: (text) => {
+    const codeMatch = text.match(/npm ERR! code\s+(\w+)/);
+    const code = codeMatch?.[1];
+    const summaryMatch = text.match(/npm ERR!\s+(.+)/);
+    const message = summaryMatch?.[1] || "npm error detected";
+    if (text.includes("ERESOLVE")) {
+      const conflictMatch = text.match(/Conflicting peer dependency:\s*(.+)/);
+      return {
+        type: "ERESOLVE",
+        category: "npm",
+        message: conflictMatch?.[1] || "Dependency resolution conflict",
+        code: "ERESOLVE",
+        suggestion: "Try: npm install --legacy-peer-deps or npm install --force",
+        rawText: text
+      };
+    }
+    if (text.includes("E404") || text.includes("404 Not Found")) {
+      const packageMatch = text.match(/Not Found.*?:\s*(.+)/);
+      return {
+        type: "E404",
+        category: "npm",
+        message: `Package not found: ${packageMatch?.[1] || "unknown"}`,
+        code: "E404",
+        suggestion: "Check package name spelling or registry configuration",
+        rawText: text
+      };
+    }
+    return {
+      type: "npm error",
+      category: "npm",
+      message,
+      code,
+      rawText: text
+    };
+  }
+};
+var expoPatterns = {
+  name: "Expo/React Native Errors",
+  category: "expo",
+  patterns: [
+    /Error:\s*Unable to resolve module/,
+    /Metro Bundler/i,
+    /BUNDLE\s+.*failed/i,
+    /Red Box/i,
+    /Invariant Violation/,
+    /Native module.+cannot be null/,
+    /Cannot read property.+of undefined/,
+    /expo-.*error/i,
+    /RCTFatalException/,
+    /ExceptionsManager/
+  ],
+  extractInfo: (text) => {
+    const moduleMatch = text.match(/Unable to resolve module\s+['"]?([^'"]+)['"]?/);
+    if (moduleMatch) {
+      return {
+        type: "ModuleResolutionError",
+        category: "expo",
+        message: `Cannot find module: ${moduleMatch[1]}`,
+        suggestion: `Try: npx expo install ${moduleMatch[1]}`,
+        rawText: text
+      };
+    }
+    const invariantMatch = text.match(/Invariant Violation:\s*(.+)/);
+    if (invariantMatch) {
+      return {
+        type: "InvariantViolation",
+        category: "expo",
+        message: invariantMatch[1].trim(),
+        rawText: text
+      };
+    }
+    const nativeMatch = text.match(/Native module\s+['"]?([^'"]+)['"]?\s+cannot be null/);
+    if (nativeMatch) {
+      return {
+        type: "NativeModuleError",
+        category: "expo",
+        message: `Native module missing: ${nativeMatch[1]}`,
+        suggestion: "Try: npx expo prebuild --clean && npx expo run:ios/android",
+        rawText: text
+      };
+    }
+    if (text.includes("BUNDLE") && text.includes("failed")) {
+      return {
+        type: "BundleError",
+        category: "expo",
+        message: "Metro bundler failed to build",
+        suggestion: "Try: npx expo start -c (clear cache)",
+        rawText: text
+      };
+    }
+    return {
+      type: "ExpoError",
+      category: "expo",
+      message: "Expo/React Native error detected",
+      rawText: text
+    };
+  }
+};
+var webpackPatterns = {
+  name: "Webpack/Build Errors",
+  category: "webpack",
+  patterns: [
+    /Module not found:\s*Error/,
+    /ModuleNotFoundError/,
+    /ERROR in\s+/,
+    /webpack.*error/i,
+    /Failed to compile/i,
+    /Module build failed/,
+    /Syntax error in/i,
+    /Can't resolve/,
+    /You may need an appropriate loader/
+  ],
+  extractInfo: (text) => {
+    const moduleMatch = text.match(/Can't resolve\s+['"]?([^'"]+)['"]?/);
+    if (moduleMatch) {
+      return {
+        type: "ModuleNotFound",
+        category: "webpack",
+        message: `Cannot resolve: ${moduleMatch[1]}`,
+        suggestion: `Try: npm install ${moduleMatch[1]}`,
+        rawText: text
+      };
+    }
+    const fileMatch = text.match(/ERROR in\s+(.+):(\d+):(\d+)/);
+    if (fileMatch) {
+      return {
+        type: "WebpackError",
+        category: "webpack",
+        message: "Build error",
+        file: fileMatch[1],
+        line: parseInt(fileMatch[2], 10),
+        column: parseInt(fileMatch[3], 10),
+        rawText: text
+      };
+    }
+    if (text.includes("appropriate loader")) {
+      const extensionMatch = text.match(/\.(\w+)(?:\?|$)/);
+      return {
+        type: "LoaderError",
+        category: "webpack",
+        message: `Missing loader for .${extensionMatch?.[1] || "unknown"} files`,
+        suggestion: "Check webpack.config.js for missing loaders",
+        rawText: text
+      };
+    }
+    return {
+      type: "WebpackError",
+      category: "webpack",
+      message: "Webpack build error detected",
+      rawText: text
+    };
+  }
+};
+var typescriptPatterns = {
+  name: "TypeScript Errors",
+  category: "typescript",
+  patterns: [
+    /TS\d+:/,
+    /error TS\d+/,
+    /Type '.+' is not assignable to type/,
+    /Property '.+' does not exist on type/,
+    /Cannot find module '.+' or its corresponding type declarations/,
+    /Argument of type '.+' is not assignable/,
+    /Object is possibly 'undefined'/,
+    /Object is possibly 'null'/
+  ],
+  extractInfo: (text) => {
+    const codeMatch = text.match(/TS(\d+)/);
+    const code = codeMatch ? `TS${codeMatch[1]}` : void 0;
+    const fileMatch = text.match(/(.+\.tsx?)\((\d+),(\d+)\)/);
+    const file = fileMatch?.[1];
+    const line = fileMatch ? parseInt(fileMatch[2], 10) : void 0;
+    const column = fileMatch ? parseInt(fileMatch[3], 10) : void 0;
+    const messageMatch = text.match(/error TS\d+:\s*(.+)/);
+    const message = messageMatch?.[1] || "TypeScript error detected";
+    return {
+      type: "TypeScriptError",
+      category: "typescript",
+      message,
+      code,
+      file,
+      line,
+      column,
+      rawText: text
+    };
+  }
+};
+var pythonPatterns = {
+  name: "Python Errors",
+  category: "python",
+  patterns: [
+    /Traceback \(most recent call last\)/,
+    /^\s+File ".+", line \d+/m,
+    /^(NameError|TypeError|ValueError|KeyError|AttributeError|ImportError|ModuleNotFoundError|SyntaxError|IndentationError|IndexError|ZeroDivisionError|FileNotFoundError):/m,
+    /raise\s+\w+Error/
+  ],
+  extractInfo: (text) => {
+    if (!text.includes("Traceback")) {
+      const errorMatch2 = text.match(
+        /^(NameError|TypeError|ValueError|KeyError|AttributeError|ImportError|ModuleNotFoundError|SyntaxError|IndentationError|IndexError|ZeroDivisionError|FileNotFoundError):\s*(.+)/m
+      );
+      if (errorMatch2) {
+        return {
+          type: errorMatch2[1],
+          category: "python",
+          message: errorMatch2[2].trim(),
+          rawText: text
+        };
+      }
+      return null;
+    }
+    const lines = text.split("\n").filter((l) => l.trim());
+    const lastLine = lines[lines.length - 1];
+    const errorMatch = lastLine.match(/^(\w+Error):\s*(.+)/);
+    const fileMatch = text.match(/File "(.+)", line (\d+)/);
+    const file = fileMatch?.[1];
+    const line = fileMatch ? parseInt(fileMatch[2], 10) : void 0;
+    const stackLines = text.split("\n").filter((l) => l.trim().startsWith("File "));
+    const stack = stackLines.join("\n");
+    return {
+      type: errorMatch?.[1] || "PythonError",
+      category: "python",
+      message: errorMatch?.[2] || "Python error detected",
+      stack,
+      file,
+      line,
+      rawText: text
+    };
+  }
+};
+var ALL_PATTERNS = [
+  nodeJsPatterns,
+  npmPatterns,
+  expoPatterns,
+  webpackPatterns,
+  typescriptPatterns,
+  pythonPatterns
+];
+function detectError(text) {
+  if (!text || text.length < 10) return null;
+  for (const pattern of ALL_PATTERNS) {
+    const hasMatch = pattern.patterns.some((p) => p.test(text));
+    if (hasMatch) {
+      const info = pattern.extractInfo(text);
+      if (info) return info;
+    }
+  }
+  return null;
+}
+function getErrorSummary(error) {
+  const parts = [];
+  parts.push(`[${error.category.toUpperCase()}]`);
+  parts.push(error.type);
+  if (error.message.length > 80) {
+    parts.push(error.message.substring(0, 77) + "...");
+  } else {
+    parts.push(error.message);
+  }
+  if (error.file) {
+    const shortFile = error.file.split(/[/\\]/).slice(-2).join("/");
+    parts.push(`@ ${shortFile}`);
+    if (error.line) {
+      parts[parts.length - 1] += `:${error.line}`;
+    }
+  }
+  return parts.join(" ");
+}
+function formatErrorForNotes(error) {
+  const lines = [];
+  lines.push(`## Error Details`);
+  lines.push("");
+  lines.push(`**Type:** ${error.type}`);
+  lines.push(`**Category:** ${error.category}`);
+  lines.push(`**Message:** ${error.message}`);
+  if (error.code) {
+    lines.push(`**Code:** ${error.code}`);
+  }
+  if (error.file) {
+    lines.push(`**File:** \`${error.file}\``);
+    if (error.line) {
+      lines.push(`**Line:** ${error.line}${error.column ? `:${error.column}` : ""}`);
+    }
+  }
+  if (error.suggestion) {
+    lines.push("");
+    lines.push(`### Suggestion`);
+    lines.push(error.suggestion);
+  }
+  if (error.stack) {
+    lines.push("");
+    lines.push(`### Stack Trace`);
+    lines.push("```");
+    lines.push(error.stack);
+    lines.push("```");
+  }
+  lines.push("");
+  lines.push(`### Raw Error`);
+  lines.push("```");
+  const rawLines = error.rawText.split("\n");
+  if (rawLines.length > 30) {
+    lines.push(rawLines.slice(0, 30).join("\n"));
+    lines.push(`... (${rawLines.length - 30} more lines)`);
+  } else {
+    lines.push(error.rawText);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function createClipboardMonitor(options) {
+  const interval = options.interval || 1e3;
+  const minLength = options.minLength || 20;
+  let running = false;
+  let lastClipboardContent = "";
+  let intervalId = null;
+  const checkClipboard = async () => {
+    try {
+      const clipboard = await getClipboardy();
+      const content = await clipboard.default.read();
+      if (content === lastClipboardContent || content.length < minLength) {
+        return;
+      }
+      lastClipboardContent = content;
+      const error = detectError(content);
+      if (error) {
+        options.onError(error);
+      }
+    } catch {
+    }
+  };
+  return {
+    start: async () => {
+      if (running) return;
+      await getClipboardy();
+      try {
+        const clipboard = await getClipboardy();
+        lastClipboardContent = await clipboard.default.read();
+      } catch {
+        lastClipboardContent = "";
+      }
+      running = true;
+      options.onStart?.();
+      intervalId = setInterval(checkClipboard, interval);
+    },
+    stop: () => {
+      if (!running) return;
+      running = false;
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      options.onStop?.();
+    },
+    isRunning: () => running
+  };
+}
+async function readClipboard() {
+  const clipboard = await getClipboardy();
+  return clipboard.default.read();
+}
+async function checkClipboardForError() {
+  try {
+    const content = await readClipboard();
+    return detectError(content);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  detectError,
+  getErrorSummary,
+  formatErrorForNotes,
+  createClipboardMonitor,
+  checkClipboardForError
+};

package/dist/daemon-config-EUSBQA4E.js

@@ -0,0 +1,10 @@
+import {
+  DEFAULT_DAEMON_CONFIG,
+  DaemonConfigManager,
+  daemonConfigManager
+} from "./chunk-2KRLRG4G.js";
+export {
+  DEFAULT_DAEMON_CONFIG,
+  DaemonConfigManager,
+  daemonConfigManager
+};