@codebyplan/cli 3.0.2 → 3.1.0

package/dist/cli.js

@@ -37,7 +37,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "3.0.2";
+    VERSION = "3.1.0";
     PACKAGE_NAME = "@codebyplan/cli";
   }
 });
@@ -465,6 +465,7 @@ async function executeSyncToLocal(options) {
   const worktree = await isGitWorktree(projectPath);
   const byType = {};
   const totals = { created: 0, updated: 0, deleted: 0, unchanged: 0 };
+  const dbOnlyFiles = [];
   for (const [syncKey, typeName] of Object.entries(syncKeyToType)) {
     if (worktree && typeName === "command") {
       byType["commands"] = { created: [], updated: [], deleted: [], unchanged: [] };
@@ -489,6 +490,13 @@ async function executeSyncToLocal(options) {
       const fullPath = join2(targetDir, relPath);
       const localContent = localFiles.get(relPath);
       if (localContent === void 0) {
+        const remoteFile = remoteFiles.find((f) => f.name === name);
+        dbOnlyFiles.push({
+          type: typeName,
+          name,
+          category: remoteFile?.category ?? null,
+          localPath: fullPath
+        });
         if (!dryRun) {
           await mkdir(dirname(fullPath), { recursive: true });
           await writeFile(fullPath, content, "utf-8");
@@ -659,7 +667,7 @@ async function executeSyncToLocal(options) {
   if (!dryRun) {
     await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
   }
-  return { byType, totals };
+  return { byType, totals, dbOnlyFiles };
 }
 var typeConfig, syncKeyToType;
 var init_sync_engine = __esm({
@@ -1055,6 +1063,36 @@ async function confirmProceed(message) {
     rl.close();
   }
 }
+async function promptChoice(message, options) {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  try {
+    const answer = await rl.question(message);
+    const a = answer.trim().toLowerCase();
+    return options.includes(a) ? a : options[0];
+  } finally {
+    rl.close();
+  }
+}
+async function confirmEach(items, label) {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  const accepted = [];
+  try {
+    for (const item of items) {
+      const answer = await rl.question(`    ${label(item)} \u2014 delete? [y/n/a] `);
+      const a = answer.trim().toLowerCase();
+      if (a === "a") {
+        accepted.push(item, ...items.slice(items.indexOf(item) + 1));
+        break;
+      }
+      if (a === "y" || a === "yes" || a === "") {
+        accepted.push(item);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  return accepted;
+}
 var init_confirm = __esm({
   "src/cli/confirm.ts"() {
     "use strict";
@@ -1062,7 +1100,7 @@ var init_confirm = __esm({
 });
 
 // src/lib/tech-detect.ts
-import { readFile as readFile6, access } from "node:fs/promises";
+import { readFile as readFile6, readdir as readdir4, access } from "node:fs/promises";
 import { join as join6 } from "node:path";
 async function fileExists(filePath) {
   try {
@@ -1072,10 +1110,9 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function detectTechStack(projectPath) {
-  const seen = /* @__PURE__ */ new Map();
+async function scanPackageJson(pkgPath, seen) {
   try {
-    const raw = await readFile6(join6(projectPath, "package.json"), "utf-8");
+    const raw = await readFile6(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     const allDeps = {
       ...pkg.dependencies,
@@ -1092,12 +1129,42 @@ async function detectTechStack(projectPath) {
     }
   } catch {
   }
+}
+async function scanConfigFiles(dir, seen) {
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join6(projectPath, file))) {
+    if (!seen.has(key) && await fileExists(join6(dir, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
+}
+async function detectWorkspaceDirs(projectPath) {
+  const isTurbo = await fileExists(join6(projectPath, "turbo.json"));
+  const isPnpm = await fileExists(join6(projectPath, "pnpm-workspace.yaml"));
+  if (!isTurbo && !isPnpm) return [];
+  const dirs = [];
+  for (const parent of ["apps", "packages"]) {
+    try {
+      const entries = await readdir4(join6(projectPath, parent), { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          dirs.push(join6(projectPath, parent, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  return dirs;
+}
+async function detectTechStack(projectPath) {
+  const seen = /* @__PURE__ */ new Map();
+  await scanPackageJson(join6(projectPath, "package.json"), seen);
+  await scanConfigFiles(projectPath, seen);
+  const workspaceDirs = await detectWorkspaceDirs(projectPath);
+  for (const dir of workspaceDirs) {
+    await scanPackageJson(join6(dir, "package.json"), seen);
+    await scanConfigFiles(dir, seen);
+  }
   return Array.from(seen.values()).sort((a, b) => {
     const catCmp = a.category.localeCompare(b.category);
     if (catCmp !== 0) return catCmp;
@@ -1200,13 +1267,126 @@ var init_tech_detect = __esm({
   }
 });
 
+// src/lib/server-detect.ts
+import { readFile as readFile7, readdir as readdir5, access as access2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+async function fileExists2(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(dir) {
+  return (async () => {
+    if (await fileExists2(join7(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join7(dir, "yarn.lock"))) return "yarn";
+    return "npm";
+  })();
+}
+function detectFramework(pkg) {
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  const hasDep = (name) => name in deps || name in devDeps;
+  if (hasDep("next")) return "nextjs";
+  if (hasDep("@tauri-apps/api") || hasDep("@tauri-apps/cli")) return "tauri";
+  if (hasDep("expo")) return "expo";
+  if (hasDep("vite")) return "vite";
+  if (hasDep("express")) return "express";
+  if (hasDep("@nestjs/core")) return "nestjs";
+  return "custom";
+}
+function detectPortFromScripts(pkg) {
+  const scripts = pkg.scripts;
+  if (!scripts?.dev) return null;
+  const parts = scripts.dev.split(/\s+/);
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (parts[i] === "--port" || parts[i] === "-p") {
+      const next = parts[i + 1];
+      if (next) {
+        const port = parseInt(next, 10);
+        if (!isNaN(port)) return port;
+      }
+    }
+  }
+  return null;
+}
+async function isMonorepo(dir) {
+  return await fileExists2(join7(dir, "turbo.json")) || await fileExists2(join7(dir, "pnpm-workspace.yaml"));
+}
+async function detectServers(projectPath) {
+  let pkg;
+  try {
+    const raw = await readFile7(join7(projectPath, "package.json"), "utf-8");
+    pkg = JSON.parse(raw);
+  } catch {
+    return {
+      name: "unknown",
+      isMonorepo: false,
+      packageManager: "npm",
+      servers: []
+    };
+  }
+  const rawName = pkg.name ?? "unknown";
+  const name = rawName.startsWith("@") ? projectPath.split("/").pop() ?? rawName : rawName;
+  const pkgManager = await detectPackageManager(projectPath);
+  const mono = await isMonorepo(projectPath);
+  const servers = [];
+  if (mono) {
+    const appsDir = join7(projectPath, "apps");
+    try {
+      const entries = await readdir5(appsDir, { withFileTypes: true });
+      const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of sorted) {
+        if (!entry.isDirectory()) continue;
+        const appPkgPath = join7(appsDir, entry.name, "package.json");
+        try {
+          const appRaw = await readFile7(appPkgPath, "utf-8");
+          const appPkg = JSON.parse(appRaw);
+          const appName = entry.name;
+          const framework = detectFramework(appPkg);
+          const port = detectPortFromScripts(appPkg);
+          let command;
+          switch (pkgManager) {
+            case "pnpm":
+              command = `pnpm --filter ${appName} dev`;
+              break;
+            case "yarn":
+              command = `yarn workspace ${appName} dev`;
+              break;
+            default:
+              command = `npm run dev -w apps/${appName}`;
+              break;
+          }
+          servers.push({ label: appName, port, command, server_type: framework });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  } else {
+    const framework = detectFramework(pkg);
+    const port = detectPortFromScripts(pkg);
+    const command = `${pkgManager} run dev`;
+    servers.push({ label: "dev", port, command, server_type: framework });
+  }
+  return { name, isMonorepo: mono, packageManager: pkgManager, servers };
+}
+var init_server_detect = __esm({
+  "src/lib/server-detect.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/sync.ts
 var sync_exports = {};
 __export(sync_exports, {
   runSync: () => runSync
 });
-import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir2, chmod as chmod2 } from "node:fs/promises";
-import { join as join7, dirname as dirname2 } from "node:path";
+import { readFile as readFile8, writeFile as writeFile3, mkdir as mkdir2, chmod as chmod2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join8, dirname as dirname2 } from "node:path";
 async function runSync() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -1222,7 +1402,7 @@ async function runSync() {
   if (force) console.log(`  Mode: force`);
   console.log();
   console.log("  Reading local and remote state...");
-  const claudeDir = join7(projectPath, ".claude");
+  const claudeDir = join8(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
@@ -1306,27 +1486,61 @@ async function runSync() {
   }
   const pulls = plan.filter((p) => p.action === "pull");
   const pushes = plan.filter((p) => p.action === "push");
-  if (pulls.length > 0) {
-    console.log(`  Pull (DB \u2192 local): ${pulls.length}`);
-    for (const p of pulls) console.log(`    \u2193 ${p.displayPath}`);
+  const remoteOnly = plan.filter((p) => p.action === "pull" && p.localContent === null);
+  const contentPulls = pulls.filter((p) => p.localContent !== null);
+  if (contentPulls.length > 0) {
+    console.log(`  Pull (DB \u2192 local): ${contentPulls.length}`);
+    for (const p of contentPulls) console.log(`    \u2193 ${p.displayPath}`);
   }
   if (pushes.length > 0) {
     console.log(`  Push (local \u2192 DB): ${pushes.length}`);
     for (const p of pushes) console.log(`    \u2191 ${p.displayPath}`);
   }
-  if (pulls.length === 0 && pushes.length === 0) {
+  if (remoteOnly.length > 0) {
+    console.log(`
+  DB-only (not on disk): ${remoteOnly.length}`);
+    for (const p of remoteOnly) console.log(`    \u2715 ${p.displayPath}`);
+  }
+  if (contentPulls.length === 0 && pushes.length === 0 && remoteOnly.length === 0) {
     console.log("  All .claude/ files in sync.");
   }
   if (plan.length > 0 && !dryRun) {
-    if (!force && pulls.length + pushes.length > 0) {
+    let toDelete = [];
+    let toPull = contentPulls;
+    if (remoteOnly.length > 0) {
       console.log();
-      const confirmed = await confirmProceed();
-      if (!confirmed) {
-        console.log("  Cancelled.\n");
-        return;
+      console.log(`  ${remoteOnly.length} file(s) exist in DB but not locally.`);
+      const choice = await promptChoice(
+        "  Delete from DB? [a]ll / [o]ne-by-one / [p]ull instead: ",
+        ["a", "o", "p"]
+      );
+      if (choice === "a") {
+        toDelete = remoteOnly;
+      } else if (choice === "o") {
+        toDelete = await confirmEach(
+          remoteOnly,
+          (p) => p.displayPath
+        );
+        const deleteKeys = new Set(toDelete.map((d) => d.key));
+        const pullBack = remoteOnly.filter((p) => !deleteKeys.has(p.key));
+        toPull = [...toPull, ...pullBack];
+      } else {
+        toPull = [...toPull, ...remoteOnly];
       }
     }
-    for (const p of pulls) {
+    if (toPull.length + pushes.length + toDelete.length > 0 && !force) {
+      if (toPull.length > 0 || pushes.length > 0) {
+        const confirmed = await confirmProceed(
+          `
+  Apply ${toPull.length} pull(s), ${pushes.length} push(es), ${toDelete.length} deletion(s)? [Y/n] `
+        );
+        if (!confirmed) {
+          console.log("  Cancelled.\n");
+          return;
+        }
+      }
+    }
+    for (const p of toPull) {
       if (p.filePath && p.remoteContent !== null) {
         await mkdir2(dirname2(p.filePath), { recursive: true });
         await writeFile3(p.filePath, p.remoteContent, "utf-8");
@@ -1345,9 +1559,20 @@ async function runSync() {
         files: toUpsert
       });
     }
+    if (toDelete.length > 0) {
+      const deleteKeys = toDelete.map((p) => ({
+        type: p.type,
+        name: p.name,
+        category: p.category
+      }));
+      await apiPost("/sync/files", {
+        repo_id: repoId,
+        delete_keys: deleteKeys
+      });
+    }
     await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
     console.log(`
-  Applied: ${pulls.length} pulled, ${pushes.length} pushed`);
+  Applied: ${toPull.length} pulled, ${pushes.length} pushed, ${toDelete.length} deleted from DB`);
   } else if (dryRun) {
     console.log("\n  (dry-run \u2014 no changes)");
   }
@@ -1357,10 +1582,12 @@ async function runSync() {
   await syncConfig(repoId, projectPath, dryRun);
   console.log("  Tech stack...");
   await syncTechStack(repoId, projectPath, dryRun);
+  console.log("  Desktop server configs...");
+  await syncDesktopConfigs(repoId, projectPath, repoData, dryRun);
   console.log("\n  Sync complete.\n");
 }
 async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
-  const settingsPath = join7(claudeDir, "settings.json");
+  const settingsPath = join8(claudeDir, "settings.json");
   const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
@@ -1373,11 +1600,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     repoSettings = JSON.parse(substituteVariables(rf.content, repoData));
   }
   const combinedTemplate = mergeGlobalAndRepoSettings(globalSettings, repoSettings);
-  const hooksDir = join7(projectPath, ".claude", "hooks");
+  const hooksDir = join8(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile7(settingsPath, "utf-8");
+    const raw = await readFile8(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -1392,7 +1619,7 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   const mergedContent = JSON.stringify(merged, null, 2) + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile7(settingsPath, "utf-8");
+    currentContent = await readFile8(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -1408,10 +1635,10 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join7(projectPath, ".codebyplan.json");
+  const configPath = join8(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile7(configPath, "utf-8");
+    const raw = await readFile8(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
@@ -1478,15 +1705,15 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
     claude_md: { dir: "", ext: "" },
     settings: { dir: "", ext: "" }
   };
-  if (remote.type === "claude_md") return join7(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join7(claudeDir, "settings.json");
+  if (remote.type === "claude_md") return join8(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join8(claudeDir, "settings.json");
   const cfg = typeConfig2[remote.type];
-  if (!cfg) return join7(claudeDir, remote.name);
-  const typeDir = remote.type === "command" ? join7(claudeDir, cfg.dir, "cbp") : join7(claudeDir, cfg.dir);
-  if (cfg.subfolder) return join7(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
-  if (remote.type === "command" && remote.category) return join7(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  if (remote.type === "template") return join7(typeDir, remote.name);
-  return join7(typeDir, `${remote.name}${cfg.ext}`);
+  if (!cfg) return join8(claudeDir, remote.name);
+  const typeDir = remote.type === "command" ? join8(claudeDir, cfg.dir, "cbp") : join8(claudeDir, cfg.dir);
+  if (cfg.subfolder) return join8(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
+  if (remote.type === "command" && remote.category) return join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  if (remote.type === "template") return join8(typeDir, remote.name);
+  return join8(typeDir, `${remote.name}${cfg.ext}`);
 }
 function flattenSyncData(data) {
   const result = /* @__PURE__ */ new Map();
@@ -1514,6 +1741,99 @@ function flattenSyncData(data) {
   }
   return result;
 }
+async function syncDesktopConfigs(repoId, projectPath, repoData, dryRun) {
+  try {
+    const cbpDir = join8(homedir2(), ".codebyplan");
+    const configsPath = join8(cbpDir, "server-configs.json");
+    let configFile = { repos: [] };
+    try {
+      const raw = await readFile8(configsPath, "utf-8");
+      configFile = JSON.parse(raw);
+    } catch {
+    }
+    const detection = await detectServers(projectPath);
+    let portAllocations = [];
+    try {
+      const localConfigRaw = await readFile8(join8(projectPath, ".codebyplan.json"), "utf-8");
+      const localConfig = JSON.parse(localConfigRaw);
+      portAllocations = localConfig.port_allocations ?? [];
+    } catch {
+    }
+    const rootAllocations = portAllocations.filter((a) => !a.worktree_id);
+    const worktreeAllocations = portAllocations.filter((a) => a.worktree_id);
+    const matchDetected = (alloc) => {
+      let matched = detection.servers.find(
+        (s) => alloc.label.toLowerCase().includes(s.label.toLowerCase())
+      );
+      if (!matched) {
+        matched = detection.servers.find(
+          (s) => s.server_type === alloc.server_type
+        );
+      }
+      return {
+        label: alloc.label,
+        port: alloc.port,
+        command: matched?.command ?? "",
+        server_type: alloc.server_type,
+        auto_start: alloc.auto_start
+      };
+    };
+    let servers;
+    if (rootAllocations.length > 0) {
+      servers = rootAllocations.map(matchDetected);
+    } else {
+      servers = detection.servers.map((s) => ({
+        label: s.label,
+        port: s.port,
+        command: s.command,
+        server_type: s.server_type,
+        auto_start: "off"
+      }));
+    }
+    const worktreeGroups = /* @__PURE__ */ new Map();
+    for (const alloc of worktreeAllocations) {
+      const wId = alloc.worktree_id;
+      if (!worktreeGroups.has(wId)) worktreeGroups.set(wId, []);
+      worktreeGroups.get(wId).push(alloc);
+    }
+    const worktrees = Array.from(worktreeGroups.entries()).map(
+      ([worktreeId, allocs]) => {
+        const firstLabel = allocs[0]?.label ?? "";
+        const parenMatch = firstLabel.match(/\(([^)]+)\)/);
+        const worktreeName = parenMatch?.[1] ?? worktreeId;
+        return {
+          name: worktreeName,
+          path: "",
+          // Path is managed by the desktop app
+          cloud_id: worktreeId,
+          servers: allocs.map(matchDetected)
+        };
+      }
+    );
+    const repoEntry = {
+      name: repoData.name,
+      path: projectPath,
+      servers,
+      cloud_id: repoId,
+      ...worktrees.length > 0 ? { worktrees } : {}
+    };
+    const existingIndex = configFile.repos.findIndex((r) => r.cloud_id === repoId);
+    if (existingIndex >= 0) {
+      configFile.repos[existingIndex] = repoEntry;
+    } else {
+      configFile.repos.push(repoEntry);
+    }
+    if (dryRun) {
+      console.log("    Desktop server configs would be updated (dry-run).");
+      return;
+    }
+    await mkdir2(cbpDir, { recursive: true });
+    await writeFile3(configsPath, JSON.stringify(configFile, null, 2) + "\n", "utf-8");
+    console.log(`    Updated server-configs.json (${servers.length} server(s), ${worktrees.length} worktree(s))`);
+  } catch {
+    console.log("    Desktop server config sync skipped.");
+  }
+}
 var init_sync = __esm({
   "src/cli/sync.ts"() {
     "use strict";
@@ -1523,6 +1843,7 @@ var init_sync = __esm({
     init_api();
     init_variables();
     init_tech_detect();
+    init_server_detect();
     init_settings_merge();
     init_hook_registry();
   }
@@ -24031,17 +24352,52 @@ function registerWriteTools(server) {
   }, async ({ repo_id, project_path }) => {
     try {
       const syncResult = await executeSyncToLocal({ repoId: repo_id, projectPath: project_path });
-      const { byType, totals } = syncResult;
+      const { byType, totals, dbOnlyFiles } = syncResult;
       const summary = {
         ...byType,
         totals: { created: totals.created, updated: totals.updated, deleted: totals.deleted },
         message: totals.created + totals.updated + totals.deleted === 0 ? "All files up to date" : `Synced: ${totals.created} created, ${totals.updated} updated, ${totals.deleted} deleted`
       };
+      if (dbOnlyFiles.length > 0) {
+        summary.db_only_files = dbOnlyFiles;
+        summary.message += `
+
+${dbOnlyFiles.length} file(s) exist in DB but were missing locally (recreated). Use delete_claude_files to remove them from DB if they were intentionally deleted.`;
+      }
       return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
     }
   });
+  server.registerTool("delete_claude_files", {
+    description: "Soft-delete claude files from the CodeByPlan DB. Use after sync_claude_files reports db_only_files that should be removed. Each file is identified by type, name, and optional category.",
+    inputSchema: {
+      repo_id: external_exports.string().uuid().describe("Repository ID"),
+      files: external_exports.array(external_exports.object({
+        type: external_exports.string().describe("File type: command, agent, skill, rule, hook, template, docs_stack"),
+        name: external_exports.string().describe("File name"),
+        category: external_exports.string().nullable().optional().describe("Category (for commands: e.g. 'development/checkpoint')")
+      })).describe("Files to soft-delete from DB")
+    }
+  }, async ({ repo_id, files }) => {
+    try {
+      const res = await apiPost("/sync/files", {
+        repo_id,
+        delete_keys: files
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            deleted: res.data.deleted,
+            message: `Soft-deleted ${res.data.deleted} file(s) from DB. Run sync_claude_files to clean up local copies.`
+          }, null, 2)
+        }]
+      };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+  });
   server.registerTool("update_session_state", {
     description: "Update session state for a repo. Actions: activate (deactivates other repos), deactivate, pause, refresh, clear_refresh.",
     inputSchema: {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@codebyplan/cli",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "MCP server for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {
-    "@codebyplan/cli": "dist/index.js",
-    "codebyplan": "dist/index.js"
+    "@codebyplan/cli": "dist/cli.js",
+    "codebyplan": "dist/cli.js"
   },
   "files": [
     "dist/cli.js",