@hasna/todos 0.3.3 → 0.3.5

package/dist/cli/index.js

@@ -2638,6 +2638,178 @@ var init_search = __esm(() => {
   init_database();
 });
 
+// src/lib/claude-tasks.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+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 allTasks = listTasks({});
+  const byClaudeId = new Map;
+  for (const t of allTasks) {
+    const cid = t.metadata["claude_task_id"];
+    if (cid)
+      byClaudeId.set(String(cid), t);
+  }
+  const byTodosId = new Map;
+  for (const t of allTasks) {
+    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]
+  };
+}
+var HOME;
+var init_claude_tasks = __esm(() => {
+  init_tasks();
+  HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -6667,6 +6839,7 @@ var init_mcp = __esm(() => {
   init_comments();
   init_projects();
   init_search();
+  init_claude_tasks();
   init_database();
   init_types();
   server = new McpServer({
@@ -6964,6 +7137,42 @@ ${text}` }] };
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
+  server.tool("sync", "Sync tasks with a Claude Code task list. Auto-detects task list from session ID if not specified. Use --push to write SQLite tasks to Claude task list, --pull to import, or both for bidirectional sync.", {
+    task_list_id: exports_external.string().optional().describe("Claude Code task list ID (defaults to session ID)"),
+    project_id: exports_external.string().optional().describe("Limit sync to a project"),
+    direction: exports_external.enum(["push", "pull", "both"]).optional().describe("Sync direction: push (SQLite->Claude), pull (Claude->SQLite), or both (default)")
+  }, async ({ task_list_id, project_id, direction }) => {
+    try {
+      const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
+      const taskListId = task_list_id || process.env["TODOS_CLAUDE_TASK_LIST"] || process.env["CLAUDE_CODE_TASK_LIST_ID"] || process.env["CLAUDE_CODE_SESSION_ID"];
+      if (!taskListId) {
+        return { content: [{ type: "text", text: "Could not detect task list ID. Pass task_list_id or set CLAUDE_CODE_TASK_LIST_ID." }], isError: true };
+      }
+      let result;
+      if (direction === "push") {
+        result = pushToClaudeTaskList(taskListId, resolvedProjectId);
+      } else if (direction === "pull") {
+        result = pullFromClaudeTaskList(taskListId, resolvedProjectId);
+      } else {
+        result = syncClaudeTaskList(taskListId, resolvedProjectId);
+      }
+      const parts = [];
+      if (result.pulled > 0)
+        parts.push(`Pulled ${result.pulled} task(s) from Claude task list.`);
+      if (result.pushed > 0)
+        parts.push(`Pushed ${result.pushed} task(s) to Claude task list.`);
+      if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
+        parts.push("Nothing to sync.");
+      }
+      for (const err of result.errors) {
+        parts.push(`Error: ${err}`);
+      }
+      return { content: [{ type: "text", text: parts.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
   server.resource("tasks", "todos://tasks", { description: "All active tasks", mimeType: "application/json" }, async () => {
     const tasks = listTasks({ status: ["pending", "in_progress"] });
     return { contents: [{ uri: "todos://tasks", text: JSON.stringify(tasks, null, 2), mimeType: "application/json" }] };
@@ -8440,182 +8649,12 @@ init_tasks();
 init_projects();
 init_comments();
 init_search();
+init_claude_tasks();
 import chalk from "chalk";
 import { execSync as execSync2 } from "child_process";
 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 allTasks = listTasks({});
-  const byClaudeId = new Map;
-  for (const t of allTasks) {
-    const cid = t.metadata["claude_task_id"];
-    if (cid)
-      byClaudeId.set(String(cid), t);
-  }
-  const byTodosId = new Map;
-  for (const t of allTasks) {
-    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 = join4(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
@@ -9137,18 +9176,21 @@ hooks.command("install").description("Install Claude Code hooks for auto-sync").
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
-# Auto-detects task list ID from Claude Code env vars.
+# Reads session_id and tool_name from the hook JSON stdin.
+
+INPUT=$(cat)
 
-set -e
+# Extract session_id from stdin JSON (hooks always receive this)
+SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
 
-# Auto-detect: explicit override > Claude task list > Claude session ID
-TASK_LIST="\${TODOS_CLAUDE_TASK_LIST:-\${CLAUDE_CODE_TASK_LIST_ID:-\${CLAUDE_CODE_SESSION_ID:-}}}"
+# Task list priority: env override > session ID from hook input
+TASK_LIST="\${TODOS_CLAUDE_TASK_LIST:-\${CLAUDE_CODE_TASK_LIST_ID:-$SESSION_ID}}"
 
 if [ -z "$TASK_LIST" ]; then
   exit 0
 fi
 
-TOOL_NAME=$(cat /dev/stdin | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
+TOOL_NAME=$(echo "$INPUT" | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
 
 case "$TOOL_NAME" in
   TaskCreate|TaskUpdate)
@@ -9175,19 +9217,24 @@ exit 0
     hooksConfig["PostToolUse"] = [];
   }
   const postToolUse = hooksConfig["PostToolUse"];
-  const filtered = postToolUse.filter((h) => !(h["command"] || "").includes("todos-sync.sh"));
+  const filtered = postToolUse.filter((group) => {
+    const groupHooks = group["hooks"];
+    if (!groupHooks)
+      return true;
+    return !groupHooks.some((h) => (h["command"] || "").includes("todos-sync.sh"));
+  });
   filtered.push({
     matcher: "TaskCreate|TaskUpdate",
-    command: hookPath
+    hooks: [{ type: "command", command: hookPath }]
   });
   filtered.push({
     matcher: "mcp__todos__create_task|mcp__todos__update_task|mcp__todos__complete_task|mcp__todos__start_task",
-    command: hookPath
+    hooks: [{ type: "command", 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 auto-detected from CLAUDE_CODE_TASK_LIST_ID or CLAUDE_CODE_SESSION_ID."));
+  console.log(chalk.dim("Task list ID auto-detected from hook stdin session_id."));
 });
 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) {

package/dist/mcp/index.js

@@ -4529,6 +4529,174 @@ function searchTasks(query, projectId, db) {
   return rows.map(rowToTask2);
 }
 
+// src/lib/claude-tasks.ts
+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 errors2 = [];
+  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) {
+      errors2.push(`push ${task.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  writeHighWaterMark(dir, hwm);
+  return { pushed, pulled: 0, errors: errors2 };
+}
+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 errors2 = [];
+  const allTasks = listTasks({});
+  const byClaudeId = new Map;
+  for (const t of allTasks) {
+    const cid = t.metadata["claude_task_id"];
+    if (cid)
+      byClaudeId.set(String(cid), t);
+  }
+  const byTodosId = new Map;
+  for (const t of allTasks) {
+    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) {
+      errors2.push(`pull ${f}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { pushed: 0, pulled, errors: errors2 };
+}
+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/mcp/index.ts
 var server = new McpServer({
   name: "todos",
@@ -4873,6 +5041,42 @@ ${text}` }] };
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("sync", "Sync tasks with a Claude Code task list. Auto-detects task list from session ID if not specified. Use --push to write SQLite tasks to Claude task list, --pull to import, or both for bidirectional sync.", {
+  task_list_id: exports_external.string().optional().describe("Claude Code task list ID (defaults to session ID)"),
+  project_id: exports_external.string().optional().describe("Limit sync to a project"),
+  direction: exports_external.enum(["push", "pull", "both"]).optional().describe("Sync direction: push (SQLite->Claude), pull (Claude->SQLite), or both (default)")
+}, async ({ task_list_id, project_id, direction }) => {
+  try {
+    const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
+    const taskListId = task_list_id || process.env["TODOS_CLAUDE_TASK_LIST"] || process.env["CLAUDE_CODE_TASK_LIST_ID"] || process.env["CLAUDE_CODE_SESSION_ID"];
+    if (!taskListId) {
+      return { content: [{ type: "text", text: "Could not detect task list ID. Pass task_list_id or set CLAUDE_CODE_TASK_LIST_ID." }], isError: true };
+    }
+    let result;
+    if (direction === "push") {
+      result = pushToClaudeTaskList(taskListId, resolvedProjectId);
+    } else if (direction === "pull") {
+      result = pullFromClaudeTaskList(taskListId, resolvedProjectId);
+    } else {
+      result = syncClaudeTaskList(taskListId, resolvedProjectId);
+    }
+    const parts = [];
+    if (result.pulled > 0)
+      parts.push(`Pulled ${result.pulled} task(s) from Claude task list.`);
+    if (result.pushed > 0)
+      parts.push(`Pushed ${result.pushed} task(s) to Claude task list.`);
+    if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
+      parts.push("Nothing to sync.");
+    }
+    for (const err of result.errors) {
+      parts.push(`Error: ${err}`);
+    }
+    return { content: [{ type: "text", text: parts.join(`
+`) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 server.resource("tasks", "todos://tasks", { description: "All active tasks", mimeType: "application/json" }, async () => {
   const tasks = listTasks({ status: ["pending", "in_progress"] });
   return { contents: [{ uri: "todos://tasks", text: JSON.stringify(tasks, null, 2), mimeType: "application/json" }] };

package/package.json

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