claude-queue 1.0.0

package/dist/server/index.js

@@ -0,0 +1,1306 @@
+// src/index.ts
+import express from "express";
+import cors from "cors";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import { customAlphabet as customAlphabet2 } from "nanoid";
+
+// src/api/projects.ts
+import { Router } from "express";
+import { customAlphabet, nanoid } from "nanoid";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/db/schema.ts
+function initSchema(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      path TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      paused INTEGER DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+  const projectColumns = db2.prepare("PRAGMA table_info(projects)").all();
+  const hasPausedColumn = projectColumns.some((col) => col.name === "paused");
+  if (!hasPausedColumn) {
+    db2.exec("ALTER TABLE projects ADD COLUMN paused INTEGER DEFAULT 0");
+  }
+  db2.exec(`
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'backlog',
+      blocked INTEGER DEFAULT 0,
+      current_activity TEXT,
+      position INTEGER NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      author TEXT NOT NULL,
+      content TEXT NOT NULL,
+      seen INTEGER DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_project_id ON tasks(project_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_comments_task_id ON comments(task_id);
+
+    CREATE TABLE IF NOT EXISTS templates (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      position INTEGER NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_templates_project_id ON templates(project_id);
+
+    CREATE TABLE IF NOT EXISTS seeded_templates (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id TEXT NOT NULL,
+      template_key TEXT NOT NULL,
+      seeded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+      UNIQUE(project_id, template_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_seeded_templates_project_id ON seeded_templates(project_id);
+
+    CREATE TABLE IF NOT EXISTS task_activity (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      old_value TEXT,
+      new_value TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_task_activity_task_id ON task_activity(task_id);
+
+    CREATE TABLE IF NOT EXISTS attachments (
+      id TEXT PRIMARY KEY,
+      task_id TEXT,
+      template_id TEXT,
+      filename TEXT NOT NULL,
+      original_name TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+      FOREIGN KEY (template_id) REFERENCES templates(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_attachments_task_id ON attachments(task_id);
+
+    CREATE TABLE IF NOT EXISTS prompts (
+      id TEXT PRIMARY KEY,
+      project_id TEXT,
+      type TEXT NOT NULL CHECK(type IN ('master', 'project')),
+      content TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_prompts_project_id ON prompts(project_id);
+    CREATE INDEX IF NOT EXISTS idx_prompts_type ON prompts(type);
+  `);
+  const commentColumns = db2.prepare("PRAGMA table_info(comments)").all();
+  const hasSeenColumn = commentColumns.some((col) => col.name === "seen");
+  if (!hasSeenColumn) {
+    db2.exec("ALTER TABLE comments ADD COLUMN seen INTEGER DEFAULT 0");
+  }
+  const taskColumns = db2.prepare("PRAGMA table_info(tasks)").all();
+  const hasStartingCommit = taskColumns.some((col) => col.name === "starting_commit");
+  if (!hasStartingCommit) {
+    db2.exec("ALTER TABLE tasks ADD COLUMN starting_commit TEXT");
+  }
+  const hasClaudeLastSeen = projectColumns.some((col) => col.name === "claude_last_seen");
+  if (!hasClaudeLastSeen) {
+    db2.exec("ALTER TABLE projects ADD COLUMN claude_last_seen DATETIME");
+  }
+  const hasStartedAt = taskColumns.some((col) => col.name === "started_at");
+  if (!hasStartedAt) {
+    db2.exec("ALTER TABLE tasks ADD COLUMN started_at DATETIME");
+  }
+  const hasCompletedAt = taskColumns.some((col) => col.name === "completed_at");
+  if (!hasCompletedAt) {
+    db2.exec("ALTER TABLE tasks ADD COLUMN completed_at DATETIME");
+  }
+  const attachmentColumns = db2.prepare("PRAGMA table_info(attachments)").all();
+  const hasTemplateId = attachmentColumns.some((col) => col.name === "template_id");
+  if (!hasTemplateId) {
+    db2.exec("ALTER TABLE attachments ADD COLUMN template_id TEXT REFERENCES templates(id) ON DELETE CASCADE");
+  }
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_attachments_template_id ON attachments(template_id)");
+  const existingProjects = db2.prepare("SELECT id FROM projects").all();
+  const DEFAULT_TEMPLATE_KEYS = ["bug-fix", "add-tests", "refactor", "code-review", "documentation"];
+  for (const project of existingProjects) {
+    const seededCount = db2.prepare("SELECT COUNT(*) as count FROM seeded_templates WHERE project_id = ?").get(project.id);
+    if (seededCount.count === 0) {
+      const templateCount = db2.prepare("SELECT COUNT(*) as count FROM templates WHERE project_id = ?").get(project.id);
+      if (templateCount.count > 0) {
+        const insertStmt = db2.prepare("INSERT OR IGNORE INTO seeded_templates (project_id, template_key) VALUES (?, ?)");
+        for (const key of DEFAULT_TEMPLATE_KEYS) {
+          insertStmt.run(project.id, key);
+        }
+      }
+    }
+  }
+}
+
+// src/db/index.ts
+var DATA_DIR = join(homedir(), ".claude-queue");
+var DB_PATH = join(DATA_DIR, "kanban.db");
+var db = null;
+function getDb() {
+  if (!db) {
+    if (!existsSync(DATA_DIR)) {
+      mkdirSync(DATA_DIR, { recursive: true });
+    }
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    initSchema(db);
+  }
+  return db;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/api/projects.ts
+var router = Router();
+var generateId = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 4);
+var DEFAULT_TEMPLATES = [
+  { key: "bug-fix", title: "Bug fix", description: "Investigate and fix a reported bug. Include root cause analysis." },
+  { key: "add-tests", title: "Add tests", description: "Write unit/integration tests for existing functionality." },
+  { key: "refactor", title: "Refactor", description: "Improve code structure without changing behavior. Focus on readability and maintainability." },
+  { key: "code-review", title: "Code review", description: "Review recent changes for bugs, performance issues, and best practices." },
+  { key: "documentation", title: "Documentation", description: "Add or update documentation, comments, or README files." }
+];
+function seedDefaultTemplates(projectId) {
+  const db2 = getDb();
+  const seededKeys = db2.prepare("SELECT template_key FROM seeded_templates WHERE project_id = ?").all(projectId);
+  const seededKeySet = new Set(seededKeys.map((row) => row.template_key));
+  const templatesToSeed = DEFAULT_TEMPLATES.filter((t) => !seededKeySet.has(t.key));
+  if (templatesToSeed.length === 0) {
+    return;
+  }
+  const maxPosition = db2.prepare("SELECT COALESCE(MAX(position), -1) as max FROM templates WHERE project_id = ?").get(projectId);
+  const insertTemplateStmt = db2.prepare(`
+    INSERT INTO templates (id, project_id, title, description, position)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  const markSeededStmt = db2.prepare(`
+    INSERT INTO seeded_templates (project_id, template_key)
+    VALUES (?, ?)
+  `);
+  db2.transaction(() => {
+    templatesToSeed.forEach((template, index) => {
+      insertTemplateStmt.run(nanoid(), projectId, template.title, template.description, maxPosition.max + 1 + index);
+      markSeededStmt.run(projectId, template.key);
+    });
+  })();
+}
+router.get("/", (_req, res) => {
+  const db2 = getDb();
+  const projects = db2.prepare("SELECT * FROM projects ORDER BY created_at DESC").all();
+  res.json(projects);
+});
+router.get("/:id", (req, res) => {
+  const db2 = getDb();
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  if (req.query.heartbeat === "true") {
+    db2.prepare("UPDATE projects SET claude_last_seen = CURRENT_TIMESTAMP WHERE id = ?").run(req.params.id);
+    const updated = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+    res.json(updated);
+    return;
+  }
+  res.json(project);
+});
+router.post("/", (req, res) => {
+  const { path, name } = req.body;
+  if (!path || !name) {
+    res.status(400).json({ error: "path and name are required" });
+    return;
+  }
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    res.json(existing);
+    return;
+  }
+  const id = `kbn-${generateId()}`;
+  const stmt = db2.prepare("INSERT INTO projects (id, path, name) VALUES (?, ?, ?)");
+  stmt.run(id, path, name);
+  seedDefaultTemplates(id);
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+  res.status(201).json(project);
+});
+router.delete("/:id", (req, res) => {
+  const db2 = getDb();
+  const result = db2.prepare("DELETE FROM projects WHERE id = ?").run(req.params.id);
+  if (result.changes === 0) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  res.json({ success: true });
+});
+router.post("/:id/pause", (req, res) => {
+  const db2 = getDb();
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  db2.prepare("UPDATE projects SET paused = 1 WHERE id = ?").run(req.params.id);
+  const updated = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  res.json(updated);
+});
+router.post("/:id/resume", (req, res) => {
+  const db2 = getDb();
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  db2.prepare("UPDATE projects SET paused = 0 WHERE id = ?").run(req.params.id);
+  const updated = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  res.json(updated);
+});
+router.post("/:id/heartbeat", (req, res) => {
+  const db2 = getDb();
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  db2.prepare("UPDATE projects SET claude_last_seen = CURRENT_TIMESTAMP WHERE id = ?").run(req.params.id);
+  const updated = db2.prepare("SELECT * FROM projects WHERE id = ?").get(req.params.id);
+  res.json(updated);
+});
+function formatDateForSqlite(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}`;
+}
+router.get("/:id/stats", (req, res) => {
+  const db2 = getDb();
+  const projectId = req.params.id;
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const startOfTodayUtc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  const startOfWeekUtc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - now.getUTCDay()));
+  const startOfToday = formatDateForSqlite(startOfTodayUtc);
+  const startOfWeek = formatDateForSqlite(startOfWeekUtc);
+  const completedToday = db2.prepare(`
+    SELECT COUNT(*) as count FROM tasks
+    WHERE project_id = ? AND status = 'done' AND completed_at >= ?
+  `).get(projectId, startOfToday);
+  const completedThisWeek = db2.prepare(`
+    SELECT COUNT(*) as count FROM tasks
+    WHERE project_id = ? AND status = 'done' AND completed_at >= ?
+  `).get(projectId, startOfWeek);
+  const totalCompleted = db2.prepare(`
+    SELECT COUNT(*) as count FROM tasks
+    WHERE project_id = ? AND status = 'done'
+  `).get(projectId);
+  const tasksByStatus = db2.prepare(`
+    SELECT status, COUNT(*) as count FROM tasks
+    WHERE project_id = ?
+    GROUP BY status
+  `).all(projectId);
+  const completedTasks = db2.prepare(`
+    SELECT started_at, completed_at FROM tasks
+    WHERE project_id = ? AND status = 'done' AND started_at IS NOT NULL AND completed_at IS NOT NULL
+  `).all(projectId);
+  let totalTimeMs = 0;
+  let tasksWithTime = 0;
+  for (const task of completedTasks) {
+    const started = new Date(task.started_at).getTime();
+    const completed = new Date(task.completed_at).getTime();
+    if (completed > started) {
+      totalTimeMs += completed - started;
+      tasksWithTime++;
+    }
+  }
+  const avgTimeMs = tasksWithTime > 0 ? Math.round(totalTimeMs / tasksWithTime) : 0;
+  res.json({
+    completedToday: completedToday.count,
+    completedThisWeek: completedThisWeek.count,
+    totalCompleted: totalCompleted.count,
+    totalTimeMs,
+    avgTimeMs,
+    tasksWithTime,
+    tasksByStatus: Object.fromEntries(tasksByStatus.map((row) => [row.status, row.count]))
+  });
+});
+var projects_default = router;
+
+// src/api/tasks.ts
+import { Router as Router2 } from "express";
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/utils/heartbeat.ts
+function updateProjectHeartbeat(projectId) {
+  const db2 = getDb();
+  db2.prepare(
+    "UPDATE projects SET claude_last_seen = CURRENT_TIMESTAMP WHERE id = ?"
+  ).run(projectId);
+}
+function updateProjectHeartbeatForTask(taskId) {
+  const db2 = getDb();
+  const task = db2.prepare("SELECT project_id FROM tasks WHERE id = ?").get(taskId);
+  if (task) {
+    updateProjectHeartbeat(task.project_id);
+  }
+}
+
+// src/utils/activity.ts
+import { nanoid as nanoid2 } from "nanoid";
+function logTaskActivity(taskId, type, oldValue = null, newValue = null) {
+  const db2 = getDb();
+  const id = nanoid2();
+  db2.prepare(`
+    INSERT INTO task_activity (id, task_id, type, old_value, new_value)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(id, taskId, type, oldValue, newValue);
+}
+
+// src/utils/mappers.ts
+function rowToTask(row) {
+  return {
+    ...row,
+    blocked: Boolean(row.blocked)
+  };
+}
+function rowToComment(row) {
+  return {
+    ...row,
+    seen: Boolean(row.seen)
+  };
+}
+function rowToTaskActivity(row) {
+  return {
+    ...row
+  };
+}
+function rowToAttachment(row) {
+  return {
+    ...row
+  };
+}
+function rowToPrompt(row) {
+  return {
+    ...row
+  };
+}
+
+// src/api/tasks.ts
+var router2 = Router2();
+router2.get("/project/:projectId", (req, res) => {
+  const db2 = getDb();
+  const { status } = req.query;
+  let query = "SELECT * FROM tasks WHERE project_id = ?";
+  const params = [req.params.projectId];
+  if (status) {
+    query += " AND status = ?";
+    params.push(status);
+  }
+  query += " ORDER BY position ASC";
+  const tasks = db2.prepare(query).all(...params);
+  res.json(tasks.map(rowToTask));
+});
+router2.get("/:id", (req, res) => {
+  const db2 = getDb();
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  const commentsRaw = db2.prepare("SELECT * FROM comments WHERE task_id = ? ORDER BY created_at ASC").all(req.params.id);
+  const activitiesRaw = db2.prepare("SELECT * FROM task_activity WHERE task_id = ? ORDER BY created_at ASC").all(req.params.id);
+  const result = {
+    ...rowToTask(task),
+    comments: commentsRaw.map(rowToComment),
+    activities: activitiesRaw.map(rowToTaskActivity)
+  };
+  res.json(result);
+});
+router2.post("/project/:projectId", (req, res) => {
+  const { title, description, status = "backlog" } = req.body;
+  if (!title) {
+    res.status(400).json({ error: "title is required" });
+    return;
+  }
+  const db2 = getDb();
+  const projectId = req.params.projectId;
+  const project = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  const maxPosition = db2.prepare("SELECT COALESCE(MAX(position), -1) as max FROM tasks WHERE project_id = ? AND status = ?").get(projectId, status);
+  const id = nanoid3();
+  const position = maxPosition.max + 1;
+  db2.prepare(`
+    INSERT INTO tasks (id, project_id, title, description, status, position)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, projectId, title, description || null, status, position);
+  logTaskActivity(id, "created", null, status);
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  res.status(201).json(rowToTask(task));
+});
+router2.patch("/:id", (req, res) => {
+  const db2 = getDb();
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  const allowedFields = ["title", "description", "blocked", "current_activity"];
+  const updates = [];
+  const values = [];
+  for (const field of allowedFields) {
+    if (req.body[field] !== void 0) {
+      updates.push(`${field} = ?`);
+      values.push(field === "blocked" ? req.body[field] ? 1 : 0 : req.body[field]);
+    }
+  }
+  if (updates.length === 0) {
+    res.json(rowToTask(task));
+    return;
+  }
+  updates.push("updated_at = CURRENT_TIMESTAMP");
+  values.push(req.params.id);
+  db2.prepare(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+  if (req.body.title !== void 0 && req.body.title !== task.title) {
+    logTaskActivity(req.params.id, "title_change", task.title, req.body.title);
+  }
+  if (req.body.description !== void 0 && req.body.description !== task.description) {
+    logTaskActivity(req.params.id, "description_change", task.description, req.body.description);
+  }
+  if (req.body.blocked !== void 0 && Boolean(req.body.blocked) !== Boolean(task.blocked)) {
+    logTaskActivity(req.params.id, "blocked_change", String(Boolean(task.blocked)), String(Boolean(req.body.blocked)));
+  }
+  if (req.body.current_activity !== void 0) {
+    updateProjectHeartbeat(task.project_id);
+  }
+  const updated = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  res.json(rowToTask(updated));
+});
+router2.post("/:id/move", (req, res) => {
+  const { status, position, starting_commit } = req.body;
+  if (!status || position === void 0) {
+    res.status(400).json({ error: "status and position are required" });
+    return;
+  }
+  const db2 = getDb();
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  const oldStatus = task.status;
+  const oldPosition = task.position;
+  db2.transaction(() => {
+    if (oldStatus === status) {
+      if (position > oldPosition) {
+        db2.prepare(`
+          UPDATE tasks SET position = position - 1
+          WHERE project_id = ? AND status = ? AND position > ? AND position <= ?
+        `).run(task.project_id, status, oldPosition, position);
+      } else if (position < oldPosition) {
+        db2.prepare(`
+          UPDATE tasks SET position = position + 1
+          WHERE project_id = ? AND status = ? AND position >= ? AND position < ?
+        `).run(task.project_id, status, position, oldPosition);
+      }
+    } else {
+      db2.prepare(`
+        UPDATE tasks SET position = position - 1
+        WHERE project_id = ? AND status = ? AND position > ?
+      `).run(task.project_id, oldStatus, oldPosition);
+      db2.prepare(`
+        UPDATE tasks SET position = position + 1
+        WHERE project_id = ? AND status = ? AND position >= ?
+      `).run(task.project_id, status, position);
+    }
+    if (status === "in_progress") {
+      if (starting_commit) {
+        db2.prepare(`
+          UPDATE tasks SET status = ?, position = ?, starting_commit = ?, started_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        `).run(status, position, starting_commit, req.params.id);
+      } else {
+        db2.prepare(`
+          UPDATE tasks SET status = ?, position = ?, started_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        `).run(status, position, req.params.id);
+      }
+    } else if (status === "done") {
+      db2.prepare(`
+        UPDATE tasks SET status = ?, position = ?, completed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `).run(status, position, req.params.id);
+    } else {
+      db2.prepare(`
+        UPDATE tasks SET status = ?, position = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `).run(status, position, req.params.id);
+    }
+  })();
+  if (oldStatus !== status) {
+    logTaskActivity(req.params.id, "status_change", oldStatus, status);
+  }
+  if (status === "in_progress" || status === "done") {
+    updateProjectHeartbeat(task.project_id);
+  }
+  const updated = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  res.json(rowToTask(updated));
+});
+router2.delete("/:id", (req, res) => {
+  const db2 = getDb();
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(req.params.id);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  db2.transaction(() => {
+    db2.prepare(`
+      UPDATE tasks SET position = position - 1
+      WHERE project_id = ? AND status = ? AND position > ?
+    `).run(task.project_id, task.status, task.position);
+    db2.prepare("DELETE FROM tasks WHERE id = ?").run(req.params.id);
+  })();
+  res.json({ success: true });
+});
+router2.delete("/project/:projectId/status/:status", (req, res) => {
+  const db2 = getDb();
+  const { projectId, status } = req.params;
+  const project = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  const validStatuses = ["backlog", "ready", "in_progress", "done"];
+  if (!validStatuses.includes(status)) {
+    res.status(400).json({ error: "Invalid status" });
+    return;
+  }
+  const result = db2.prepare("DELETE FROM tasks WHERE project_id = ? AND status = ?").run(projectId, status);
+  res.json({ success: true, deleted: result.changes });
+});
+var tasks_default = router2;
+
+// src/api/comments.ts
+import { Router as Router3 } from "express";
+import { nanoid as nanoid4 } from "nanoid";
+var router3 = Router3();
+router3.get("/task/:taskId", (req, res) => {
+  const db2 = getDb();
+  const { since } = req.query;
+  let query = "SELECT * FROM comments WHERE task_id = ?";
+  const params = [req.params.taskId];
+  if (since) {
+    query += " AND created_at > ?";
+    params.push(since);
+  }
+  query += " ORDER BY created_at ASC";
+  const comments = db2.prepare(query).all(...params);
+  res.json(comments.map(rowToComment));
+});
+router3.post("/task/:taskId", (req, res) => {
+  const { author, content } = req.body;
+  if (!author || !content) {
+    res.status(400).json({ error: "author and content are required" });
+    return;
+  }
+  if (author !== "user" && author !== "claude") {
+    res.status(400).json({ error: "author must be 'user' or 'claude'" });
+    return;
+  }
+  const db2 = getDb();
+  const taskId = req.params.taskId;
+  const task = db2.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  const id = nanoid4();
+  db2.prepare(`
+    INSERT INTO comments (id, task_id, author, content)
+    VALUES (?, ?, ?, ?)
+  `).run(id, taskId, author, content);
+  logTaskActivity(taskId, "comment_added", null, author);
+  if (author === "claude") {
+    updateProjectHeartbeatForTask(taskId);
+  }
+  const comment = db2.prepare("SELECT * FROM comments WHERE id = ?").get(id);
+  res.status(201).json(rowToComment(comment));
+});
+router3.delete("/:commentId", (req, res) => {
+  const db2 = getDb();
+  const commentId = req.params.commentId;
+  const comment = db2.prepare("SELECT * FROM comments WHERE id = ?").get(commentId);
+  if (!comment) {
+    res.status(404).json({ error: "Comment not found" });
+    return;
+  }
+  if (comment.seen) {
+    res.status(400).json({ error: "Cannot delete a comment that has been seen" });
+    return;
+  }
+  db2.prepare("DELETE FROM comments WHERE id = ?").run(commentId);
+  res.status(204).send();
+});
+router3.patch("/:commentId/seen", (req, res) => {
+  const db2 = getDb();
+  const commentId = req.params.commentId;
+  const comment = db2.prepare("SELECT * FROM comments WHERE id = ?").get(commentId);
+  if (!comment) {
+    res.status(404).json({ error: "Comment not found" });
+    return;
+  }
+  db2.prepare("UPDATE comments SET seen = 1 WHERE id = ?").run(commentId);
+  const updated = db2.prepare("SELECT * FROM comments WHERE id = ?").get(commentId);
+  res.json(rowToComment(updated));
+});
+router3.patch("/task/:taskId/mark-seen", (req, res) => {
+  const db2 = getDb();
+  const taskId = req.params.taskId;
+  db2.prepare("UPDATE comments SET seen = 1 WHERE task_id = ? AND author = 'user' AND seen = 0").run(taskId);
+  updateProjectHeartbeatForTask(taskId);
+  const comments = db2.prepare("SELECT * FROM comments WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
+  res.json(comments.map(rowToComment));
+});
+router3.get("/task/:taskId/wait-for-reply", async (req, res) => {
+  const db2 = getDb();
+  const taskId = req.params.taskId;
+  const since = req.query.since;
+  const task = db2.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+  if (!task) {
+    res.status(404).json({ error: "Task not found", deleted: true });
+    return;
+  }
+  const pollInterval = 1e3;
+  const timeout = 3e4;
+  const startTime2 = Date.now();
+  const checkForReply = () => {
+    const taskExists = db2.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+    if (!taskExists) {
+      return null;
+    }
+    let query = "SELECT * FROM comments WHERE task_id = ? AND author = 'user'";
+    const params = [taskId];
+    if (since) {
+      query += " AND created_at > ?";
+      params.push(since);
+    }
+    query += " ORDER BY created_at DESC LIMIT 1";
+    const row = db2.prepare(query).get(...params);
+    return row ? rowToComment(row) : null;
+  };
+  const poll = () => {
+    const taskExists = db2.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+    if (!taskExists) {
+      res.json({ deleted: true });
+      return;
+    }
+    const reply = checkForReply();
+    if (reply) {
+      res.json(reply);
+      return;
+    }
+    if (Date.now() - startTime2 >= timeout) {
+      res.json({ timeout: true });
+      return;
+    }
+    setTimeout(poll, pollInterval);
+  };
+  poll();
+});
+var comments_default = router3;
+
+// src/api/templates.ts
+import { Router as Router4 } from "express";
+import { nanoid as nanoid5 } from "nanoid";
+var router4 = Router4();
+router4.get("/project/:projectId", (req, res) => {
+  const db2 = getDb();
+  const templates = db2.prepare("SELECT * FROM templates WHERE project_id = ? ORDER BY position ASC").all(req.params.projectId);
+  res.json(templates);
+});
+router4.get("/:id", (req, res) => {
+  const db2 = getDb();
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  res.json(template);
+});
+router4.post("/project/:projectId", (req, res) => {
+  const { title, description } = req.body;
+  if (!title) {
+    res.status(400).json({ error: "title is required" });
+    return;
+  }
+  const db2 = getDb();
+  const projectId = req.params.projectId;
+  const project = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  const maxPosition = db2.prepare("SELECT COALESCE(MAX(position), -1) as max FROM templates WHERE project_id = ?").get(projectId);
+  const id = nanoid5();
+  const position = maxPosition.max + 1;
+  db2.prepare(`
+    INSERT INTO templates (id, project_id, title, description, position)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(id, projectId, title, description || null, position);
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(id);
+  res.status(201).json(template);
+});
+router4.patch("/:id", (req, res) => {
+  const db2 = getDb();
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  const allowedFields = ["title", "description"];
+  const updates = [];
+  const values = [];
+  for (const field of allowedFields) {
+    if (req.body[field] !== void 0) {
+      updates.push(`${field} = ?`);
+      values.push(req.body[field]);
+    }
+  }
+  if (updates.length === 0) {
+    res.json(template);
+    return;
+  }
+  values.push(req.params.id);
+  db2.prepare(`UPDATE templates SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+  const updated = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  res.json(updated);
+});
+router4.post("/:id/move", (req, res) => {
+  const { position } = req.body;
+  if (position === void 0) {
+    res.status(400).json({ error: "position is required" });
+    return;
+  }
+  const db2 = getDb();
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  const oldPosition = template.position;
+  db2.transaction(() => {
+    if (position > oldPosition) {
+      db2.prepare(`
+        UPDATE templates SET position = position - 1
+        WHERE project_id = ? AND position > ? AND position <= ?
+      `).run(template.project_id, oldPosition, position);
+    } else if (position < oldPosition) {
+      db2.prepare(`
+        UPDATE templates SET position = position + 1
+        WHERE project_id = ? AND position >= ? AND position < ?
+      `).run(template.project_id, position, oldPosition);
+    }
+    db2.prepare(`UPDATE templates SET position = ? WHERE id = ?`).run(position, req.params.id);
+  })();
+  const updated = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  res.json(updated);
+});
+router4.delete("/:id", (req, res) => {
+  const db2 = getDb();
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  db2.transaction(() => {
+    db2.prepare(`
+      UPDATE templates SET position = position - 1
+      WHERE project_id = ? AND position > ?
+    `).run(template.project_id, template.position);
+    db2.prepare("DELETE FROM templates WHERE id = ?").run(req.params.id);
+  })();
+  res.json({ success: true });
+});
+router4.post("/:id/create-task", (req, res) => {
+  const { status = "backlog" } = req.body;
+  const validStatuses = ["backlog", "ready"];
+  if (!validStatuses.includes(status)) {
+    res.status(400).json({ error: "Invalid status. Must be backlog or ready" });
+    return;
+  }
+  const db2 = getDb();
+  const template = db2.prepare("SELECT * FROM templates WHERE id = ?").get(req.params.id);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  const maxPosition = db2.prepare("SELECT COALESCE(MAX(position), -1) as max FROM tasks WHERE project_id = ? AND status = ?").get(template.project_id, status);
+  const id = nanoid5();
+  const position = maxPosition.max + 1;
+  db2.prepare(`
+    INSERT INTO tasks (id, project_id, title, description, status, position)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, template.project_id, template.title, template.description, status, position);
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  res.status(201).json({
+    ...task,
+    blocked: Boolean(task.blocked)
+  });
+});
+var templates_default = router4;
+
+// src/api/attachments.ts
+import { Router as Router5 } from "express";
+import { nanoid as nanoid6 } from "nanoid";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, unlinkSync, writeFileSync, readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, extname } from "path";
+var router5 = Router5();
+var DATA_DIR2 = join2(homedir2(), ".claude-queue");
+var ATTACHMENTS_DIR = join2(DATA_DIR2, "attachments");
+function ensureAttachmentsDir() {
+  if (!existsSync2(ATTACHMENTS_DIR)) {
+    mkdirSync2(ATTACHMENTS_DIR, { recursive: true });
+  }
+}
+router5.get("/task/:taskId", (req, res) => {
+  const db2 = getDb();
+  const taskId = req.params.taskId;
+  const attachments = db2.prepare("SELECT * FROM attachments WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
+  res.json(attachments.map(rowToAttachment));
+});
+router5.get("/template/:templateId", (req, res) => {
+  const db2 = getDb();
+  const templateId = req.params.templateId;
+  const attachments = db2.prepare("SELECT * FROM attachments WHERE template_id = ? ORDER BY created_at ASC").all(templateId);
+  res.json(attachments.map(rowToAttachment));
+});
+router5.post("/task/:taskId", (req, res) => {
+  const db2 = getDb();
+  const taskId = req.params.taskId;
+  const task = db2.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+  if (!task) {
+    res.status(404).json({ error: "Task not found" });
+    return;
+  }
+  const { filename, data, mimeType } = req.body;
+  if (!filename || !data || !mimeType) {
+    res.status(400).json({ error: "filename, data, and mimeType are required" });
+    return;
+  }
+  ensureAttachmentsDir();
+  const id = nanoid6();
+  const ext = extname(filename) || ".bin";
+  const storedFilename = `${id}${ext}`;
+  const filePath = join2(ATTACHMENTS_DIR, storedFilename);
+  const buffer = Buffer.from(data, "base64");
+  writeFileSync(filePath, buffer);
+  db2.prepare(`
+    INSERT INTO attachments (id, task_id, filename, original_name, mime_type, size)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, taskId, storedFilename, filename, mimeType, buffer.length);
+  const attachment = db2.prepare("SELECT * FROM attachments WHERE id = ?").get(id);
+  res.status(201).json(rowToAttachment(attachment));
+});
+router5.post("/template/:templateId", (req, res) => {
+  const db2 = getDb();
+  const templateId = req.params.templateId;
+  const template = db2.prepare("SELECT id FROM templates WHERE id = ?").get(templateId);
+  if (!template) {
+    res.status(404).json({ error: "Template not found" });
+    return;
+  }
+  const { filename, data, mimeType } = req.body;
+  if (!filename || !data || !mimeType) {
+    res.status(400).json({ error: "filename, data, and mimeType are required" });
+    return;
+  }
+  ensureAttachmentsDir();
+  const id = nanoid6();
+  const ext = extname(filename) || ".bin";
+  const storedFilename = `${id}${ext}`;
+  const filePath = join2(ATTACHMENTS_DIR, storedFilename);
+  const buffer = Buffer.from(data, "base64");
+  writeFileSync(filePath, buffer);
+  db2.prepare(`
+    INSERT INTO attachments (id, template_id, filename, original_name, mime_type, size)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, templateId, storedFilename, filename, mimeType, buffer.length);
+  const attachment = db2.prepare("SELECT * FROM attachments WHERE id = ?").get(id);
+  res.status(201).json(rowToAttachment(attachment));
+});
+router5.get("/:attachmentId/file", (req, res) => {
+  const db2 = getDb();
+  const attachmentId = req.params.attachmentId;
+  const attachment = db2.prepare("SELECT * FROM attachments WHERE id = ?").get(attachmentId);
+  if (!attachment) {
+    res.status(404).json({ error: "Attachment not found" });
+    return;
+  }
+  const filePath = join2(ATTACHMENTS_DIR, attachment.filename);
+  if (!existsSync2(filePath)) {
+    res.status(404).json({ error: "File not found" });
+    return;
+  }
+  res.setHeader("Content-Type", attachment.mime_type);
+  res.setHeader("Content-Disposition", `inline; filename="${attachment.original_name}"`);
+  res.send(readFileSync(filePath));
+});
+router5.get("/:attachmentId/path", (req, res) => {
+  const db2 = getDb();
+  const attachmentId = req.params.attachmentId;
+  const attachment = db2.prepare("SELECT * FROM attachments WHERE id = ?").get(attachmentId);
+  if (!attachment) {
+    res.status(404).json({ error: "Attachment not found" });
+    return;
+  }
+  const filePath = join2(ATTACHMENTS_DIR, attachment.filename);
+  if (!existsSync2(filePath)) {
+    res.status(404).json({ error: "File not found" });
+    return;
+  }
+  res.json({ path: filePath });
+});
+router5.delete("/:attachmentId", (req, res) => {
+  const db2 = getDb();
+  const attachmentId = req.params.attachmentId;
+  const attachment = db2.prepare("SELECT * FROM attachments WHERE id = ?").get(attachmentId);
+  if (!attachment) {
+    res.status(404).json({ error: "Attachment not found" });
+    return;
+  }
+  const filePath = join2(ATTACHMENTS_DIR, attachment.filename);
+  if (existsSync2(filePath)) {
+    unlinkSync(filePath);
+  }
+  db2.prepare("DELETE FROM attachments WHERE id = ?").run(attachmentId);
+  res.status(204).send();
+});
+var attachments_default = router5;
+
+// src/api/prompts.ts
+import { Router as Router6 } from "express";
+import { nanoid as nanoid7 } from "nanoid";
+var router6 = Router6();
+router6.get("/master", (req, res) => {
+  const db2 = getDb();
+  const prompt = db2.prepare("SELECT * FROM prompts WHERE type = 'master' LIMIT 1").get();
+  if (!prompt) {
+    res.json(null);
+    return;
+  }
+  res.json(rowToPrompt(prompt));
+});
+router6.put("/master", (req, res) => {
+  const db2 = getDb();
+  const { content } = req.body;
+  if (typeof content !== "string") {
+    res.status(400).json({ error: "content is required" });
+    return;
+  }
+  const existing = db2.prepare("SELECT * FROM prompts WHERE type = 'master' LIMIT 1").get();
+  if (existing) {
+    db2.prepare(`
+      UPDATE prompts SET content = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+    `).run(content, existing.id);
+  } else {
+    const id = nanoid7();
+    db2.prepare(`
+      INSERT INTO prompts (id, project_id, type, content)
+      VALUES (?, NULL, 'master', ?)
+    `).run(id, content);
+  }
+  const prompt = db2.prepare("SELECT * FROM prompts WHERE type = 'master' LIMIT 1").get();
+  res.json(rowToPrompt(prompt));
+});
+router6.get("/project/:projectId", (req, res) => {
+  const db2 = getDb();
+  const projectId = req.params.projectId;
+  const prompt = db2.prepare("SELECT * FROM prompts WHERE type = 'project' AND project_id = ? LIMIT 1").get(projectId);
+  if (!prompt) {
+    res.json(null);
+    return;
+  }
+  res.json(rowToPrompt(prompt));
+});
+router6.put("/project/:projectId", (req, res) => {
+  const db2 = getDb();
+  const projectId = req.params.projectId;
+  const { content } = req.body;
+  if (typeof content !== "string") {
+    res.status(400).json({ error: "content is required" });
+    return;
+  }
+  const project = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    res.status(404).json({ error: "Project not found" });
+    return;
+  }
+  const existing = db2.prepare("SELECT * FROM prompts WHERE type = 'project' AND project_id = ? LIMIT 1").get(projectId);
+  if (existing) {
+    db2.prepare(`
+      UPDATE prompts SET content = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+    `).run(content, existing.id);
+  } else {
+    const id = nanoid7();
+    db2.prepare(`
+      INSERT INTO prompts (id, project_id, type, content)
+      VALUES (?, ?, 'project', ?)
+    `).run(id, projectId, content);
+  }
+  const prompt = db2.prepare("SELECT * FROM prompts WHERE type = 'project' AND project_id = ? LIMIT 1").get(projectId);
+  res.json(rowToPrompt(prompt));
+});
+router6.delete("/project/:projectId", (req, res) => {
+  const db2 = getDb();
+  const projectId = req.params.projectId;
+  db2.prepare("DELETE FROM prompts WHERE type = 'project' AND project_id = ?").run(projectId);
+  res.status(204).send();
+});
+var prompts_default = router6;
+
+// src/api/health.ts
+import { Router as Router7 } from "express";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync2(join3(__dirname, "..", "..", "package.json"), "utf-8"));
+var router7 = Router7();
+var startTime = Date.now();
+router7.get("/", (_req, res) => {
+  const db2 = getDb();
+  const projects = db2.prepare("SELECT id, name FROM projects").all();
+  const projectsWithCounts = projects.map((p) => {
+    const count = db2.prepare("SELECT COUNT(*) as count FROM tasks WHERE project_id = ?").get(p.id);
+    return { ...p, tasks: count.count };
+  });
+  const uptimeMs = Date.now() - startTime;
+  const uptimeMinutes = Math.floor(uptimeMs / 6e4);
+  const uptimeHours = Math.floor(uptimeMinutes / 60);
+  const uptime = uptimeHours > 0 ? `${uptimeHours}h ${uptimeMinutes % 60}m` : `${uptimeMinutes}m`;
+  res.json({
+    status: "ok",
+    version: pkg.version,
+    uptime,
+    database: "connected",
+    projects: projectsWithCounts
+  });
+});
+var health_default = router7;
+
+// src/api/maintenance.ts
+import { Router as Router8 } from "express";
+var router8 = Router8();
+router8.delete("/tasks/done", (req, res) => {
+  const db2 = getDb();
+  const result = db2.prepare("DELETE FROM tasks WHERE status = 'done'").run();
+  res.json({ success: true, deleted: result.changes });
+});
+router8.delete("/tasks/all", (req, res) => {
+  const db2 = getDb();
+  const result = db2.prepare("DELETE FROM tasks").run();
+  res.json({ success: true, deleted: result.changes });
+});
+router8.delete("/projects/all", (req, res) => {
+  const db2 = getDb();
+  const result = db2.prepare("DELETE FROM projects").run();
+  res.json({ success: true, deleted: result.changes });
+});
+router8.delete("/activity/all", (req, res) => {
+  const db2 = getDb();
+  const result = db2.prepare("DELETE FROM task_activity").run();
+  res.json({ success: true, deleted: result.changes });
+});
+router8.get("/stats", (_req, res) => {
+  const db2 = getDb();
+  const projectCount = db2.prepare("SELECT COUNT(*) as count FROM projects").get();
+  const taskCount = db2.prepare("SELECT COUNT(*) as count FROM tasks").get();
+  const tasksByStatus = db2.prepare(`
+    SELECT status, COUNT(*) as count
+    FROM tasks
+    GROUP BY status
+  `).all();
+  const commentCount = db2.prepare("SELECT COUNT(*) as count FROM comments").get();
+  const activityCount = db2.prepare("SELECT COUNT(*) as count FROM task_activity").get();
+  const templateCount = db2.prepare("SELECT COUNT(*) as count FROM templates").get();
+  res.json({
+    projects: projectCount.count,
+    tasks: {
+      total: taskCount.count,
+      byStatus: Object.fromEntries(tasksByStatus.map((row) => [row.status, row.count]))
+    },
+    comments: commentCount.count,
+    activities: activityCount.count,
+    templates: templateCount.count
+  });
+});
+router8.post("/vacuum", (_req, res) => {
+  const db2 = getDb();
+  db2.exec("VACUUM");
+  res.json({ success: true });
+});
+var maintenance_default = router8;
+
+// src/logger.ts
+import { createWriteStream, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var KANBAN_DIR = join4(homedir3(), ".claude-queue");
+var LOG_FILE = join4(KANBAN_DIR, "server.log");
+var logStream = null;
+function ensureLogFile() {
+  if (logStream) {
+    return logStream;
+  }
+  if (!existsSync3(KANBAN_DIR)) {
+    mkdirSync3(KANBAN_DIR, { recursive: true });
+  }
+  logStream = createWriteStream(LOG_FILE, { flags: "a" });
+  return logStream;
+}
+function log(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `[${timestamp}] ${message}
+`;
+  process.stdout.write(line);
+  const stream = ensureLogFile();
+  stream.write(line);
+}
+function logRequest(method, url, status, duration) {
+  log(`${method} ${url} ${status} ${duration}ms`);
+}
+
+// src/index.ts
+var generateId2 = customAlphabet2("abcdefghijklmnopqrstuvwxyz0123456789", 4);
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+function ensureDevProject() {
+  const db2 = getDb();
+  const projects = db2.prepare("SELECT * FROM projects").all();
+  if (projects.length === 0) {
+    const projectRoot = process.env.DEV_PROJECT_ROOT || process.cwd();
+    const name = projectRoot.split("/").pop() || "dev";
+    const id = `kbn-${generateId2()}`;
+    db2.prepare("INSERT INTO projects (id, path, name) VALUES (?, ?, ?)").run(id, projectRoot, name);
+    seedDefaultTemplates(id);
+    log(`Auto-created dev project: ${id} (${name})`);
+  }
+}
+function createServer(port = 3333) {
+  const app = express();
+  app.use(cors());
+  app.use(express.json({ limit: "50mb" }));
+  app.use((req, res, next) => {
+    const start = Date.now();
+    res.on("finish", () => {
+      const duration = Date.now() - start;
+      const isHealthCheck = req.path === "/health" || req.path === "/api/health";
+      if (!isHealthCheck) {
+        logRequest(req.method, req.path, res.statusCode, duration);
+      }
+    });
+    next();
+  });
+  app.use("/api/projects", projects_default);
+  app.use("/api/tasks", tasks_default);
+  app.use("/api/comments", comments_default);
+  app.use("/api/templates", templates_default);
+  app.use("/api/attachments", attachments_default);
+  app.use("/api/prompts", prompts_default);
+  app.use("/api/maintenance", maintenance_default);
+  app.use("/health", health_default);
+  const isDev = process.env.NODE_ENV === "development";
+  const viteDevPort = process.env.VITE_DEV_PORT || "5173";
+  if (isDev) {
+    app.use(
+      createProxyMiddleware({
+        target: `http://localhost:${viteDevPort}`,
+        changeOrigin: true,
+        ws: true
+      })
+    );
+  } else {
+    const uiPaths = [
+      join5(__dirname2, "../ui"),
+      // npm package: dist/server/../ui = dist/ui
+      join5(__dirname2, "../../ui/dist")
+      // development: dist/../../ui/dist
+    ];
+    const uiPath = uiPaths.find((p) => existsSync4(join5(p, "index.html")));
+    if (uiPath) {
+      app.use(express.static(uiPath));
+      app.get("*", (_req, res) => {
+        res.sendFile(join5(uiPath, "index.html"));
+      });
+    }
+  }
+  const server = app.listen(port, () => {
+    log(`Server running on http://localhost:${port}`);
+    if (isDev) {
+      ensureDevProject();
+    }
+  });
+  const shutdown = () => {
+    log("Shutting down...");
+    server.close(() => {
+      closeDb();
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return { app, server };
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  const port = parseInt(process.env.PORT || "3333", 10);
+  createServer(port);
+}
+export {
+  createServer,
+  getDb
+};