@vibeflow-tools/cli 0.1.0

package/README.md

@@ -0,0 +1,141 @@
+# vibeflow
+
+> **Feedback that becomes code.**
+
+[![npm version](https://img.shields.io/npm/v/vibeflow?color=blue)](https://www.npmjs.com/package/vibeflow)
+[![License](https://img.shields.io/badge/license-Apache--2.0-green)](https://www.apache.org/licenses/LICENSE-2.0)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D22-brightgreen)](https://nodejs.org)
+
+Annotate anything in the browser, hand structured context to your AI coding agent, ship. No Slack threads. No tickets nobody reads. No switching context.
+
+```bash
+npm install -g vibeflow
+npx vibeflow kanban
+```
+
+## Website
+
+- Main website: https://www.vibeflow.tools/
+- Tutorials: https://www.vibeflow.tools/tutorials.html
+
+---
+
+## The problem
+
+You review your AI agent's output in the browser. You spot issues. Then the hard part: re-explaining every little thing in plain text, hoping the agent understands where to look and what's wrong.
+
+- **"Just sent you a Slack message about it"** — context-switching costs 23 minutes to recover. The fix takes 2 minutes.
+- **"Here's a screenshot, the thing on the left"** — screenshots without structure become detective work. Your agent needs selectors, not JPEGs.
+- **"I described it to the AI but it got confused"** — prose descriptions lose precision. Agents work best with structured, reproducible context.
+
+**Vibeflow eliminates the guessing loop.**
+
+---
+
+## How it works
+
+Three steps. Zero ceremony.
+
+### 1. Serve
+
+One command starts a local server that injects an annotation overlay into any HTML file or add overlay script to the live app.
+
+```bash
+vibeflow serve ./my-project
+```
+
+### 2. Annotate
+
+Open the browser. Click any element, write a quick note, set priority. Every annotation becomes a task stored as JSON in `.vibeflow/` — versioned in git, visible in the Kanban board.
+
+```bash
+vibeflow kanban          # open the Kanban board
+```
+
+### 3. Hand to your agent
+
+Paste the task output into GitHub Copilot, Claude, Cursor, or any AI tool. The agent receives the CSS selector, source file, line number, and your note — no manual explanation needed.
+
+```bash
+vibeflow tasks --status todo
+```
+
+> **The magic prompt for your agent:**
+> *"Get new tasks from `vibeflow tasks --status todo` and implement them."*
+
+---
+
+## Commands
+
+### Serving
+
+| Command | Description |
+|---------|-------------|
+| `vibeflow serve [target]` | Serve an HTML folder with the annotation overlay injected |
+| `vibeflow kanban [dir]` | Start the server and open the Kanban board in your browser |
+
+### Tasks
+
+| Command | Description |
+|---------|-------------|
+| `vibeflow tasks` | List all tasks |
+| `vibeflow tasks --status todo` | Filter to open tasks |
+| `vibeflow tasks --type Bug` | Filter by type (Task, Bug, Feature, Enhancement, Research) |
+| `vibeflow tasks --get <id>` | Full task detail with comments, file attachments, and linked commits |
+| `vibeflow tasks --add --title "..." --description "..."` | Create a new task |
+| `vibeflow tasks --edit <id> --set-status review --comment "..."` | Update a task status and add an implementation report |
+| `vibeflow tasks --json` | Machine-readable JSON output |
+
+**Task statuses:** backlog → todo → in-progress → review → done
+
+---
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Local-first** | Runs entirely on your machine. Tasks in `.vibeflow/` — committed to git, readable by any tool |
+| **Agent-ready** | Works with GitHub Copilot, Claude, Cursor, Windsurf — any tool that accepts a prompt |
+| **Click-to-annotate** | Captures exact CSS selector, URL, and source location automatically |
+| **Kanban board** | Full task manager with backlog, in-progress, review, done — view in browser or drive from CLI |
+| **Screenshots** | Paste a screenshot onto any task, or let the tool capture it automatically |
+| **Keyboard shortcut** | `Alt+A` to toggle annotation mode |
+| **Error recording** | Captures recent console errors into bug reports |
+| **Offline** | Works 100% locally, no account needed |
+
+---
+
+## Quick Start
+
+```bash
+# Open the Kanban board
+npx vibeflow kanban
+
+# Tell your agent to implement open tasks
+npx vibeflow tasks --status todo
+```
+
+---
+
+## Agent workflow
+
+When running `vibeflow tasks`, the CLI prints agent instructions automatically. Key rules:
+
+1. **Claim first** — set status to `in-progress` before reading or planning
+2. **Never set `done`** — use `review`; only humans mark tasks done
+3. **Never edit `.vibeflow/` files directly** — use CLI commands only
+4. **Research tasks** — attach a `.md` report before marking review; never generate code
+5. **Bug tasks** — include error logs and stack traces in commit comments
+
+---
+
+## Requirements
+
+- **Node.js 22+** — install from [nodejs.org](https://nodejs.org)
+- **React in dev mode (recommended)** — for component names, source files, and line numbers. Run in `NODE_ENV=development` (the default for `next dev`).
+
+---
+
+## License
+
+[Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)

package/dist/chunk-43MUGU6Z.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/auth/workspace.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var SPOTA_DIR = path.join(os.homedir(), ".spota");
+var WORKSPACE_PATH = path.join(SPOTA_DIR, "workspace");
+async function readWorkspace() {
+  try {
+    const content = await fs.readFile(WORKSPACE_PATH, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeWorkspace(workspace) {
+  await fs.mkdir(SPOTA_DIR, { recursive: true });
+  await fs.writeFile(WORKSPACE_PATH, JSON.stringify(workspace, null, 2), { mode: 384 });
+}
+async function deleteWorkspace() {
+  try {
+    await fs.unlink(WORKSPACE_PATH);
+  } catch {
+  }
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  readWorkspace,
+  writeWorkspace,
+  deleteWorkspace
+};
+//# sourceMappingURL=chunk-43MUGU6Z.js.map

package/dist/chunk-4Y62J4KR.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+
+// src/core/files.ts
+import {
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync2,
+  unlinkSync as unlinkSync2,
+  statSync,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync2
+} from "fs";
+import { join as join2, basename } from "path";
+
+// src/core/types.ts
+var PROTO_DIR = ".vibeflow";
+var TASKS_DIR = "tasks";
+var FILES_DIR = "tasks/files";
+var SCREENSHOTS_DIR = "tasks/screenshots";
+var CONFIG_FILE = "config.json";
+
+// src/core/tasks.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync,
+  renameSync
+} from "fs";
+import { join, extname } from "path";
+import { randomBytes } from "crypto";
+var VALID_STATUSES = ["backlog", "todo", "in-progress", "review", "done"];
+function generateTaskId() {
+  return randomBytes(15).toString("hex");
+}
+function getTasksDir(projectDir) {
+  return join(projectDir, PROTO_DIR, TASKS_DIR);
+}
+function migrateLegacyTaskAssetFolders(projectDir) {
+  const protoRoot = join(projectDir, PROTO_DIR);
+  const legacyFilesDir = join(protoRoot, "files");
+  const nextFilesDir = join(protoRoot, FILES_DIR);
+  const legacyScreenshotsDir = join(protoRoot, "screenshots");
+  const nextScreenshotsDir = join(protoRoot, SCREENSHOTS_DIR);
+  if (existsSync(legacyFilesDir)) {
+    mkdirSync(nextFilesDir, { recursive: true });
+    for (const entry of readdirSync(legacyFilesDir)) {
+      const from = join(legacyFilesDir, entry);
+      const to = join(nextFilesDir, entry);
+      if (existsSync(to)) continue;
+      try {
+        renameSync(from, to);
+      } catch {
+      }
+    }
+  }
+  if (existsSync(legacyScreenshotsDir)) {
+    mkdirSync(nextScreenshotsDir, { recursive: true });
+    for (const entry of readdirSync(legacyScreenshotsDir)) {
+      const from = join(legacyScreenshotsDir, entry);
+      const to = join(nextScreenshotsDir, entry);
+      if (existsSync(to)) continue;
+      try {
+        renameSync(from, to);
+      } catch {
+      }
+    }
+  }
+}
+function ensureTaskDirs(projectDir) {
+  migrateLegacyTaskAssetFolders(projectDir);
+  mkdirSync(getTasksDir(projectDir), { recursive: true });
+  mkdirSync(join(projectDir, PROTO_DIR, SCREENSHOTS_DIR), { recursive: true });
+}
+function getDateSubdir(isoDate) {
+  return isoDate.slice(0, 10);
+}
+function getTaskFilePath(projectDir, taskId, created) {
+  const tasksDir = getTasksDir(projectDir);
+  if (created) {
+    return join(tasksDir, getDateSubdir(created), `${taskId}.json`);
+  }
+  return join(tasksDir, `${taskId}.json`);
+}
+function findTaskFilePath(projectDir, taskId) {
+  const tasksDir = getTasksDir(projectDir);
+  if (!existsSync(tasksDir)) return null;
+  for (const entry of readdirSync(tasksDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const candidate = join(tasksDir, entry.name, `${taskId}.json`);
+      if (existsSync(candidate)) return candidate;
+    } else if (entry.name === `${taskId}.json`) {
+      return join(tasksDir, entry.name);
+    }
+  }
+  return null;
+}
+function normalizeTask(raw) {
+  const normalizedType = (() => {
+    if (typeof raw.type !== "string") return void 0;
+    const t = raw.type.trim();
+    if (!t || t === "[object Object]") return void 0;
+    return t;
+  })();
+  return {
+    id: String(raw.id ?? ""),
+    title: String(raw.title ?? "Untitled"),
+    description: String(raw.description ?? ""),
+    status: VALID_STATUSES.includes(raw.status) ? raw.status : "todo",
+    url: raw.url ? String(raw.url) : void 0,
+    selector: (() => {
+      const sel = String(raw.selector ?? "/");
+      if (raw.file && !raw.cssSelector && sel.startsWith(String(raw.file))) {
+        return raw.url ? String(raw.url) : "/";
+      }
+      return sel;
+    })(),
+    cssSelector: raw.cssSelector && String(raw.cssSelector) !== String(raw.selector ?? "/") ? String(raw.cssSelector) : void 0,
+    file: raw.file ? String(raw.file) : void 0,
+    line: raw.line != null ? Number(raw.line) : void 0,
+    col: raw.col != null ? Number(raw.col) : void 0,
+    component: raw.component ? String(raw.component) : void 0,
+    type: normalizedType,
+    priority: raw.priority ? String(raw.priority) : void 0,
+    ...raw.reportBack === true && { reportBack: true },
+    agent: raw.agent ? String(raw.agent) : void 0,
+    model: raw.model ? String(raw.model) : void 0,
+    author: raw.author ? String(raw.author) : void 0,
+    commit: raw.commit ? String(raw.commit) : void 0,
+    commits: Array.isArray(raw.commits) ? raw.commits.map((c) => ({
+      sha: String(c.sha ?? ""),
+      message: String(c.message ?? ""),
+      timestamp: String(c.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
+    })) : void 0,
+    created: String(raw.created ?? (/* @__PURE__ */ new Date()).toISOString()),
+    updated: raw.updated ? String(raw.updated) : void 0,
+    comments: Array.isArray(raw.comments) ? raw.comments.map((c) => ({
+      ...c,
+      // Normalize legacy 'content' field → 'text' (some older agent comments used 'content')
+      text: c.text ?? c.content ?? ""
+    })) : [],
+    files: Array.isArray(raw.files) ? raw.files.map((f) => {
+      if (typeof f === "string") {
+        return { name: f, addedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      return {
+        name: String(f.name ?? ""),
+        addedAt: String(f.addedAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+        linkedPath: f.linkedPath ? String(f.linkedPath) : void 0,
+        mimeType: f.mimeType ? String(f.mimeType) : void 0
+      };
+    }).filter((f) => f.name) : [],
+    screenshot: raw.screenshot ? String(raw.screenshot) : void 0,
+    annotatedElementText: raw.annotatedElementText ? String(raw.annotatedElementText) : void 0
+  };
+}
+function writeTaskJson(projectDir, task) {
+  const dateDir = join(getTasksDir(projectDir), getDateSubdir(task.created));
+  mkdirSync(dateDir, { recursive: true });
+  const filePath = join(dateDir, `${task.id}.json`);
+  writeFileSync(filePath, JSON.stringify(task, null, 2), "utf-8");
+}
+function createTask(projectDir, input) {
+  const normalizedPriority = (() => {
+    const raw = (input.priority ?? "").trim().toLowerCase();
+    if (raw === "critical") return "Critical";
+    if (raw === "high") return "High";
+    if (raw === "low") return "Low";
+    return "Medium";
+  })();
+  const task = {
+    ...input,
+    priority: normalizedPriority,
+    id: generateTaskId(),
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    comments: [],
+    files: []
+  };
+  writeTaskJson(projectDir, task);
+  return task;
+}
+function readTaskFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    if (filePath.endsWith(".json")) {
+      const raw = JSON.parse(content);
+      if (!raw || typeof raw !== "object" || !("id" in raw)) return null;
+      return normalizeTask(raw);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function collectTaskFiles(projectDir) {
+  const tasksDir = getTasksDir(projectDir);
+  if (!existsSync(tasksDir)) return [];
+  const results = [];
+  for (const entry of readdirSync(tasksDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const dateDir = join(tasksDir, entry.name);
+      for (const file of readdirSync(dateDir)) {
+        if (extname(file) === ".json") {
+          const filePath = join(dateDir, file);
+          const task = readTaskFile(filePath);
+          if (task) results.push({ task, filePath });
+        }
+      }
+    } else if (extname(entry.name) === ".json") {
+      const filePath = join(tasksDir, entry.name);
+      const task = readTaskFile(filePath);
+      if (task) results.push({ task, filePath });
+    }
+  }
+  return results.sort((a, b) => {
+    const aDate = a.task.updated ?? a.task.created;
+    const bDate = b.task.updated ?? b.task.created;
+    return new Date(bDate).getTime() - new Date(aDate).getTime();
+  });
+}
+function listTasks(projectDir) {
+  return collectTaskFiles(projectDir).map(({ task }) => task);
+}
+function listTasksWithPaths(projectDir) {
+  return collectTaskFiles(projectDir).map(({ task, filePath }) => ({ ...task, filePath }));
+}
+function updateTask(projectDir, taskId, updates) {
+  const existingPath = findTaskFilePath(projectDir, taskId);
+  const task = existingPath ? readTaskFile(existingPath) : null;
+  if (!task) return null;
+  const updated = { ...task, ...updates, updated: (/* @__PURE__ */ new Date()).toISOString() };
+  writeTaskJson(projectDir, updated);
+  if (existingPath && existingPath !== getTaskFilePath(projectDir, taskId, updated.created)) {
+    try {
+      unlinkSync(existingPath);
+    } catch {
+    }
+  }
+  return updated;
+}
+function deleteTask(projectDir, taskId) {
+  const filePath = findTaskFilePath(projectDir, taskId);
+  if (!filePath) return false;
+  unlinkSync(filePath);
+  return true;
+}
+function formatTaskForAgent(task, comments, files) {
+  return {
+    id: task.id,
+    status: task.status,
+    title: task.title,
+    description: task.description,
+    ...task.url && { url: task.url },
+    selector: task.selector,
+    ...task.file && { file: task.file },
+    ...task.line != null && { line: task.line },
+    ...task.col != null && { col: task.col },
+    ...task.component && { component: task.component },
+    ...task.type && { type: task.type },
+    ...task.priority && { priority: task.priority },
+    ...comments && comments.length > 0 && { structuredComments: comments },
+    ...files && files.length > 0 && { linkedFiles: files },
+    ...task.reportBack && { reportBack: true },
+    created: task.created
+  };
+}
+
+// src/core/files.ts
+var LINKED_MANIFEST = ".linked.json";
+function getFilesDir(projectDir, taskId) {
+  return join2(projectDir, PROTO_DIR, FILES_DIR, taskId);
+}
+function ensureFilesDir(projectDir, taskId) {
+  mkdirSync2(getFilesDir(projectDir, taskId), { recursive: true });
+}
+function readLinked(projectDir, taskId) {
+  const manifestPath = join2(getFilesDir(projectDir, taskId), LINKED_MANIFEST);
+  if (!existsSync2(manifestPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getTaskFileRefs(projectDir, taskId) {
+  const filePath = findTaskFilePath(projectDir, taskId);
+  const task = filePath ? readTaskFile(filePath) : null;
+  if (!task?.files || task.files.length === 0) return [];
+  return task.files;
+}
+function setTaskFileRefs(projectDir, taskId, refs) {
+  updateTask(projectDir, taskId, { files: refs });
+}
+function migrateLegacyLinkedRefs(projectDir, taskId) {
+  const refs = getTaskFileRefs(projectDir, taskId);
+  const manifestPath = join2(getFilesDir(projectDir, taskId), LINKED_MANIFEST);
+  if (!existsSync2(manifestPath)) return refs;
+  const legacy = readLinked(projectDir, taskId);
+  if (legacy.length === 0) {
+    try {
+      unlinkSync2(manifestPath);
+    } catch {
+    }
+    return refs;
+  }
+  const next = refs.slice();
+  let added = false;
+  for (const entry of legacy) {
+    if (!next.find((f) => f.linkedPath === entry.path || f.name === entry.name && f.linkedPath)) {
+      next.push({
+        name: entry.name,
+        linkedPath: entry.path,
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      added = true;
+    }
+  }
+  if (added) {
+    setTaskFileRefs(projectDir, taskId, next);
+  }
+  try {
+    unlinkSync2(manifestPath);
+  } catch {
+  }
+  return next;
+}
+function listFiles(projectDir, taskId) {
+  const dir = getFilesDir(projectDir, taskId);
+  const refs = migrateLegacyLinkedRefs(projectDir, taskId);
+  const byName = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    if (ref.linkedPath && existsSync2(ref.linkedPath)) {
+      const stat = statSync(ref.linkedPath);
+      byName.set(ref.name, {
+        name: ref.name,
+        size: stat.size,
+        url: `/api/tasks/${taskId}/files/${encodeURIComponent(ref.name)}`,
+        linkedPath: ref.linkedPath,
+        createdAt: stat.mtime.toISOString()
+      });
+      continue;
+    }
+    const uploadedPath = join2(dir, ref.name);
+    if (existsSync2(uploadedPath)) {
+      const stat = statSync(uploadedPath);
+      byName.set(ref.name, {
+        name: ref.name,
+        size: stat.size,
+        url: `/api/tasks/${taskId}/files/${encodeURIComponent(ref.name)}`,
+        createdAt: stat.mtime.toISOString()
+      });
+    }
+  }
+  if (existsSync2(dir)) {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || entry.name === LINKED_MANIFEST || byName.has(entry.name)) continue;
+      const fullPath = join2(dir, entry.name);
+      const stat = statSync(fullPath);
+      byName.set(entry.name, {
+        name: entry.name,
+        size: stat.size,
+        url: `/api/tasks/${taskId}/files/${encodeURIComponent(entry.name)}`,
+        createdAt: stat.mtime.toISOString()
+      });
+    }
+  }
+  return Array.from(byName.values());
+}
+function saveFile(projectDir, taskId, filename, data) {
+  const safe = basename(filename);
+  ensureFilesDir(projectDir, taskId);
+  writeFileSync2(join2(getFilesDir(projectDir, taskId), safe), data);
+  const refs = migrateLegacyLinkedRefs(projectDir, taskId);
+  if (!refs.find((f) => f.name === safe && !f.linkedPath)) {
+    refs.push({ name: safe, addedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    setTaskFileRefs(projectDir, taskId, refs);
+  }
+  return {
+    name: safe,
+    size: data.length,
+    url: `/api/tasks/${taskId}/files/${encodeURIComponent(safe)}`
+  };
+}
+function deleteFile(projectDir, taskId, filename) {
+  const safe = basename(filename);
+  const refs = migrateLegacyLinkedRefs(projectDir, taskId);
+  const idx = refs.findIndex((f) => f.name === safe);
+  if (idx !== -1) {
+    const [removed] = refs.splice(idx, 1);
+    setTaskFileRefs(projectDir, taskId, refs);
+    if (removed && !removed.linkedPath) {
+      const uploadedPath = join2(getFilesDir(projectDir, taskId), safe);
+      if (existsSync2(uploadedPath)) unlinkSync2(uploadedPath);
+    }
+    return true;
+  }
+  const filePath = join2(getFilesDir(projectDir, taskId), safe);
+  if (!existsSync2(filePath)) return false;
+  unlinkSync2(filePath);
+  return true;
+}
+function getFilePath(projectDir, taskId, filename) {
+  const safe = basename(filename);
+  const linkedRef = migrateLegacyLinkedRefs(projectDir, taskId).find((f) => f.name === safe && f.linkedPath);
+  if (linkedRef?.linkedPath && existsSync2(linkedRef.linkedPath)) return linkedRef.linkedPath;
+  const filePath = join2(getFilesDir(projectDir, taskId), safe);
+  return existsSync2(filePath) ? filePath : null;
+}
+function getFileCount(projectDir, taskId) {
+  return listFiles(projectDir, taskId).length;
+}
+
+export {
+  PROTO_DIR,
+  SCREENSHOTS_DIR,
+  CONFIG_FILE,
+  generateTaskId,
+  ensureTaskDirs,
+  getTaskFilePath,
+  findTaskFilePath,
+  createTask,
+  readTaskFile,
+  listTasks,
+  listTasksWithPaths,
+  updateTask,
+  deleteTask,
+  formatTaskForAgent,
+  getFilesDir,
+  ensureFilesDir,
+  listFiles,
+  saveFile,
+  deleteFile,
+  getFilePath,
+  getFileCount
+};
+//# sourceMappingURL=chunk-4Y62J4KR.js.map