codebyplan 1.4.1 → 1.4.2

package/README.md

@@ -9,6 +9,7 @@ npx codebyplan setup
 ```
 
 This will:
+
 1. Prompt for your API key (get one at [codebyplan.com/settings/api-keys](https://codebyplan.com/settings/api-keys))
 2. Configure Claude Code to connect via remote MCP
 3. Optionally link a repository and run the first sync
@@ -25,13 +26,13 @@ Bidirectional sync of `.claude/` infrastructure files between your local project
 
 **Options:**
 
-| Flag | Description |
-|------|-------------|
-| `--path <dir>` | Project root directory (default: cwd) |
+| Flag               | Description                                      |
+| ------------------ | ------------------------------------------------ |
+| `--path <dir>`     | Project root directory (default: cwd)            |
 | `--repo-id <uuid>` | Repository ID (default: from `.codebyplan.json`) |
-| `--dry-run` | Preview changes without writing |
-| `--force` | Skip confirmation and conflict prompts |
-| `--fix` | Auto-create missing port allocations |
+| `--dry-run`        | Preview changes without writing                  |
+| `--force`          | Skip confirmation and conflict prompts           |
+| `--fix`            | Auto-create missing port allocations             |
 
 ### `codebyplan help`
 
@@ -49,7 +50,7 @@ Claude Code connects to CodeByPlan via a remote MCP server. The `setup` command
 {
   "mcpServers": {
     "codebyplan": {
-      "url": "https://codebyplan.com/mcp",
+      "url": "https://www.codebyplan.com/mcp",
       "headers": { "x-api-key": "your-api-key" }
     }
   }

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.4.1";
+    VERSION = "1.4.2";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -52,7 +52,7 @@ function isRetryable(err) {
   return false;
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function request(method, path, options) {
   const url = buildUrl(path, options?.params);
@@ -126,7 +126,7 @@ var init_api = __esm({
     "use strict";
     init_version();
     API_KEY = process.env.CODEBYPLAN_API_KEY ?? "";
-    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com").replace(/\/$/, "");
+    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
     REQUEST_TIMEOUT_MS = 12e4;
     MAX_RETRIES = 3;
     BASE_DELAY_MS = 1e3;
@@ -211,11 +211,14 @@ var init_settings_merge = __esm({
 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;
+  const lineMatch = content.match(/^#\s*@hook:(.*)$/m);
+  if (!lineMatch) return null;
+  const parts = lineMatch[1].trim().split(/\s+/);
+  const event = parts[0];
+  if (!event) return null;
   return {
-    event: match[1],
-    matcher: match[2]?.trim() ?? ""
+    event,
+    matcher: parts.slice(1).join(" ")
   };
 }
 async function discoverHooks(hooksDir) {
@@ -550,7 +553,7 @@ async function executeSyncToLocal(options) {
       const substituted = substituteVariables(remote.content, repoData);
       remotePathMap.set(relPath, {
         content: substituted,
-        name: `${remote.category ?? ""}/${remote.name}`
+        name: remote.category ? `${remote.category}/${remote.name}` : remote.name
       });
     }
     for (const [relPath, { content, name }] of remotePathMap) {
@@ -793,7 +796,7 @@ async function readConfig(path) {
   }
 }
 function buildMcpEntry(apiKey) {
-  const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+  const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com";
   return {
     url: `${baseUrl}/mcp`,
     headers: { "x-api-key": apiKey }
@@ -835,7 +838,7 @@ async function runSetup() {
       return;
     }
     console.log("\n  Validating API key...");
-    const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+    const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com";
     const res = await fetch(`${baseUrl}/api/repos`, {
       headers: { "x-api-key": apiKey },
       signal: AbortSignal.timeout(1e4)
@@ -887,7 +890,7 @@ async function runSetup() {
 `
       );
       console.log(
-        `    { "url": "https://codebyplan.com/mcp", "headers": { "x-api-key": "${apiKey}" } }
+        `    { "url": "https://www.codebyplan.com/mcp", "headers": { "x-api-key": "${apiKey}" } }
 `
       );
     }
@@ -971,14 +974,30 @@ var init_setup = __esm({
 
 // src/cli/config.ts
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join4, resolve } from "node:path";
+async function findCodebyplanConfig(startDir, maxDepth = 20) {
+  let cursor = resolve(startDir);
+  for (let depth = 0; depth < maxDepth; depth++) {
+    const configPath = join4(cursor, ".codebyplan.json");
+    try {
+      const raw = await readFile4(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { path: configPath, contents: parsed };
+    } catch {
+    }
+    const parent = resolve(cursor, "..");
+    if (parent === cursor) return null;
+    cursor = parent;
+  }
+  return null;
+}
 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);
+    const arg = args[i];
+    if (arg.startsWith("--") && i + 1 < args.length) {
+      const key = arg.slice(2);
       flags[key] = args[++i];
     }
   }
@@ -992,13 +1011,10 @@ async function resolveConfig(flags) {
   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 {
+    const found = await findCodebyplanConfig(projectPath);
+    if (found) {
+      if (!repoId) repoId = found.contents.repo_id;
+      if (!worktreeId) worktreeId = found.contents.worktree_id;
     }
   }
   if (!repoId) {
@@ -1633,12 +1649,77 @@ async function discoverMonorepoApps(projectPath) {
   }
   return apps;
 }
+async function hasJsxFile(dir, depth = 0) {
+  if (depth > 6) return false;
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
+        if (await hasJsxFile(join6(dir, name), depth + 1)) return true;
+      } else if (entry.isFile()) {
+        if (JSX_TEST_PATTERN.test(name)) continue;
+        if (name.endsWith(".tsx") || name.endsWith(".jsx")) return true;
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return false;
+    }
+    console.error(
+      `detectCapabilities: readdir failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return false;
+}
+async function detectCapabilities(dirPath, pkgJson) {
+  const caps = /* @__PURE__ */ new Set();
+  for (const sub of JSX_SCAN_DIRS) {
+    if (await hasJsxFile(join6(dirPath, sub))) {
+      caps.add("jsx");
+      break;
+    }
+  }
+  if (pkgJson) {
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
+    for (const dep of Object.keys(allDeps)) {
+      if (SERVER_FRAMEWORK_DEPS.has(dep)) {
+        caps.add("node-server");
+        break;
+      }
+    }
+    if (!caps.has("node-server") && typeof pkgJson.main === "string") {
+      if (SERVER_MAIN_ENTRIES.has(pkgJson.main.trim())) {
+        caps.add("node-server");
+      }
+    }
+  }
+  if (!caps.has("node-server") && await fileExists(join6(dirPath, "src", "main.ts"))) {
+    caps.add("node-server");
+  }
+  if (pkgJson && pkgJson.bin) {
+    if (typeof pkgJson.bin === "string" && pkgJson.bin.trim().length > 0) {
+      caps.add("cli-bin");
+    } else if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && Object.keys(pkgJson.bin).length > 0) {
+      caps.add("cli-bin");
+    }
+  }
+  return caps;
+}
 async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
