@a-company/paradigm 5.10.0 → 5.21.0

package/dist/migrate-LS45DNEV.js

@@ -1,889 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.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 findUnmigratedAssessments(assessDir) {
-  try {
-    const walk = (dir) => {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          if (walk(path.join(dir, entry.name))) return true;
-        } else if (entry.name.endsWith(".yaml") && !entry.name.endsWith(".migrated")) {
-          if (entry.name !== "index.yaml" && entry.name !== "arc.yaml") return true;
-        }
-      }
-      return false;
-    };
-    return walk(assessDir);
-  } catch {
-    return false;
-  }
-}
-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 hasUnmigrated = findUnmigratedAssessments(assessDir);
-      if (!hasUnmigrated) return { needed: false, reason: "All assessments already migrated" };
-      return {
-        needed: true,
-        reason: "Unmigrated assessment entries found",
-        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-HFWSCGPV.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
-};