codebyplan 1.13.28 → 1.13.30

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.28";
+    VERSION = "1.13.30";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -698,7 +698,7 @@ function isRetryable(err) {
   return false;
 }
 function delay(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 async function request(method, path10, options) {
   const url = buildUrl(path10, options?.params);
@@ -1056,7 +1056,7 @@ var init_device_flow = __esm({
         this.name = "OAuthInvalidClientError";
       }
     };
-    defaultSleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
+    defaultSleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
   }
 });
 
@@ -4596,7 +4596,7 @@ function setRetryDelayMs(ms) {
   RETRY_DELAY_MS = ms;
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 function isTransientMcpError(err) {
   if (!(err instanceof McpError)) return false;
@@ -8538,11 +8538,11 @@ async function ask(q, opts) {
   try {
     while (true) {
       const choices = q.choices.map((c) => `[${c.key}] ${c.label}`).join("  ");
-      const answer = await new Promise((resolve9) => {
+      const answer = await new Promise((resolve11) => {
         rl.question(`${q.message}
   ${choices}
 > `, (input) => {
-          resolve9(input.trim().toLowerCase());
+          resolve11(input.trim().toLowerCase());
         });
       });
       const match = q.choices.find(
@@ -9128,14 +9128,684 @@ var init_uninstall = __esm({
   }
 });
 
+// src/lib/structure-generator.ts
+function renderTechStack(techStack) {
+  const entries = Object.entries(techStack).filter(([, value]) => value.trim().length > 0).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) return "";
+  const lines = entries.map(([cat, names]) => `- **${cat}**: ${names}`);
+  return `## Tech Stack
+
+${lines.join("\n")}
+`;
+}
+function renderPackageManager(pm) {
+  if (!pm.trim()) return "";
+  return `## Package Manager
+
+\`${pm}\`
+`;
+}
+function renderMonorepoStructure(packages) {
+  if (packages.length === 0) return "";
+  const sorted = [...packages].sort((a, b) => a.path.localeCompare(b.path));
+  const rows = sorted.map(
+    (p) => `| \`${p.path}\` | \`${p.name}\` | ${p.purpose ?? ""} |`
+  );
+  return `## Monorepo Structure
+
+| Location | Package | Purpose |
+|----------|---------|----------|
+` + rows.join("\n") + "\n";
+}
+function renderPorts(ports) {
+  if (ports.length === 0) return "";
+  const sorted = [...ports].sort((a, b) => a.port - b.port);
+  const rows = sorted.map(
+    (p) => `| ${p.port} | ${p.label} | ${p.server_type} |`
+  );
+  return `## Ports
+
+| Port | Label | Type |
+|------|-------|------|
+` + rows.join("\n") + "\n";
+}
+function renderBranchModel(model) {
+  const lines = [];
+  lines.push(`- **Production**: \`${model.production}\``);
+  if (model.protected && model.protected.length > 0) {
+    const sorted = [...model.protected].sort();
+    lines.push(`- **Protected**: ${sorted.map((b) => `\`${b}\``).join(", ")}`);
+  }
+  return `## Branch Model
+
+${lines.join("\n")}
+`;
+}
+function resolvePlatform(key, platform2) {
+  if (platform2) return platform2;
+  if (key.startsWith("vercel")) return "vercel";
+  if (key.startsWith("railway")) return "railway";
+  if (key.startsWith("supabase")) return "supabase";
+  if (key === "npm") return "npm";
+  return key;
+}
+function renderShipmentSurfaces(surfaces) {
+  if (surfaces.length === 0) return "";
+  const sorted = [...surfaces].sort((a, b) => a.key.localeCompare(b.key));
+  const rows = sorted.map(
+    (s) => `| \`${s.key}\` | ${resolvePlatform(s.key, s.platform)} | ${s.urlOrPath ?? ""} |`
+  );
+  return `## Shipment Surfaces
+
+| Surface | Platform/Type | Path/URL |
+|---------|---------------|----------|
+` + rows.join("\n") + "\n";
+}
+function generateStructureMd(config) {
+  const sections = [];
+  if (config.techStack && Object.keys(config.techStack).length > 0) {
+    const rendered = renderTechStack(config.techStack);
+    if (rendered) sections.push(rendered);
+  }
+  if (config.packageManager) {
+    const rendered = renderPackageManager(config.packageManager);
+    if (rendered) sections.push(rendered);
+  }
+  if (config.packages && config.packages.length > 0) {
+    const rendered = renderMonorepoStructure(config.packages);
+    if (rendered) sections.push(rendered);
+  }
+  if (config.ports && config.ports.length > 0) {
+    const rendered = renderPorts(config.ports);
+    if (rendered) sections.push(rendered);
+  }
+  if (config.branchModel) {
+    const rendered = renderBranchModel(config.branchModel);
+    if (rendered) sections.push(rendered);
+  }
+  if (config.shipmentSurfaces && config.shipmentSurfaces.length > 0) {
+    const rendered = renderShipmentSurfaces(config.shipmentSurfaces);
+    if (rendered) sections.push(rendered);
+  }
+  const body = sections.join("\n");
+  return `${SENTINEL_START}
+${body}${SENTINEL_END}
+`;
+}
+var SENTINEL_START, SENTINEL_END;
+var init_structure_generator = __esm({
+  "src/lib/structure-generator.ts"() {
+    "use strict";
+    SENTINEL_START = "<!-- @codebyplan-generated: structure start -->";
+    SENTINEL_END = "<!-- @codebyplan-generated: structure end -->";
+  }
+});
+
+// src/cli/claude/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  runGenerate: () => runGenerate
+});
+import { readFile as readFile21, mkdir as mkdir10, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join30, resolve as resolve8 } from "node:path";
+async function readJsonFile3(filePath) {
+  try {
+    const raw = await readFile21(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readPkgName(absPath) {
+  try {
+    const raw = await readFile21(join30(absPath, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return typeof pkg.name === "string" ? pkg.name : null;
+  } catch {
+    return null;
+  }
+}
+async function runGenerate(opts) {
+  const projectDir = opts.projectDir ?? opts["project-dir"] ?? process.cwd();
+  const dryRun = opts.dryRun ?? opts["dryRun"] ?? false;
+  const rootDir = resolve8(projectDir);
+  let packageManager;
+  try {
+    const raw = await readFile21(join30(rootDir, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    if (typeof pkg.packageManager === "string") {
+      packageManager = pkg.packageManager;
+    }
+  } catch {
+  }
+  const serverJson = await readJsonFile3(
+    join30(rootDir, ".codebyplan", "server.json")
+  );
+  const ports = [];
+  for (const alloc of serverJson?.port_allocations ?? []) {
+    if (typeof alloc.port === "number") {
+      ports.push({
+        port: alloc.port,
+        label: alloc.label ?? "",
+        server_type: alloc.server_type ?? ""
+      });
+    }
+  }
+  const gitJson = await readJsonFile3(
+    join30(rootDir, ".codebyplan", "git.json")
+  );
+  const branchModel = gitJson?.branch_config?.production ? {
+    production: gitJson.branch_config.production,
+    protected: gitJson.branch_config.protected?.filter(
+      (b) => typeof b === "string"
+    )
+  } : void 0;
+  const shipmentJson = await readJsonFile3(
+    join30(rootDir, ".codebyplan", "shipment.json")
+  );
+  const shipmentSurfaces = [];
+  const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
+  for (const [key, surface] of Object.entries(rawSurfaces).sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const urlOrPath = surface.custom_domain ?? surface.url ?? surface.app_path ?? void 0;
+    shipmentSurfaces.push({
+      key,
+      platform: surface.platform,
+      urlOrPath
+    });
+  }
+  const discoveredApps = (await discoverMonorepoApps(rootDir)).sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  const packages = [];
+  for (const app of discoveredApps) {
+    const pkgName = await readPkgName(app.absPath);
+    packages.push({
+      path: app.path,
+      name: pkgName ?? app.name
+    });
+  }
+  const techResult = await detectTechStack(rootDir);
+  const CATEGORY_LABELS = {
+    "component-lib": "Component Library",
+    graphql: "GraphQL",
+    quality: "Code Quality"
+  };
+  const categoryMap = {};
+  for (const entry of techResult.flat) {
+    if (entry.name === SYNTHETIC_CARRIER_NAME) continue;
+    if (!categoryMap[entry.category]) {
+      categoryMap[entry.category] = [];
+    }
+    categoryMap[entry.category].push(entry.name);
+  }
+  if ((categoryMap["mobile"]?.length ?? 0) > 0) {
+    const frameworkEntries = categoryMap["framework"] ?? [];
+    const filtered = frameworkEntries.filter((n) => n !== "React");
+    if (filtered.length > 0) {
+      categoryMap["framework"] = filtered;
+    } else {
+      delete categoryMap["framework"];
+    }
+  }
+  const hasNextjs = (categoryMap["framework"] ?? []).some(
+    (n) => n.toLowerCase().includes("next")
+  );
+  const filteredPorts = ports.filter((p) => {
+    if (p.server_type === "nextjs" && !hasNextjs) return false;
+    return true;
+  });
+  const techStack = {};
+  for (const [cat, names] of Object.entries(categoryMap)) {
+    const label = CATEGORY_LABELS[cat] ?? cat.charAt(0).toUpperCase() + cat.slice(1);
+    techStack[label] = [...names].sort().join(" + ");
+  }
+  const config = {
+    techStack: Object.keys(techStack).length > 0 ? techStack : void 0,
+    packageManager,
+    packages: packages.length > 0 ? packages : void 0,
+    ports: filteredPorts.length > 0 ? filteredPorts : void 0,
+    branchModel,
+    shipmentSurfaces: shipmentSurfaces.length > 0 ? shipmentSurfaces : void 0
+  };
+  const content = generateStructureMd(config);
+  if (dryRun) {
+    process.stdout.write(
+      `[dry-run] Would write: .claude/generated/structure.md
+
+`
+    );
+    process.stdout.write(content);
+    return;
+  }
+  const outputDir = join30(rootDir, ".claude", "generated");
+  await mkdir10(outputDir, { recursive: true });
+  const outputPath = join30(outputDir, "structure.md");
+  await writeFile16(outputPath, content, "utf-8");
+  process.stdout.write(`Wrote: .claude/generated/structure.md
+`);
+}
+var init_generate = __esm({
+  "src/cli/claude/generate.ts"() {
+    "use strict";
+    init_tech_detect();
+    init_structure_generator();
+  }
+});
+
+// src/cli/claude/migrate-memory.ts
+var migrate_memory_exports = {};
+__export(migrate_memory_exports, {
+  applyPlan: () => applyPlan,
+  buildPlan: () => buildPlan,
+  encodeProjectPath: () => encodeProjectPath,
+  flagDropCandidates: () => flagDropCandidates,
+  inventoryFiles: () => inventoryFiles,
+  resolveAutoMemoryDir: () => resolveAutoMemoryDir,
+  runMigrateMemory: () => runMigrateMemory
+});
+import {
+  readFile as readFile22,
+  writeFile as writeFile17,
+  mkdir as mkdir11,
+  unlink as unlink4,
+  rmdir,
+  readdir as readdir4
+} from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join31, resolve as resolve9, dirname as dirname11, sep as sep2 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+function encodeProjectPath(absPath) {
+  return resolve9(absPath).replace(/[/\\]/g, "-");
+}
+function resolveAutoMemoryDir(opts) {
+  if (opts.autoMemoryDir) {
+    return opts.autoMemoryDir;
+  }
+  const projectDir = opts.projectDir ?? process.cwd();
+  const encoded = encodeProjectPath(projectDir);
+  return join31(homedir8(), ".claude", "projects", encoded, "memory");
+}
+function parseFrontmatter(content) {
+  content = content.replace(/\r\n/g, "\n");
+  if (!content.startsWith("---")) {
+    return {
+      ok: false,
+      error: "File does not start with a YAML frontmatter fence (---)"
+    };
+  }
+  const rest = content.slice(3);
+  const closingIdx = rest.indexOf("\n---");
+  if (closingIdx === -1) {
+    return { ok: false, error: "Frontmatter closing fence (---) not found" };
+  }
+  const fmBlock = rest.slice(0, closingIdx);
+  const lines = fmBlock.split("\n");
+  let name = "";
+  let description = "";
+  let metadataType = null;
+  let inMetadata = false;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (/^metadata:\s*$/.test(line)) {
+      inMetadata = true;
+      continue;
+    }
+    if (inMetadata && /^\s{2,}/.test(line)) {
+      const match2 = line.trim().match(/^(\w+):\s*(.*)$/);
+      if (match2) {
+        const [, key2, val2] = match2;
+        if (key2 === "type") {
+          metadataType = val2?.trim() || null;
+        }
+      }
+      continue;
+    }
+    if (inMetadata) {
+      inMetadata = false;
+    }
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (!match) continue;
+    const [, key, rawVal] = match;
+    const val = (rawVal ?? "").trim().replace(/^["']|["']$/g, "");
+    if (key === "name") name = val;
+    if (key === "description") description = val;
+  }
+  return {
+    ok: true,
+    data: {
+      name,
+      description,
+      metadata: { type: metadataType }
+    }
+  };
+}
+async function inventoryFiles(dir) {
+  let filenames;
+  try {
+    const entries = await readdir4(dir);
+    filenames = entries.filter((f) => f.endsWith(".md") && f !== "MEMORY.md").sort();
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const filename of filenames) {
+    const sourcePath = join31(dir, filename);
+    let raw;
+    try {
+      raw = await readFile22(sourcePath, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      results.push({
+        filename,
+        source_path: sourcePath,
+        name: filename.replace(/\.md$/, ""),
+        description: "",
+        metadata_type: null,
+        suggested_action: "keep",
+        parse_error: `Could not read file: ${msg}`
+      });
+      continue;
+    }
+    const parseResult = parseFrontmatter(raw);
+    if (!parseResult.ok) {
+      console.error(
+        `[migrate-memory] WARNING: could not parse frontmatter in ${filename}: ${parseResult.error}`
+      );
+      results.push({
+        filename,
+        source_path: sourcePath,
+        name: filename.replace(/\.md$/, ""),
+        description: "",
+        metadata_type: null,
+        suggested_action: "keep",
+        parse_error: parseResult.error
+      });
+      continue;
+    }
+    const { name, description, metadata } = parseResult.data;
+    const entry = {
+      filename,
+      source_path: sourcePath,
+      name: name || filename.replace(/\.md$/, ""),
+      description,
+      metadata_type: metadata.type,
+      suggested_action: "keep"
+    };
+    if (DROP_PATTERN.test(description)) {
+      entry.suggested_action = "drop";
+      const match = description.match(DROP_PATTERN);
+      entry.drop_reason = `Description contains "${match[0]}" keyword`;
+    }
+    if (entry.suggested_action === "keep") {
+      const typeSlug = metadata.type?.toLowerCase().replace(/[^a-z0-9-]/g, "-") ?? "misc";
+      entry.suggested_target = `nested:.claude/memory/${typeSlug}`;
+    }
+    results.push(entry);
+  }
+  return results;
+}
+function flagDropCandidates(entries) {
+  return entries.map((entry) => {
+    if (entry.parse_error) {
+      return entry;
+    }
+    if (DROP_PATTERN.test(entry.description)) {
+      const match = entry.description.match(DROP_PATTERN);
+      return {
+        ...entry,
+        suggested_action: "drop",
+        drop_reason: entry.drop_reason ?? `Description contains "${match[0]}" keyword`
+      };
+    }
+    return entry;
+  });
+}
+function buildPlan(entries, opts) {
+  const plan = {
+    auto_memory_dir: opts.autoMemoryDir,
+    entries,
+    generate_step: "After --apply, run `codebyplan claude generate` to regenerate .claude/generated/structure.md"
+  };
+  if (!opts.omitTimestamp) {
+    plan.generated_at = opts.now ? opts.now() : (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return plan;
+}
+async function applyPlan(plan, opts) {
+  const projectDir = resolve9(opts.projectDir);
+  const dryRun = opts.dryRun ?? false;
+  for (const entry of plan.entries) {
+    if (entry.suggested_action !== "keep") continue;
+    if (!entry.suggested_target?.startsWith("nested:")) continue;
+    const relPath = entry.suggested_target.slice("nested:".length);
+    const targetDir = resolve9(join31(projectDir, relPath));
+    const targetFile = join31(targetDir, "CLAUDE.md");
+    if (!targetDir.startsWith(resolve9(projectDir) + sep2)) {
+      process.stderr.write(
+        `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
+`
+      );
+      continue;
+    }
+    const anchor = `_Source: ${entry.filename}_`;
+    const appendContent = `
+## ${entry.name}
+
+${entry.description}
+
+${anchor}
+`;
+    if (dryRun) {
+      process.stdout.write(`[dry-run] Would create/append: ${targetFile}
+`);
+      if (resolve9(entry.source_path).startsWith(
+        resolve9(plan.auto_memory_dir) + sep2
+      )) {
+        process.stdout.write(
+          `[dry-run] Would delete migrated keep source: ${entry.source_path}
+`
+        );
+      }
+      continue;
+    }
+    await mkdir11(targetDir, { recursive: true });
+    let existing = "";
+    try {
+      existing = await readFile22(targetFile, "utf-8");
+    } catch {
+    }
+    if (!existing.includes(anchor)) {
+      await writeFile17(targetFile, existing + appendContent, "utf-8");
+    }
+    if (resolve9(entry.source_path).startsWith(resolve9(plan.auto_memory_dir) + sep2)) {
+      try {
+        await unlink4(entry.source_path);
+      } catch {
+      }
+    } else {
+      process.stderr.write(
+        `migrate-memory: skipping delete of migrated keep source "${entry.source_path}" \u2014 resolves outside auto_memory_dir
+`
+      );
+    }
+  }
+  const rootClaudeMd = join31(projectDir, ".claude", "CLAUDE.md");
+  if (dryRun) {
+    process.stdout.write(
+      `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
+`
+    );
+  } else {
+    let claudeMdContent = "";
+    try {
+      claudeMdContent = await readFile22(rootClaudeMd, "utf-8");
+    } catch {
+      await mkdir11(dirname11(rootClaudeMd), { recursive: true });
+    }
+    if (!claudeMdContent.includes(IMPORT_LINE)) {
+      await writeFile17(
+        rootClaudeMd,
+        claudeMdContent + `
+${IMPORT_LINE}
+`,
+        "utf-8"
+      );
+    }
+  }
+  for (const entry of plan.entries) {
+    if (entry.suggested_action !== "drop") continue;
+    if (!resolve9(entry.source_path).startsWith(
+      resolve9(plan.auto_memory_dir) + sep2
+    )) {
+      process.stderr.write(
+        `migrate-memory: skipping delete of "${entry.source_path}" \u2014 resolves outside auto_memory_dir
+`
+      );
+      continue;
+    }
+    if (dryRun) {
+      process.stdout.write(`[dry-run] Would delete: ${entry.source_path}
+`);
+      continue;
+    }
+    try {
+      await unlink4(entry.source_path);
+    } catch {
+    }
+  }
+  const memoryMd = join31(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join31(homedir8(), ".claude", "projects");
+  if (dryRun) {
+    process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
+`);
+  } else {
+    if (resolve9(plan.auto_memory_dir).startsWith(safeRmdirBase + sep2)) {
+      try {
+        await unlink4(memoryMd);
+      } catch {
+      }
+    } else {
+      process.stderr.write(
+        `migrate-memory: skipping MEMORY.md deletion \u2014 auto_memory_dir not under ~/.claude/projects
+`
+      );
+    }
+  }
+  if (dryRun) {
+    process.stdout.write(
+      `[dry-run] Would rmdir (if empty): ${plan.auto_memory_dir}
+`
+    );
+  } else {
+    if (!resolve9(plan.auto_memory_dir).startsWith(safeRmdirBase + sep2)) {
+      process.stderr.write(
+        `migrate-memory: skipping rmdir of "${plan.auto_memory_dir}" \u2014 not under ~/.claude/projects
+`
+      );
+    } else {
+      try {
+        const remaining = await readdir4(plan.auto_memory_dir);
+        if (remaining.length === 0) {
+          await rmdir(plan.auto_memory_dir);
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function runMigrateMemory(opts) {
+  const rest = opts.rest ?? [];
+  const projectDir = opts.projectDir ?? process.cwd();
+  const filteredRest = rest.filter(
+    (v, i) => v !== "--project-dir" && rest[i - 1] !== "--project-dir"
+  );
+  const isJson = filteredRest.includes("--json") || filteredRest.length === 0;
+  const isDryRun = rest.includes("--dry-run");
+  const applyIdx = rest.indexOf("--apply");
+  const applyFile = applyIdx !== -1 ? rest[applyIdx + 1] : void 0;
+  const autoMemoryDir = resolveAutoMemoryDir(opts);
+  if (applyFile) {
+    let planJson;
+    try {
+      planJson = await readFile22(resolve9(applyFile), "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `migrate-memory: cannot read plan file "${applyFile}": ${msg}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let plan2;
+    try {
+      plan2 = JSON.parse(planJson);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `migrate-memory: plan file is not valid JSON: ${msg}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    await applyPlan(plan2, { projectDir, dryRun: isDryRun });
+    process.stdout.write(
+      isDryRun ? "migrate-memory: dry-run complete (no changes written).\n" : "migrate-memory: apply complete.\n"
+    );
+    return;
+  }
+  if (!existsSync10(autoMemoryDir)) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          auto_memory_dir: autoMemoryDir,
+          entries: [],
+          generate_step: "After --apply, run `codebyplan claude generate` to regenerate .claude/generated/structure.md",
+          note: "Auto-memory directory does not exist \u2014 nothing to migrate."
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    return;
+  }
+  const rawEntries = await inventoryFiles(autoMemoryDir);
+  const entries = flagDropCandidates(rawEntries);
+  const plan = buildPlan(entries, {
+    autoMemoryDir,
+    omitTimestamp: opts.omitTimestamp,
+    now: opts.now
+  });
+  if (isDryRun) {
+    process.stdout.write("[dry-run] Plan:\n");
+    process.stdout.write(JSON.stringify(plan, null, 2) + "\n\n");
+    await applyPlan(plan, { projectDir, dryRun: true });
+    return;
+  }
+  if (isJson) {
+    process.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+  }
+}
+var DROP_PATTERN, IMPORT_LINE;
+var init_migrate_memory = __esm({
+  "src/cli/claude/migrate-memory.ts"() {
+    "use strict";
+    DROP_PATTERN = /\b(RESOLVED|SHIPPED|RETIRED|ROLLED.?BACK)\b/i;
+    IMPORT_LINE = "@.claude/generated/structure.md";
+  }
+});
+
 // src/index.ts
 init_version();
 import { readFileSync as readFileSync10 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 void (async () => {
   if (!process.env.CODEBYPLAN_API_KEY) {
     try {
-      const envPath = resolve8(process.cwd(), ".env.local");
+      const envPath = resolve10(process.cwd(), ".env.local");
       const content = readFileSync10(envPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -9336,16 +10006,40 @@ void (async () => {
       );
       process.exit(process.exitCode ?? 0);
     }
+    if (subcommand === "generate") {
+      if (parsed === null) {
+        process.exit(1);
+      }
+      const { runGenerate: runGenerate2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
+      await runGenerate2(
+        parsed.projectDir != null ? { ...parsed.opts, projectDir: parsed.projectDir } : parsed.opts
+      );
+      process.exit(process.exitCode ?? 0);
+    }
+    if (subcommand === "migrate-memory") {
+      if (parsed === null) {
+        process.exit(1);
+      }
+      const { runMigrateMemory: runMigrateMemory2 } = await Promise.resolve().then(() => (init_migrate_memory(), migrate_memory_exports));
+      const rest = process.argv.slice(4);
+      await runMigrateMemory2({
+        rest,
+        projectDir: parsed.projectDir ?? void 0
+      });
+      process.exit(process.exitCode ?? 0);
+    }
     console.log(`
   CodeByPlan Claude asset management v${VERSION}
 
   Usage:
-    codebyplan claude install [flags]     Install skills/agents/hooks into ./.claude/
-    codebyplan claude update  [flags]     Update installed assets to latest versions
-    codebyplan claude uninstall [flags]   Remove installed assets from ./.claude/
-    codebyplan claude status              Check package-sync state (drift, version skip, settings drift)
-                                           --write-cache  Write result to .codebyplan/claude-status.local.json
-                                           --quiet        Suppress stdout output
+    codebyplan claude install [flags]         Install skills/agents/hooks into ./.claude/
+    codebyplan claude update  [flags]         Update installed assets to latest versions
+    codebyplan claude uninstall [flags]       Remove installed assets from ./.claude/
+    codebyplan claude status                  Check package-sync state (drift, version skip, settings drift)
+                                               --write-cache  Write result to .codebyplan/claude-status.local.json
+                                               --quiet        Suppress stdout output
+    codebyplan claude generate [flags]        Write .claude/generated/structure.md from local config
+    codebyplan claude migrate-memory [flags]  Inventory auto-memory files and emit migration plan
 
   Flags (apply to install/update/uninstall):
     --yes, -y               Auto-accept every prompt with its recommended default
@@ -9359,6 +10053,10 @@ void (async () => {
     --bash                  Set statusline renderer to bash after install/update
     --node                  Set statusline renderer to node after install/update
     --python                Set statusline renderer to python after install/update
+
+  Flags (apply to generate):
+    --project-dir <path>    Override the project root (default: cwd)
+    --dry-run               Print what would be written, write nothing
 `);
     process.exit(0);
   }
@@ -9387,7 +10085,7 @@ void (async () => {
     codebyplan upload-e2e-images     Upload new/changed committed e2e PNGs for a checkpoint
     codebyplan scaffold-publish-workflow   Write the publish-on-main GitHub workflow into ./.github/workflows/
     codebyplan branch migrate        Rewrite branch_config from 3-branch to 2-tier model
-    codebyplan claude                Claude asset management (install/update/uninstall)
+    codebyplan claude                Claude asset management (install/update/uninstall/generate/migrate-memory)
     codebyplan statusline            Show or set the statusline renderer (bash/node/python)
     codebyplan resolve-worktree      Resolve active worktree UUID from device+path+branch tuple
     codebyplan version-status        Report installed vs latest version + update guard (JSON)
@@ -9419,9 +10117,11 @@ void (async () => {
     codebyplan eslint init  Detect tech stack, resolve presets, generate configs
 
   Claude asset management:
-    codebyplan claude install [flags]     Install skills/agents/hooks into ./.claude/
-    codebyplan claude update  [flags]     Update installed assets to latest versions
-    codebyplan claude uninstall [flags]   Remove installed assets from ./.claude/
+    codebyplan claude install [flags]         Install skills/agents/hooks into ./.claude/
+    codebyplan claude update  [flags]         Update installed assets to latest versions
+    codebyplan claude uninstall [flags]       Remove installed assets from ./.claude/
+    codebyplan claude generate [flags]        Write .claude/generated/structure.md from local config
+    codebyplan claude migrate-memory [flags]  Inventory auto-memory files and emit migration plan
 
     Flags (install/update/uninstall):
       --yes, -y               Auto-accept prompts with recommended defaults
@@ -9433,6 +10133,16 @@ void (async () => {
       --node                  Set statusline renderer to node after install/update
       --python                Set statusline renderer to python after install/update
 
+    Flags (generate):
+      --project-dir <path>    Override the project root (default: cwd)
+      --dry-run               Print what would be written, write nothing
+
+    Flags (migrate-memory):
+      --project-dir <path>    Override the project root (default: cwd)
+      --json                  Inventory mode: print plan JSON to stdout, write nothing (default)
+      --dry-run               Print plan + what apply would do, write nothing
+      --apply <file>          Read an approved plan JSON file and apply it
+
   Resolve-worktree options:
     --json                  Structured JSON output instead of bare UUID
     --fallback-from-branch  Fallback resolver: filter by (device_id, branch) client-side