+  let pkgJson = null;
   try {
     const raw = await readFile6(join6(dirPath, "package.json"), "utf-8");
-    const pkg = JSON.parse(raw);
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    pkgJson = JSON.parse(raw);
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
     for (const depName of Object.keys(allDeps)) {
       const rule = PACKAGE_MAP[depName];
       if (rule) {
@@ -1669,11 +1750,40 @@ async function detectFromDirectory(dirPath) {
       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);
+  const capabilities = await detectCapabilities(dirPath, pkgJson);
+  const capsArray = Array.from(capabilities).sort();
+  const entries = Array.from(seen.values()).map((entry) => {
+    const isBearer = CAPABILITY_BEARER_NAMES.has(entry.name.toLowerCase());
+    return {
+      ...entry,
+      capabilities: isBearer ? capsArray : []
+    };
   });
+  if (capsArray.length > 0) {
+    const hasBearerWithCaps = entries.some(
+      (e) => CAPABILITY_BEARER_NAMES.has(e.name.toLowerCase()) && (e.capabilities?.some((c) => c.length > 0) ?? false)
+    );
+    if (!hasBearerWithCaps) {
+      entries.push({
+        name: SYNTHETIC_CARRIER_NAME,
+        category: "tool",
+        capabilities: capsArray
+      });
+    }
+  }
+  return entries.sort(compareByCategoryThenName);
+}
+function collectCapabilities(entries) {
+  const set = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.capabilities) continue;
+    for (const cap of entry.capabilities) {
+      if (typeof cap === "string" && cap.length > 0) {
+        set.add(cap.toLowerCase());
+      }
+    }
+  }
+  return Array.from(set).sort();
 }
 async function detectTechStack(projectPath) {
   const repo = await detectFromDirectory(projectPath);
@@ -1692,40 +1802,80 @@ async function detectTechStack(projectPath) {
   for (const app of apps) {
     for (const entry of app.stack) {
       const key = entry.name.toLowerCase();
-      if (!flatMap.has(key)) {
+      const existing = flatMap.get(key);
+      if (!existing) {
         flatMap.set(key, entry);
+      } else if (entry.capabilities?.length) {
+        const merged = Array.from(
+          /* @__PURE__ */ new Set([...existing.capabilities ?? [], ...entry.capabilities])
+        ).sort();
+        flatMap.set(key, { ...existing, capabilities: merged });
       }
     }
   }
-  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 };
+  const repoCleaned = stripSyntheticIfCovered(repo).sort(
+    compareByCategoryThenName
+  );
+  const appsCleaned = apps.map((a) => ({
+    ...a,
+    stack: stripSyntheticIfCovered(a.stack).sort(compareByCategoryThenName)
+  }));
+  const flat = stripSyntheticIfCovered(Array.from(flatMap.values())).sort(
+    compareByCategoryThenName
+  );
+  return { repo: repoCleaned, apps: appsCleaned, flat };
+}
+function stripSyntheticIfCovered(entries) {
+  const synth = entries.find((e) => e.name === SYNTHETIC_CARRIER_NAME);
+  if (!synth?.capabilities?.length) return entries;
+  const realBearerCaps = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.name === SYNTHETIC_CARRIER_NAME) continue;
+    for (const c of e.capabilities ?? []) realBearerCaps.add(c);
+  }
+  if (synth.capabilities.every((c) => realBearerCaps.has(c))) {
+    return entries.filter((e) => e.name !== SYNTHETIC_CARRIER_NAME);
+  }
+  return entries;
 }
 function mergeTechStack(remote, detected) {
-  const remoteResult = Array.isArray(remote) ? { repo: remote, apps: [], flat: remote } : remote;
+  const stripCarrier = (e) => e.name !== SYNTHETIC_CARRIER_NAME;
+  const cleanDetected = {
+    repo: detected.repo.filter(stripCarrier),
+    apps: detected.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: detected.flat.filter(stripCarrier)
+  };
+  const remoteResult = Array.isArray(remote) ? {
+    repo: remote.filter(stripCarrier),
+    apps: [],
+    flat: remote.filter(stripCarrier)
+  } : {
+    repo: remote.repo.filter(stripCarrier),
+    apps: remote.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: remote.flat.filter(stripCarrier)
+  };
   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) {
+  for (const entry of cleanDetected.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 flat = Array.from(seen.values()).sort(compareByCategoryThenName);
   const merged = {
-    repo: detected.repo,
-    apps: detected.apps,
+    repo: cleanDetected.repo,
+    apps: cleanDetected.apps,
     flat
   };
   return { merged, added };
@@ -1825,7 +1975,7 @@ async function scanAllDependencies(projectPath) {
   }
   return { dependencies };
 }
-var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SKIP_DIRS;
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SYNTHETIC_CARRIER_NAME, CAPABILITY_BEARER_NAMES, JSX_TEST_PATTERN, JSX_SKIP_DIRS, JSX_SCAN_DIRS, SERVER_MAIN_ENTRIES, SERVER_FRAMEWORK_DEPS, compareByCategoryThenName, SKIP_DIRS;
 var init_tech_detect = __esm({
   "src/lib/tech-detect.ts"() {
     "use strict";
@@ -1841,6 +1991,7 @@ var init_tech_detect = __esm({
       svelte: { name: "Svelte", category: "framework" },
       astro: { name: "Astro", category: "framework" },
       "@angular/core": { name: "Angular", category: "framework" },
+      "@nestjs/core": { name: "NestJS", category: "framework" },
       // Libraries (UI)
       react: { name: "React", category: "framework" },
       vue: { name: "Vue", category: "framework" },
@@ -1955,6 +2106,47 @@ var init_tech_detect = __esm({
       { file: "nx.json", rule: { name: "Nx", category: "build" } },
       { file: "lerna.json", rule: { name: "Lerna", category: "build" } }
     ];
+    SYNTHETIC_CARRIER_NAME = "__capabilities__";
+    CAPABILITY_BEARER_NAMES = /* @__PURE__ */ new Set([
+      "react",
+      "next.js",
+      "vue",
+      "svelte",
+      "solid",
+      "preact",
+      "remix",
+      "astro",
+      "angular",
+      "nestjs",
+      "nuxt",
+      "gatsby",
+      "express",
+      "fastify",
+      "hono",
+      "react native",
+      "expo"
+    ]);
+    JSX_TEST_PATTERN = /\.(test|spec)\.(tsx|jsx)$/;
+    JSX_SKIP_DIRS = /* @__PURE__ */ new Set(["__tests__", "test", "tests"]);
+    JSX_SCAN_DIRS = ["src", "app", "pages"];
+    SERVER_MAIN_ENTRIES = /* @__PURE__ */ new Set([
+      "dist/main.js",
+      "dist/server.js",
+      "dist/index.js",
+      "main.js",
+      "server.js"
+    ]);
+    SERVER_FRAMEWORK_DEPS = /* @__PURE__ */ new Set([
+      "@nestjs/core",
+      "express",
+      "fastify",
+      "hono"
+    ]);
+    compareByCategoryThenName = (a, b) => {
+      const catCmp = a.category.localeCompare(b.category);
+      if (catCmp !== 0) return catCmp;
+      return a.name.localeCompare(b.name);
+    };
     SKIP_DIRS = /* @__PURE__ */ new Set([
       "node_modules",
       ".next",
@@ -2032,30 +2224,65 @@ async function verifyPorts(projectPath, portAllocations) {
   }
   return mismatches;
 }
+function isDevServerScript(pkg) {
+  const scripts = pkg.scripts;
+  const raw = scripts?.dev;
+  if (!raw || typeof raw !== "string") return false;
+  const script = raw.trim().toLowerCase();
+  if (!script) return false;
+  for (const pattern of DEV_SERVER_BIN_PATTERNS) {
+    if (pattern.test(script)) return true;
+  }
+  const tokens = script.split(/\s+/);
+  for (const token of tokens) {
+    if (token === "--port" || token === "-p") return true;
+    if (token.startsWith("--port=")) return true;
+  }
+  return false;
+}
+function labelMatchesAppName(label, appName) {
+  if (!label || !appName) return false;
+  const normalize = (s) => s.toLowerCase().replace(/-/g, " ").replace(/[()]/g, " ").replace(/\s+/g, " ").trim();
+  const labelTokens = normalize(label).split(" ").filter(Boolean);
+  const appToken = normalize(appName);
+  if (!appToken) return false;
+  const appTokens = appToken.split(" ").filter(Boolean);
+  if (appTokens.length === 1) {
+    return labelTokens.includes(appTokens[0]);
+  }
+  for (let i = 0; i <= labelTokens.length - appTokens.length; i++) {
+    if (appTokens.every((t, j) => labelTokens[i + j] === t)) return true;
+  }
+  return false;
+}
 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;
+    if (portAllocations.some((a) => labelMatchesAppName(a.label ?? "", app.name))) {
+      continue;
+    }
+    let pkg;
     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
-      });
+      pkg = JSON.parse(raw);
     } catch {
+      continue;
     }
+    if (!isDevServerScript(pkg)) continue;
+    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
+    });
   }
   return unallocated;
 }
@@ -2066,16 +2293,46 @@ function getAppLabel(relativePath) {
   }
   return "root";
 }
