@codebyplan/cli 3.1.0 → 3.2.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.1.0";
+    VERSION = "3.2.0";
     PACKAGE_NAME = "@codebyplan/cli";
   }
 });
@@ -1063,35 +1063,89 @@ async function confirmProceed(message) {
     rl.close();
   }
 }
-async function promptChoice(message, options) {
+function parseReviewAction(input, fallback) {
+  const a = input.trim().toLowerCase();
+  switch (a) {
+    case "d":
+    case "delete":
+      return { action: "delete", all: false };
+    case "p":
+    case "pull":
+      return { action: "pull", all: false };
+    case "s":
+    case "push":
+      return { action: "push", all: false };
+    case "k":
+    case "skip":
+      return { action: "skip", all: false };
+    case "da":
+      return { action: "delete", all: true };
+    case "pa":
+      return { action: "pull", all: true };
+    case "sa":
+      return { action: "push", all: true };
+    case "ka":
+      return { action: "skip", all: true };
+    case "":
+      return { action: fallback, all: false };
+    default:
+      return { action: fallback, all: false };
+  }
+}
+async function promptReviewMode() {
   const rl = createInterface2({ input: stdin2, output: stdout2 });
   try {
-    const answer = await rl.question(message);
+    const answer = await rl.question("  Review [o]ne-by-one or [f]older-by-folder? ");
     const a = answer.trim().toLowerCase();
-    return options.includes(a) ? a : options[0];
+    return a === "f" || a === "folder" ? "folder" : "file";
   } finally {
     rl.close();
   }
 }
-async function confirmEach(items, label) {
+async function reviewFilesOneByOne(items, label, plannedAction) {
   const rl = createInterface2({ input: stdin2, output: stdout2 });
-  const accepted = [];
+  const results = [];
   try {
+    let applyAll = null;
     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);
+      if (applyAll) {
+        results.push(applyAll);
+        continue;
       }
+      const planned = plannedAction(item);
+      const answer = await rl.question(
+        `    ${label(item)} (${planned}) \u2014 [d]elete [p]ull pu[s]h s[k]ip: `
+      );
+      const { action, all } = parseReviewAction(answer, planned);
+      results.push(action);
+      if (all) applyAll = action;
     }
   } finally {
     rl.close();
   }
-  return accepted;
+  return results;
+}
+async function reviewFolder(folderName, items, label, plannedAction) {
+  console.log(`
+  ${folderName} (${items.length} files):`);
+  for (const item of items) {
+    console.log(`    ${label(item)} (${plannedAction(item)})`);
+  }
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  let answer;
+  try {
+    answer = await rl.question(
+      `  Action for all: [d]elete [p]ull pu[s]h s[k]ip [o]ne-by-one: `
+    );
+  } finally {
+    rl.close();
+  }
+  const a = answer.trim().toLowerCase();
+  if (a === "o" || a === "one-by-one") {
+    return reviewFilesOneByOne(items, label, plannedAction);
+  }
+  const { action } = parseReviewAction(a, "skip");
+  return items.map(() => action);
 }
 var init_confirm = __esm({
   "src/cli/confirm.ts"() {
@@ -1100,7 +1154,7 @@ var init_confirm = __esm({
 });
 
 // src/lib/tech-detect.ts
-import { readFile as readFile6, readdir as readdir4, access } from "node:fs/promises";
+import { readFile as readFile6, access, readdir as readdir4 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 async function fileExists(filePath) {
   try {
@@ -1110,14 +1164,56 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function scanPackageJson(pkgPath, seen) {
+async function discoverMonorepoApps(projectPath) {
+  const apps = [];
+  const patterns = [];
   try {
-    const raw = await readFile6(pkgPath, "utf-8");
+    const raw = await readFile6(join6(projectPath, "pnpm-workspace.yaml"), "utf-8");
+    const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
+    if (matches) {
+      for (const m of matches) {
+        const pattern = m.replace(/^\s*-\s*['"]?/, "").replace(/['"]?\s*$/, "").trim();
+        if (pattern) patterns.push(pattern);
+      }
+    }
+  } catch {
+  }
+  if (patterns.length === 0) {
+    try {
+      const raw = await readFile6(join6(projectPath, "package.json"), "utf-8");
+      const pkg = JSON.parse(raw);
+      const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
+      if (ws) patterns.push(...ws);
+    } catch {
+    }
+  }
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const dir = pattern.slice(0, -2);
+      const absDir = join6(projectPath, dir);
+      try {
+        const entries = await readdir4(absDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const relPath = join6(dir, entry.name);
+            const absPath = join6(absDir, entry.name);
+            if (await fileExists(join6(absPath, "package.json"))) {
+              apps.push({ name: entry.name, path: relPath, absPath });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return apps;
+}
+async function detectFromDirectory(dirPath) {
+  const seen = /* @__PURE__ */ new Map();
+  try {
+    const raw = await readFile6(join6(dirPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const depName of Object.keys(allDeps)) {
       const rule = PACKAGE_MAP[depName];
       if (rule) {
@@ -1125,79 +1221,121 @@ async function scanPackageJson(pkgPath, seen) {
         if (!seen.has(key)) {
           seen.set(key, { name: rule.name, category: rule.category });
         }
+        continue;
+      }
+      for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+        if (depName.startsWith(prefix)) {
+          const key = prefixRule.name.toLowerCase();
+          if (!seen.has(key)) {
+            seen.set(key, { name: prefixRule.name, category: prefixRule.category });
+          }
+          break;
+        }
       }
     }
   } 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(dir, file))) {
+    if (!seen.has(key) && await fileExists(join6(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
+  return Array.from(seen.values()).sort((a, b) => {
+    const catCmp = a.category.localeCompare(b.category);
+    if (catCmp !== 0) return catCmp;
+    return a.name.localeCompare(b.name);
+  });
 }
-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 {
+async function detectTechStack(projectPath) {
+  const repo = await detectFromDirectory(projectPath);
+  const discoveredApps = await discoverMonorepoApps(projectPath);
+  const apps = [];
+  for (const app of discoveredApps) {
+    const stack = await detectFromDirectory(app.absPath);
+    if (stack.length > 0) {
+      apps.push({ name: app.name, path: app.path, stack });
     }
   }
-  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);
+  const flatMap = /* @__PURE__ */ new Map();
+  for (const entry of repo) {
+    flatMap.set(entry.name.toLowerCase(), entry);
   }
-  return Array.from(seen.values()).sort((a, b) => {
+  for (const app of apps) {
+    for (const entry of app.stack) {
+      const key = entry.name.toLowerCase();
+      if (!flatMap.has(key)) {
+        flatMap.set(key, entry);
+      }
+    }
+  }
+  const flat = Array.from(flatMap.values()).sort((a, b) => {
     const catCmp = a.category.localeCompare(b.category);
     if (catCmp !== 0) return catCmp;
     return a.name.localeCompare(b.name);
   });
+  return { repo, apps, flat };
 }
 function mergeTechStack(remote, detected) {
+  const remoteResult = Array.isArray(remote) ? { repo: remote, apps: [], flat: remote } : remote;
   const seen = /* @__PURE__ */ new Map();
-  for (const entry of remote) {
+  for (const entry of remoteResult.flat) {
     seen.set(entry.name.toLowerCase(), entry);
   }
   const added = [];
-  for (const entry of detected) {
+  for (const entry of detected.flat) {
     const key = entry.name.toLowerCase();
     if (!seen.has(key)) {
       seen.set(key, entry);
       added.push(entry);
     }
   }
-  const merged = Array.from(seen.values()).sort((a, b) => {
+  const flat = Array.from(seen.values()).sort((a, b) => {
     const catCmp = a.category.localeCompare(b.category);
     if (catCmp !== 0) return catCmp;
     return a.name.localeCompare(b.name);
   });
+  const merged = {
+    repo: detected.repo,
+    apps: detected.apps,
+    flat
+  };
   return { merged, added };
 }
 function parseTechStack(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter(
+      (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
+    );
+  }
+  if (typeof raw === "object" && raw !== null && "flat" in raw) {
+    return parseTechStack(raw.flat);
+  }
+  return [];
+}
+function parseAppTechStacks(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.filter(
-    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
-  );
+    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.path === "string" && Array.isArray(item.stack)
+  ).map((item) => ({
+    name: item.name,
+    path: item.path,
+    stack: parseTechStack(item.stack)
+  }));
+}
+function parseTechStackResult(raw) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && "flat" in raw) {
+    const obj = raw;
+    return {
+      repo: parseTechStack(obj.repo),
+      apps: parseAppTechStacks(obj.apps),
+      flat: parseTechStack(obj.flat)
+    };
+  }
+  const flat = parseTechStack(raw);
+  return { repo: flat, apps: [], flat };
 }
-var PACKAGE_MAP, CONFIG_FILE_MAP;
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP;
 var init_tech_detect = __esm({
   "src/lib/tech-detect.ts"() {
     "use strict";
@@ -1240,17 +1378,50 @@ var init_tech_detect = __esm({
       playwright: { name: "Playwright", category: "testing" },
       "@playwright/test": { name: "Playwright", category: "testing" },
       cypress: { name: "Cypress", category: "testing" },
+      supertest: { name: "Supertest", category: "testing" },
       // Build tools
       turbo: { name: "Turborepo", category: "build" },
       vite: { name: "Vite", category: "build" },
       webpack: { name: "Webpack", category: "build" },
       esbuild: { name: "esbuild", category: "build" },
       rollup: { name: "Rollup", category: "build" },
+      nx: { name: "Nx", category: "build" },
+      lerna: { name: "Lerna", category: "build" },
+      tsup: { name: "tsup", category: "build" },
+      "@swc/core": { name: "SWC", category: "build" },
+      parcel: { name: "Parcel", category: "build" },
       // Tools
       eslint: { name: "ESLint", category: "tool" },
       prettier: { name: "Prettier", category: "tool" },
-      "@biomejs/biome": { name: "Biome", category: "tool" }
-    };
+      "@biomejs/biome": { name: "Biome", category: "tool" },
+      storybook: { name: "Storybook", category: "tool" },
+      // Component libs
+      "@mui/material": { name: "MUI", category: "component-lib" },
+      "@chakra-ui/react": { name: "Chakra UI", category: "component-lib" },
+      "@mantine/core": { name: "Mantine", category: "component-lib" },
+      // GraphQL
+      graphql: { name: "GraphQL", category: "graphql" },
+      "@apollo/client": { name: "Apollo Client", category: "graphql" },
+      urql: { name: "urql", category: "graphql" },
+      "graphql-request": { name: "graphql-request", category: "graphql" },
+      // Documentation
+      typedoc: { name: "TypeDoc", category: "documentation" },
+      "@docusaurus/core": { name: "Docusaurus", category: "documentation" },
+      vitepress: { name: "VitePress", category: "documentation" },
+      // Code quality
+      husky: { name: "Husky", category: "quality" },
+      "lint-staged": { name: "lint-staged", category: "quality" },
+      commitlint: { name: "commitlint", category: "quality" },
+      "@commitlint/cli": { name: "commitlint", category: "quality" },
+      // Mobile
+      "react-native": { name: "React Native", category: "mobile" },
+      expo: { name: "Expo", category: "mobile" }
+    };
+    PACKAGE_PREFIX_MAP = [
+      { prefix: "@radix-ui/", rule: { name: "Radix UI", category: "component-lib" } },
+      { prefix: "@storybook/", rule: { name: "Storybook", category: "tool" } },
+      { prefix: "@testing-library/", rule: { name: "Testing Library", category: "testing" } }
+    ];
     CONFIG_FILE_MAP = [
       { file: "tsconfig.json", rule: { name: "TypeScript", category: "language" } },
       { file: "next.config.js", rule: { name: "Next.js", category: "framework" } },
@@ -1262,131 +1433,24 @@ var init_tech_detect = __esm({
       { file: "docker-compose.yml", rule: { name: "Docker", category: "deployment" } },
       { file: "docker-compose.yaml", rule: { name: "Docker", category: "deployment" } },
       { file: "Dockerfile", rule: { name: "Docker", category: "deployment" } },
-      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } }
+      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } },
+      { file: ".storybook/main.js", rule: { name: "Storybook", category: "tool" } },
+      { file: ".storybook/main.ts", rule: { name: "Storybook", category: "tool" } },
+      { file: ".storybook/main.mjs", rule: { name: "Storybook", category: "tool" } },
+      { file: "components.json", rule: { name: "shadcn/ui", category: "component-lib" } },
+      { file: "nx.json", rule: { name: "Nx", category: "build" } },
+      { file: "lerna.json", rule: { name: "Lerna", category: "build" } }
     ];
   }
 });
 
-// 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 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";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
+import { join as join7, dirname as dirname2 } from "node:path";
 async function runSync() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -1402,7 +1466,7 @@ async function runSync() {
   if (force) console.log(`  Mode: force`);
   console.log();
   console.log("  Reading local and remote state...");
-  const claudeDir = join8(projectPath, ".claude");
+  const claudeDir = join7(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
@@ -1432,7 +1496,7 @@ async function runSync() {
         localContent: local.content,
         remoteContent: null,
         pushContent: reverseSubstituteVariables(local.content, repoData),
-        filePath: null,
+        filePath: getLocalFilePath(claudeDir, projectPath, { type: local.type, name: local.name, category: local.category }),
         type: local.type,
         name: local.name,
         category: local.category,
@@ -1475,7 +1539,7 @@ async function runSync() {
         action,
         localContent: local.content,
         remoteContent: resolvedRemote,
-        pushContent: action === "push" ? reverseSubstituteVariables(local.content, repoData) : null,
+        pushContent: reverseSubstituteVariables(local.content, repoData),
         filePath: getLocalFilePath(claudeDir, projectPath, remote),
         type: local.type,
         name: local.name,
@@ -1505,74 +1569,87 @@ async function runSync() {
     console.log("  All .claude/ files in sync.");
   }
   if (plan.length > 0 && !dryRun) {
-    let toDelete = [];
-    let toPull = contentPulls;
-    if (remoteOnly.length > 0) {
-      console.log();
-      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];
-      }
-    }
-    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;
+    if (!force) {
+      const agreed = await confirmProceed(`
+  Agree with sync? [Y/n] `);
+      if (!agreed) {
+        const mode = await promptReviewMode();
+        if (mode === "file") {
+          const actions = await reviewFilesOneByOne(
+            plan,
+            (p) => p.displayPath,
+            (p) => p.action
+          );
+          for (let i = 0; i < plan.length; i++) {
+            plan[i].action = actions[i];
+          }
+        } else {
+          const groups = groupByType(plan);
+          for (const [typeName, items] of groups) {
+            const actions = await reviewFolder(
+              typeName,
+              items,
+              (p) => p.displayPath,
+              (p) => p.action
+            );
+            for (let i = 0; i < items.length; i++) {
+              items[i].action = actions[i];
+            }
+          }
         }
       }
     }
-    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");
-        if (p.isHook) await chmod2(p.filePath, 493);
+    const toPull = plan.filter((p) => p.action === "pull");
+    const toPush = plan.filter((p) => p.action === "push");
+    const toDelete = plan.filter((p) => p.action === "delete");
+    const skipped = plan.filter((p) => p.action === "skip");
+    if (toPull.length + toPush.length + toDelete.length === 0) {
+      console.log("\n  All items skipped \u2014 no changes applied.");
+    } else {
+      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");
+          if (p.isHook) await chmod2(p.filePath, 493);
+        }
       }
-    }
-    const toUpsert = pushes.filter((p) => p.pushContent !== null).map((p) => ({
-      type: p.type,
-      name: p.name,
-      category: p.category,
-      content: p.pushContent
-    }));
-    if (toUpsert.length > 0) {
-      await apiPost("/sync/files", {
-        repo_id: repoId,
-        files: toUpsert
-      });
-    }
-    if (toDelete.length > 0) {
-      const deleteKeys = toDelete.map((p) => ({
+      const toUpsert = toPush.filter((p) => p.pushContent !== null).map((p) => ({
         type: p.type,
         name: p.name,
-        category: p.category
+        category: p.category,
+        content: p.pushContent
       }));
-      await apiPost("/sync/files", {
-        repo_id: repoId,
-        delete_keys: deleteKeys
-      });
+      if (toUpsert.length > 0) {
+        await apiPost("/sync/files", {
+          repo_id: repoId,
+          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
+        });
+        for (const p of toDelete) {
+          if (p.filePath) {
+            try {
+              await unlink2(p.filePath);
+            } catch {
+            }
+          }
+        }
+      }
+      await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
+      console.log(
+        `
+  Applied: ${toPull.length} pulled, ${toPush.length} pushed, ${toDelete.length} deleted` + (skipped.length > 0 ? `, ${skipped.length} skipped` : "")
+      );
     }
-    await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(`
-  Applied: ${toPull.length} pulled, ${pushes.length} pushed, ${toDelete.length} deleted from DB`);
   } else if (dryRun) {
     console.log("\n  (dry-run \u2014 no changes)");
   }
@@ -1582,12 +1659,10 @@ 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 = join8(claudeDir, "settings.json");
+  const settingsPath = join7(claudeDir, "settings.json");
   const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
@@ -1600,11 +1675,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     repoSettings = JSON.parse(substituteVariables(rf.content, repoData));
   }
   const combinedTemplate = mergeGlobalAndRepoSettings(globalSettings, repoSettings);
-  const hooksDir = join8(projectPath, ".claude", "hooks");
+  const hooksDir = join7(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile8(settingsPath, "utf-8");
+    const raw = await readFile7(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -1619,7 +1694,7 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   const mergedContent = JSON.stringify(merged, null, 2) + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile8(settingsPath, "utf-8");
+    currentContent = await readFile7(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -1635,10 +1710,10 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join8(projectPath, ".codebyplan.json");
+  const configPath = join7(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile8(configPath, "utf-8");
+    const raw = await readFile7(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
@@ -1676,14 +1751,17 @@ async function syncConfig(repoId, projectPath, dryRun) {
 async function syncTechStack(repoId, projectPath, dryRun) {
   try {
     const detected = await detectTechStack(projectPath);
-    if (detected.length === 0) {
+    if (detected.flat.length === 0) {
       console.log("    No tech stack detected.");
       return;
     }
     const repoRes = await apiGet(`/repos/${repoId}`);
-    const remote = parseTechStack(repoRes.data.tech_stack);
+    const remote = parseTechStackResult(repoRes.data.tech_stack);
     const { merged, added } = mergeTechStack(remote, detected);
-    console.log(`    ${detected.length} detected${added.length > 0 ? ` (${added.length} new)` : ""}`);
+    console.log(`    ${detected.flat.length} detected${added.length > 0 ? ` (${added.length} new)` : ""}`);
+    if (detected.apps.length > 0) {
+      console.log(`    Apps: ${detected.apps.map((a) => a.name).join(", ")}`);
+    }
     for (const entry of added) {
       console.log(`      + ${entry.name} (${entry.category})`);
     }
@@ -1694,6 +1772,25 @@ async function syncTechStack(repoId, projectPath, dryRun) {
     console.log("    Tech stack detection skipped.");
   }
 }
+function groupByType(items) {
+  const groups = /* @__PURE__ */ new Map();
+  const typeLabels = {
+    command: "Commands",
+    agent: "Agents",
+    skill: "Skills",
+    rule: "Rules",
+    hook: "Hooks",
+    template: "Templates",
+    settings: "Settings"
+  };
+  for (const item of items) {
+    const label = typeLabels[item.type] ?? item.type;
+    const group = groups.get(label) ?? [];
+    group.push(item);
+    groups.set(label, group);
+  }
+  return groups;
+}
 function getLocalFilePath(claudeDir, projectPath, remote) {
   const typeConfig2 = {
     command: { dir: "commands", ext: ".md" },
@@ -1705,15 +1802,15 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
     claude_md: { dir: "", ext: "" },
     settings: { dir: "", ext: "" }
   };
-  if (remote.type === "claude_md") return join8(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join8(claudeDir, "settings.json");
+  if (remote.type === "claude_md") return join7(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join7(claudeDir, "settings.json");
   const cfg = typeConfig2[remote.type];
-  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}`);
+  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}`);
 }
 function flattenSyncData(data) {
   const result = /* @__PURE__ */ new Map();
@@ -1741,99 +1838,6 @@ 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";
@@ -1843,7 +1847,6 @@ var init_sync = __esm({
     init_api();
     init_variables();
     init_tech_detect();
-    init_server_detect();
     init_settings_merge();
     init_hook_registry();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebyplan/cli",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "MCP server for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {