@a-company/paradigm 3.27.0 → 3.34.0

package/dist/migrate-HRN5TUBQ.js

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/migrate/index.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/commands/migrate/detector.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml2 from "js-yaml";
+import { createRequire } from "module";
+
+// src/commands/migrate/migrations.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+function dirExists(rootDir, ...segments) {
+  return fs.existsSync(path.join(rootDir, ...segments));
+}
+function ensureDir(rootDir, ...segments) {
+  fs.mkdirSync(path.join(rootDir, ...segments), { recursive: true });
+}
+function readConfig(rootDir) {
+  const p = path.join(rootDir, ".paradigm", "config.yaml");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return yaml.load(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readConfigRaw(rootDir) {
+  const p = path.join(rootDir, ".paradigm", "config.yaml");
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p, "utf8");
+}
+function writeConfigRaw(rootDir, content) {
+  fs.writeFileSync(path.join(rootDir, ".paradigm", "config.yaml"), content, "utf8");
+}
+function configHasField(config, field) {
+  return field in config || field.replace(/-/g, "_") in config || field.replace(/_/g, "-") in config;
+}
+var legacyFileToDirectory = {
+  id: "legacy-file-to-directory",
+  introducedIn: "1.0.0",
+  description: "Convert .paradigm file to .paradigm/ directory",
+  category: "directory",
+  auto: true,
+  async check(rootDir) {
+    const p = path.join(rootDir, ".paradigm");
+    if (!fs.existsSync(p)) return { needed: false, reason: "No .paradigm found" };
+    if (fs.statSync(p).isFile()) {
+      return { needed: true, reason: ".paradigm is a file, not a directory", details: ["Legacy format \u2014 must convert to directory"] };
+    }
+    return { needed: false, reason: ".paradigm/ is already a directory" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would convert .paradigm file to directory" };
+    const p = path.join(rootDir, ".paradigm");
+    const backup = path.join(rootDir, ".paradigm.backup");
+    const content = fs.readFileSync(p, "utf8");
+    fs.copyFileSync(p, backup);
+    fs.unlinkSync(p);
+    fs.mkdirSync(p, { recursive: true });
+    fs.mkdirSync(path.join(p, "specs"), { recursive: true });
+    fs.mkdirSync(path.join(p, "docs"), { recursive: true });
+    fs.mkdirSync(path.join(p, "prompts"), { recursive: true });
+    fs.writeFileSync(path.join(p, "config.yaml"), content, "utf8");
+    return {
+      status: "applied",
+      message: "Converted .paradigm file to directory (backup at .paradigm.backup)",
+      filesCreated: [".paradigm/", ".paradigm/config.yaml", ".paradigm/specs/", ".paradigm/docs/", ".paradigm/prompts/"]
+    };
+  }
+};
+var legacyScanIndexLocation = {
+  id: "legacy-scan-index-location",
+  introducedIn: "1.0.0",
+  description: "Move .paradigm-scan-index.json into .paradigm/",
+  category: "format",
+  auto: true,
+  async check(rootDir) {
+    const old = path.join(rootDir, ".paradigm-scan-index.json");
+    if (fs.existsSync(old)) {
+      return { needed: true, reason: "Scan index at root level needs relocation" };
+    }
+    return { needed: false, reason: "No legacy scan index at root" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would move .paradigm-scan-index.json" };
+    const old = path.join(rootDir, ".paradigm-scan-index.json");
+    const dest = path.join(rootDir, ".paradigm", "scan-index.json");
+    fs.renameSync(old, dest);
+    return { status: "applied", message: "Moved scan index into .paradigm/", filesModified: [".paradigm/scan-index.json"] };
+  }
+};
+function makeDirectoryMigration(id, version, relPath, description, details) {
+  return {
+    id,
+    introducedIn: version,
+    description,
+    category: "directory",
+    auto: true,
+    async check(rootDir) {
+      if (dirExists(rootDir, ".paradigm", relPath)) {
+        return { needed: false, reason: `.paradigm/${relPath}/ already exists` };
+      }
+      return { needed: true, reason: `Missing .paradigm/${relPath}/`, details };
+    },
+    async apply(rootDir, opts) {
+      if (opts.dryRun) return { status: "skipped", message: `Would create .paradigm/${relPath}/` };
+      ensureDir(rootDir, ".paradigm", relPath);
+      return { status: "applied", message: `Created .paradigm/${relPath}/`, filesCreated: [`.paradigm/${relPath}/`] };
+    }
+  };
+}
+var addSpecsDirectory = makeDirectoryMigration(
+  "add-specs-directory",
+  "3.0.0",
+  "specs",
+  "Create .paradigm/specs/ for specifications",
+  ["Stores logger spec, symbols spec, scan spec, etc."]
+);
+var addDocsDirectory = makeDirectoryMigration(
+  "add-docs-directory",
+  "3.0.0",
+  "docs",
+  "Create .paradigm/docs/ for documentation",
+  ["Stores commands, patterns, troubleshooting docs"]
+);
+var addPromptsDirectory = makeDirectoryMigration(
+  "add-prompts-directory",
+  "3.0.0",
+  "prompts",
+  "Create .paradigm/prompts/ for task templates",
+  ["Stores add-feature, refactor, trace-flow prompts"]
+);
+var addTagBankConfig = {
+  id: "add-tag-bank-config",
+  introducedIn: "3.2.0",
+  description: "Add tag-bank section to config.yaml",
+  category: "config",
+  auto: true,
+  async check(rootDir) {
+    const config = readConfig(rootDir);
+    if (!config) return { needed: false, reason: "No config.yaml found" };
+    if (configHasField(config, "tag-bank")) {
+      return { needed: false, reason: "tag-bank already configured" };
+    }
+    return { needed: true, reason: "Missing tag-bank configuration" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would add tag-bank to config.yaml" };
+    const raw = readConfigRaw(rootDir);
+    if (!raw) return { status: "error", message: "Cannot read config.yaml" };
+    const tagBankBlock = `
+# Tag bank configuration
+tag-bank:
+  file: tags.yaml
+  core-tags:
+    - feature
+    - integration
+    - state
+    - idea
+    - deprecated
+    - critical
+    - security
+    - compliance
+  allow-suggestions: true
+`;
+    writeConfigRaw(rootDir, raw.trimEnd() + "\n" + tagBankBlock);
+    return { status: "applied", message: "Added tag-bank to config.yaml", filesModified: [".paradigm/config.yaml"] };
+  }
+};
+var addPurposeRequiredConfig = {
+  id: "add-purpose-required-config",
+  introducedIn: "3.3.0",
+  description: "Add purpose-required patterns to config.yaml",
+  category: "config",
+  auto: true,
+  async check(rootDir) {
+    const config = readConfig(rootDir);
+    if (!config) return { needed: false, reason: "No config.yaml found" };
+    if (configHasField(config, "purpose-required")) {
+      return { needed: false, reason: "purpose-required already configured" };
+    }
+    return { needed: true, reason: "Missing purpose-required patterns" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would add purpose-required to config.yaml" };
+    const raw = readConfigRaw(rootDir);
+    if (!raw) return { status: "error", message: "Cannot read config.yaml" };
+    const block = `
+# Where .purpose files should exist
+purpose-required:
+  - pattern: "src/*"
+    depth: 1
+  - pattern: "lib/*"
+    depth: 1
+  - pattern: "packages/*"
+    depth: 1
+`;
+    writeConfigRaw(rootDir, raw.trimEnd() + "\n" + block);
+    return { status: "applied", message: "Added purpose-required to config.yaml", filesModified: [".paradigm/config.yaml"] };
+  }
+};
+var addLoreDirectory = makeDirectoryMigration(
+  "add-lore-directory",
+  "3.7.0",
+  "lore",
+  "Create .paradigm/lore/ for project reflections and decisions",
+  ["Stores lore entries (reflections, decisions, arcs)"]
+);
+var addTasksDirectory = makeDirectoryMigration(
+  "add-tasks-directory",
+  "3.8.0",
+  "tasks",
+  "Create .paradigm/tasks/ for work item tracking",
+  ["Stores task YAML files for persistent task management"]
+);
+var addPersonasDirectory = makeDirectoryMigration(
+  "add-personas-directory",
+  "3.9.0",
+  "personas",
+  "Create .paradigm/personas/ for actor-driven journey testing",
+  ["Stores .persona files with traits, triggers, fixtures, journey steps"]
+);
+var addProtocolsDirectory = makeDirectoryMigration(
+  "add-protocols-directory",
+  "3.10.0",
+  "protocols",
+  "Create .paradigm/protocols/ for repeatable implementation patterns",
+  ["Stores protocol YAML files captured from implementation workflows"]
+);
+var addHabitsDirectory = makeDirectoryMigration(
+  "add-habits-directory",
+  "3.14.0",
+  "habits",
+  "Create .paradigm/habits/ for session habit tracking"
+);
+var addWisdomDirectory = makeDirectoryMigration(
+  "add-wisdom-directory",
+  "3.5.0",
+  "wisdom",
+  "Create .paradigm/wisdom/ for antipatterns and team knowledge",
+  ["Stores antipatterns.yaml and other team knowledge files"]
+);
+var addHistoryDirectory = makeDirectoryMigration(
+  "add-history-directory",
+  "3.6.0",
+  "history",
+  "Create .paradigm/history/ for symbol change history",
+  ["Stores log.jsonl for commit-level symbol tracking"]
+);
+var migrateAssessmentsToLore = {
+  id: "migrate-assessments-to-lore",
+  introducedIn: "3.19.0",
+  description: "Convert old assessment entries to lore format",
+  category: "schema",
+  auto: false,
+  // Manual — delegates to `paradigm lore migrate-assessments`
+  async check(rootDir) {
+    const assessDir = path.join(rootDir, ".paradigm", "assessments");
+    if (!fs.existsSync(assessDir)) return { needed: false, reason: "No assessments directory found" };
+    try {
+      const files = fs.readdirSync(assessDir);
+      if (files.length === 0) return { needed: false, reason: "Assessments directory is empty" };
+      return {
+        needed: true,
+        reason: `${files.length} assessment file(s) to migrate`,
+        details: ["Run: paradigm lore migrate-assessments --dry-run"]
+      };
+    } catch {
+      return { needed: false, reason: "Cannot read assessments directory" };
+    }
+  },
+  async apply(_rootDir, _opts) {
+    return { status: "skipped", message: "Run `paradigm lore migrate-assessments` manually" };
+  }
+};
+var addComponentTypesConfig = {
+  id: "add-component-types-config",
+  introducedIn: "3.33.0",
+  description: "Add component_types glossary to config.yaml",
+  category: "config",
+  auto: true,
+  async check(rootDir) {
+    const config = readConfig(rootDir);
+    if (!config) return { needed: false, reason: "No config.yaml found" };
+    if (configHasField(config, "component_types")) {
+      return { needed: false, reason: "component_types already configured" };
+    }
+    return { needed: true, reason: "Missing component_types glossary" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would add component_types to config.yaml" };
+    const raw = readConfigRaw(rootDir);
+    if (!raw) return { status: "error", message: "Cannot read config.yaml" };
+    const block = `
+# Component types glossary \u2014 defines the project vocabulary for the \`type\` field on components
+component_types:
+  command: "CLI command handler \u2014 registers subcommand, parses args, calls core logic"
+  tool: "MCP tool definition + handler \u2014 serves AI agents via JSON-RPC"
+  utility: "Shared helper function or module \u2014 no side effects, pure logic"
+  engine: "Stateful processing core \u2014 owns data transformation lifecycle"
+  loader: "Reads and parses data sources into typed structures"
+  writer: "Writes structured data to files (YAML, JSON)"
+  service: "Business logic coordinator \u2014 orchestrates tools, loaders, writers"
+  model: "Data shape \u2014 TypeScript interface or type definition"
+  view: "UI rendering unit \u2014 SwiftUI view, React component"
+  provider: "Protocol-conforming platform capability wrapper \u2014 owns lifecycle"
+  manager: "Stateful coordinator that owns child lifecycles"
+  detector: "Observes external state and emits events"
+  router: "Maps input signals to targets based on rules"
+  filter: "Transforms or smooths data in a pipeline"
+  store: "Persistent or reactive state container"
+  handler: "Event handler, webhook receiver, or request processor"
+  config: "Configuration, environment, constants"
+`;
+    writeConfigRaw(rootDir, raw.trimEnd() + "\n" + block);
+    return { status: "applied", message: "Added component_types glossary to config.yaml", filesModified: [".paradigm/config.yaml"] };
+  }
+};
+var addDisciplineConfig = {
+  id: "add-discipline-config",
+  introducedIn: "3.4.0",
+  description: "Add discipline field to config.yaml",
+  category: "config",
+  auto: true,
+  async check(rootDir) {
+    const config = readConfig(rootDir);
+    if (!config) return { needed: false, reason: "No config.yaml found" };
+    if (configHasField(config, "discipline")) {
+      return { needed: false, reason: "discipline already set" };
+    }
+    return { needed: true, reason: "Missing discipline field" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would add discipline to config.yaml" };
+    const raw = readConfigRaw(rootDir);
+    if (!raw) return { status: "error", message: "Cannot read config.yaml" };
+    const updated = raw.replace(
+      /^(project:\s*.+)$/m,
+      "$1\ndiscipline: auto"
+    );
+    if (updated === raw) {
+      writeConfigRaw(rootDir, raw.trimEnd() + "\ndiscipline: auto\n");
+    } else {
+      writeConfigRaw(rootDir, updated);
+    }
+    return { status: "applied", message: "Added discipline: auto to config.yaml", filesModified: [".paradigm/config.yaml"] };
+  }
+};
+var syncTemplates = {
+  id: "sync-templates",
+  introducedIn: "evergreen",
+  description: "Update specs/ and docs/ from installed CLI templates",
+  category: "template",
+  auto: true,
+  async check(rootDir) {
+    const templatesDir = getTemplatesDir();
+    if (!templatesDir) return { needed: false, reason: "Templates directory not found" };
+    const newFiles = [];
+    const subdirs = ["specs", "docs", "prompts"];
+    for (const sub of subdirs) {
+      const templateSub = path.join(templatesDir, sub);
+      const projectSub = path.join(rootDir, ".paradigm", sub);
+      if (!fs.existsSync(templateSub)) continue;
+      try {
+        const files = fs.readdirSync(templateSub).filter((f) => {
+          const s = fs.statSync(path.join(templateSub, f));
+          return s.isFile();
+        });
+        for (const file of files) {
+          if (!fs.existsSync(path.join(projectSub, file))) {
+            newFiles.push(`${sub}/${file}`);
+          }
+        }
+      } catch {
+      }
+    }
+    if (newFiles.length === 0) return { needed: false, reason: "All templates are up to date" };
+    return {
+      needed: true,
+      reason: `${newFiles.length} new template file(s) available`,
+      details: newFiles.map((f) => `New: ${f}`)
+    };
+  },
+  async apply(rootDir, opts) {
+    const templatesDir = getTemplatesDir();
+    if (!templatesDir) return { status: "error", message: "Templates directory not found" };
+    const projectName = path.basename(rootDir);
+    const created = [];
+    const subdirs = ["specs", "docs", "prompts"];
+    for (const sub of subdirs) {
+      const templateSub = path.join(templatesDir, sub);
+      const projectSub = path.join(rootDir, ".paradigm", sub);
+      if (!fs.existsSync(templateSub)) continue;
+      if (!opts.dryRun) {
+        fs.mkdirSync(projectSub, { recursive: true });
+      }
+      try {
+        const entries = fs.readdirSync(templateSub, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) continue;
+          const dest = path.join(projectSub, entry.name);
+          if (!fs.existsSync(dest)) {
+            if (opts.dryRun) {
+              created.push(`${sub}/${entry.name}`);
+              continue;
+            }
+            let content = fs.readFileSync(path.join(templateSub, entry.name), "utf8");
+            content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+            fs.writeFileSync(dest, content, "utf8");
+            created.push(`${sub}/${entry.name}`);
+          }
+        }
+      } catch {
+      }
+    }
+    if (opts.dryRun) {
+      return { status: "skipped", message: `Would copy ${created.length} template file(s)` };
+    }
+    if (created.length === 0) return { status: "skipped", message: "No new templates to sync" };
+    return {
+      status: "applied",
+      message: `Synced ${created.length} template file(s)`,
+      filesCreated: created.map((f) => `.paradigm/${f}`)
+    };
+  }
+};
+var refreshHooks = {
+  id: "refresh-hooks",
+  introducedIn: "evergreen",
+  description: "Reinstall hook scripts from plugin",
+  category: "hook",
+  auto: true,
+  async check(rootDir) {
+    const hookLocations = [
+      path.join(rootDir, ".claude", "hooks"),
+      path.join(rootDir, ".cursor", "hooks")
+    ];
+    for (const hookDir of hookLocations) {
+      if (!fs.existsSync(hookDir)) continue;
+      try {
+        const files = fs.readdirSync(hookDir);
+        if (files.some((f) => f.includes("paradigm"))) {
+          return { needed: false, reason: "Hooks are installed" };
+        }
+      } catch {
+      }
+    }
+    const claudeSettings = path.join(rootDir, ".claude", "settings.local.json");
+    if (fs.existsSync(claudeSettings)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(claudeSettings, "utf8"));
+        if (settings.hooks) {
+          return { needed: false, reason: "Plugin-managed hooks are configured" };
+        }
+      } catch {
+      }
+    }
+    return { needed: true, reason: "No paradigm hooks found" };
+  },
+  async apply(rootDir, opts) {
+    if (opts.dryRun) return { status: "skipped", message: "Would reinstall hooks" };
+    try {
+      const { hooksInstallCommand } = await import("./hooks-TCUHQMPF.js");
+      await hooksInstallCommand({ force: true });
+      return { status: "applied", message: "Hooks reinstalled" };
+    } catch (err) {
+      return { status: "error", message: `Hook install failed: ${err.message}` };
+    }
+  }
+};
+var migrations = [
+  // Pre-3.0 legacy
+  legacyFileToDirectory,
+  legacyScanIndexLocation,
+  // 3.0–3.5 foundation
+  addSpecsDirectory,
+  addDocsDirectory,
+  addPromptsDirectory,
+  addTagBankConfig,
+  addPurposeRequiredConfig,
+  addDisciplineConfig,
+  // 3.5–3.18 features
+  addWisdomDirectory,
+  addHistoryDirectory,
+  addLoreDirectory,
+  addTasksDirectory,
+  addPersonasDirectory,
+  addProtocolsDirectory,
+  addHabitsDirectory,
+  // 3.19+ refinements
+  migrateAssessmentsToLore,
+  addComponentTypesConfig,
+  // Evergreen
+  syncTemplates,
+  refreshHooks
+];
+
+// src/commands/migrate/detector.ts
+var require2 = createRequire(import.meta.url);
+var { version: CLI_VERSION } = require2("../package.json");
+function loadMigrationState(rootDir) {
+  const p = path2.join(rootDir, ".paradigm", "migrate.yaml");
+  if (!fs2.existsSync(p)) return null;
+  try {
+    const content = fs2.readFileSync(p, "utf8");
+    return yaml2.load(content);
+  } catch {
+    return null;
+  }
+}
+async function detectProjectState(rootDir) {
+  const paradigmDir = path2.join(rootDir, ".paradigm");
+  const state = loadMigrationState(rootDir);
+  const appliedIds = state?.applied.map((a) => a.id) ?? [];
+  let configVersion = "unknown";
+  const configPath = path2.join(paradigmDir, "config.yaml");
+  if (fs2.existsSync(configPath)) {
+    try {
+      const config = yaml2.load(fs2.readFileSync(configPath, "utf8"));
+      configVersion = String(config.version ?? "unknown");
+    } catch {
+    }
+  }
+  const expectedDirs = ["specs", "docs", "prompts", "lore", "tasks", "protocols", "personas"];
+  const missingDirectories = expectedDirs.filter((d) => !fs2.existsSync(path2.join(paradigmDir, d)));
+  const expectedConfigFields = ["discipline", "tag-bank", "purpose-required", "component_types"];
+  let missingConfigFields = [];
+  if (fs2.existsSync(configPath)) {
+    try {
+      const config = yaml2.load(fs2.readFileSync(configPath, "utf8"));
+      missingConfigFields = expectedConfigFields.filter((f) => {
+        const key = f.replace(/-/g, "_");
+        return !(f in config) && !(key in config) && !(f.replace(/_/g, "-") in config);
+      });
+    } catch {
+    }
+  }
+  const staleTemplates = [];
+  const templatesDir = getTemplatesDir();
+  if (templatesDir) {
+    const templateSubdirs = ["specs", "docs"];
+    for (const sub of templateSubdirs) {
+      const templateSub = path2.join(templatesDir, sub);
+      const projectSub = path2.join(paradigmDir, sub);
+      if (fs2.existsSync(templateSub) && fs2.existsSync(projectSub)) {
+        const templateFiles = fs2.readdirSync(templateSub).filter((f) => !fs2.statSync(path2.join(templateSub, f)).isDirectory());
+        for (const file of templateFiles) {
+          const projectFile = path2.join(projectSub, file);
+          if (!fs2.existsSync(projectFile)) {
+            staleTemplates.push(`${sub}/${file}`);
+          }
+        }
+      }
+    }
+  }
+  const hooksOutdated = !fs2.existsSync(path2.join(rootDir, ".claude", "hooks"));
+  const pendingMigrations = [];
+  for (const migration of migrations) {
+    const isEvergreen = migration.introducedIn === "evergreen";
+    if (appliedIds.includes(migration.id) && !isEvergreen) continue;
+    const result = await migration.check(rootDir);
+    if (result.needed) {
+      pendingMigrations.push(migration);
+    }
+  }
+  if (!state) {
+  }
+  return {
+    configVersion,
+    cliVersion: CLI_VERSION,
+    pendingMigrations,
+    appliedIds,
+    health: {
+      missingDirectories,
+      missingConfigFields,
+      staleTemplates,
+      hooksOutdated
+    }
+  };
+}
+async function bootstrapAppliedList(rootDir) {
+  const applied = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const migration of migrations) {
+    if (migration.introducedIn === "evergreen") continue;
+    const result = await migration.check(rootDir);
+    if (!result.needed) {
+      applied.push({ id: migration.id, appliedAt: now, cliVersion: CLI_VERSION });
+    }
+  }
+  return applied;
+}
+function getTemplatesDir() {
+  const __filename = new URL(import.meta.url).pathname;
+  const __dirname = path2.dirname(__filename);
+  const candidates = [
+    path2.join(__dirname, "..", "..", "..", "templates", "paradigm"),
+    path2.join(__dirname, "..", "..", "templates", "paradigm"),
+    path2.join(__dirname, "..", "templates", "paradigm")
+  ];
+  for (const p of candidates) {
+    if (fs2.existsSync(p)) return p;
+  }
+  return null;
+}
+
+// src/commands/migrate/runner.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as yaml3 from "js-yaml";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var { version: CLI_VERSION2 } = require3("../package.json");
+async function getOrCreateState(rootDir) {
+  const existing = loadMigrationState(rootDir);
+  if (existing) return existing;
+  const applied = await bootstrapAppliedList(rootDir);
+  const state = {
+    version: "1.0",
+    cliVersion: CLI_VERSION2,
+    lastMigrated: (/* @__PURE__ */ new Date()).toISOString(),
+    applied
+  };
+  return state;
+}
+function saveMigrationState(rootDir, state) {
+  const p = path3.join(rootDir, ".paradigm", "migrate.yaml");
+  fs3.mkdirSync(path3.dirname(p), { recursive: true });
+  state.cliVersion = CLI_VERSION2;
+  state.lastMigrated = (/* @__PURE__ */ new Date()).toISOString();
+  fs3.writeFileSync(p, yaml3.dump(state, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+    quotingType: '"'
+  }), "utf8");
+}
+async function runMigrations(rootDir, pending, options, state) {
+  const summary = { applied: 0, skipped: 0, errors: 0, manual: 0, results: [] };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const migration of pending) {
+    if (!migration.auto) {
+      summary.manual++;
+      summary.results.push({ id: migration.id, result: { status: "skipped", message: "Manual review recommended" } });
+      continue;
+    }
+    try {
+      const result = await migration.apply(rootDir, options);
+      summary.results.push({ id: migration.id, result });
+      if (result.status === "applied") {
+        summary.applied++;
+        state.applied.push({ id: migration.id, appliedAt: now, cliVersion: CLI_VERSION2 });
+      } else if (result.status === "skipped") {
+        summary.skipped++;
+      } else {
+        summary.errors++;
+      }
+    } catch (err) {
+      summary.errors++;
+      summary.results.push({
+        id: migration.id,
+        result: { status: "error", message: err.message }
+      });
+    }
+  }
+  return summary;
+}
+
+// src/commands/migrate/index.ts
+async function migrateCommand(options = {}) {
+  const cwd = process.cwd();
+  const paradigmDir = path4.join(cwd, ".paradigm");
+  if (!fs4.existsSync(paradigmDir) || !fs4.statSync(paradigmDir).isDirectory()) {
+    if (fs4.existsSync(paradigmDir) && fs4.statSync(paradigmDir).isFile()) {
+    } else {
+      if (!options.quiet) {
+        console.log(chalk.yellow("\n  No .paradigm/ directory found. Run `paradigm init` or `paradigm shift` first.\n"));
+      }
+      return;
+    }
+  }
+  const spinner = ora();
+  if (!options.quiet) {
+    spinner.start("Detecting project state...");
+  }
+  const detection = await detectProjectState(cwd);
+  if (!options.quiet) {
+    spinner.stop();
+  }
+  const state = await getOrCreateState(cwd);
+  let pending = detection.pendingMigrations;
+  if (options.only && options.only.length > 0) {
+    pending = pending.filter((m) => options.only.includes(m.id));
+  }
+  if (options.category) {
+    pending = pending.filter((m) => m.category === options.category);
+  }
+  if (options.force) {
+    const all = options.only ? migrations.filter((m) => options.only.includes(m.id)) : options.category ? migrations.filter((m) => m.category === options.category) : migrations;
+    pending = [];
+    for (const m of all) {
+      const result = await m.check(cwd);
+      if (result.needed || options.force) {
+        pending.push(m);
+      }
+    }
+  }
+  const autoMigrations = pending.filter((m) => m.auto);
+  const manualMigrations = pending.filter((m) => !m.auto);
+  if (options.list) {
+    printMigrationList(state, detection, options);
+    return;
+  }
+  if (options.quiet) {
+    if (autoMigrations.length === 0) return;
+    const summary = await runMigrations(cwd, autoMigrations, options, state);
+    saveMigrationState(cwd, state);
+    return summary;
+  }
+  const existingState = loadMigrationState(cwd);
+  console.log(chalk.blue("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.blue("\u2502") + chalk.white.bold("  paradigm migrate                                ") + chalk.blue("\u2502"));
+  console.log(chalk.blue("\u2502") + chalk.gray("  Bring your project up to date                  ") + chalk.blue("\u2502"));
+  console.log(chalk.blue("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n"));
+  console.log(chalk.white(`  Project:        ${chalk.cyan(path4.basename(cwd))}`));
+  console.log(chalk.white(`  Config version: ${chalk.cyan(detection.configVersion)}`));
+  console.log(chalk.white(`  CLI version:    ${chalk.cyan(detection.cliVersion)}`));
+  console.log(chalk.white(`  Last migrated:  ${chalk.cyan(existingState?.lastMigrated ?? "never")}`));
+  console.log("");
+  if (pending.length === 0) {
+    console.log(chalk.green("  All migrations are up to date.\n"));
+    if (!existingState) {
+      saveMigrationState(cwd, state);
+      if (options.verbose) {
+        console.log(chalk.gray("  Created .paradigm/migrate.yaml with bootstrap state.\n"));
+      }
+    }
+    return;
+  }
+  if (options.verbose) {
+    const h = detection.health;
+    if (h.missingDirectories.length > 0) {
+      console.log(chalk.yellow(`  Missing directories: ${h.missingDirectories.join(", ")}`));
+    }
+    if (h.missingConfigFields.length > 0) {
+      console.log(chalk.yellow(`  Missing config fields: ${h.missingConfigFields.join(", ")}`));
+    }
+    if (h.staleTemplates.length > 0) {
+      console.log(chalk.yellow(`  New templates available: ${h.staleTemplates.join(", ")}`));
+    }
+    if (h.hooksOutdated) {
+      console.log(chalk.yellow("  Hooks need installation"));
+    }
+    console.log("");
+  }
+  const autoCount = autoMigrations.length;
+  const manualCount = manualMigrations.length;
+  console.log(chalk.white(`  Pending Migrations (${autoCount} auto${manualCount > 0 ? `, ${manualCount} manual` : ""})`));
+  console.log(chalk.gray("  " + "\u2500".repeat(49)));
+  if (autoMigrations.length > 0) {
+    console.log(chalk.white("  AUTO:"));
+    for (const m of autoMigrations) {
+      const idPad = m.id.padEnd(30);
+      console.log(chalk.green("  \u2713 ") + chalk.white(idPad) + chalk.gray(m.description));
+      if (options.verbose) {
+        const checkResult = await m.check(cwd);
+        if (checkResult.details) {
+          for (const d of checkResult.details) {
+            console.log(chalk.gray("    \u21B3 ") + chalk.gray(d));
+          }
+        }
+      }
+    }
+  }
+  if (manualMigrations.length > 0) {
+    console.log("");
+    console.log(chalk.white("  MANUAL (review recommended):"));
+    for (const m of manualMigrations) {
+      const idPad = m.id.padEnd(30);
+      console.log(chalk.yellow("  \u25CB ") + chalk.white(idPad) + chalk.gray(m.description));
+      const checkResult = await m.check(cwd);
+      if (checkResult.details) {
+        for (const d of checkResult.details) {
+          console.log(chalk.gray("    \u2192 ") + chalk.cyan(d));
+        }
+      }
+    }
+  }
+  console.log("");
+  if (options.dryRun) {
+    console.log(chalk.yellow("  Dry run \u2014 no changes applied.\n"));
+    return;
+  }
+  if (autoMigrations.length > 0) {
+    if (!options.apply) {
+      const prompts = (await import("prompts")).default;
+      const { confirm } = await prompts({
+        type: "confirm",
+        name: "confirm",
+        message: `Apply ${autoMigrations.length} automatic migration(s)?`,
+        initial: true
+      });
+      if (!confirm) {
+        console.log(chalk.gray("\n  Skipped. Run with --apply to auto-apply.\n"));
+        return;
+      }
+    }
+    spinner.start(`Applying ${autoMigrations.length} migration(s)...`);
+    const summary = await runMigrations(cwd, autoMigrations, options, state);
+    spinner.stop();
+    for (const { id, result } of summary.results) {
+      if (result.status === "applied") {
+        console.log(chalk.green("  \u2713 ") + chalk.white(id) + chalk.gray(` \u2014 ${result.message}`));
+      } else if (result.status === "error") {
+        console.log(chalk.red("  \u2717 ") + chalk.white(id) + chalk.gray(` \u2014 ${result.message}`));
+      } else {
+        console.log(chalk.yellow("  \u25CB ") + chalk.white(id) + chalk.gray(` \u2014 ${result.message}`));
+      }
+    }
+    console.log("");
+    console.log(chalk.green(`  Applied ${summary.applied} migration(s).`));
+    if (summary.errors > 0) {
+      console.log(chalk.red(`  ${summary.errors} error(s).`));
+    }
+  }
+  saveMigrationState(cwd, state);
+  console.log(chalk.gray("  Updated .paradigm/migrate.yaml"));
+  console.log("");
+}
+function printMigrationList(state, detection, options) {
+  const appliedIds = new Set(state.applied.map((a) => a.id));
+  const pendingIds = new Set(detection.pendingMigrations.map((m) => m.id));
+  console.log(chalk.blue("\n  All Migrations"));
+  console.log(chalk.gray("  " + "\u2500".repeat(70)));
+  console.log(
+    chalk.gray("  Status  ") + chalk.gray("ID".padEnd(34)) + chalk.gray("Version".padEnd(12)) + chalk.gray("Category")
+  );
+  console.log(chalk.gray("  " + "\u2500".repeat(70)));
+  for (const m of migrations) {
+    let status;
+    if (appliedIds.has(m.id)) {
+      status = chalk.green("  \u2713     ");
+    } else if (pendingIds.has(m.id)) {
+      status = m.auto ? chalk.yellow("  \u25CF     ") : chalk.yellow("  \u25CB     ");
+    } else {
+      status = chalk.gray("  -     ");
+    }
+    const id = m.id.padEnd(34);
+    const version = (m.introducedIn === "evergreen" ? "evergreen" : m.introducedIn).padEnd(12);
+    const cat = m.category;
+    console.log(status + chalk.white(id) + chalk.gray(version) + chalk.gray(cat));
+    if (options.verbose) {
+      console.log(chalk.gray(`          ${m.description}`));
+    }
+  }
+  console.log("");
+  console.log(chalk.gray(`  \u2713 = applied  \u25CF = pending (auto)  \u25CB = pending (manual)  - = not needed`));
+  console.log("");
+}
+export {
+  migrateCommand
+};