@hasna/todos 0.2.1 → 0.3.0

package/dist/cli/index.js

@@ -6975,27 +6975,27 @@ __export(exports_serve, {
   startServer: () => startServer
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2, dirname as dirname2, extname } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname as dirname2, extname } from "path";
 import { fileURLToPath } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname2(fileURLToPath(import.meta.url));
-    candidates.push(join2(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join2(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname2(process.argv[1]);
-    candidates.push(join2(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join2(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join2(process.cwd(), "dashboard", "dist"));
+  candidates.push(join3(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync2(candidate))
+    if (existsSync3(candidate))
       return candidate;
   }
-  return join2(process.cwd(), "dashboard", "dist");
+  return join3(process.cwd(), "dashboard", "dist");
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -7009,14 +7009,14 @@ function json(data, status = 200, port) {
 }
 function getPackageVersion() {
   try {
-    const pkgPath = join2(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join3(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync2(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function serveStaticFile(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync3(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -7027,7 +7027,7 @@ function serveStaticFile(filePath) {
 async function startServer(port, options) {
   const shouldOpen = options?.open ?? true;
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync2(dashboardDir);
+  const dashboardExists = existsSync3(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -7297,12 +7297,12 @@ Dashboard not found at: ${dashboardDir}`);
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join2(dashboardDir, path);
+          const filePath = join3(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join2(dashboardDir, "index.html");
+        const indexPath = join3(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -8433,13 +8433,187 @@ init_comments();
 init_search();
 import chalk from "chalk";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { basename, dirname as dirname3, join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/claude-tasks.ts
+init_tasks();
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+function getTaskListDir(taskListId) {
+  return join2(HOME, ".claude", "tasks", taskListId);
+}
+function readHighWaterMark(dir) {
+  const path = join2(dir, ".highwatermark");
+  if (!existsSync2(path))
+    return 1;
+  const val = parseInt(readFileSync(path, "utf-8").trim(), 10);
+  return isNaN(val) ? 1 : val;
+}
+function writeHighWaterMark(dir, value) {
+  writeFileSync(join2(dir, ".highwatermark"), String(value));
+}
+function readClaudeTask(dir, filename) {
+  try {
+    const content = readFileSync(join2(dir, filename), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeClaudeTask(dir, task) {
+  writeFileSync(join2(dir, `${task.id}.json`), JSON.stringify(task, null, 2) + `
+`);
+}
+function toClaudeStatus(status) {
+  if (status === "pending" || status === "in_progress" || status === "completed") {
+    return status;
+  }
+  return "completed";
+}
+function toSqliteStatus(status) {
+  return status;
+}
+function taskToClaudeTask(task, claudeTaskId) {
+  return {
+    id: claudeTaskId,
+    subject: task.title,
+    description: task.description || "",
+    activeForm: "",
+    status: toClaudeStatus(task.status),
+    owner: task.assigned_to || task.agent_id || "",
+    blocks: [],
+    blockedBy: [],
+    metadata: {
+      todos_id: task.id,
+      priority: task.priority
+    }
+  };
+}
+function pushToClaudeTaskList(taskListId, projectId) {
+  const dir = getTaskListDir(taskListId);
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+  const filter = {};
+  if (projectId)
+    filter["project_id"] = projectId;
+  const tasks = listTasks(filter);
+  const existingByTodosId = new Map;
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  for (const f of files) {
+    const ct = readClaudeTask(dir, f);
+    if (ct?.metadata?.["todos_id"]) {
+      existingByTodosId.set(ct.metadata["todos_id"], ct);
+    }
+  }
+  let hwm = readHighWaterMark(dir);
+  let pushed = 0;
+  const errors = [];
+  for (const task of tasks) {
+    try {
+      const existing = existingByTodosId.get(task.id);
+      if (existing) {
+        const updated = taskToClaudeTask(task, existing.id);
+        updated.blocks = existing.blocks;
+        updated.blockedBy = existing.blockedBy;
+        updated.activeForm = existing.activeForm;
+        writeClaudeTask(dir, updated);
+      } else {
+        const claudeId = String(hwm);
+        hwm++;
+        const ct = taskToClaudeTask(task, claudeId);
+        writeClaudeTask(dir, ct);
+        const current = getTask(task.id);
+        if (current) {
+          const newMeta = { ...current.metadata, claude_task_id: claudeId };
+          updateTask(task.id, { version: current.version, metadata: newMeta });
+        }
+      }
+      pushed++;
+    } catch (e) {
+      errors.push(`push ${task.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  writeHighWaterMark(dir, hwm);
+  return { pushed, pulled: 0, errors };
+}
+function pullFromClaudeTaskList(taskListId, projectId) {
+  const dir = getTaskListDir(taskListId);
+  if (!existsSync2(dir)) {
+    return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
+  }
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  let pulled = 0;
+  const errors = [];
+  const filter = {};
+  if (projectId)
+    filter["project_id"] = projectId;
+  const existingTasks = listTasks(filter);
+  const byClaudeId = new Map;
+  for (const t of existingTasks) {
+    const cid = t.metadata["claude_task_id"];
+    if (cid)
+      byClaudeId.set(String(cid), t);
+  }
+  const byTodosId = new Map;
+  for (const t of existingTasks) {
+    byTodosId.set(t.id, t);
+  }
+  for (const f of files) {
+    try {
+      const ct = readClaudeTask(dir, f);
+      if (!ct)
+        continue;
+      if (ct.metadata?.["_internal"])
+        continue;
+      const todosId = ct.metadata?.["todos_id"];
+      const existingByMapping = byClaudeId.get(ct.id);
+      const existingByTodos = todosId ? byTodosId.get(todosId) : undefined;
+      const existing = existingByMapping || existingByTodos;
+      if (existing) {
+        updateTask(existing.id, {
+          version: existing.version,
+          title: ct.subject,
+          description: ct.description || undefined,
+          status: toSqliteStatus(ct.status),
+          assigned_to: ct.owner || undefined,
+          metadata: { ...existing.metadata, claude_task_id: ct.id }
+        });
+      } else {
+        createTask({
+          title: ct.subject,
+          description: ct.description || undefined,
+          status: toSqliteStatus(ct.status),
+          assigned_to: ct.owner || undefined,
+          project_id: projectId,
+          metadata: { claude_task_id: ct.id },
+          priority: ct.metadata?.["priority"] || "medium"
+        });
+      }
+      pulled++;
+    } catch (e) {
+      errors.push(`pull ${f}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { pushed: 0, pulled, errors };
+}
+function syncClaudeTaskList(taskListId, projectId) {
+  const pullResult = pullFromClaudeTaskList(taskListId, projectId);
+  const pushResult = pushToClaudeTaskList(taskListId, projectId);
+  return {
+    pushed: pushResult.pushed,
+    pulled: pullResult.pulled,
+    errors: [...pullResult.errors, ...pushResult.errors]
+  };
+}
+
+// src/cli/index.tsx
 function getPackageVersion2() {
   try {
-    const pkgPath = join3(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync2(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join4(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync3(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -8909,81 +9083,187 @@ program2.command("export").description("Export tasks").option("-f, --format <for
     console.log(JSON.stringify(tasks, null, 2));
   }
 });
-program2.command("mcp").description("Start MCP server (stdio)").option("--register <agent>", "Register MCP server with an agent (claude, codex, gemini, all)").option("--unregister <agent>", "Unregister MCP server from an agent (claude, codex, gemini, all)").action(async (opts) => {
+program2.command("sync").description("Sync tasks with a Claude Code task list").option("--task-list <id>", "Claude Code task list ID (or env TODOS_CLAUDE_TASK_LIST)").option("--push", "One-way: push SQLite tasks to Claude task list").option("--pull", "One-way: pull Claude task list into SQLite").action((opts) => {
+  const globalOpts = program2.opts();
+  const projectId = autoProject(globalOpts);
+  const taskListId = opts.taskList || process.env["TODOS_CLAUDE_TASK_LIST"];
+  if (!taskListId) {
+    console.error(chalk.red("Task list ID required. Use --task-list <id> or set TODOS_CLAUDE_TASK_LIST."));
+    process.exit(1);
+  }
+  let result;
+  if (opts.push && !opts.pull) {
+    result = pushToClaudeTaskList(taskListId, projectId);
+  } else if (opts.pull && !opts.push) {
+    result = pullFromClaudeTaskList(taskListId, projectId);
+  } else {
+    result = syncClaudeTaskList(taskListId, projectId);
+  }
+  if (globalOpts.json) {
+    output(result, true);
+    return;
+  }
+  if (result.pulled > 0)
+    console.log(chalk.green(`Pulled ${result.pulled} task(s) from Claude task list.`));
+  if (result.pushed > 0)
+    console.log(chalk.green(`Pushed ${result.pushed} task(s) to Claude task list.`));
+  if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
+    console.log(chalk.dim("Nothing to sync."));
+  }
+  for (const err of result.errors) {
+    console.error(chalk.red(`  Error: ${err}`));
+  }
+});
+var hooks = program2.command("hooks").description("Manage Claude Code hook integration");
+hooks.command("install").description("Install Claude Code hooks for auto-sync").option("--task-list <id>", "Claude Code task list ID (or env TODOS_CLAUDE_TASK_LIST)").action((opts) => {
+  const taskListId = opts.taskList || process.env["TODOS_CLAUDE_TASK_LIST"];
+  if (!taskListId) {
+    console.error(chalk.red("Task list ID required. Use --task-list <id> or set TODOS_CLAUDE_TASK_LIST."));
+    process.exit(1);
+  }
+  let todosBin = "todos";
+  try {
+    const p = execSync2("which todos", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (p)
+      todosBin = p;
+  } catch {}
+  const hooksDir = join4(process.cwd(), ".claude", "hooks");
+  if (!existsSync4(hooksDir))
+    mkdirSync3(hooksDir, { recursive: true });
+  const hookScript = `#!/usr/bin/env bash
+# Auto-generated by: todos hooks install
+# Syncs todos with Claude Code task list on tool use events.
+# Reads hook JSON from stdin; determines sync direction from tool_name.
+
+set -e
+
+TASK_LIST="\${TODOS_CLAUDE_TASK_LIST:-${taskListId}}"
+TOOL_NAME=$(cat /dev/stdin | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
+
+case "$TOOL_NAME" in
+  TaskCreate|TaskUpdate)
+    ${todosBin} sync --pull --task-list "$TASK_LIST" 2>/dev/null || true
+    ;;
+  mcp__todos__*)
+    ${todosBin} sync --push --task-list "$TASK_LIST" 2>/dev/null || true
+    ;;
+  *)
+    # Unknown tool, run bidirectional sync
+    ${todosBin} sync --task-list "$TASK_LIST" 2>/dev/null || true
+    ;;
+esac
+
+exit 0
+`;
+  const hookPath = join4(hooksDir, "todos-sync.sh");
+  writeFileSync2(hookPath, hookScript);
+  execSync2(`chmod +x "${hookPath}"`);
+  console.log(chalk.green(`Hook script created: ${hookPath}`));
+  const settingsPath = join4(process.cwd(), ".claude", "settings.json");
+  const settings = readJsonFile(settingsPath);
+  if (!settings["hooks"]) {
+    settings["hooks"] = {};
+  }
+  const hooksConfig = settings["hooks"];
+  if (!hooksConfig["PostToolUse"]) {
+    hooksConfig["PostToolUse"] = [];
+  }
+  const postToolUse = hooksConfig["PostToolUse"];
+  const filtered = postToolUse.filter((h) => !(h["command"] || "").includes("todos-sync.sh"));
+  filtered.push({
+    matcher: "TaskCreate|TaskUpdate",
+    command: hookPath
+  });
+  filtered.push({
+    matcher: "mcp__todos__create_task|mcp__todos__update_task|mcp__todos__complete_task|mcp__todos__start_task",
+    command: hookPath
+  });
+  hooksConfig["PostToolUse"] = filtered;
+  writeJsonFile(settingsPath, settings);
+  console.log(chalk.green(`Claude Code hooks configured in: ${settingsPath}`));
+  console.log(chalk.dim(`Task list ID: ${taskListId}`));
+  console.log(chalk.dim("Set TODOS_CLAUDE_TASK_LIST env var to override at runtime."));
+});
+program2.command("mcp").description("Start MCP server (stdio)").option("--register <agent>", "Register MCP server with an agent (claude, codex, gemini, all)").option("--unregister <agent>", "Unregister MCP server from an agent (claude, codex, gemini, all)").option("-g, --global", "Register/unregister globally (user-level) instead of project-level").action(async (opts) => {
   if (opts.register) {
-    registerMcp(opts.register);
+    registerMcp(opts.register, opts.global);
     return;
   }
   if (opts.unregister) {
-    unregisterMcp(opts.unregister);
+    unregisterMcp(opts.unregister, opts.global);
     return;
   }
   await Promise.resolve().then(() => (init_mcp(), exports_mcp));
 });
-var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+var HOME2 = process.env["HOME"] || process.env["USERPROFILE"] || "~";
 function getMcpBinaryPath() {
   try {
     const p = execSync2("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join3(HOME, ".bun", "bin", "todos-mcp");
-  if (existsSync3(bunBin))
+  const bunBin = join4(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync4(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return {};
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeJsonFile(path, data) {
   const dir = dirname3(path);
-  if (!existsSync3(dir))
-    mkdirSync2(dir, { recursive: true });
-  writeFileSync(path, JSON.stringify(data, null, 2) + `
+  if (!existsSync4(dir))
+    mkdirSync3(dir, { recursive: true });
+  writeFileSync2(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return "";
-  return readFileSync2(path, "utf-8");
+  return readFileSync3(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname3(path);
-  if (!existsSync3(dir))
-    mkdirSync2(dir, { recursive: true });
-  writeFileSync(path, content);
+  if (!existsSync4(dir))
+    mkdirSync3(dir, { recursive: true });
+  writeFileSync2(path, content);
 }
-function registerClaude(binPath) {
-  const cwd = process.cwd();
-  const configPath = join3(cwd, ".mcp.json");
+function registerClaude(binPath, global) {
+  const configPath = global ? join4(HOME2, ".claude", ".mcp.json") : join4(process.cwd(), ".mcp.json");
   const config = readJsonFile(configPath);
-  config["todos"] = {
+  if (!config["mcpServers"]) {
+    config["mcpServers"] = {};
+  }
+  const servers = config["mcpServers"];
+  servers["todos"] = {
     command: binPath,
     args: []
   };
   writeJsonFile(configPath, config);
-  console.log(chalk.green(`Claude Code: registered in ${configPath}`));
+  const scope = global ? "global" : "project";
+  console.log(chalk.green(`Claude Code (${scope}): registered in ${configPath}`));
 }
-function unregisterClaude() {
-  const cwd = process.cwd();
-  const configPath = join3(cwd, ".mcp.json");
+function unregisterClaude(global) {
+  const configPath = global ? join4(HOME2, ".claude", ".mcp.json") : join4(process.cwd(), ".mcp.json");
   const config = readJsonFile(configPath);
-  if (!("todos" in config)) {
+  const servers = config["mcpServers"];
+  if (!servers || !("todos" in servers)) {
     console.log(chalk.dim(`Claude Code: todos not found in ${configPath}`));
     return;
   }
-  delete config["todos"];
+  delete servers["todos"];
   writeJsonFile(configPath, config);
-  console.log(chalk.green(`Claude Code: unregistered from ${configPath}`));
+  const scope = global ? "global" : "project";
+  console.log(chalk.green(`Claude Code (${scope}): unregistered from ${configPath}`));
 }
 function registerCodex(binPath) {
-  const configPath = join3(HOME, ".codex", "config.toml");
+  const configPath = join4(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -8997,7 +9277,7 @@ args = []
   console.log(chalk.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join3(HOME, ".codex", "config.toml");
+  const configPath = join4(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -9030,7 +9310,7 @@ function removeTomlBlock(content, blockName) {
 `);
 }
 function registerGemini(binPath) {
-  const configPath = join3(HOME, ".gemini", "settings.json");
+  const configPath = join4(HOME2, ".gemini", "settings.json");
   const config = readJsonFile(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -9044,7 +9324,7 @@ function registerGemini(binPath) {
   console.log(chalk.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join3(HOME, ".gemini", "settings.json");
+  const configPath = join4(HOME2, ".gemini", "settings.json");
   const config = readJsonFile(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -9055,13 +9335,13 @@ function unregisterGemini() {
   writeJsonFile(configPath, config);
   console.log(chalk.green(`Gemini CLI: unregistered from ${configPath}`));
 }
-function registerMcp(agent) {
+function registerMcp(agent, global) {
   const agents = agent === "all" ? ["claude", "codex", "gemini"] : [agent];
   const binPath = getMcpBinaryPath();
   for (const a of agents) {
     switch (a) {
       case "claude":
-        registerClaude(binPath);
+        registerClaude(binPath, global);
         break;
       case "codex":
         registerCodex(binPath);
@@ -9074,12 +9354,12 @@ function registerMcp(agent) {
     }
   }
 }
-function unregisterMcp(agent) {
+function unregisterMcp(agent, global) {
   const agents = agent === "all" ? ["claude", "codex", "gemini"] : [agent];
   for (const a of agents) {
     switch (a) {
       case "claude":
-        unregisterClaude();
+        unregisterClaude(global);
         break;
       case "codex":
         unregisterCodex();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/todos",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   "type": "module",
   "main": "dist/index.js",