codebyplan 0.0.1 → 1.1.0

package/dist/cli.js

@@ -0,0 +1,2830 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/version.ts
+var VERSION, PACKAGE_NAME;
+var init_version = __esm({
+  "src/lib/version.ts"() {
+    "use strict";
+    VERSION = "1.1.0";
+    PACKAGE_NAME = "codebyplan";
+  }
+});
+
+// src/lib/api.ts
+function validateApiKey() {
+  if (!API_KEY) {
+    throw new Error(
+      `Missing CODEBYPLAN_API_KEY environment variable.
+
+Quick setup:
+  npx ${PACKAGE_NAME} setup
+
+Or manually:
+  1. Get your API key at https://codebyplan.com/settings/api-keys/
+  2. claude mcp add codebyplan -e CODEBYPLAN_API_KEY=<key> -- npx -y ${PACKAGE_NAME}`
+    );
+  }
+}
+function buildUrl(path, params) {
+  const url = new URL(`${BASE_URL}/api${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, value);
+      }
+    }
+  }
+  return url.toString();
+}
+function isRetryable(err) {
+  if (err instanceof TypeError) return true;
+  if (err instanceof Error && err.name === "AbortError") return false;
+  if (err instanceof ApiError) return err.status >= 500;
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function request(method, path, options) {
+  const url = buildUrl(path, options?.params);
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      const jitter = Math.random() * 0.5 + 0.75;
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt - 1) * jitter;
+      await delay(backoff);
+    }
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: {
+          "x-api-key": API_KEY,
+          ...options?.body !== void 0 ? { "Content-Type": "application/json" } : {}
+        },
+        body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) {
+        let message = `API ${method} ${path} failed with status ${res.status}`;
+        let code;
+        try {
+          const body = await res.json();
+          if (body.error && typeof body.error === "object") {
+            const err = body.error;
+            if (err.message) message = err.message;
+            if (err.code) code = err.code;
+          } else if (typeof body.error === "string") {
+            message = body.error;
+          }
+          if (body.code && typeof body.code === "string") code = body.code;
+        } catch {
+        }
+        const apiError = new ApiError(message, res.status, code);
+        if (isRetryable(apiError) && attempt < MAX_RETRIES) {
+          lastError = apiError;
+          continue;
+        }
+        throw apiError;
+      }
+      if (res.status === 204) {
+        return void 0;
+      }
+      return res.json();
+    } catch (err) {
+      lastError = err;
+      if (!isRetryable(err) || attempt >= MAX_RETRIES) {
+        throw err;
+      }
+    }
+  }
+  throw lastError;
+}
+async function apiGet(path, params) {
+  return request("GET", path, { params });
+}
+async function apiPost(path, body) {
+  return request("POST", path, { body });
+}
+async function apiPut(path, body) {
+  return request("PUT", path, { body });
+}
+async function apiDelete(path, params) {
+  await request("DELETE", path, { params });
+}
+var API_KEY, BASE_URL, REQUEST_TIMEOUT_MS, MAX_RETRIES, BASE_DELAY_MS, ApiError;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_version();
+    API_KEY = process.env.CODEBYPLAN_API_KEY ?? "";
+    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com").replace(/\/$/, "");
+    REQUEST_TIMEOUT_MS = 12e4;
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 1e3;
+    ApiError = class extends Error {
+      status;
+      code;
+      constructor(message, status, code) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/lib/settings-merge.ts
+function mergeSettings(template, local) {
+  const merged = { ...local };
+  for (const key of TEMPLATE_MANAGED_KEYS) {
+    if (key in template) {
+      merged[key] = template[key];
+    }
+  }
+  if (template.permissions && typeof template.permissions === "object") {
+    const templatePerms = template.permissions;
+    const localPerms = local.permissions && typeof local.permissions === "object" ? local.permissions : {};
+    const mergedPerms = { ...localPerms };
+    for (const key of TEMPLATE_MANAGED_PERMISSION_KEYS) {
+      if (key in templatePerms) {
+        mergedPerms[key] = templatePerms[key];
+      }
+    }
+    merged.permissions = mergedPerms;
+  }
+  return merged;
+}
+function mergeGlobalAndRepoSettings(global, repo) {
+  const merged = { ...global, ...repo };
+  const globalPerms = global.permissions && typeof global.permissions === "object" ? global.permissions : {};
+  const repoPerms = repo.permissions && typeof repo.permissions === "object" ? repo.permissions : {};
+  if (Object.keys(globalPerms).length > 0 || Object.keys(repoPerms).length > 0) {
+    const mergedPerms = { ...globalPerms, ...repoPerms };
+    for (const key of ARRAY_PERMISSION_KEYS) {
+      const globalArr = Array.isArray(globalPerms[key]) ? globalPerms[key] : [];
+      const repoArr = Array.isArray(repoPerms[key]) ? repoPerms[key] : [];
+      if (globalArr.length > 0 || repoArr.length > 0) {
+        mergedPerms[key] = [.../* @__PURE__ */ new Set([...globalArr, ...repoArr])];
+      }
+    }
+    merged.permissions = mergedPerms;
+  }
+  return merged;
+}
+function stripPermissionsAllow(settings) {
+  if (!settings.permissions || typeof settings.permissions !== "object") {
+    return settings;
+  }
+  const perms = { ...settings.permissions };
+  delete perms.allow;
+  if (Object.keys(perms).length === 0) {
+    const { permissions: _, ...rest } = settings;
+    return rest;
+  }
+  return { ...settings, permissions: perms };
+}
+var TEMPLATE_MANAGED_KEYS, TEMPLATE_MANAGED_PERMISSION_KEYS, ARRAY_PERMISSION_KEYS;
+var init_settings_merge = __esm({
+  "src/lib/settings-merge.ts"() {
+    "use strict";
+    TEMPLATE_MANAGED_KEYS = ["attribution", "hooks", "statusLine"];
+    TEMPLATE_MANAGED_PERMISSION_KEYS = [
+      "deny",
+      "ask",
+      "additionalDirectories"
+    ];
+    ARRAY_PERMISSION_KEYS = ["deny", "ask"];
+  }
+});
+
+// src/lib/hook-registry.ts
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+function parseHookMeta(content) {
+  const match = content.match(/^#\s*@hook:\s*(\S+)(?:\s+(.+))?$/m);
+  if (!match) return null;
+  return {
+    event: match[1],
+    matcher: match[2]?.trim() ?? ""
+  };
+}
+async function discoverHooks(hooksDir) {
+  const discovered = /* @__PURE__ */ new Map();
+  let filenames;
+  try {
+    const entries = await readdir(hooksDir);
+    filenames = entries.filter((e) => e.endsWith(".sh"));
+  } catch {
+    return discovered;
+  }
+  for (const filename of filenames) {
+    const content = await readFile(join(hooksDir, filename), "utf-8");
+    const meta = parseHookMeta(content);
+    if (meta) {
+      discovered.set(filename.replace(/\.sh$/, ""), meta);
+    }
+  }
+  return discovered;
+}
+function mergeDiscoveredHooks(existing, discovered, hooksRelPath = ".claude/hooks") {
+  if (discovered.size === 0) return existing;
+  const merged = {};
+  for (const [event, matchers] of Object.entries(existing)) {
+    merged[event] = matchers.map((m) => ({
+      matcher: m.matcher,
+      hooks: [...m.hooks]
+    }));
+  }
+  for (const [filename, meta] of discovered) {
+    const command = `bash ${hooksRelPath}/${filename}.sh`;
+    if (!merged[meta.event]) {
+      merged[meta.event] = [];
+    }
+    const eventEntries = merged[meta.event];
+    const alreadyRegistered = eventEntries.some(
+      (m) => m.hooks.some((h) => h.command === command)
+    );
+    if (alreadyRegistered) continue;
+    const matcherEntry = eventEntries.find((m) => m.matcher === meta.matcher);
+    if (matcherEntry) {
+      matcherEntry.hooks.push({ type: "command", command });
+    } else {
+      eventEntries.push({
+        matcher: meta.matcher,
+        hooks: [{ type: "command", command }]
+      });
+    }
+  }
+  return merged;
+}
+function stripDiscoveredHooks(config, hooksRelPath = ".claude/hooks") {
+  const prefix = `bash ${hooksRelPath}/`;
+  const stripped = {};
+  for (const [event, matchers] of Object.entries(config)) {
+    const filteredMatchers = [];
+    for (const matcher of matchers) {
+      const filteredHooks = matcher.hooks.filter(
+        (h) => !(h.command && h.command.startsWith(prefix) && h.command.endsWith(".sh"))
+      );
+      if (filteredHooks.length > 0) {
+        filteredMatchers.push({
+          matcher: matcher.matcher,
+          hooks: filteredHooks
+        });
+      }
+    }
+    if (filteredMatchers.length > 0) {
+      stripped[event] = filteredMatchers;
+    }
+  }
+  return stripped;
+}
+var init_hook_registry = __esm({
+  "src/lib/hook-registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/variables.ts
+function substituteVariables(content, repoData) {
+  if (!content.includes("{{")) return content;
+  let result = content;
+  for (const [name, resolver] of Object.entries(TEMPLATE_VARIABLES)) {
+    const placeholder = `{{${name}}}`;
+    if (result.includes(placeholder)) {
+      result = result.replaceAll(placeholder, resolver(repoData));
+    }
+  }
+  return result;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function reverseSubstituteVariables(content, repoData) {
+  const entries = [];
+  for (const [name, resolver] of Object.entries(TEMPLATE_VARIABLES)) {
+    const value = resolver(repoData);
+    if (value.length === 0) continue;
+    entries.push([value, `{{${name}}}`]);
+  }
+  entries.sort((a, b) => b[0].length - a[0].length);
+  let result = content;
+  for (const [value, placeholder] of entries) {
+    if (value.length < 8) {
+      const pattern = new RegExp(`\\b${escapeRegex(value)}\\b`, "g");
+      result = result.replace(pattern, placeholder);
+    } else {
+      result = result.replaceAll(value, placeholder);
+    }
+  }
+  return result;
+}
+var TEMPLATE_VARIABLES;
+var init_variables = __esm({
+  "src/lib/variables.ts"() {
+    "use strict";
+    TEMPLATE_VARIABLES = {
+      REPO_ID: (repo) => repo.id,
+      REPO_NAME: (repo) => repo.name,
+      REPO_PATH: (repo) => repo.path ?? "",
+      GIT_BRANCH: (repo) => repo.git_branch ?? "development",
+      SERVER_PORT: (repo) => repo.server_port != null ? String(repo.server_port) : "",
+      SERVER_TYPE: (repo) => repo.server_type ?? "none"
+    };
+  }
+});
+
+// src/lib/sync-engine.ts
+var sync_engine_exports = {};
+__export(sync_engine_exports, {
+  executeSyncToLocal: () => executeSyncToLocal
+});
+import {
+  readdir as readdir2,
+  readFile as readFile2,
+  writeFile,
+  unlink,
+  mkdir,
+  rmdir,
+  chmod,
+  stat
+} from "node:fs/promises";
+import { join as join2, dirname } from "node:path";
+function getTypeDir(claudeDir, dir) {
+  if (dir === "commands") return join2(claudeDir, dir, "cbp");
+  return join2(claudeDir, dir);
+}
+function getFilePath(claudeDir, typeName, file) {
+  const cfg = typeConfig[typeName];
+  const typeDir = getTypeDir(claudeDir, cfg.dir);
+  if (cfg.subfolder) {
+    return join2(typeDir, file.name, `${cfg.subfolder}${cfg.ext}`);
+  }
+  if (typeName === "command" && file.category) {
+    return join2(typeDir, file.category, `${file.name}${cfg.ext}`);
+  }
+  if (typeName === "template") {
+    return join2(typeDir, file.name);
+  }
+  return join2(typeDir, `${file.name}${cfg.ext}`);
+}
+async function readDirRecursive(dir, base = dir) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        const sub = await readDirRecursive(fullPath, base);
+        for (const [k, v] of sub) result.set(k, v);
+      } else {
+        const relPath = fullPath.slice(base.length + 1);
+        const fileContent = await readFile2(fullPath, "utf-8");
+        result.set(relPath, fileContent);
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+async function isGitWorktree(projectPath) {
+  try {
+    const gitPath = join2(projectPath, ".git");
+    const info = await stat(gitPath);
+    return info.isFile();
+  } catch {
+    return false;
+  }
+}
+async function removeEmptyParents(filePath, stopAt) {
+  let dir = dirname(filePath);
+  while (dir.length > stopAt.length && dir.startsWith(stopAt)) {
+    try {
+      await rmdir(dir);
+      dir = dirname(dir);
+    } catch {
+      break;
+    }
+  }
+}
+async function executeSyncToLocal(options) {
+  const { repoId, projectPath, dryRun = false } = options;
+  const [syncRes, repoRes] = await Promise.all([
+    apiGet("/sync/defaults"),
+    apiGet(`/repos/${repoId}`)
+  ]);
+  const syncData = syncRes.data;
+  const repoData = repoRes.data;
+  syncData.claude_md = [];
+  const claudeDir = join2(projectPath, ".claude");
+  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: []
+      };
+      continue;
+    }
+    const cfg = typeConfig[typeName];
+    const targetDir = getTypeDir(claudeDir, cfg.dir);
+    const remoteFiles = syncData[syncKey] ?? [];
+    const result = {
+      created: [],
+      updated: [],
+      deleted: [],
+      unchanged: []
+    };
+    if (!dryRun) {
+      await mkdir(targetDir, { recursive: true });
+    }
+    const localFiles = await readDirRecursive(targetDir);
+    const remotePathMap = /* @__PURE__ */ new Map();
+    for (const remote of remoteFiles) {
+      const fullPath = getFilePath(claudeDir, typeName, remote);
+      const relPath = fullPath.slice(targetDir.length + 1);
+      const substituted = substituteVariables(remote.content, repoData);
+      remotePathMap.set(relPath, { content: substituted, name: remote.name });
+    }
+    for (const [relPath, { content, name }] of remotePathMap) {
+      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");
+          if (typeName === "hook") await chmod(fullPath, 493);
+        }
+        result.created.push(name);
+        totals.created++;
+      } else if (localContent !== content) {
+        if (!dryRun) {
+          await writeFile(fullPath, content, "utf-8");
+          if (typeName === "hook") await chmod(fullPath, 493);
+        }
+        result.updated.push(name);
+        totals.updated++;
+      } else {
+        result.unchanged.push(name);
+        totals.unchanged++;
+      }
+    }
+    for (const [relPath] of localFiles) {
+      if (!remotePathMap.has(relPath)) {
+        const fullPath = join2(targetDir, relPath);
+        if (!dryRun) {
+          await unlink(fullPath);
+          await removeEmptyParents(fullPath, targetDir);
+        }
+        const pathName = relPath.replace(/\.(md|sh)$/, "").replace(/\/(AGENT|SKILL)$/, "");
+        result.deleted.push(pathName);
+        totals.deleted++;
+      }
+    }
+    byType[`${typeName}s`] = result;
+  }
+  {
+    const typeName = "docs_stack";
+    const syncKey = "docs_stack";
+    const targetDir = join2(projectPath, "docs", "stack");
+    const remoteFiles = syncData[syncKey] ?? [];
+    const result = {
+      created: [],
+      updated: [],
+      deleted: [],
+      unchanged: []
+    };
+    if (remoteFiles.length > 0 && !dryRun) {
+      await mkdir(targetDir, { recursive: true });
+    }
+    const localFiles = await readDirRecursive(targetDir);
+    const remotePathMap = /* @__PURE__ */ new Map();
+    for (const remote of remoteFiles) {
+      const relPath = remote.category ? join2(remote.category, remote.name) : remote.name;
+      const substituted = substituteVariables(remote.content, repoData);
+      remotePathMap.set(relPath, {
+        content: substituted,
+        name: `${remote.category ?? ""}/${remote.name}`
+      });
+    }
+    for (const [relPath, { content, name }] of remotePathMap) {
+      const fullPath = join2(targetDir, relPath);
+      const localContent = localFiles.get(relPath);
+      if (localContent === void 0) {
+        if (!dryRun) {
+          await mkdir(dirname(fullPath), { recursive: true });
+          await writeFile(fullPath, content, "utf-8");
+        }
+        result.created.push(name);
+        totals.created++;
+      } else if (localContent !== content) {
+        if (!dryRun) {
+          await writeFile(fullPath, content, "utf-8");
+        }
+        result.updated.push(name);
+        totals.updated++;
+      } else {
+        result.unchanged.push(name);
+        totals.unchanged++;
+      }
+    }
+    for (const [relPath] of localFiles) {
+      if (!remotePathMap.has(relPath)) {
+        const fullPath = join2(targetDir, relPath);
+        if (!dryRun) {
+          await unlink(fullPath);
+          await removeEmptyParents(fullPath, targetDir);
+        }
+        result.deleted.push(relPath);
+        totals.deleted++;
+      }
+    }
+    byType[typeName] = result;
+  }
+  const globalSettingsFiles = syncData.global_settings ?? [];
+  let globalSettings = {};
+  for (const gf of globalSettingsFiles) {
+    const parsed = JSON.parse(
+      substituteVariables(gf.content, repoData)
+    );
+    globalSettings = { ...globalSettings, ...parsed };
+  }
+  const specialTypes = {
+    claude_md: () => join2(projectPath, "CLAUDE.md"),
+    settings: () => join2(projectPath, ".claude", "settings.json")
+  };
+  for (const [typeName, getPath] of Object.entries(specialTypes)) {
+    const remoteFiles = syncData[typeName] ?? [];
+    const result = {
+      created: [],
+      updated: [],
+      deleted: [],
+      unchanged: []
+    };
+    for (const remote of remoteFiles) {
+      const targetPath = getPath(remote.name);
+      const remoteContent = substituteVariables(remote.content, repoData);
+      let localContent;
+      try {
+        localContent = await readFile2(targetPath, "utf-8");
+      } catch {
+      }
+      if (typeName === "settings") {
+        const repoSettings = JSON.parse(remoteContent);
+        const combinedTemplate = mergeGlobalAndRepoSettings(
+          globalSettings,
+          repoSettings
+        );
+        const hooksDir = join2(projectPath, ".claude", "hooks");
+        const discovered = await discoverHooks(hooksDir);
+        if (localContent === void 0) {
+          const finalSettings = stripPermissionsAllow(combinedTemplate);
+          if (discovered.size > 0) {
+            finalSettings.hooks = mergeDiscoveredHooks(
+              finalSettings.hooks ?? {},
+              discovered
+            );
+          }
+          if (!dryRun) {
+            await mkdir(dirname(targetPath), { recursive: true });
+            await writeFile(
+              targetPath,
+              JSON.stringify(finalSettings, null, 2) + "\n",
+              "utf-8"
+            );
+          }
+          result.created.push(remote.name);
+          totals.created++;
+        } else {
+          const localSettings = JSON.parse(localContent);
+          let merged = mergeSettings(combinedTemplate, localSettings);
+          merged = stripPermissionsAllow(merged);
+          if (discovered.size > 0) {
+            merged.hooks = mergeDiscoveredHooks(
+              merged.hooks ?? {},
+              discovered
+            );
+          }
+          const mergedContent = JSON.stringify(merged, null, 2) + "\n";
+          if (localContent !== mergedContent) {
+            if (!dryRun) {
+              await writeFile(targetPath, mergedContent, "utf-8");
+            }
+            result.updated.push(remote.name);
+            totals.updated++;
+          } else {
+            result.unchanged.push(remote.name);
+            totals.unchanged++;
+          }
+        }
+      } else {
+        if (localContent === void 0) {
+          if (!dryRun) {
+            await mkdir(dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, remoteContent, "utf-8");
+          }
+          result.created.push(remote.name);
+          totals.created++;
+        } else if (localContent !== remoteContent) {
+          if (!dryRun) {
+            await writeFile(targetPath, remoteContent, "utf-8");
+          }
+          result.updated.push(remote.name);
+          totals.updated++;
+        } else {
+          result.unchanged.push(remote.name);
+          totals.unchanged++;
+        }
+      }
+    }
+    byType[typeName] = result;
+  }
+  if (!dryRun) {
+    await apiPost("/sync/state", {
+      repo_id: repoId,
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      was_skipped: false,
+      files_synced_count: totals.created + totals.updated + totals.deleted + totals.unchanged,
+      files_pushed: 0,
+      files_pulled: totals.created + totals.updated,
+      files_deleted: totals.deleted,
+      files_skipped: 0
+    });
+    const fileRepoUpdates = [];
+    const syncTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    for (const [syncKey, typeName] of Object.entries(syncKeyToType)) {
+      const remoteFiles = syncData[syncKey] ?? [];
+      for (const file of remoteFiles) {
+        fileRepoUpdates.push({
+          claude_file_id: file.id ?? void 0,
+          file_type: typeName,
+          file_name: file.name,
+          file_category: file.category ?? null,
+          file_scope: file.scope ?? "shared",
+          last_synced_at: syncTimestamp,
+          sync_status: "synced"
+        });
+      }
+    }
+    for (const typeName of ["claude_md", "settings"]) {
+      const remoteFiles = syncData[typeName] ?? [];
+      for (const file of remoteFiles) {
+        fileRepoUpdates.push({
+          claude_file_id: file.id ?? void 0,
+          file_type: typeName,
+          file_name: file.name,
+          file_category: file.category ?? null,
+          file_scope: file.scope ?? `local:${repoId}`,
+          last_synced_at: syncTimestamp,
+          sync_status: "synced"
+        });
+      }
+    }
+    if (fileRepoUpdates.length > 0) {
+      try {
+        await apiPost("/sync/file-repos", {
+          repo_id: repoId,
+          file_repos: fileRepoUpdates
+        });
+      } catch {
+      }
+    }
+  }
+  return { byType, totals, dbOnlyFiles };
+}
+var typeConfig, syncKeyToType;
+var init_sync_engine = __esm({
+  "src/lib/sync-engine.ts"() {
+    "use strict";
+    init_api();
+    init_settings_merge();
+    init_hook_registry();
+    init_variables();
+    typeConfig = {
+      command: { dir: "commands", ext: ".md" },
+      agent: { dir: "agents", ext: ".md", subfolder: "AGENT" },
+      skill: { dir: "skills", ext: ".md", subfolder: "SKILL" },
+      rule: { dir: "rules", ext: ".md" },
+      hook: { dir: "hooks", ext: ".sh" },
+      template: { dir: "templates", ext: "" },
+      context: { dir: "context", ext: ".md" }
+    };
+    syncKeyToType = {
+      commands: "command",
+      agents: "agent",
+      skills: "skill",
+      rules: "rule",
+      hooks: "hook",
+      templates: "template",
+      contexts: "context"
+    };
+  }
+});
+
+// src/cli/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  runSetup: () => runSetup
+});
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+function getConfigPath(scope) {
+  return scope === "user" ? join3(homedir(), ".claude.json") : join3(process.cwd(), ".mcp.json");
+}
+async function readConfig(path) {
+  try {
+    const raw = await readFile3(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function buildMcpEntry(apiKey) {
+  const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+  return {
+    url: `${baseUrl}/mcp`,
+    headers: { "x-api-key": apiKey }
+  };
+}
+async function writeMcpConfig(scope, apiKey) {
+  const configPath = getConfigPath(scope);
+  const config = await readConfig(configPath);
+  if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  config.mcpServers.codebyplan = buildMcpEntry(apiKey);
+  await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+async function verifyMcpConfig(scope, apiKey) {
+  try {
+    const config = await readConfig(getConfigPath(scope));
+    const servers = config.mcpServers;
+    if (!servers) return false;
+    const entry = servers.codebyplan;
+    return entry?.url !== void 0 && entry?.headers?.["x-api-key"] === apiKey;
+  } catch {
+    return false;
+  }
+}
+async function runSetup() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  console.log("\n  CodeByPlan Setup\n");
+  console.log("  This will configure Claude Code to use CodeByPlan.\n");
+  console.log("  1. Sign up at https://codebyplan.com");
+  console.log(
+    "  2. Create an API key at https://codebyplan.com/settings/api-keys/\n"
+  );
+  try {
+    const apiKey = (await rl.question("  Enter your API key: ")).trim();
+    if (!apiKey) {
+      console.log("\n  No API key provided. Aborting setup.\n");
+      return;
+    }
+    console.log("\n  Validating API key...");
+    const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+    const res = await fetch(`${baseUrl}/api/repos`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.status === 401) {
+      console.log("  Invalid API key. Please check and try again.\n");
+      return;
+    }
+    let repos = [];
+    if (res.ok) {
+      try {
+        const body = await res.json();
+        repos = body.data ?? [];
+        if (repos.length === 0) {
+          console.log("  API key is valid but no repositories found.");
+          console.log("  Create one at https://codebyplan.com after setup.\n");
+        } else {
+          console.log("  API key is valid!\n");
+        }
+      } catch {
+        console.log("  API key is valid!\n");
+      }
+    } else {
+      console.log(
+        `  Warning: API returned status ${res.status}, but continuing.
+`
+      );
+    }
+    console.log("  Where should the MCP server be configured?\n");
+    console.log("    1. Global \u2014 available in all projects (~/.claude.json)");
+    console.log("    2. Project \u2014 only this project (.mcp.json)\n");
+    const scopeInput = (await rl.question("  Select (1/2, default: 1): ")).trim();
+    const scope = scopeInput === "2" ? "project" : "user";
+    console.log("\n  Configuring MCP server...");
+    const configPath = await writeMcpConfig(scope, apiKey);
+    const verified = await verifyMcpConfig(scope, apiKey);
+    if (verified) {
+      console.log(`  Done! Config written to ${configPath}
+`);
+      if (scope === "project") {
+        console.log(
+          "  Note: .mcp.json contains your API key \u2014 add it to .gitignore.\n"
+        );
+      }
+    } else {
+      console.log("  Warning: Could not verify the saved configuration.\n");
+      console.log(
+        `  Manually add to ~/.claude.json under mcpServers.codebyplan:
+`
+      );
+      console.log(
+        `    { "url": "https://codebyplan.com/mcp", "headers": { "x-api-key": "${apiKey}" } }
+`
+      );
+    }
+    if (repos.length > 0) {
+      console.log("  Initialize this project?\n");
+      const initAnswer = (await rl.question("  Link to a repository? (Y/n): ")).trim().toLowerCase();
+      if (initAnswer === "" || initAnswer === "y" || initAnswer === "yes") {
+        process.env.CODEBYPLAN_API_KEY = apiKey;
+        console.log("\n  Your repositories:\n");
+        for (let i = 0; i < repos.length; i++) {
+          console.log(`    ${i + 1}. ${repos[i].name}`);
+        }
+        console.log();
+        const choice = (await rl.question("  Select a repository (number): ")).trim();
+        const index = parseInt(choice, 10) - 1;
+        if (isNaN(index) || index < 0 || index >= repos.length) {
+          console.log("  Invalid selection. Skipping project init.\n");
+        } else {
+          const selectedRepo = repos[index];
+          console.log(`
+  Selected: ${selectedRepo.name}
+`);
+          let worktreeId;
+          const projectPath = process.cwd();
+          try {
+            const worktreesRes = await apiGet(`/worktrees?repo_id=${selectedRepo.id}`);
+            const match = worktreesRes.data.find(
+              (wt) => projectPath === wt.path || projectPath.startsWith(wt.path + "/")
+            );
+            if (match) worktreeId = match.id;
+          } catch {
+          }
+          const codebyplanPath = join3(projectPath, ".codebyplan.json");
+          const codebyplanConfig = {
+            repo_id: selectedRepo.id
+          };
+          if (worktreeId) codebyplanConfig.worktree_id = worktreeId;
+          await writeFile2(
+            codebyplanPath,
+            JSON.stringify(codebyplanConfig, null, 2) + "\n",
+            "utf-8"
+          );
+          console.log(`  Created ${codebyplanPath}`);
+          console.log("\n  Running initial sync...\n");
+          try {
+            const { executeSyncToLocal: executeSyncToLocal2 } = await Promise.resolve().then(() => (init_sync_engine(), sync_engine_exports));
+            const syncResult = await executeSyncToLocal2({
+              repoId: selectedRepo.id,
+              projectPath
+            });
+            const totalChanges = syncResult.totals.created + syncResult.totals.updated + syncResult.totals.deleted;
+            if (totalChanges > 0) {
+              console.log(
+                `  Synced: ${syncResult.totals.created} created, ${syncResult.totals.updated} updated, ${syncResult.totals.deleted} deleted
+`
+              );
+            } else {
+              console.log("  All files already up to date.\n");
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  Sync failed: ${msg}`);
+            console.log("  Run 'codebyplan sync' later to sync files.\n");
+          }
+        }
+      }
+    }
+    console.log(
+      "  Setup complete! Start a new Claude Code session to begin.\n"
+    );
+  } finally {
+    rl.close();
+  }
+}
+var init_setup = __esm({
+  "src/cli/setup.ts"() {
+    "use strict";
+    init_api();
+  }
+});
+
+// src/cli/config.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function parseFlags(startIndex) {
+  const flags = {};
+  const args = process.argv.slice(startIndex);
+  for (let i = 0; i < args.length; i++) {
+    const arg2 = args[i];
+    if (arg2.startsWith("--") && i + 1 < args.length) {
+      const key = arg2.slice(2);
+      flags[key] = args[++i];
+    }
+  }
+  return flags;
+}
+function hasFlag(name, startIndex) {
+  return process.argv.slice(startIndex).includes(`--${name}`);
+}
+async function resolveConfig(flags) {
+  const projectPath = flags["path"] ?? process.cwd();
+  let repoId = flags["repo-id"] ?? process.env.CODEBYPLAN_REPO_ID;
+  let worktreeId = flags["worktree-id"] ?? process.env.CODEBYPLAN_WORKTREE_ID;
+  if (!repoId || !worktreeId) {
+    try {
+      const configPath = join4(projectPath, ".codebyplan.json");
+      const raw = await readFile4(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      if (!repoId) repoId = config.repo_id;
+      if (!worktreeId) worktreeId = config.worktree_id;
+    } catch {
+    }
+  }
+  if (!repoId) {
+    throw new Error(
+      'Could not determine repo_id.\n\nProvide it via one of:\n  --repo-id <uuid>              CLI flag\n  CODEBYPLAN_REPO_ID=<uuid>     environment variable\n  .codebyplan.json              { "repo_id": "<uuid>" } in project root'
+    );
+  }
+  return { repoId, worktreeId, projectPath };
+}
+var init_config = __esm({
+  "src/cli/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/fileMapper.ts
+import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
+import { join as join5, extname } from "node:path";
+function extractScope(content, type) {
+  if (type === "hook") {
+    const match = content.match(/^#\s*@scope:\s*(\S+)/m);
+    if (match) {
+      const raw = match[1];
+      return raw === "shared" ? "shared" : `local:${raw}`;
+    }
+    return "shared";
+  }
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const scopeLine = fmMatch[1].match(/^scope:\s*(\S+)/m);
+    if (scopeLine) {
+      const raw = scopeLine[1];
+      return raw === "shared" ? "shared" : `local:${raw}`;
+    }
+    if (/^scope\b/m.test(fmMatch[1])) {
+      console.error(
+        `  Warning: frontmatter contains "scope" but could not parse it. Expected format: "scope: shared" or "scope: <repo-name>". Defaulting to "shared".`
+      );
+    }
+  }
+  return "shared";
+}
+function compositeKey(type, name, category) {
+  return category ? `${type}:${category}/${name}` : `${type}:${name}`;
+}
+async function scanLocalFiles(claudeDir, projectPath) {
+  const result = /* @__PURE__ */ new Map();
+  await scanCommands(join5(claudeDir, "commands", "cbp"), result);
+  await scanSubfolderType(
+    join5(claudeDir, "agents"),
+    "agent",
+    "AGENT.md",
+    result
+  );
+  await scanSubfolderType(
+    join5(claudeDir, "skills"),
+    "skill",
+    "SKILL.md",
+    result
+  );
+  await scanFlatType(join5(claudeDir, "rules"), "rule", ".md", result);
+  await scanFlatType(join5(claudeDir, "hooks"), "hook", ".sh", result);
+  await scanTemplates(join5(claudeDir, "templates"), result);
+  await scanSettings(claudeDir, projectPath, result);
+  return result;
+}
+async function scanCommands(dir, result) {
+  await scanCommandsRecursive(dir, dir, result);
+}
+async function scanCommandsRecursive(baseDir, currentDir, result) {
+  let entries;
+  try {
+    entries = await readdir3(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      await scanCommandsRecursive(
+        baseDir,
+        join5(currentDir, entry.name),
+        result
+      );
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const name = entry.name.slice(0, -3);
+      const content = await readFile5(join5(currentDir, entry.name), "utf-8");
+      const relDir = currentDir.slice(baseDir.length + 1);
+      const category = relDir || null;
+      const scope = extractScope(content, "command");
+      const key = compositeKey("command", name, category);
+      result.set(key, { type: "command", name, category, content, scope });
+    }
+  }
+}
+async function scanSubfolderType(dir, type, fileName, result) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const filePath = join5(dir, entry.name, fileName);
+      try {
+        const content = await readFile5(filePath, "utf-8");
+        const scope = extractScope(content, type);
+        const key = compositeKey(type, entry.name, null);
+        result.set(key, {
+          type,
+          name: entry.name,
+          category: null,
+          content,
+          scope
+        });
+      } catch {
+      }
+    }
+  }
+}
+async function scanFlatType(dir, type, ext, result) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(ext)) {
+      const name = entry.name.slice(0, -ext.length);
+      const content = await readFile5(join5(dir, entry.name), "utf-8");
+      const scope = extractScope(content, type);
+      const key = compositeKey(type, name, null);
+      result.set(key, { type, name, category: null, content, scope });
+    }
+  }
+}
+async function scanTemplates(dir, result) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && extname(entry.name)) {
+      const content = await readFile5(join5(dir, entry.name), "utf-8");
+      const scope = extractScope(content, "template");
+      const key = compositeKey("template", entry.name, null);
+      result.set(key, {
+        type: "template",
+        name: entry.name,
+        category: null,
+        content,
+        scope
+      });
+    }
+  }
+}
+async function scanSettings(claudeDir, projectPath, result) {
+  const settingsPath = join5(claudeDir, "settings.json");
+  let raw;
+  try {
+    raw = await readFile5(settingsPath, "utf-8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  parsed = stripPermissionsAllow(parsed);
+  if (parsed.hooks && typeof parsed.hooks === "object") {
+    const hooksDir = projectPath ? join5(projectPath, ".claude", "hooks") : join5(claudeDir, "hooks");
+    const discovered = await discoverHooks(hooksDir);
+    if (discovered.size > 0) {
+      parsed.hooks = stripDiscoveredHooks(
+        parsed.hooks,
+        ".claude/hooks"
+      );
+      if (Object.keys(parsed.hooks).length === 0) {
+        delete parsed.hooks;
+      }
+    }
+  }
+  const content = JSON.stringify(parsed, null, 2) + "\n";
+  const key = compositeKey("settings", "settings", null);
+  result.set(key, {
+    type: "settings",
+    name: "settings",
+    category: null,
+    content,
+    scope: "shared"
+  });
+}
+var init_fileMapper = __esm({
+  "src/cli/fileMapper.ts"() {
+    "use strict";
+    init_settings_merge();
+    init_hook_registry();
+  }
+});
+
+// src/cli/confirm.ts
+var confirm_exports = {};
+__export(confirm_exports, {
+  SyncCancelledError: () => SyncCancelledError,
+  confirmEach: () => confirmEach,
+  confirmProceed: () => confirmProceed,
+  promptChoice: () => promptChoice,
+  promptReviewMode: () => promptReviewMode,
+  reviewFilesOneByOne: () => reviewFilesOneByOne,
+  reviewFolder: () => reviewFolder
+});
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
+function isAbortError(err) {
+  return err instanceof Error && err.code === "ABORT_ERR";
+}
+async function confirmProceed(message) {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  try {
+    while (true) {
+      const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
+      const a = answer.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes") return true;
+      if (a === "n" || a === "no") return false;
+      console.log(
+        `    Unknown option "${answer.trim()}". Valid: y/yes, n/no, or Enter for yes.`
+      );
+    }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    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];
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } 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);
+      }
+    }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
+  }
+  return accepted;
+}
+function parseReviewAction(input) {
+  const a = input.trim().toLowerCase();
+  switch (a) {
+    case "d":
+    case "delete":
+      return { action: "delete", all: false, special: null };
+    case "p":
+    case "pull":
+      return { action: "pull", all: false, special: null };
+    case "s":
+    case "push":
+      return { action: "push", all: false, special: null };
+    case "k":
+    case "skip":
+      return { action: "skip", all: false, special: null };
+    case "da":
+      return { action: "delete", all: true, special: null };
+    case "pa":
+      return { action: "pull", all: true, special: null };
+    case "sa":
+      return { action: "push", all: true, special: null };
+    case "ka":
+      return { action: "skip", all: true, special: null };
+    case "v":
+    case "view":
+      return { action: null, all: false, special: "view" };
+    case "r":
+    case "recommended":
+      return { action: null, all: false, special: "recommended" };
+    case "":
+      return { action: null, all: false, special: "recommended" };
+    // Enter = recommended
+    default:
+      return { action: null, all: false, special: null };
+  }
+}
+function formatActionPrompt(recommended, includeView, includeRecommended) {
+  const actions = [
+    `[d]elete${recommended === "delete" ? "\u2605" : ""}`,
+    `[p]ull${recommended === "pull" ? "\u2605" : ""}`,
+    `pu[s]h${recommended === "push" ? "\u2605" : ""}`,
+    `s[k]ip${recommended === "skip" ? "\u2605" : ""}`
+  ];
+  if (includeView) actions.push("[v]iew");
+  if (includeRecommended) actions.push("[r]ecommended");
+  return actions.join(" ");
+}
+function showDiff(local, remote, displayPath) {
+  console.log(`
+    --- ${displayPath} (diff) ---`);
+  if (local === null && remote !== null) {
+    console.log("    (no local file \u2014 remote content below)");
+    for (const line of remote.split("\n").slice(0, 30)) {
+      console.log(`    + ${line}`);
+    }
+    if (remote.split("\n").length > 30) console.log("    ... (truncated)");
+  } else if (local !== null && remote === null) {
+    console.log("    (no remote file \u2014 local content below)");
+    for (const line of local.split("\n").slice(0, 30)) {
+      console.log(`    - ${line}`);
+    }
+    if (local.split("\n").length > 30) console.log("    ... (truncated)");
+  } else if (local !== null && remote !== null) {
+    const localLines = local.split("\n");
+    const remoteLines = remote.split("\n");
+    let shown = 0;
+    const maxLines = 40;
+    for (let i = 0; i < Math.max(localLines.length, remoteLines.length) && shown < maxLines; i++) {
+      const l = localLines[i];
+      const r = remoteLines[i];
+      if (l === r) {
+        console.log(`      ${l ?? ""}`);
+      } else {
+        if (l !== void 0) console.log(`    - ${l}`);
+        if (r !== void 0) console.log(`    + ${r}`);
+      }
+      shown++;
+    }
+    if (Math.max(localLines.length, remoteLines.length) > maxLines) {
+      console.log("    ... (truncated)");
+    }
+  }
+  console.log();
+}
+async function promptReviewMode() {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  try {
+    while (true) {
+      const answer = await rl.question(
+        "  Review [o]ne-by-one or [f]older-by-folder? "
+      );
+      const a = answer.trim().toLowerCase();
+      if (a === "o" || a === "one-by-one" || a === "one" || a === "file")
+        return "file";
+      if (a === "f" || a === "folder") return "folder";
+      console.log(
+        `    Unknown option "${answer.trim()}". Valid: o/one-by-one, f/folder`
+      );
+    }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
+  }
+}
+async function reviewFilesOneByOne(items, label, plannedAction, recommendedAction, content) {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  const results = [];
+  try {
+    let applyAll = null;
+    for (const item of items) {
+      if (applyAll) {
+        results.push(applyAll);
+        continue;
+      }
+      const planned = plannedAction(item);
+      const rec = recommendedAction ? recommendedAction(item) : planned;
+      const hasContent = content != null;
+      const prompt = `    ${label(item)} (${planned}) \u2014 ${formatActionPrompt(rec, hasContent, false)}: `;
+      while (true) {
+        const answer = await rl.question(prompt);
+        const result = parseReviewAction(answer);
+        if (result.special === "view") {
+          if (content) {
+            showDiff(content.local(item), content.remote(item), label(item));
+          } else {
+            console.log("    No content available for diff.");
+          }
+          continue;
+        }
+        if (result.special === "recommended") {
+          results.push(rec);
+          break;
+        }
+        if (result.action === null) {
+          console.log(
+            `    Unknown option "${answer.trim()}". Valid: ${formatActionPrompt(rec, hasContent, false)}`
+          );
+          continue;
+        }
+        results.push(result.action);
+        if (result.all) applyAll = result.action;
+        break;
+      }
+    }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
+  }
+  return results;
+}
+async function reviewFolder(folderName, items, label, plannedAction, recommendedAction, content) {
+  console.log(`
+  ${folderName} (${items.length} files):`);
+  for (const item of items) {
+    const rec = recommendedAction ? recommendedAction(item) : plannedAction(item);
+    const actionLabel = plannedAction(item);
+    const star = actionLabel === rec ? "\u2605" : "";
+    console.log(`    ${label(item)} (${actionLabel}${star})`);
+  }
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
+  try {
+    while (true) {
+      const promptStr = `  Action for all: ${formatActionPrompt(
+        recommendedAction ? recommendedAction(items[0]) : plannedAction(items[0]),
+        false,
+        true
+      )} [o]ne-by-one: `;
+      const answer = await rl.question(promptStr);
+      const a = answer.trim().toLowerCase();
+      if (a === "o" || a === "one-by-one") {
+        rl.close();
+        return reviewFilesOneByOne(
+          items,
+          label,
+          plannedAction,
+          recommendedAction,
+          content
+        );
+      }
+      if (a === "r" || a === "recommended") {
+        return items.map(
+          (item) => recommendedAction ? recommendedAction(item) : plannedAction(item)
+        );
+      }
+      if (a === "v" || a === "view") {
+        if (content) {
+          for (const item of items) {
+            showDiff(content.local(item), content.remote(item), label(item));
+          }
+        } else {
+          console.log("    No content available for diff.");
+        }
+        continue;
+      }
+      const result = parseReviewAction(a);
+      if (result.action !== null) {
+        return items.map(() => result.action);
+      }
+      console.log(
+        `    Unknown option "${answer.trim()}". Valid: ${formatActionPrompt(
+          recommendedAction ? recommendedAction(items[0]) : plannedAction(items[0]),
+          false,
+          true
+        )} [o]ne-by-one`
+      );
+    }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
+  }
+}
+var SyncCancelledError;
+var init_confirm = __esm({
+  "src/cli/confirm.ts"() {
+    "use strict";
+    SyncCancelledError = class extends Error {
+      constructor() {
+        super("Sync cancelled");
+        this.name = "SyncCancelledError";
+      }
+    };
+  }
+});
+
+// src/lib/tech-detect.ts
+import { readFile as readFile6, access, readdir as readdir4 } from "node:fs/promises";
+import { join as join6, relative } from "node:path";
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function discoverMonorepoApps(projectPath) {
+  const apps = [];
+  const patterns = [];
+  try {
+    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 };
+    for (const depName of Object.keys(allDeps)) {
+      const rule = PACKAGE_MAP[depName];
+      if (rule) {
+        const key = rule.name.toLowerCase();
+        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 {
+  }
+  for (const { file, rule } of CONFIG_FILE_MAP) {
+    const key = rule.name.toLowerCase();
+    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 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 });
+    }
+  }
+  const flatMap = /* @__PURE__ */ new Map();
+  for (const entry of repo) {
+    flatMap.set(entry.name.toLowerCase(), entry);
+  }
+  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 remoteResult.flat) {
+    seen.set(entry.name.toLowerCase(), entry);
+  }
+  const added = [];
+  for (const entry of detected.flat) {
+    const key = entry.name.toLowerCase();
+    if (!seen.has(key)) {
+      seen.set(key, entry);
+      added.push(entry);
+    }
+  }
+  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.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 };
+}
+function categorizeDependency(depName) {
+  const rule = PACKAGE_MAP[depName];
+  if (rule) return rule.category;
+  for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+    if (depName.startsWith(prefix)) return prefixRule.category;
+  }
+  return "other";
+}
+async function findPackageJsonFiles(dir, projectPath, depth = 0) {
+  if (depth > 4) return [];
+  const results = [];
+  const pkgPath = join6(dir, "package.json");
+  if (await fileExists(pkgPath)) {
+    results.push(pkgPath);
+  }
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+      const subResults = await findPackageJsonFiles(
+        join6(dir, entry.name),
+        projectPath,
+        depth + 1
+      );
+      results.push(...subResults);
+    }
+  } catch {
+  }
+  return results;
+}
+async function scanAllDependencies(projectPath) {
+  const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
+  const dependencies = [];
+  for (const pkgPath of packageJsonPaths) {
+    try {
+      const raw = await readFile6(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const sourcePath = relative(projectPath, pkgPath);
+      const depSections = [
+        { deps: pkg.dependencies, depType: "production", isDev: false },
+        { deps: pkg.devDependencies, depType: "dev", isDev: true },
+        { deps: pkg.peerDependencies, depType: "peer", isDev: false },
+        { deps: pkg.optionalDependencies, depType: "optional", isDev: false }
+      ];
+      for (const { deps, depType, isDev } of depSections) {
+        if (!deps) continue;
+        for (const [name, version] of Object.entries(deps)) {
+          dependencies.push({
+            name,
+            version,
+            category: categorizeDependency(name),
+            source_path: sourcePath,
+            is_dev: isDev,
+            dep_type: depType
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return { dependencies };
+}
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SKIP_DIRS;
+var init_tech_detect = __esm({
+  "src/lib/tech-detect.ts"() {
+    "use strict";
+    PACKAGE_MAP = {
+      // Frameworks
+      next: { name: "Next.js", category: "framework" },
+      nuxt: { name: "Nuxt", category: "framework" },
+      gatsby: { name: "Gatsby", category: "framework" },
+      express: { name: "Express", category: "framework" },
+      fastify: { name: "Fastify", category: "framework" },
+      hono: { name: "Hono", category: "framework" },
+      "@remix-run/node": { name: "Remix", category: "framework" },
+      svelte: { name: "Svelte", category: "framework" },
+      astro: { name: "Astro", category: "framework" },
+      "@angular/core": { name: "Angular", category: "framework" },
+      // Libraries (UI)
+      react: { name: "React", category: "framework" },
+      vue: { name: "Vue", category: "framework" },
+      "solid-js": { name: "Solid", category: "framework" },
+      preact: { name: "Preact", category: "framework" },
+      // Languages (detected via devDeps)
+      typescript: { name: "TypeScript", category: "language" },
+      // Styling
+      tailwindcss: { name: "Tailwind CSS", category: "styling" },
+      sass: { name: "SCSS", category: "styling" },
+      "styled-components": { name: "styled-components", category: "styling" },
+      "@emotion/react": { name: "Emotion", category: "styling" },
+      // Database
+      prisma: { name: "Prisma", category: "database" },
+      "@prisma/client": { name: "Prisma", category: "database" },
+      "drizzle-orm": { name: "Drizzle", category: "database" },
+      "@supabase/supabase-js": { name: "Supabase", category: "database" },
+      mongoose: { name: "MongoDB", category: "database" },
+      typeorm: { name: "TypeORM", category: "database" },
+      knex: { name: "Knex", category: "database" },
+      // Testing
+      jest: { name: "Jest", category: "testing" },
+      vitest: { name: "Vitest", category: "testing" },
+      mocha: { name: "Mocha", category: "testing" },
+      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" },
+      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" } },
+      { file: "next.config.mjs", rule: { name: "Next.js", category: "framework" } },
+      { file: "next.config.ts", rule: { name: "Next.js", category: "framework" } },
+      {
+        file: "tailwind.config.js",
+        rule: { name: "Tailwind CSS", category: "styling" }
+      },
+      {
+        file: "tailwind.config.ts",
+        rule: { name: "Tailwind CSS", category: "styling" }
+      },
+      { file: "turbo.json", rule: { name: "Turborepo", category: "build" } },
+      {
+        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: ".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" } }
+    ];
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".next",
+      "dist",
+      ".turbo",
+      ".git",
+      "coverage",
+      "build",
+      "out",
+      ".vercel",
+      ".expo"
+    ]);
+  }
+});
+
+// src/lib/server-detect.ts
+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;
+}
+var init_server_detect = __esm({
+  "src/lib/server-detect.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/port-verify.ts
+import { readFile as readFile7 } from "node:fs/promises";
+async function verifyPorts(projectPath, portAllocations) {
+  const mismatches = [];
+  const allocatedPorts = new Set(portAllocations.map((a) => a.port));
+  const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
+  for (const pkgPath of packageJsonPaths) {
+    try {
+      const raw = await readFile7(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const scriptPort = detectPortFromScripts(pkg);
+      if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
+        const relativePath = pkgPath.replace(projectPath + "/", "");
+        const matchingAlloc = portAllocations.find(
+          (a) => a.label === getAppLabel(relativePath)
+        );
+        mismatches.push({
+          packageJsonPath: relativePath,
+          scriptPort,
+          allocation: matchingAlloc ?? null,
+          reason: matchingAlloc ? `Script uses port ${scriptPort} but allocation has port ${matchingAlloc.port}` : `Port ${scriptPort} in scripts is not in any allocation`
+        });
+      }
+    } catch {
+    }
+  }
+  return mismatches;
+}
+async function findUnallocatedApps(projectPath, portAllocations) {
+  const apps = await discoverMonorepoApps(projectPath);
+  if (apps.length === 0) {
+    return [];
+  }
+  const allocatedLabels = new Set(portAllocations.map((a) => a.label));
+  const unallocated = [];
+  for (const app of apps) {
+    if (allocatedLabels.has(app.name)) continue;
+    try {
+      const raw = await readFile7(`${app.absPath}/package.json`, "utf-8");
+      const pkg = JSON.parse(raw);
+      const framework = detectFramework(pkg);
+      const detectedPort = detectPortFromScripts(pkg);
+      const command = `pnpm --filter ${app.name} dev`;
+      unallocated.push({
+        name: app.name,
+        path: app.path,
+        framework,
+        detectedPort,
+        command
+      });
+    } catch {
+    }
+  }
+  return unallocated;
+}
+function getAppLabel(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts.length >= 3 && parts[0] === "apps") {
+    return parts[1];
+  }
+  return "root";
+}
+var init_port_verify = __esm({
+  "src/lib/port-verify.ts"() {
+    "use strict";
+    init_tech_detect();
+    init_server_detect();
+  }
+});
+
+// src/cli/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  runSync: () => runSync
+});
+import { createHash } from "node:crypto";
+import { readFile as readFile8, 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";
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function runSync() {
+  const flags = parseFlags(3);
+  const dryRun = hasFlag("dry-run", 3);
+  const force = hasFlag("force", 3);
+  const fix = hasFlag("fix", 3);
+  validateApiKey();
+  const config = await resolveConfig(flags);
+  const { repoId, projectPath } = config;
+  console.log(`
+  CodeByPlan Sync`);
+  console.log(`  Repo: ${repoId}`);
+  console.log(`  Path: ${projectPath}`);
+  if (dryRun) console.log(`  Mode: dry-run`);
+  if (force) console.log(`  Mode: force`);
+  console.log();
+  if (!dryRun) {
+    console.log("  Acquiring sync lock...");
+    try {
+      await apiPost("/sync/lock", {
+        repo_id: repoId,
+        locked_by: `cli-sync`,
+        reason: "Bidirectional sync",
+        ttl_minutes: 10
+      });
+      console.log("  Lock acquired.\n");
+    } catch (lockErr) {
+      const lockStatus = await apiGet("/sync/lock", { repo_id: repoId });
+      if (lockStatus.data.locked && lockStatus.data.lock) {
+        const lock = lockStatus.data.lock;
+        console.log(
+          `  Sync locked by ${lock.locked_by} since ${lock.locked_at}.`
+        );
+        console.log(`  Expires: ${lock.expires_at}`);
+        console.log(`  Use --force to override, or wait for lock to expire.
+`);
+        if (!force) return;
+        await apiPost("/sync/lock", {
+          repo_id: repoId,
+          locked_by: `cli-sync`,
+          reason: "Bidirectional sync (forced)",
+          ttl_minutes: 10
+        });
+        console.log("  Lock acquired (forced).\n");
+      } else {
+        throw lockErr;
+      }
+    }
+  }
+  try {
+    await runSyncInner(repoId, projectPath, dryRun, force, fix);
+  } finally {
+    if (!dryRun) {
+      try {
+        await apiDelete("/sync/lock", { repo_id: repoId });
+      } catch (err) {
+        console.error(
+          `  Warning: failed to release sync lock: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+}
+async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
+  console.log("  Reading local and remote state...");
+  const claudeDir = join7(projectPath, ".claude");
+  let localFiles = /* @__PURE__ */ new Map();
+  try {
+    localFiles = await scanLocalFiles(claudeDir, projectPath);
+  } catch {
+  }
+  const [defaultsRes, repoSyncRes, repoRes, , fileReposRes] = await Promise.all(
+    [
+      apiGet("/sync/defaults"),
+      apiGet("/sync/files", { repo_id: repoId }),
+      apiGet(`/repos/${repoId}`),
+      apiGet("/sync/state", {
+        repo_id: repoId
+      }),
+      apiGet("/sync/file-repos", {
+        repo_id: repoId
+      })
+    ]
+  );
+  const syncStartTime = Date.now();
+  const repoData = repoRes.data;
+  const remoteDefaults = flattenSyncData(defaultsRes.data);
+  const remoteRepoFiles = flattenSyncData(repoSyncRes.data);
+  const fileRepoHashes = /* @__PURE__ */ new Map();
+  const fileRepoByClaudeFileId = /* @__PURE__ */ new Map();
+  for (const entry of fileReposRes.data ?? []) {
+    const baseKey = compositeKey(
+      entry.file_type,
+      entry.file_name,
+      entry.file_category
+    );
+    const scopedKey = `${baseKey}:${entry.file_scope}`;
+    fileRepoHashes.set(scopedKey, entry.last_synced_content_hash);
+    if (!fileRepoHashes.has(baseKey)) {
+      fileRepoHashes.set(baseKey, entry.last_synced_content_hash);
+    }
+    if (entry.claude_file_id) {
+      fileRepoByClaudeFileId.set(
+        entry.claude_file_id,
+        entry.last_synced_content_hash
+      );
+    }
+  }
+  const remoteFiles = new Map([...remoteDefaults, ...remoteRepoFiles]);
+  console.log(
+    `  Local: ${localFiles.size} files, Remote: ${remoteFiles.size} files
+`
+  );
+  const plan = [];
+  const allKeys = /* @__PURE__ */ new Set([...localFiles.keys(), ...remoteFiles.keys()]);
+  for (const key of allKeys) {
+    const local = localFiles.get(key);
+    const remote = remoteFiles.get(key);
+    if (local && !remote) {
+      plan.push({
+        key,
+        displayPath: `${local.type}/${local.category ? local.category + "/" : ""}${local.name}`,
+        action: "push",
+        recommended: "push",
+        localContent: local.content,
+        remoteContent: null,
+        pushContent: reverseSubstituteVariables(local.content, repoData),
+        filePath: getLocalFilePath(claudeDir, projectPath, {
+          type: local.type,
+          name: local.name,
+          category: local.category
+        }),
+        type: local.type,
+        name: local.name,
+        category: local.category,
+        scope: local.scope,
+        isHook: local.type === "hook",
+        claudeFileId: null
+      });
+    } else if (!local && remote) {
+      const resolvedContent = substituteVariables(remote.content, repoData);
+      const hadSyncedThisFile = remote.id ? fileRepoByClaudeFileId.has(remote.id) : fileRepoHashes.has(key);
+      const recommended = hadSyncedThisFile ? "delete" : "pull";
+      plan.push({
+        key,
+        displayPath: `${remote.type}/${remote.category ? remote.category + "/" : ""}${remote.name}`,
+        action: recommended,
+        recommended,
+        localContent: null,
+        remoteContent: resolvedContent,
+        pushContent: null,
+        filePath: getLocalFilePath(claudeDir, projectPath, remote),
+        type: remote.type,
+        name: remote.name,
+        category: remote.category ?? null,
+        scope: remote.scope ?? "shared",
+        isHook: remote.type === "hook",
+        claudeFileId: remote.id ?? null
+      });
+    } else if (local && remote) {
+      const resolvedRemote = substituteVariables(remote.content, repoData);
+      if (local.content === resolvedRemote) {
+        continue;
+      }
+      const localHash = contentHash(local.content);
+      const scopedKey = `${key}:${local.scope}`;
+      const lastSyncedHash = fileRepoHashes.get(scopedKey) ?? fileRepoHashes.get(key) ?? null;
+      const localChanged = lastSyncedHash ? localHash !== lastSyncedHash : true;
+      let action;
+      if (force) {
+        action = "pull";
+      } else if (!localChanged) {
+        action = "pull";
+      } else if (lastSyncedHash === null) {
+        action = "conflict";
+      } else {
+        const remoteResolvedHash = contentHash(resolvedRemote);
+        const remoteChanged = remoteResolvedHash !== lastSyncedHash;
+        if (remoteChanged) {
+          action = "conflict";
+        } else {
+          action = "push";
+        }
+      }
+      plan.push({
+        key,
+        displayPath: `${local.type}/${local.category ? local.category + "/" : ""}${local.name}`,
+        action,
+        recommended: action === "conflict" ? "pull" : action,
+        localContent: local.content,
+        remoteContent: resolvedRemote,
+        pushContent: reverseSubstituteVariables(local.content, repoData),
+        filePath: getLocalFilePath(claudeDir, projectPath, remote),
+        type: local.type,
+        name: local.name,
+        category: local.category,
+        scope: local.scope,
+        isHook: local.type === "hook",
+        claudeFileId: remote.id ?? null
+      });
+    }
+  }
+  const pulls = plan.filter((p) => p.action === "pull");
+  const pushes = plan.filter((p) => p.action === "push");
+  const conflicts = plan.filter((p) => p.action === "conflict");
+  const contentPulls = pulls.filter((p) => p.localContent !== null);
+  const dbOnlyPull = plan.filter(
+    (p) => p.localContent === null && p.action === "pull"
+  );
+  const dbOnlyDelete = plan.filter(
+    (p) => p.localContent === null && p.action === "delete"
+  );
+  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 (dbOnlyPull.length > 0) {
+    console.log(`
+  DB-only (new, will pull): ${dbOnlyPull.length}`);
+    for (const p of dbOnlyPull) console.log(`    \u2193 ${p.displayPath}`);
+  }
+  if (dbOnlyDelete.length > 0) {
+    console.log(
+      `
+  DB-only (previously synced, will delete): ${dbOnlyDelete.length}`
+    );
+    for (const p of dbOnlyDelete) console.log(`    \u2715 ${p.displayPath}`);
+  }
+  if (conflicts.length > 0) {
+    console.log(`
+  Conflicts (both sides changed): ${conflicts.length}`);
+    for (const p of conflicts) console.log(`    \u26A0 ${p.displayPath}`);
+  }
+  if (contentPulls.length === 0 && pushes.length === 0 && dbOnlyPull.length === 0 && dbOnlyDelete.length === 0 && conflicts.length === 0) {
+    console.log("  All .claude/ files in sync.");
+  }
+  if (plan.length > 0 && !dryRun) {
+    if (!force) {
+      const agreed = await confirmProceed(`
+  Agree with sync? [Y/n] `);
+      if (!agreed) {
+        const mode = await promptReviewMode();
+        const contentProvider = {
+          local: (p) => p.localContent,
+          remote: (p) => p.remoteContent
+        };
+        if (mode === "file") {
+          const actions = await reviewFilesOneByOne(
+            plan,
+            (p) => p.displayPath,
+            (p) => p.action,
+            (p) => p.recommended,
+            contentProvider
+          );
+          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,
+              (p) => p.recommended,
+              contentProvider
+            );
+            for (let i = 0; i < items.length; i++) {
+              items[i].action = actions[i];
+            }
+          }
+        }
+      }
+    }
+    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 = toPush.filter((p) => p.pushContent !== null).map((p) => ({
+        type: p.type,
+        name: p.name,
+        category: p.category,
+        content: p.pushContent,
+        scope: p.scope
+      }));
+      if (toUpsert.length > 0) {
+        await apiPost("/sync/files", {
+          repo_id: repoId,
+          files: toUpsert,
+          changed_by_repo_id: repoId
+        });
+      }
+      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 (err) {
+              if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
+                console.error(
+                  `  Warning: failed to delete ${p.filePath}: ${err.message}`
+                );
+              }
+            }
+          }
+        }
+      }
+      const syncDurationMs = Date.now() - syncStartTime;
+      await apiPost("/sync/state", {
+        repo_id: repoId,
+        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+        was_skipped: skipped.length > 0,
+        files_synced_count: toPull.length + toPush.length + toDelete.length,
+        files_pushed: toPush.length,
+        files_pulled: toPull.length,
+        files_deleted: toDelete.length,
+        files_skipped: skipped.length,
+        sync_duration_ms: syncDurationMs,
+        sync_version: getSyncVersion()
+      });
+      const syncTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const fileRepoUpdates = [];
+      for (const p of toPull) {
+        if (p.remoteContent !== null) {
+          fileRepoUpdates.push({
+            claude_file_id: p.claudeFileId ?? void 0,
+            file_type: p.type,
+            file_name: p.name,
+            file_category: p.category,
+            file_scope: p.scope,
+            last_synced_at: syncTimestamp,
+            last_synced_content_hash: contentHash(p.remoteContent),
+            sync_status: "synced"
+          });
+        }
+      }
+      for (const p of toPush) {
+        if (p.localContent !== null) {
+          fileRepoUpdates.push({
+            claude_file_id: p.claudeFileId ?? void 0,
+            file_type: p.type,
+            file_name: p.name,
+            file_category: p.category,
+            file_scope: p.scope,
+            last_synced_at: syncTimestamp,
+            last_synced_content_hash: contentHash(p.localContent),
+            sync_status: "synced"
+          });
+        }
+      }
+      if (fileRepoUpdates.length > 0) {
+        try {
+          await apiPost("/sync/file-repos", {
+            repo_id: repoId,
+            file_repos: fileRepoUpdates
+          });
+        } catch {
+        }
+      }
+      console.log(
+        `
+  Applied: ${toPull.length} pulled, ${toPush.length} pushed, ${toDelete.length} deleted` + (skipped.length > 0 ? `, ${skipped.length} skipped` : "")
+      );
+    }
+    const unresolvedConflicts = plan.filter(
+      (p) => p.action === "conflict" || p.action === "skip" && p.localContent !== null && p.remoteContent !== null
+    );
+    if (unresolvedConflicts.length > 0) {
+      let stored = 0;
+      for (const p of unresolvedConflicts) {
+        try {
+          await apiPost("/sync/conflicts", {
+            repo_id: repoId,
+            claude_file_id: p.claudeFileId ?? void 0,
+            file_type: p.type,
+            file_name: p.name,
+            file_category: p.category,
+            file_scope: p.scope,
+            conflict_type: "both_modified",
+            local_content: p.localContent,
+            remote_content: p.remoteContent
+          });
+          stored++;
+        } catch (err) {
+          console.error(`Failed to store conflict for ${p.displayPath}:`, err);
+        }
+      }
+      if (stored > 0) {
+        console.log(
+          `
+  ${stored} conflict(s) stored in DB for later resolution.`
+        );
+      }
+    }
+  } else if (dryRun) {
+    console.log("\n  (dry-run \u2014 no changes)");
+  }
+  console.log("\n  Settings sync...");
+  await syncSettings(
+    claudeDir,
+    projectPath,
+    defaultsRes.data,
+    repoData,
+    dryRun
+  );
+  console.log("  Config sync...");
+  await syncConfig(repoId, projectPath, dryRun);
+  console.log("  Tech stack...");
+  await syncTechStack(repoId, projectPath, dryRun);
+  console.log("  Port verification...");
+  await syncPortVerification(repoId, projectPath, dryRun, fix);
+  console.log("\n  Sync complete.\n");
+}
+async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
+  const settingsPath = join7(claudeDir, "settings.json");
+  const globalSettingsFiles = syncData.global_settings ?? [];
+  let globalSettings = {};
+  for (const gf of globalSettingsFiles) {
+    const parsed = JSON.parse(
+      substituteVariables(gf.content, repoData)
+    );
+    globalSettings = { ...globalSettings, ...parsed };
+  }
+  const repoSettingsFiles = syncData.settings ?? [];
+  let repoSettings = {};
+  for (const rf of repoSettingsFiles) {
+    repoSettings = JSON.parse(
+      substituteVariables(rf.content, repoData)
+    );
+  }
+  const combinedTemplate = mergeGlobalAndRepoSettings(
+    globalSettings,
+    repoSettings
+  );
+  const hooksDir = join7(projectPath, ".claude", "hooks");
+  const discovered = await discoverHooks(hooksDir);
+  let localSettings = {};
+  try {
+    const raw = await readFile8(settingsPath, "utf-8");
+    localSettings = JSON.parse(raw);
+  } catch {
+  }
+  let merged = Object.keys(localSettings).length > 0 ? mergeSettings(combinedTemplate, localSettings) : combinedTemplate;
+  merged = stripPermissionsAllow(merged);
+  if (discovered.size > 0) {
+    merged.hooks = mergeDiscoveredHooks(
+      merged.hooks ?? {},
+      discovered
+    );
+  }
+  const mergedContent = JSON.stringify(merged, null, 2) + "\n";
+  let currentContent = "";
+  try {
+    currentContent = await readFile8(settingsPath, "utf-8");
+  } catch {
+  }
+  if (currentContent === mergedContent) {
+    console.log("    Settings up to date.");
+    return;
+  }
+  if (dryRun) {
+    console.log("    Settings would be updated (dry-run).");
+    return;
+  }
+  await mkdir2(dirname2(settingsPath), { recursive: true });
+  await writeFile3(settingsPath, mergedContent, "utf-8");
+  console.log("    Updated settings.json");
+}
+async function syncConfig(repoId, projectPath, dryRun) {
+  const configPath = join7(projectPath, ".codebyplan.json");
+  let currentConfig = {};
+  try {
+    const raw = await readFile8(configPath, "utf-8");
+    currentConfig = JSON.parse(raw);
+  } catch {
+    currentConfig = { repo_id: repoId };
+  }
+  const repoRes = await apiGet(`/repos/${repoId}`);
+  const repo = repoRes.data;
+  let portAllocations = [];
+  try {
+    const portsRes = await apiGet(
+      `/port-allocations`,
+      { repo_id: repoId }
+    );
+    const allAllocations = portsRes.data ?? [];
+    const worktreeId2 = currentConfig.worktree_id;
+    const filtered = worktreeId2 ? allAllocations.filter((a) => a.worktree_id === worktreeId2) : allAllocations.filter((a) => !a.worktree_id);
+    const ALLOWED_FIELDS = [
+      "id",
+      "repo_id",
+      "port",
+      "label",
+      "server_type",
+      "auto_start",
+      "command",
+      "working_dir",
+      "env_vars",
+      "external_refs",
+      "worktree_id",
+      "created_at",
+      "updated_at"
+    ];
+    portAllocations = filtered.map((a) => {
+      const clean = {};
+      for (const key of ALLOWED_FIELDS) {
+        if (key in a) clean[key] = a[key];
+      }
+      return clean;
+    });
+  } catch {
+  }
+  const worktreeId = currentConfig.worktree_id;
+  const matchingAlloc = portAllocations[0];
+  const defaultBranchConfig = {
+    protected: ["main", "development"],
+    integration: "development",
+    production: "main",
+    staging: null
+  };
+  const branchConfig = repo.branch_config ?? defaultBranchConfig;
+  const newConfig = {
+    repo_id: repoId,
+    ...worktreeId ? { worktree_id: worktreeId } : {},
+    server_port: worktreeId && matchingAlloc ? matchingAlloc.port : repo.server_port,
+    server_type: worktreeId && matchingAlloc ? matchingAlloc.server_type : repo.server_type,
+    git_branch: repo.git_branch ?? "development",
+    auto_push_enabled: repo.auto_push_enabled,
+    branch_config: branchConfig,
+    ...portAllocations.length > 0 ? { port_allocations: portAllocations } : {}
+  };
+  const currentJson = JSON.stringify(currentConfig, null, 2);
+  const newJson = JSON.stringify(newConfig, null, 2);
+  if (currentJson === newJson) {
+    console.log("    Config up to date.");
+    return;
+  }
+  if (dryRun) {
+    console.log("    Config would be updated (dry-run).");
+    return;
+  }
+  await writeFile3(configPath, newJson + "\n", "utf-8");
+  console.log("    Updated .codebyplan.json");
+}
+async function syncTechStack(repoId, projectPath, dryRun) {
+  try {
+    const { dependencies } = await scanAllDependencies(projectPath);
+    if (dependencies.length === 0) {
+      console.log("    No dependencies found.");
+      return;
+    }
+    const sourcePaths = new Set(dependencies.map((d) => d.source_path));
+    console.log(
+      `    ${dependencies.length} dependencies from ${sourcePaths.size} package.json file${sourcePaths.size !== 1 ? "s" : ""}`
+    );
+    if (!dryRun) {
+      const result = await apiPost(`/repos/${repoId}/tech-stack`, { dependencies });
+      if (result.data.stale_removed > 0) {
+        console.log(
+          `    ${result.data.stale_removed} stale dependencies removed`
+        );
+      }
+    }
+    const detected = await detectTechStack(projectPath);
+    if (detected.flat.length > 0) {
+      const repoRes = await apiGet(`/repos/${repoId}`);
+      const remote = parseTechStackResult(repoRes.data.tech_stack);
+      const { merged, added } = mergeTechStack(remote, detected);
+      if (added.length > 0) {
+        console.log(`    ${added.length} new tech entries`);
+        if (!dryRun) {
+          await apiPut(`/repos/${repoId}`, { tech_stack: merged });
+        }
+      }
+    }
+  } catch {
+    console.log("    Tech stack detection skipped.");
+  }
+}
+async function syncPortVerification(repoId, projectPath, dryRun, fix) {
+  try {
+    const portsRes = await apiGet(
+      `/port-allocations`,
+      { repo_id: repoId }
+    );
+    const allocations = portsRes.data ?? [];
+    if (allocations.length === 0) {
+      console.log("    No port allocations found \u2014 skipping verification.");
+      return;
+    }
+    const mismatches = await verifyPorts(projectPath, allocations);
+    if (mismatches.length > 0) {
+      console.log(`    Port mismatches: ${mismatches.length}`);
+      for (const m of mismatches) {
+        console.log(`      ! ${m.packageJsonPath}: ${m.reason}`);
+      }
+    }
+    const unallocated = await findUnallocatedApps(projectPath, allocations);
+    if (unallocated.length > 0) {
+      console.log(`    Unallocated apps: ${unallocated.length}`);
+      for (const app of unallocated) {
+        console.log(
+          `      + ${app.name} (${app.framework}${app.detectedPort ? `, port ${app.detectedPort}` : ""})`
+        );
+      }
+      if (fix && !dryRun) {
+        const maxPort = Math.max(...allocations.map((a) => a.port), 2999);
+        let nextPort = maxPort + 1;
+        for (const app of unallocated) {
+          const port = app.detectedPort ?? nextPort++;
+          try {
+            await apiPost("/port-allocations", {
+              repo_id: repoId,
+              port,
+              label: app.name,
+              server_type: app.framework,
+              auto_start: "manual",
+              command: app.command,
+              working_dir: app.path
+            });
+            console.log(`      Created allocation: ${app.name} \u2192 port ${port}`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(
+              `      Failed to create allocation for ${app.name}: ${msg}`
+            );
+          }
+          if (app.detectedPort && app.detectedPort >= nextPort) {
+            nextPort = app.detectedPort + 1;
+          }
+        }
+      } else if (fix && dryRun) {
+        console.log("    (dry-run \u2014 would create allocations with --fix)");
+      } else {
+        console.log("    Run with --fix to auto-create allocations.");
+      }
+    }
+    if (mismatches.length === 0 && unallocated.length === 0) {
+      console.log("    Ports verified.");
+    }
+  } catch {
+    console.log("    Port verification 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" },
+    agent: { dir: "agents", ext: ".md", subfolder: "AGENT" },
+    skill: { dir: "skills", ext: ".md", subfolder: "SKILL" },
+    rule: { dir: "rules", ext: ".md" },
+    hook: { dir: "hooks", ext: ".sh" },
+    template: { dir: "templates", ext: "" },
+    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");
+  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}`);
+}
+function getSyncVersion() {
+  try {
+    return "1.1.0";
+  } catch {
+    return "unknown";
+  }
+}
+function flattenSyncData(data) {
+  const result = /* @__PURE__ */ new Map();
+  const typeMap = {
+    commands: "command",
+    agents: "agent",
+    skills: "skill",
+    rules: "rule",
+    hooks: "hook",
+    templates: "template",
+    settings: "settings"
+  };
+  for (const [syncKey, typeName] of Object.entries(typeMap)) {
+    const files = data[syncKey] ?? [];
+    for (const file of files) {
+      const key = compositeKey(typeName, file.name, file.category ?? null);
+      result.set(key, {
+        id: file.id,
+        type: typeName,
+        name: file.name,
+        content: file.content,
+        category: file.category,
+        updated_at: file.updated_at,
+        content_hash: file.content_hash
+      });
+    }
+  }
+  return result;
+}
+var init_sync = __esm({
+  "src/cli/sync.ts"() {
+    "use strict";
+    init_config();
+    init_fileMapper();
+    init_confirm();
+    init_api();
+    init_variables();
+    init_tech_detect();
+    init_settings_merge();
+    init_hook_registry();
+    init_port_verify();
+  }
+});
+
+// src/index.ts
+init_version();
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+if (!process.env.CODEBYPLAN_API_KEY) {
+  try {
+    const envPath = resolve(process.cwd(), ".env.local");
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      const val = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+      if (!process.env[key]) process.env[key] = val;
+    }
+  } catch {
+  }
+}
+if (process.env.CODEBYPLAN_API_KEY?.startsWith("CODEBYPLAN_API_KEY=")) {
+  process.env.CODEBYPLAN_API_KEY = process.env.CODEBYPLAN_API_KEY.slice(
+    "CODEBYPLAN_API_KEY=".length
+  );
+}
+var arg = process.argv[2];
+if (arg === "--version" || arg === "-v") {
+  console.log(VERSION);
+  process.exit(0);
+}
+if (arg === "setup") {
+  const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await runSetup2();
+  process.exit(0);
+}
+if (arg === "sync") {
+  const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
+  try {
+    await runSync2();
+  } catch (err) {
+    if (err instanceof SyncCancelledError2) {
+      console.log("\n  Sync cancelled.\n");
+      process.exit(0);
+    }
+    throw err;
+  }
+  process.exit(0);
+}
+if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
+  console.log(`
+  CodeByPlan CLI v${VERSION}
+
+  Usage:
+    codebyplan setup        Interactive setup (API key + project init + first sync)
+    codebyplan sync         Bidirectional sync (pull + push + config)
+    codebyplan help         Show this help message
+    codebyplan --version    Print version
+
+  Sync options:
+    --path <dir>            Project root directory (default: cwd)
+    --repo-id <uuid>        Repository ID (or set via .codebyplan.json)
+    --dry-run               Preview changes without writing
+    --force                 Skip confirmation and conflict prompts
+    --fix                   Auto-create missing port allocations
+
+  MCP Server:
+    Claude Code connects to CodeByPlan via remote MCP:
+      URL: https://codebyplan.com/mcp
+      Auth: x-api-key header (configured during setup)
+
+  Learn more: https://codebyplan.com
+`);
+  process.exit(0);
+}
+console.error(`Unknown command: ${arg}`);
+console.error("Run 'codebyplan help' for usage.");
+process.exit(1);