claude-queue 1.0.0

package/dist/cli.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+
+// src/constants.ts
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_PORT = 3333;
+var KANBAN_DIR = join(homedir(), ".claude-queue");
+var PID_FILE = join(KANBAN_DIR, "server.pid");
+var LOG_FILE = join(KANBAN_DIR, "server.log");
+var CLAUDE_DIR = join(homedir(), ".claude");
+var SKILLS_DIR = join(CLAUDE_DIR, "skills");
+
+// src/server.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+function ensureKanbanDir() {
+  if (!existsSync(KANBAN_DIR)) {
+    mkdirSync(KANBAN_DIR, { recursive: true });
+  }
+}
+async function isServerRunning(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}/api/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function getRunningPid() {
+  if (!existsSync(PID_FILE)) {
+    return null;
+  }
+  try {
+    const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim());
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function savePid(pid) {
+  ensureKanbanDir();
+  writeFileSync(PID_FILE, pid.toString());
+}
+async function clearPid() {
+  if (existsSync(PID_FILE)) {
+    const fs = await import("fs/promises");
+    await fs.unlink(PID_FILE).catch(() => {
+    });
+  }
+}
+function getServerPath() {
+  const npmServerPath = join2(import.meta.dirname, "server", "index.js");
+  if (existsSync(npmServerPath)) {
+    return npmServerPath;
+  }
+  const devServerPath = join2(import.meta.dirname, "..", "..", "server", "dist", "index.js");
+  if (existsSync(devServerPath)) {
+    return devServerPath;
+  }
+  throw new Error("Server not found. Run 'pnpm build' first.");
+}
+async function startServer(port, detach, verbose) {
+  const serverPath = getServerPath();
+  const env = {
+    ...process.env,
+    PORT: port.toString(),
+    NODE_ENV: "production"
+  };
+  if (detach) {
+    ensureKanbanDir();
+    const logStream = await import("fs").then(
+      (fs) => fs.createWriteStream(LOG_FILE, { flags: "a" })
+    );
+    const child2 = spawn("node", [serverPath], {
+      env,
+      detached: true,
+      stdio: ["ignore", logStream, logStream]
+    });
+    child2.unref();
+    if (child2.pid) {
+      savePid(child2.pid);
+    }
+    if (verbose) {
+      console.log(`Server started in background (PID: ${child2.pid})`);
+    }
+    return null;
+  }
+  const child = spawn("node", [serverPath], {
+    env,
+    stdio: verbose ? "inherit" : "pipe"
+  });
+  return child;
+}
+async function waitForServer(port, maxWait = 1e4) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    if (await isServerRunning(port)) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return false;
+}
+
+// src/project.ts
+import { basename, resolve } from "path";
+import { customAlphabet } from "nanoid";
+var generateId = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 4);
+function generateProjectId() {
+  return `kbn-${generateId()}`;
+}
+async function registerProject(port, projectPath, verbose) {
+  const absolutePath = resolve(projectPath);
+  const projectName = basename(absolutePath);
+  const response = await fetch(`http://localhost:${port}/api/projects`);
+  const projects = await response.json();
+  const existing = projects.find((p) => p.path === absolutePath);
+  if (existing) {
+    if (verbose) {
+      console.log(`Project already registered: ${existing.id}`);
+    }
+    return existing.id;
+  }
+  const createResponse = await fetch(`http://localhost:${port}/api/projects`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      id: generateProjectId(),
+      name: projectName,
+      path: absolutePath
+    })
+  });
+  if (!createResponse.ok) {
+    throw new Error(`Failed to register project: ${await createResponse.text()}`);
+  }
+  const project = await createResponse.json();
+  if (verbose) {
+    console.log(`Registered new project: ${project.id}`);
+  }
+  return project.id;
+}
+
+// src/skills.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, rmSync } from "fs";
+import { join as join3 } from "path";
+async function configureMcp() {
+  const settingsPath = join3(CLAUDE_DIR, "settings.json");
+  if (!existsSync2(CLAUDE_DIR)) {
+    mkdirSync2(CLAUDE_DIR, { recursive: true });
+  }
+  let settings = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    } catch {
+      console.log("Warning: Could not parse existing settings.json");
+    }
+  }
+  const mcpServers = settings.mcpServers || {};
+  if (!mcpServers["claude-queue"]) {
+    mcpServers["claude-queue"] = {
+      command: "npx",
+      args: ["-y", "-p", "claude-queue", "claude-queue-mcp"],
+      env: {
+        KANBAN_SERVER_URL: `http://localhost:${DEFAULT_PORT}`
+      }
+    };
+    settings.mcpServers = mcpServers;
+    writeFileSync2(settingsPath, JSON.stringify(settings, null, 2));
+    console.log("\u2713 Configured MCP server in ~/.claude/settings.json");
+  }
+}
+function getSkillPath() {
+  const npmSkillPath = join3(import.meta.dirname, "skills", "queue", "SKILL.md");
+  if (existsSync2(npmSkillPath)) {
+    return npmSkillPath;
+  }
+  const devSkillPath = join3(import.meta.dirname, "..", "..", "skills", "queue", "SKILL.md");
+  if (existsSync2(devSkillPath)) {
+    return devSkillPath;
+  }
+  throw new Error("Skill file not found. Run 'pnpm build' first.");
+}
+function installSkills() {
+  const queueSkillDir = join3(SKILLS_DIR, "queue");
+  const queueSkillFile = join3(queueSkillDir, "SKILL.md");
+  if (existsSync2(queueSkillFile)) {
+    return;
+  }
+  if (!existsSync2(SKILLS_DIR)) {
+    mkdirSync2(SKILLS_DIR, { recursive: true });
+  }
+  if (!existsSync2(queueSkillDir)) {
+    mkdirSync2(queueSkillDir, { recursive: true });
+  }
+  const skillSourcePath = getSkillPath();
+  const skillContent = readFileSync2(skillSourcePath, "utf-8");
+  writeFileSync2(queueSkillFile, skillContent);
+  console.log("\u2713 Installed /queue skill to ~/.claude/skills/queue/");
+}
+function removeMcp() {
+  const settingsPath = join3(CLAUDE_DIR, "settings.json");
+  if (!existsSync2(settingsPath)) {
+    return false;
+  }
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+  } catch {
+    return false;
+  }
+  const mcpServers = settings.mcpServers || {};
+  if (!mcpServers["claude-queue"]) {
+    return false;
+  }
+  delete mcpServers["claude-queue"];
+  settings.mcpServers = mcpServers;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2));
+  return true;
+}
+function removeSkills() {
+  const queueSkillDir = join3(SKILLS_DIR, "queue");
+  if (!existsSync2(queueSkillDir)) {
+    return false;
+  }
+  rmSync(queueSkillDir, { recursive: true });
+  return true;
+}
+
+// src/doctor.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+async function runDoctor(port, fix) {
+  console.log("\n\u{1FA7A} Claude Queue Doctor\n");
+  console.log("Checking your setup...\n");
+  let issues = 0;
+  let warnings = 0;
+  const claudeDirExists = existsSync3(CLAUDE_DIR);
+  if (claudeDirExists) {
+    console.log("\u2705 Claude directory exists (~/.claude)");
+  } else {
+    console.log("\u274C Claude directory not found (~/.claude)");
+    issues++;
+    if (fix) {
+      mkdirSync3(CLAUDE_DIR, { recursive: true });
+      console.log("   \u2192 Created ~/.claude");
+    }
+  }
+  const settingsPath = join4(CLAUDE_DIR, "settings.json");
+  let mcpConfigured = false;
+  if (existsSync3(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      const mcpServers = settings.mcpServers || {};
+      mcpConfigured = !!mcpServers["claude-queue"];
+      if (mcpConfigured) {
+        console.log("\u2705 MCP server configured in settings.json");
+      } else {
+        console.log("\u274C MCP server not configured");
+        issues++;
+        if (fix) {
+          await configureMcp();
+          console.log("   \u2192 Configured MCP server");
+        }
+      }
+    } catch {
+      console.log("\u26A0\uFE0F  Could not parse settings.json");
+      warnings++;
+    }
+  } else {
+    console.log("\u274C settings.json not found");
+    issues++;
+    if (fix) {
+      await configureMcp();
+      console.log("   \u2192 Created settings.json with MCP config");
+    }
+  }
+  const skillPath = join4(SKILLS_DIR, "kanban", "SKILL.md");
+  if (existsSync3(skillPath)) {
+    console.log("\u2705 /queue skill installed");
+  } else {
+    console.log("\u274C /queue skill not installed");
+    issues++;
+    if (fix) {
+      installSkills();
+      console.log("   \u2192 Installed /queue skill");
+    }
+  }
+  if (existsSync3(KANBAN_DIR)) {
+    console.log("\u2705 Queue data directory exists (~/.claude-queue)");
+  } else {
+    console.log("\u26A0\uFE0F  Queue data directory not created yet");
+    warnings++;
+  }
+  const dbPath = join4(KANBAN_DIR, "kanban.db");
+  if (existsSync3(dbPath)) {
+    const stats = await import("fs/promises").then((fs) => fs.stat(dbPath));
+    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+    console.log(`\u2705 Database exists (${sizeMB} MB)`);
+  } else {
+    console.log("\u26A0\uFE0F  Database not created yet (will be created on first run)");
+    warnings++;
+  }
+  const serverRunning = await isServerRunning(port);
+  if (serverRunning) {
+    console.log(`\u2705 Server running on port ${port}`);
+    try {
+      const response = await fetch(`http://localhost:${port}/api/maintenance/stats`);
+      if (response.ok) {
+        const stats = await response.json();
+        console.log(`   \u2514\u2500\u2500 ${stats.projects} projects, ${stats.tasks.total} tasks`);
+      }
+    } catch {
+    }
+  } else {
+    console.log(`\u26A0\uFE0F  Server not running on port ${port}`);
+    warnings++;
+  }
+  const pid = getRunningPid();
+  if (pid) {
+    console.log(`\u2705 PID file valid (${pid})`);
+  } else if (existsSync3(join4(KANBAN_DIR, "server.pid"))) {
+    console.log("\u26A0\uFE0F  Stale PID file found");
+    warnings++;
+    if (fix) {
+      await clearPid();
+      console.log("   \u2192 Removed stale PID file");
+    }
+  }
+  console.log("\n" + "\u2500".repeat(40));
+  if (issues === 0 && warnings === 0) {
+    console.log("\u2705 All checks passed! Your setup looks good.\n");
+  } else if (issues === 0) {
+    console.log(`\u26A0\uFE0F  ${warnings} warning(s), but no critical issues.
+`);
+  } else {
+    console.log(`\u274C ${issues} issue(s) found, ${warnings} warning(s).
+`);
+    if (!fix) {
+      console.log("Run with --fix to attempt automatic fixes:");
+      console.log("  npx claude-queue doctor --fix\n");
+    }
+  }
+  console.log("Quick reference:");
+  console.log("  Start server:     npx claude-queue");
+  console.log("  View board:       http://localhost:" + port);
+  console.log("  Run skill:        /queue <project-id>");
+  console.log("  View logs:        npx claude-queue logs -f");
+  console.log("");
+}
+
+// src/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync4(join5(__dirname, "..", "package.json"), "utf-8"));
+program.name("claude-queue").description("Local queue board for managing Claude Code projects").version(pkg.version);
+program.command("start", { isDefault: true }).description("Start the queue server and register current directory as a project").option("-p, --port <port>", "Server port", DEFAULT_PORT.toString()).option("-d, --detach", "Run server in background").option("-v, --verbose", "Verbose output").action(async (options) => {
+  const port = parseInt(options.port);
+  const detach = options.detach || false;
+  const verbose = options.verbose || false;
+  ensureKanbanDir();
+  await configureMcp();
+  installSkills();
+  const running = await isServerRunning(port);
+  if (!running) {
+    if (verbose) {
+      console.log("Starting queue server...");
+    }
+    const child = await startServer(port, detach, verbose);
+    const serverReady = await waitForServer(port);
+    if (!serverReady) {
+      console.error("Server failed to start");
+      process.exit(1);
+    }
+    if (child && !detach) {
+      const projectId = await registerProject(port, process.cwd(), verbose);
+      console.log(`Kanban board: http://localhost:${port}?project=${projectId}`);
+      console.log("Press Ctrl+C to stop");
+      process.on("SIGINT", () => {
+        child.kill();
+        process.exit(0);
+      });
+      await new Promise(() => {
+      });
+    }
+  } else {
+    if (verbose) {
+      console.log("Server already running");
+    }
+  }
+  if (running || detach) {
+    const projectId = await registerProject(port, process.cwd(), verbose);
+    console.log(`Kanban board: http://localhost:${port}?project=${projectId}`);
+  }
+});
+program.command("list").description("List all registered projects").option("-p, --port <port>", "Server port", DEFAULT_PORT.toString()).action(async (options) => {
+  const port = parseInt(options.port);
+  if (!await isServerRunning(port)) {
+    console.error("Server is not running. Start it with: claude-queue");
+    process.exit(1);
+  }
+  const response = await fetch(`http://localhost:${port}/api/projects`);
+  const projects = await response.json();
+  if (projects.length === 0) {
+    console.log("No projects registered");
+    return;
+  }
+  console.log("Registered projects:");
+  for (const project of projects) {
+    console.log(`  ${project.id}  ${project.name}`);
+    console.log(`           ${project.path}`);
+  }
+});
+program.command("delete <projectId>").description("Delete a project from the queue").option("-p, --port <port>", "Server port", DEFAULT_PORT.toString()).action(async (projectId, options) => {
+  const port = parseInt(options.port);
+  if (!await isServerRunning(port)) {
+    console.error("Server is not running. Start it with: claude-queue");
+    process.exit(1);
+  }
+  const response = await fetch(`http://localhost:${port}/api/projects/${projectId}`, {
+    method: "DELETE"
+  });
+  if (!response.ok) {
+    console.error(`Failed to delete project: ${await response.text()}`);
+    process.exit(1);
+  }
+  console.log(`Deleted project: ${projectId}`);
+});
+program.command("status").description("Check server status").option("-p, --port <port>", "Server port", DEFAULT_PORT.toString()).action(async (options) => {
+  const port = parseInt(options.port);
+  const running = await isServerRunning(port);
+  const pid = getRunningPid();
+  if (running) {
+    console.log(`Server is running on port ${port}`);
+    if (pid) {
+      console.log(`PID: ${pid}`);
+    }
+  } else {
+    console.log("Server is not running");
+  }
+});
+program.command("stop").description("Stop the background server").action(async () => {
+  const pid = getRunningPid();
+  if (!pid) {
+    console.log("No background server running");
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Stopped server (PID: ${pid})`);
+    clearPid();
+  } catch (error) {
+    console.error(`Failed to stop server: ${error}`);
+  }
+});
+program.command("logs").description("View server logs").option("-f, --follow", "Follow log output").option("-n, --lines <lines>", "Number of lines to show", "50").action(async (options) => {
+  if (!existsSync4(LOG_FILE)) {
+    console.log("No logs found");
+    return;
+  }
+  if (options.follow) {
+    const { spawn: spawn2 } = await import("child_process");
+    const tail = spawn2("tail", ["-f", LOG_FILE], { stdio: "inherit" });
+    process.on("SIGINT", () => {
+      tail.kill();
+      process.exit(0);
+    });
+  } else {
+    const { spawn: spawn2 } = await import("child_process");
+    spawn2("tail", ["-n", options.lines, LOG_FILE], { stdio: "inherit" });
+  }
+});
+program.command("clean").description("Clean up log files and temporary data").option("--logs", "Remove log files only").option("--all", "Remove all data (logs, database, PID file)").action(async (options) => {
+  const fs = await import("fs/promises");
+  const { join: join6 } = await import("path");
+  const removed = [];
+  if (options.logs || !options.all) {
+    if (existsSync4(LOG_FILE)) {
+      await fs.unlink(LOG_FILE);
+      removed.push("server.log");
+    }
+  }
+  if (options.all) {
+    const dbFile = join6(KANBAN_DIR, "queue.db");
+    if (existsSync4(LOG_FILE)) {
+      await fs.unlink(LOG_FILE);
+      removed.push("server.log");
+    }
+    if (existsSync4(PID_FILE)) {
+      await fs.unlink(PID_FILE);
+      removed.push("server.pid");
+    }
+    if (existsSync4(dbFile)) {
+      await fs.unlink(dbFile);
+      removed.push("queue.db");
+    }
+  }
+  if (removed.length === 0) {
+    console.log("No files to clean");
+  } else {
+    console.log(`Cleaned: ${removed.join(", ")}`);
+  }
+});
+program.command("doctor").description("Check system configuration and diagnose common issues").option("-p, --port <port>", "Server port", DEFAULT_PORT.toString()).option("--fix", "Attempt to fix issues automatically").action(async (options) => {
+  const port = parseInt(options.port);
+  const fix = options.fix || false;
+  await runDoctor(port, fix);
+});
+program.command("uninstall").description("Remove MCP server and skill from Claude Code configuration").option("--all", "Also remove all data (database, logs)").action(async (options) => {
+  const fs = await import("fs/promises");
+  const { join: join6 } = await import("path");
+  const removed = [];
+  const mcpRemoved = removeMcp();
+  if (mcpRemoved) {
+    removed.push("MCP server config");
+  }
+  const skillsRemoved = removeSkills();
+  if (skillsRemoved) {
+    removed.push("/queue skill");
+  }
+  if (options.all) {
+    const dbFile = join6(KANBAN_DIR, "queue.db");
+    if (existsSync4(LOG_FILE)) {
+      await fs.unlink(LOG_FILE);
+      removed.push("server.log");
+    }
+    if (existsSync4(PID_FILE)) {
+      await fs.unlink(PID_FILE);
+      removed.push("server.pid");
+    }
+    if (existsSync4(dbFile)) {
+      await fs.unlink(dbFile);
+      removed.push("queue.db");
+    }
+    if (existsSync4(KANBAN_DIR)) {
+      await fs.rmdir(KANBAN_DIR).catch(() => {
+      });
+    }
+  }
+  if (removed.length === 0) {
+    console.log("Nothing to uninstall");
+  } else {
+    console.log(`\u2713 Removed: ${removed.join(", ")}`);
+    console.log("\nRestart Claude Code to complete the uninstall.");
+  }
+});
+program.parse();

package/dist/mcp/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node