+var DEV_SERVER_BIN_PATTERNS;
 var init_port_verify = __esm({
   "src/lib/port-verify.ts"() {
     "use strict";
     init_tech_detect();
     init_server_detect();
+    DEV_SERVER_BIN_PATTERNS = [
+      /\bnext\s+dev\b/,
+      /\bnest\s+start\b/,
+      /\bvite\s+(?:dev|serve)\b/,
+      /\bvite\s+preview\b/,
+      /\bnuxt\s+dev\b/,
+      /\b(?:svelte-kit|sveltekit)\s+dev\b/,
+      /\bexpo\s+start\b/
+    ];
   }
 });
 
 // src/lib/eslint-generator.ts
 import { createHash } from "node:crypto";
+function importedIdentifiers(importLines) {
+  const names = /* @__PURE__ */ new Set();
+  for (const line of importLines) {
+    let m = line.match(/^import\s+([A-Za-z_$][\w$]*)\s+from/);
+    if (m) names.add(m[1]);
+    m = line.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from/);
+    if (m) names.add(m[1]);
+    m = line.match(/^import\s*\{([^}]*)\}\s*from/);
+    if (m) {
+      for (const entry of m[1].split(",")) {
+        const parts = entry.trim().split(/\s+as\s+/);
+        const n = (parts[1] ?? parts[0]).trim();
+        if (n) names.add(n);
+      }
+    }
+    m = line.match(/^const\s+([A-Za-z_$][\w$]*)\s*=\s*require/);
+    if (m) names.add(m[1]);
+  }
+  return names;
+}
 function parseFragment(fragment) {
   if (!fragment) return { imports: [], configComments: [] };
   const lines = fragment.split("\n");
@@ -2125,7 +2382,7 @@ function collectDependencies(presets) {
 function hashConfig(content) {
   return createHash("sha256").update(content).digest("hex");
 }
-function buildRules(presets, userOverrides) {
+function buildRules(presets) {
   const merged = {};
   for (const preset of presets) {
     const rules = preset.rules;
@@ -2133,11 +2390,30 @@ function buildRules(presets, userOverrides) {
       Object.assign(merged, rules);
     }
   }
-  if (userOverrides) {
-    Object.assign(merged, userOverrides);
-  }
   return merged;
 }
+function splitRulesByPlugin(rules, hasNextJs) {
+  const reactHooks = {};
+  const reactOrA11y = {};
+  const importPlugin = {};
+  const generic = {};
+  for (const [key, value] of Object.entries(rules)) {
+    if (key.startsWith("react-hooks/") || key.startsWith("react-compiler/")) {
+      reactHooks[key] = value;
+    } else if (key.startsWith("react/") || key.startsWith("jsx-a11y/")) {
+      reactOrA11y[key] = value;
+    } else if (key.startsWith("import/")) {
+      if (hasNextJs) {
+        importPlugin[key] = value;
+      } else {
+        generic[key] = value;
+      }
+    } else {
+      generic[key] = value;
+    }
+  }
+  return { reactHooks, reactOrA11y, importPlugin, generic };
+}
 function formatRules(rules, indent) {
   const entries = Object.entries(rules);
   if (entries.length === 0) return "{}";
@@ -2151,6 +2427,7 @@ ${indent}}`;
 }
 function generateEslintConfig(input) {
   const { presets, ruleOverrides, tsconfigRootDir, ignorePatterns } = input;
+  const hasNextJs = presets.some((p) => p.is_system && p.name === "nextjs");
   const allImports = [];
   const allConfigComments = [];
   for (const preset of presets) {
@@ -2163,7 +2440,14 @@ function generateEslintConfig(input) {
   const dedupedImports = deduplicateImports(allImports);
   const tsCheck = dedupedImports.find((i) => i === "// @ts-check");
   const importLines = dedupedImports.filter((i) => i !== "// @ts-check");
-  const rules = buildRules(presets, ruleOverrides);
+  const presetRules = buildRules(presets);
+  const userOverrides = ruleOverrides ?? {};
+  const presetRulesClean = Object.fromEntries(
+    Object.entries(presetRules).filter(
+      ([k]) => !Object.hasOwn(userOverrides, k)
+    )
+  );
+  const splitRules = splitRulesByPlugin(presetRulesClean, hasNextJs);
   const defaultIgnores = [
     "eslint.config.mjs",
     "node_modules/**",
@@ -2174,7 +2458,24 @@ function generateEslintConfig(input) {
   const ignores = [.../* @__PURE__ */ new Set([...defaultIgnores, ...ignorePatterns ?? []])];
   const rootDir = tsconfigRootDir ?? "import.meta.dirname";
   const rootDirValue = rootDir === "import.meta.dirname" ? "import.meta.dirname" : `"${rootDir}"`;
-  const hasNextJs = presets.some((p) => p.is_system && p.name === "nextjs");
+  const KNOWN_SYSTEM_PRESETS = [
+    "base",
+    "react",
+    "nextjs",
+    "node",
+    "cli",
+    "testing",
+    "testing-react",
+    "testing-e2e"
+  ];
+  for (const preset of presets) {
+    if (preset.is_system && !KNOWN_SYSTEM_PRESETS.includes(preset.name) && !warnedPresetNames.has(preset.name)) {
+      console.warn(
+        `Unknown system preset: ${preset.name} \u2014 skipping structural emission`
+      );
+      warnedPresetNames.add(preset.name);
+    }
+  }
   const hasReact = presets.some((p) => p.is_system && p.name === "react");
   const hasNode = presets.some((p) => p.is_system && p.name === "node");
   const hasTesting = presets.some((p) => p.is_system && p.name === "testing");
@@ -2204,8 +2505,9 @@ function generateEslintConfig(input) {
   if ((hasNode || hasReact || hasNextJs) && !hasGlobalsImport) {
     sections.push('import globals from "globals";');
   }
+  sections.push('import { defineConfig } from "eslint/config";');
   sections.push("");
-  sections.push("export default [");
+  sections.push("export default defineConfig([");
   sections.push(`  { ignores: ${JSON.stringify(ignores)} },`);
   sections.push("");
   const hasBase = presets.some((p) => p.is_system && p.name === "base");
@@ -2226,11 +2528,43 @@ function generateEslintConfig(input) {
     sections.push("");
   }
   if (hasNextJs) {
+    const bindings = importedIdentifiers(importLines);
+    const nextFusedRules = {
+      ...splitRules.reactHooks,
+      ...splitRules.importPlugin
+    };
     sections.push("  // Next.js: Core Web Vitals + TypeScript");
     sections.push("  ...nextCoreWebVitals,");
     sections.push("  ...nextTypescript,");
-    sections.push("  { rules: jsxA11y.flatConfigs.strict.rules },");
-    sections.push('  { plugins: { "react-compiler": reactCompiler } },');
+    if (bindings.has("jsxA11y")) {
+      sections.push("  { rules: jsxA11y.flatConfigs.strict.rules },");
+    } else {
+      console.warn(
+        "eslint-generator: skipping `jsxA11y.flatConfigs.strict.rules` emission \u2014 `jsxA11y` binding missing from nextjs preset config_fragment. See CHK-087 TASK-4/TASK-5."
+      );
+    }
+    if (Object.keys(nextFusedRules).length > 0) {
+      sections.push("  {");
+      sections.push('    plugins: { "react-compiler": reactCompiler },');
+      sections.push(`    rules: ${formatRules(nextFusedRules, "    ")},`);
+      sections.push("  },");
+    } else {
+      sections.push('  { plugins: { "react-compiler": reactCompiler } },');
+    }
+    if (Object.keys(splitRules.reactOrA11y).length > 0) {
+      if (bindings.has("react") && bindings.has("jsxA11y")) {
+        sections.push("  {");
+        sections.push('    plugins: { react, "jsx-a11y": jsxA11y },');
+        sections.push(
+          `    rules: ${formatRules(splitRules.reactOrA11y, "    ")},`
+        );
+        sections.push("  },");
+      } else {
+        console.warn(
+          "eslint-generator: skipping defensive reactOrA11y block \u2014 requires both `react` and `jsxA11y` bindings from nextjs preset config_fragment. See CHK-087 TASK-4/TASK-5."
+        );
+      }
+    }
     sections.push("");
   }
   if (hasReact && !hasNextJs) {
@@ -2250,6 +2584,12 @@ function generateEslintConfig(input) {
     sections.push("    rules: {");
     sections.push("      ...react.configs.flat.recommended.rules,");
     sections.push('      ...react.configs.flat["jsx-runtime"].rules,');
+    for (const [key, value] of Object.entries(splitRules.reactHooks)) {
+      sections.push(`      "${key}": ${JSON.stringify(value)},`);
+    }
+    for (const [key, value] of Object.entries(splitRules.reactOrA11y)) {
+      sections.push(`      "${key}": ${JSON.stringify(value)},`);
+    }
     sections.push("    },");
     sections.push("  },");
     sections.push("  jsxA11y.flatConfigs.strict,");
@@ -2270,10 +2610,14 @@ function generateEslintConfig(input) {
     sections.push("  prettier,");
     sections.push("");
   }
-  if (Object.keys(rules).length > 0) {
+  const overridesCombined = {
+    ...splitRules.generic,
+    ...userOverrides
+  };
+  if (Object.keys(overridesCombined).length > 0) {
     sections.push("  // Rule overrides");
     sections.push("  {");
-    sections.push(`    rules: ${formatRules(rules, "    ")},`);
+    sections.push(`    rules: ${formatRules(overridesCombined, "    ")},`);
     sections.push("  },");
     sections.push("");
   }
@@ -2335,25 +2679,28 @@ function generateEslintConfig(input) {
     sections.push("  },");
     sections.push("");
   }
-  sections.push("];");
+  sections.push("]);");
   sections.push("");
   return sections.join("\n");
 }
+var warnedPresetNames;
 var init_eslint_generator = __esm({
   "src/lib/eslint-generator.ts"() {
     "use strict";
+    warnedPresetNames = /* @__PURE__ */ new Set();
   }
 });
 
 // src/cli/eslint.ts
 var eslint_exports = {};
 __export(eslint_exports, {
+  autoDetectIgnorePatterns: () => autoDetectIgnorePatterns,
   checkEslintDrift: () => checkEslintDrift,
   eslintInit: () => eslintInit,
   eslintSync: () => eslintSync,
   runEslint: () => runEslint
 });
-import { readFile as readFile8, writeFile as writeFile3, access as access2 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile3, access as access2, readdir as readdir5 } from "node:fs/promises";
 import { join as join7, relative as relative2 } from "node:path";
 async function fileExists2(filePath) {
   try {
@@ -2363,6 +2710,46 @@ async function fileExists2(filePath) {
     return false;
   }
 }
+async function autoDetectIgnorePatterns(absPath) {
+  const patterns = [];
+  if (await fileExists2(join7(absPath, "esbuild.js"))) {
+    patterns.push("esbuild.js");
+  }
+  let entries = [];
+  try {
+    entries = await readdir5(absPath);
+  } catch (err) {
+    console.error(
+      `  autoDetectIgnorePatterns: failed to read ${absPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    entries = [];
+  }
+  const esbuildVariant = /^esbuild\.[^.]+\.(mjs|cjs|js)$/;
+  for (const name of entries) {
+    if (esbuildVariant.test(name)) {
+      patterns.push(name);
+    }
+  }
+  for (const ext of ["ts", "mts", "js", "mjs"]) {
+    const candidate = `vitest.config.${ext}`;
+    if (await fileExists2(join7(absPath, candidate))) {
+      patterns.push(candidate);
+      break;
+    }
+  }
+  for (const ext of ["ts", "mts", "js", "mjs"]) {
+    const candidate = `vite.config.${ext}`;
+    if (await fileExists2(join7(absPath, candidate))) {
+      patterns.push(candidate);
+      break;
+    }
+  }
+  if (await fileExists2(join7(absPath, "tauri.conf.json"))) {
+    patterns.push("src-tauri/**");
+    patterns.push("**/*.d.ts");
+  }
+  return patterns;
+}
 function detectPackageManager(projectPath) {
   return (async () => {
     if (await fileExists2(join7(projectPath, "pnpm-lock.yaml"))) return "pnpm";
@@ -2393,11 +2780,13 @@ function buildInstallCommand(pm, packages, workspaceRoot) {
       return `npm install -D ${pkgStr}`;
   }
 }
-async function resolvePresetsForTechStack(techNames) {
+async function resolvePresetsForTechStack(techNames, capabilities = []) {
   const techParam = techNames.join(",");
-  const res = await apiGet("/eslint-presets", {
-    tech_stack: techParam
-  });
+  const query = { tech_stack: techParam };
+  if (capabilities.length > 0) {
+    query.capabilities = capabilities.join(",");
+  }
+  const res = await apiGet("/eslint-presets", query);
   return res.data ?? [];
 }
 async function eslintInit(repoId, projectPath) {
@@ -2432,19 +2821,27 @@ async function eslintInit(repoId, projectPath) {
   const allRequiredDeps = /* @__PURE__ */ new Map();
   const configsToWrite = [];
   for (const target of targets) {
-    const techNames = target.techStack.map((t) => t.name);
+    const techNames = target.techStack.map((t) => t.name).filter((n) => n !== SYNTHETIC_CARRIER_NAME);
+    const capabilities = collectCapabilities(target.techStack);
     console.log(
       `  ${target.name}: ${techNames.length > 0 ? techNames.join(", ") : "(no tech detected)"}`
     );
-    if (techNames.length === 0) {
-      console.log(`    Skipping \u2014 no tech stack detected.
-`);
+    if (capabilities.length > 0) {
+      console.log(`    Capabilities: ${capabilities.join(", ")}`);
+    }
+    if (techNames.length === 0 && capabilities.length === 0) {
+      console.log(
+        `    Skipping ${target.name}: no tech or capabilities detected
+`
+      );
       continue;
     }
-    const presets = await resolvePresetsForTechStack(techNames);
+    const presets = await resolvePresetsForTechStack(techNames, capabilities);
     if (presets.length === 0) {
-      console.log(`    No matching presets found.
-`);
+      console.log(
+        `    No preset matches ${target.name}; skipping (override via --force-preset if needed)
+`
+      );
       continue;
     }
     console.log(`    Presets: ${presets.map((p) => p.name).join(", ")}`);
@@ -2465,9 +2862,14 @@ async function eslintInit(repoId, projectPath) {
       }
     } catch {
     }
+    const detectedIgnores = await autoDetectIgnorePatterns(target.absPath);
+    if (detectedIgnores.length > 0) {
+      console.log(`    Auto-ignore: ${detectedIgnores.join(", ")}`);
+    }
     const content = generateEslintConfig({
       presets,
-      ruleOverrides: userOverrides
+      ruleOverrides: userOverrides,
+      ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
     const configPath = join7(target.absPath, "eslint.config.mjs");
@@ -2621,8 +3023,12 @@ async function eslintSync(repoId, projectPath) {
     const absPath = config.source_path === "." ? projectPath : join7(projectPath, config.source_path);
     const configPath = join7(absPath, "eslint.config.mjs");
     const detected = await detectTechStack(absPath);
-    const techNames = detected.flat.map((t) => t.name);
-    const currentPresets = await resolvePresetsForTechStack(techNames);
+    const techNames = detected.flat.map((t) => t.name).filter((n) => n !== SYNTHETIC_CARRIER_NAME);
+    const capabilities = collectCapabilities(detected.flat);
+    const currentPresets = await resolvePresetsForTechStack(
+      techNames,
+      capabilities
+    );
     const currentPresetIds = currentPresets.map((p) => p.id).sort();
     const savedPresetIds = [...config.active_preset_ids ?? []].sort();
     const presetsChanged = currentPresetIds.length !== savedPresetIds.length || currentPresetIds.some((id) => !savedPresetIds.includes(id));
@@ -2651,11 +3057,15 @@ async function eslintSync(repoId, projectPath) {
         );
       }
     }
-    console.log(`  ${config.source_path}: presets changed, regenerating...`);
+    if (presetsChanged) {
+      console.log(`  ${config.source_path}: presets changed, regenerating...`);
+    }
     const userOverrides = config.rule_overrides;
+    const detectedIgnores = await autoDetectIgnorePatterns(absPath);
     const content = generateEslintConfig({
       presets: currentPresets,
-      ruleOverrides: userOverrides && Object.keys(userOverrides).length > 0 ? userOverrides : void 0
+      ruleOverrides: userOverrides && Object.keys(userOverrides).length > 0 ? userOverrides : void 0,
+      ignorePatterns: detectedIgnores
     });
     try {
       await writeFile3(configPath, content, "utf-8");
@@ -2823,7 +3233,10 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
-  } catch {
+  } catch (err) {
+    console.warn(
+      `  Local file scan incomplete: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
   const [defaultsRes, repoSyncRes, repoRes, , fileReposRes] = await Promise.all(
     [
@@ -3142,7 +3555,10 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
             repo_id: repoId,
             file_repos: fileRepoUpdates
           });
-        } catch {
+        } catch (err) {
+          console.warn(
+            `  Warning: failed to update file-repo tracking for ${fileRepoUpdates.length} files: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
       }
       console.log(
@@ -3298,7 +3714,10 @@ async function syncConfig(repoId, projectPath, dryRun) {
       }
       return clean;
     });
-  } catch {
+  } catch (err) {
+    console.warn(
+      `  Warning: failed to fetch port allocations: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
   const worktreeId = currentConfig.worktree_id;
   const matchingAlloc = portAllocations[0];
@@ -3363,8 +3782,10 @@ async function syncTechStack(repoId, projectPath, dryRun) {
         }
       }
     }
-  } catch {
-    console.log("    Tech stack detection skipped.");
+  } catch (err) {
+    console.warn(
+      `    Tech stack detection skipped: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 async function syncEslintDriftCheck(repoId, projectPath) {
@@ -3442,8 +3863,10 @@ async function syncPortVerification(repoId, projectPath, dryRun, fix) {
     if (mismatches.length === 0 && unallocated.length === 0) {
       console.log("    Ports verified.");
     }
-  } catch {
-    console.log("    Port verification skipped.");
+  } catch (err) {
+    console.warn(
+      `    Port verification skipped: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 function groupByType(items) {
@@ -3498,7 +3921,7 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
 }
 function getSyncVersion() {
   try {
-    return "1.4.1";
+    return "1.4.2";
   } catch {
     return "unknown";
   }
@@ -3554,68 +3977,69 @@ var init_sync = __esm({
 // 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;
+import { resolve as resolve2 } from "node:path";
+void (async () => {
+  if (!process.env.CODEBYPLAN_API_KEY) {
+    try {
+      const envPath = resolve2(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 {
     }
-  } 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);
+  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
+    );
+  }
+  const 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;
     }
-    throw err;
+    process.exit(0);
   }
-  process.exit(0);
-}
-if (arg === "eslint") {
-  const { runEslint: runEslint2 } = await Promise.resolve().then(() => (init_eslint(), eslint_exports));
-  const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
-  try {
-    await runEslint2();
-  } catch (err) {
-    if (err instanceof SyncCancelledError2) {
-      console.log("\n  Cancelled.\n");
-      process.exit(0);
+  if (arg === "eslint") {
+    const { runEslint: runEslint2 } = await Promise.resolve().then(() => (init_eslint(), eslint_exports));
+    const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
+    try {
+      await runEslint2();
+    } catch (err) {
+      if (err instanceof SyncCancelledError2) {
+        console.log("\n  Cancelled.\n");
+        process.exit(0);
+      }
+      throw err;
     }
-    throw err;
+    process.exit(0);
   }
-  process.exit(0);
-}
-if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
-  console.log(`
+  if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
+    console.log(`
   CodeByPlan CLI v${VERSION}
 
   Usage:
@@ -3638,13 +4062,14 @@ if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
 
   MCP Server:
     Claude Code connects to CodeByPlan via remote MCP:
-      URL: https://codebyplan.com/mcp
+      URL: https://www.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);
+    process.exit(0);
+  }
+  console.error(`Unknown command: ${arg}`);
+  console.error("Run 'codebyplan help' for usage.");
+  process.exit(1);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc --project tsconfig.build.json",
     "build:npm": "node esbuild.npm.mjs",
     "prepublishOnly": "npm run build:npm",
     "lint": "eslint",
@@ -47,7 +47,7 @@
     "@eslint/js": "^9.18.0",
     "@types/node": "^20",
     "@vitest/eslint-plugin": "^1.1.44",
-    "esbuild": "^0.25",
+    "esbuild": "^0.28",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-no-secrets": "^2.2.1",