codebyplan 1.3.1 → 1.4.1

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.3.1";
+    VERSION = "1.4.1";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -2074,16 +2074,686 @@ var init_port_verify = __esm({
   }
 });
 
+// src/lib/eslint-generator.ts
+import { createHash } from "node:crypto";
+function parseFragment(fragment) {
+  if (!fragment) return { imports: [], configComments: [] };
+  const lines = fragment.split("\n");
+  const imports = [];
+  const configComments = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("import ") || trimmed.startsWith("const ") || trimmed.startsWith("// @ts-check")) {
+      imports.push(trimmed);
+    } else if (trimmed.startsWith("//")) {
+      configComments.push(trimmed);
+    }
+  }
+  return { imports, configComments };
+}
+function importKey(line) {
+  const fromMatch = line.match(/from\s+["']([^"']+)["']/);
+  if (fromMatch) return fromMatch[1];
+  const requireMatch = line.match(/require\(["']([^"']+)["']\)/);
+  if (requireMatch) return requireMatch[1];
+  return line;
+}
+function deduplicateImports(allImports) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const imp of allImports) {
+    const key = importKey(imp);
+    if (!seen.has(key)) {
+      seen.set(key, imp);
+    }
+  }
+  return Array.from(seen.values());
+}
+function collectDependencies(presets) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const preset of presets) {
+    const presetDeps = preset.dependencies;
+    if (!presetDeps || typeof presetDeps !== "object") continue;
+    for (const [pkg, version] of Object.entries(presetDeps)) {
+      if (typeof version === "string" && !deps.has(pkg)) {
+        deps.set(pkg, version);
+      }
+    }
+  }
+  return deps;
+}
+function hashConfig(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function buildRules(presets, userOverrides) {
+  const merged = {};
+  for (const preset of presets) {
+    const rules = preset.rules;
+    if (rules && typeof rules === "object") {
+      Object.assign(merged, rules);
+    }
+  }
+  if (userOverrides) {
+    Object.assign(merged, userOverrides);
+  }
+  return merged;
+}
+function formatRules(rules, indent) {
+  const entries = Object.entries(rules);
+  if (entries.length === 0) return "{}";
+  const lines = entries.map(([key, value]) => {
+    const formattedValue = JSON.stringify(value);
+    return `${indent}  "${key}": ${formattedValue},`;
+  });
+  return `{
+${lines.join("\n")}
+${indent}}`;
+}
+function generateEslintConfig(input) {
+  const { presets, ruleOverrides, tsconfigRootDir, ignorePatterns } = input;
+  const allImports = [];
+  const allConfigComments = [];
+  for (const preset of presets) {
+    const parsed = parseFragment(preset.config_fragment);
+    allImports.push(...parsed.imports);
+    allConfigComments.push(
+      ...parsed.configComments.map((c) => `  ${c} (from: ${preset.name})`)
+    );
+  }
+  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 defaultIgnores = [
+    "eslint.config.mjs",
+    "node_modules/**",
+    "dist/**",
+    ".next/**",
+    "coverage/**"
+  ];
+  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 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");
+  const hasTestingReact = presets.some(
+    (p) => p.is_system && p.name === "testing-react"
+  );
+  const hasTestingE2e = presets.some(
+    (p) => p.is_system && p.name === "testing-e2e"
+  );
+  const hasCli = presets.some((p) => p.is_system && p.name === "cli");
+  const sections = [];
+  if (tsCheck) {
+    sections.push("// @ts-check");
+  }
+  sections.push(
+    "/**",
+    " * ESLint flat config \u2014 generated by CodeByPlan CLI.",
+    " * Edit rule overrides via the web UI, then run `codebyplan eslint sync`.",
+    " * Manual edits will be detected as drift.",
+    " */",
+    ""
+  );
+  for (const imp of importLines) {
+    sections.push(imp);
+  }
+  const hasGlobalsImport = importLines.some((i) => i.includes("globals"));
+  if ((hasNode || hasReact || hasNextJs) && !hasGlobalsImport) {
+    sections.push('import globals from "globals";');
+  }
+  sections.push("");
+  sections.push("export default [");
+  sections.push(`  { ignores: ${JSON.stringify(ignores)} },`);
+  sections.push("");
+  const hasBase = presets.some((p) => p.is_system && p.name === "base");
+  if (hasBase) {
+    sections.push("  // Base: TypeScript + security + Prettier");
+    sections.push("  eslint.configs.recommended,");
+    sections.push("  ...tseslint.configs.recommendedTypeChecked,");
+    sections.push("  security.configs.recommended,");
+    sections.push('  { plugins: { "no-secrets": noSecrets } },');
+    sections.push("  {");
+    sections.push("    languageOptions: {");
+    sections.push("      parserOptions: {");
+    sections.push("        projectService: true,");
+    sections.push(`        tsconfigRootDir: ${rootDirValue},`);
+    sections.push("      },");
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasNextJs) {
+    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 } },');
+    sections.push("");
+  }
+  if (hasReact && !hasNextJs) {
+    sections.push("  // React: hooks + compiler + a11y");
+    sections.push("  {");
+    sections.push('    files: ["**/*.{ts,tsx,jsx}"],');
+    sections.push("    plugins: {");
+    sections.push("      react,");
+    sections.push('      "react-hooks": reactHooks,');
+    sections.push('      "react-compiler": reactCompiler,');
+    sections.push("    },");
+    sections.push("    languageOptions: {");
+    sections.push("      parserOptions: { ecmaFeatures: { jsx: true } },");
+    sections.push("      globals: { ...globals.browser },");
+    sections.push("    },");
+    sections.push('    settings: { react: { version: "detect" } },');
+    sections.push("    rules: {");
+    sections.push("      ...react.configs.flat.recommended.rules,");
+    sections.push('      ...react.configs.flat["jsx-runtime"].rules,');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("  jsxA11y.flatConfigs.strict,");
+    sections.push("");
+  }
+  if (hasNode) {
+    sections.push("  // Node.js globals");
+    sections.push("  {");
+    sections.push("    languageOptions: {");
+    sections.push("      globals: { ...globals.node },");
+    sections.push('      sourceType: "module",');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasBase) {
+    sections.push("  // Prettier (must be last base config)");
+    sections.push("  prettier,");
+    sections.push("");
+  }
+  if (Object.keys(rules).length > 0) {
+    sections.push("  // Rule overrides");
+    sections.push("  {");
+    sections.push(`    rules: ${formatRules(rules, "    ")},`);
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasCli) {
+    sections.push("  // CLI overrides");
+    sections.push("  {");
+    sections.push("    rules: {");
+    sections.push('      "no-console": "off",');
+    sections.push('      "security/detect-non-literal-fs-filename": "off",');
+    sections.push('      "security/detect-object-injection": "off",');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasTesting) {
+    sections.push("  // Testing: Vitest");
+    sections.push("  {");
+    sections.push(
+      '    files: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx"],'
+    );
+    sections.push("    plugins: { vitest },");
+    sections.push("    rules: {");
+    sections.push("      ...vitest.configs.recommended.rules,");
+    sections.push('      "@typescript-eslint/no-explicit-any": "off",');
+    sections.push('      "@typescript-eslint/no-unsafe-assignment": "off",');
+    sections.push('      "@typescript-eslint/no-unsafe-member-access": "off",');
+    sections.push('      "@typescript-eslint/no-unsafe-call": "off",');
+    sections.push('      "@typescript-eslint/no-unsafe-argument": "off",');
+    sections.push('      "@typescript-eslint/no-unsafe-return": "off",');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasTestingReact) {
+    sections.push("  // Testing: React Testing Library + jest-dom");
+    sections.push("  {");
+    sections.push(
+      '    files: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx"],'
+    );
+    sections.push(
+      '    plugins: { "testing-library": testingLibrary, "jest-dom": jestDom },'
+    );
+    sections.push("    rules: {");
+    sections.push('      ...testingLibrary.configs["flat/react"].rules,');
+    sections.push('      ...jestDom.configs["flat/recommended"].rules,');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  if (hasTestingE2e) {
+    sections.push("  // Testing: Playwright E2E");
+    sections.push("  {");
+    sections.push('    files: ["e2e/**"],');
+    sections.push("    plugins: { playwright },");
+    sections.push("    rules: {");
+    sections.push('      ...playwright.configs["flat/recommended"].rules,');
+    sections.push('      "no-console": "off",');
+    sections.push("    },");
+    sections.push("  },");
+    sections.push("");
+  }
+  sections.push("];");
+  sections.push("");
+  return sections.join("\n");
+}
+var init_eslint_generator = __esm({
+  "src/lib/eslint-generator.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/eslint.ts
+var eslint_exports = {};
+__export(eslint_exports, {
+  checkEslintDrift: () => checkEslintDrift,
+  eslintInit: () => eslintInit,
+  eslintSync: () => eslintSync,
+  runEslint: () => runEslint
+});
+import { readFile as readFile8, writeFile as writeFile3, access as access2 } from "node:fs/promises";
+import { join as join7, relative as relative2 } from "node:path";
+async function fileExists2(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(projectPath) {
+  return (async () => {
+    if (await fileExists2(join7(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join7(projectPath, "yarn.lock"))) return "yarn";
+    return "npm";
+  })();
+}
+async function getInstalledDeps(pkgJsonPath) {
+  try {
+    const raw = await readFile8(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const all = /* @__PURE__ */ new Set();
+    for (const name of Object.keys(pkg.dependencies ?? {})) all.add(name);
+    for (const name of Object.keys(pkg.devDependencies ?? {})) all.add(name);
+    return all;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function buildInstallCommand(pm, packages, workspaceRoot) {
+  const pkgStr = packages.join(" ");
+  switch (pm) {
+    case "pnpm":
+      return workspaceRoot ? `pnpm add -D -w ${pkgStr}` : `pnpm add -D ${pkgStr}`;
+    case "yarn":
+      return workspaceRoot ? `yarn add -D -W ${pkgStr}` : `yarn add -D ${pkgStr}`;
+    case "npm":
+      return `npm install -D ${pkgStr}`;
+  }
+}
+async function resolvePresetsForTechStack(techNames) {
+  const techParam = techNames.join(",");
+  const res = await apiGet("/eslint-presets", {
+    tech_stack: techParam
+  });
+  return res.data ?? [];
+}
+async function eslintInit(repoId, projectPath) {
+  console.log("\n  ESLint Init");
+  console.log(`  Repo: ${repoId}`);
+  console.log(`  Path: ${projectPath}
+`);
+  const apps = await discoverMonorepoApps(projectPath);
+  const isMonorepo = apps.length > 0;
+  const targets = [];
+  if (isMonorepo) {
+    console.log(`  Monorepo detected: ${apps.length} apps/packages
+`);
+    for (const app of apps) {
+      const detected = await detectTechStack(app.absPath);
+      targets.push({
+        name: app.name,
+        sourcePath: app.path,
+        absPath: app.absPath,
+        techStack: detected.flat
+      });
+    }
+  } else {
+    const detected = await detectTechStack(projectPath);
+    targets.push({
+      name: "root",
+      sourcePath: ".",
+      absPath: projectPath,
+      techStack: detected.flat
+    });
+  }
+  const allRequiredDeps = /* @__PURE__ */ new Map();
+  const configsToWrite = [];
+  for (const target of targets) {
+    const techNames = target.techStack.map((t) => t.name);
+    console.log(
+      `  ${target.name}: ${techNames.length > 0 ? techNames.join(", ") : "(no tech detected)"}`
+    );
+    if (techNames.length === 0) {
+      console.log(`    Skipping \u2014 no tech stack detected.
+`);
+      continue;
+    }
+    const presets = await resolvePresetsForTechStack(techNames);
+    if (presets.length === 0) {
+      console.log(`    No matching presets found.
+`);
+      continue;
+    }
+    console.log(`    Presets: ${presets.map((p) => p.name).join(", ")}`);
+    let userOverrides;
+    try {
+      const configRes = await apiGet(`/repos/${repoId}/eslint-config`);
+      const existing = configRes.data?.find(
+        (c) => c.source_path === target.sourcePath
+      );
+      if (existing?.rule_overrides) {
+        const overrides = existing.rule_overrides;
+        if (Object.keys(overrides).length > 0) {
+          userOverrides = overrides;
+          console.log(
+            `    User overrides: ${Object.keys(overrides).length} rule(s)`
+          );
+        }
+      }
+    } catch {
+    }
+    const content = generateEslintConfig({
+      presets,
+      ruleOverrides: userOverrides
+    });
+    const hash = hashConfig(content);
+    const configPath = join7(target.absPath, "eslint.config.mjs");
+    configsToWrite.push({
+      target,
+      presets,
+      content,
+      hash,
+      configPath,
+      userOverrides
+    });
+    const deps = collectDependencies(presets);
+    for (const [pkg, version] of deps) {
+      if (!allRequiredDeps.has(pkg)) {
+        allRequiredDeps.set(pkg, version);
+      }
+    }
+    console.log("");
+  }
+  if (configsToWrite.length === 0) {
+    console.log("  No configs to generate.\n");
+    return;
+  }
+  const pm = await detectPackageManager(projectPath);
+  const rootPkgJsonPath = join7(projectPath, "package.json");
+  const installed = await getInstalledDeps(rootPkgJsonPath);
+  if (isMonorepo) {
+    for (const { target } of configsToWrite) {
+      const appPkgJson = join7(target.absPath, "package.json");
+      const appDeps = await getInstalledDeps(appPkgJson);
+      for (const dep of appDeps) {
+        installed.add(dep);
+      }
+    }
+  }
+  const missingPkgs = [];
+  for (const [pkg] of allRequiredDeps) {
+    if (!installed.has(pkg)) {
+      missingPkgs.push(pkg);
+    }
+  }
+  if (missingPkgs.length > 0) {
+    console.log(`  Missing npm packages (${missingPkgs.length}):`);
+    for (const pkg of missingPkgs) {
+      console.log(`    - ${pkg}`);
+    }
+    const installCmd = buildInstallCommand(pm, missingPkgs, isMonorepo);
+    console.log(`
+  Install command: ${installCmd}`);
+    const confirmed = await confirmProceed(
+      `
+  Install ${missingPkgs.length} missing packages? [Y/n] `
+    );
+    if (confirmed) {
+      const { execSync } = await import("node:child_process");
+      try {
+        execSync(installCmd, { cwd: projectPath, stdio: "inherit" });
+        console.log("  Packages installed.\n");
+      } catch (err) {
+        console.error(
+          `  Package installation failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        console.log("  You can install manually and re-run.\n");
+      }
+    } else {
+      console.log(
+        "  Skipping installation. Generated configs may not work without these packages.\n"
+      );
+    }
+  }
+  for (const {
+    target,
+    presets,
+    content,
+    hash,
+    configPath,
+    userOverrides
+  } of configsToWrite) {
+    if (await fileExists2(configPath)) {
+      try {
+        const existing = await readFile8(configPath, "utf-8");
+        const existingHash = hashConfig(existing);
+        if (existingHash === hash) {
+          console.log(
+            `  ${target.name}: eslint.config.mjs already up to date.`
+          );
+          continue;
+        }
+      } catch {
+      }
+      const overwrite = await confirmProceed(
+        `  ${target.name}: eslint.config.mjs already exists. Overwrite? [Y/n] `
+      );
+      if (!overwrite) {
+        console.log(`  ${target.name}: Skipped.
+`);
+        continue;
+      }
+    }
+    try {
+      await writeFile3(configPath, content, "utf-8");
+    } catch (err) {
+      console.error(
+        `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
+    console.log(`  ${target.name}: wrote ${relative2(projectPath, configPath)}`);
+    try {
+      await apiPut(`/repos/${repoId}/eslint-config`, {
+        source_path: target.sourcePath,
+        preset_ids: presets.map((p) => p.id),
+        rule_overrides: userOverrides ?? {},
+        generated_hash: hash
+      });
+    } catch (err) {
+      console.error(
+        `  Warning: Failed to save config to server: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  console.log("\n  ESLint init complete.\n");
+}
+async function eslintSync(repoId, projectPath) {
+  console.log("\n  ESLint Sync");
+  console.log(`  Repo: ${repoId}`);
+  console.log(`  Path: ${projectPath}
+`);
+  let configs;
+  try {
+    const res = await apiGet(
+      `/repos/${repoId}/eslint-config`
+    );
+    configs = res.data ?? [];
+  } catch {
+    console.log(
+      "  No existing ESLint config found. Run `codebyplan eslint init` first.\n"
+    );
+    return;
+  }
+  if (configs.length === 0) {
+    console.log(
+      "  No ESLint configs registered. Run `codebyplan eslint init` first.\n"
+    );
+    return;
+  }
+  let updatedCount = 0;
+  let skippedCount = 0;
+  let driftCount = 0;
+  for (const config of configs) {
+    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 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));
+    if (!presetsChanged) {
+      if (await fileExists2(configPath)) {
+        try {
+          const currentContent = await readFile8(configPath, "utf-8");
+          const currentHash = hashConfig(currentContent);
+          if (config.generated_hash && currentHash !== config.generated_hash) {
+            console.log(
+              `  ${config.source_path}: drift detected (manually edited). Not overwriting.`
+            );
+            driftCount++;
+            continue;
+          }
+          skippedCount++;
+          continue;
+        } catch {
+          console.warn(
+            `  ${config.source_path}: config file unreadable, regenerating...`
+          );
+        }
+      } else {
+        console.log(
+          `  ${config.source_path}: config file missing, regenerating...`
+        );
+      }
+    }
+    console.log(`  ${config.source_path}: presets changed, regenerating...`);
+    const userOverrides = config.rule_overrides;
+    const content = generateEslintConfig({
+      presets: currentPresets,
+      ruleOverrides: userOverrides && Object.keys(userOverrides).length > 0 ? userOverrides : void 0
+    });
+    try {
+      await writeFile3(configPath, content, "utf-8");
+    } catch (err) {
+      console.error(
+        `  ${config.source_path}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
+    const newHash = hashConfig(content);
+    try {
+      await apiPut(`/repos/${repoId}/eslint-config`, {
+        source_path: config.source_path,
+        preset_ids: currentPresetIds,
+        rule_overrides: userOverrides ?? {},
+        generated_hash: newHash
+      });
+    } catch (err) {
+      console.error(
+        `  Warning: Failed to update server: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    updatedCount++;
+  }
+  console.log(
+    `
+  Sync: ${updatedCount} updated, ${skippedCount} unchanged, ${driftCount} drift detected.
+`
+  );
+}
+async function checkEslintDrift(repoId, projectPath) {
+  try {
+    const res = await apiGet(
+      `/repos/${repoId}/eslint-config`
+    );
+    const configs = res.data ?? [];
+    for (const config of configs) {
+      if (!config.generated_hash) continue;
+      const absPath = config.source_path === "." ? projectPath : join7(projectPath, config.source_path);
+      const configPath = join7(absPath, "eslint.config.mjs");
+      if (!await fileExists2(configPath)) continue;
+      try {
+        const content = await readFile8(configPath, "utf-8");
+        const currentHash = hashConfig(content);
+        if (currentHash !== config.generated_hash) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function runEslint() {
+  const subcommand = process.argv[3];
+  const flags = parseFlags(4);
+  validateApiKey();
+  const config = await resolveConfig(flags);
+  const { repoId, projectPath } = config;
+  switch (subcommand) {
+    case "init":
+      await eslintInit(repoId, projectPath);
+      break;
+    case "sync":
+      await eslintSync(repoId, projectPath);
+      break;
+    default:
+      console.log(`
+  Usage:
+    codebyplan eslint init     Detect tech stack, resolve presets, generate eslint.config.mjs
+    codebyplan eslint sync     Regenerate if presets changed, detect drift
+`);
+      break;
+  }
+}
+var init_eslint = __esm({
+  "src/cli/eslint.ts"() {
+    "use strict";
+    init_config();
+    init_confirm();
+    init_api();
+    init_tech_detect();
+    init_eslint_generator();
+  }
+});
+
 // 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";
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile9, writeFile as writeFile4, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
+import { join as join8, dirname as dirname2 } from "node:path";
 function contentHash(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 async function runSync() {
   const flags = parseFlags(3);
@@ -2149,7 +2819,7 @@ async function runSync() {
 }
 async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
   console.log("  Reading local and remote state...");
-  const claudeDir = join7(projectPath, ".claude");
+  const claudeDir = join8(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
@@ -2381,7 +3051,7 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
       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");
+          await writeFile4(p.filePath, p.remoteContent, "utf-8");
           if (p.isHook) await chmod2(p.filePath, 493);
         }
       }
@@ -2525,12 +3195,14 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
   await syncConfig(repoId, projectPath, dryRun);
   console.log("  Tech stack...");
   await syncTechStack(repoId, projectPath, dryRun);
+  console.log("  ESLint config...");
+  await syncEslintDriftCheck(repoId, projectPath);
   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 settingsPath = join8(claudeDir, "settings.json");
   const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
@@ -2550,11 +3222,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     globalSettings,
     repoSettings
   );
-  const hooksDir = join7(projectPath, ".claude", "hooks");
+  const hooksDir = join8(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile8(settingsPath, "utf-8");
+    const raw = await readFile9(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -2569,7 +3241,7 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   const mergedContent = JSON.stringify(merged, null, 2) + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile8(settingsPath, "utf-8");
+    currentContent = await readFile9(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -2581,14 +3253,14 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     return;
   }
   await mkdir2(dirname2(settingsPath), { recursive: true });
-  await writeFile3(settingsPath, mergedContent, "utf-8");
+  await writeFile4(settingsPath, mergedContent, "utf-8");
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join7(projectPath, ".codebyplan.json");
+  const configPath = join8(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile8(configPath, "utf-8");
+    const raw = await readFile9(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
@@ -2657,7 +3329,7 @@ async function syncConfig(repoId, projectPath, dryRun) {
     console.log("    Config would be updated (dry-run).");
     return;
   }
-  await writeFile3(configPath, newJson + "\n", "utf-8");
+  await writeFile4(configPath, newJson + "\n", "utf-8");
   console.log("    Updated .codebyplan.json");
 }
 async function syncTechStack(repoId, projectPath, dryRun) {
@@ -2695,6 +3367,20 @@ async function syncTechStack(repoId, projectPath, dryRun) {
     console.log("    Tech stack detection skipped.");
   }
 }
+async function syncEslintDriftCheck(repoId, projectPath) {
+  try {
+    const hasDrift = await checkEslintDrift(repoId, projectPath);
+    if (hasDrift) {
+      console.log(
+        "    ESLint config drift detected. Run `codebyplan eslint sync` to update."
+      );
+    } else {
+      console.log("    ESLint configs up to date.");
+    }
+  } catch (error) {
+    console.warn("    ESLint drift check skipped:", error);
+  }
+}
 async function syncPortVerification(repoId, projectPath, dryRun, fix) {
   try {
     const portsRes = await apiGet(
@@ -2791,28 +3477,28 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
     hook: { dir: "hooks", ext: ".sh" },
     template: { dir: "templates", ext: "" },
     context: { dir: "context", ext: ".md" },
-    docs_stack: { dir: join7("docs", "stack"), ext: ".md" },
+    docs_stack: { dir: join8("docs", "stack"), ext: ".md" },
     docs: { dir: "docs", ext: ".md" },
     claude_md: { dir: "", ext: "" },
     settings: { dir: "", ext: "" }
   };
-  if (remote.type === "claude_md") return join7(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join7(claudeDir, "settings.json");
+  if (remote.type === "claude_md") return join8(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join8(claudeDir, "settings.json");
   const cfg = typeConfig2[remote.type];
-  if (!cfg) return join7(claudeDir, remote.name);
-  const typeDir = remote.type === "command" ? join7(claudeDir, cfg.dir, "cbp") : join7(claudeDir, cfg.dir);
+  if (!cfg) return join8(claudeDir, remote.name);
+  const typeDir = remote.type === "command" ? join8(claudeDir, cfg.dir, "cbp") : join8(claudeDir, cfg.dir);
   if (cfg.subfolder)
-    return join7(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
+    return join8(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 join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  if (remote.type === "template") return join8(typeDir, remote.name);
   if (remote.category && (remote.type === "context" || remote.type === "docs_stack" || remote.type === "docs"))
-    return join7(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  return join7(typeDir, `${remote.name}${cfg.ext}`);
+    return join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  return join8(typeDir, `${remote.name}${cfg.ext}`);
 }
 function getSyncVersion() {
   try {
-    return "1.3.1";
+    return "1.4.1";
   } catch {
     return "unknown";
   }
@@ -2861,6 +3547,7 @@ var init_sync = __esm({
     init_settings_merge();
     init_hook_registry();
     init_port_verify();
+    init_eslint();
   }
 });
 
@@ -2913,6 +3600,20 @@ if (arg === "sync") {
   }
   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;
+  }
+  process.exit(0);
+}
 if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
   console.log(`
   CodeByPlan CLI v${VERSION}
@@ -2920,6 +3621,7 @@ if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
   Usage:
     codebyplan setup        Interactive setup (API key + project init + first sync)
     codebyplan sync         Bidirectional sync (pull + push + config)
+    codebyplan eslint       ESLint config management (init, sync)
     codebyplan help         Show this help message
     codebyplan --version    Print version
 
@@ -2930,6 +3632,10 @@ if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
     --force                 Skip confirmation and conflict prompts
     --fix                   Auto-create missing port allocations
 
+  ESLint commands:
+    codebyplan eslint init  Detect tech stack, resolve presets, generate configs
+    codebyplan eslint sync  Regenerate if presets changed, detect drift
+
   MCP Server:
     Claude Code connects to CodeByPlan via remote MCP:
       URL: https://codebyplan.com/mcp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {