schemashift-cli 0.3.0

package/dist/cli.js

@@ -0,0 +1,810 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+import {
+  loadConfig,
+  SchemaAnalyzer,
+  TransformEngine
+} from "@schemashift/core";
+import { createIoTsToZodHandler } from "@schemashift/io-ts-zod";
+import { createJoiToZodHandler } from "@schemashift/joi-zod";
+import { canUseMigration, LicenseManager, LicenseTier, TIER_FEATURES } from "@schemashift/license";
+import { createYupToZodHandler } from "@schemashift/yup-zod";
+import { createZodV3ToV4Handler } from "@schemashift/zod-v3-v4";
+import { Command } from "commander";
+import { glob as glob2 } from "glob";
+import { Listr } from "listr2";
+import pc2 from "picocolors";
+
+// src/backup.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, relative } from "path";
+var BackupManager = class {
+  backupDir;
+  constructor(backupDir = ".schemashift-backup") {
+    this.backupDir = backupDir;
+  }
+  createBackup(files, from, to) {
+    const id = `backup-${Date.now()}`;
+    const backupPath = join(this.backupDir, id);
+    if (!existsSync(backupPath)) {
+      mkdirSync(backupPath, { recursive: true });
+    }
+    const manifest = {
+      id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      from,
+      to,
+      files: []
+    };
+    for (const file of files) {
+      const relativePath = relative(process.cwd(), file);
+      const backupFile = join(backupPath, relativePath);
+      const backupFileDir = dirname(backupFile);
+      if (!existsSync(backupFileDir)) {
+        mkdirSync(backupFileDir, { recursive: true });
+      }
+      copyFileSync(file, backupFile);
+      manifest.files.push({
+        original: file,
+        backup: backupFile,
+        transformed: false
+      });
+    }
+    writeFileSync(join(backupPath, "manifest.json"), JSON.stringify(manifest, null, 2));
+    return manifest;
+  }
+  listBackups() {
+    if (!existsSync(this.backupDir)) return [];
+    const backups = [];
+    const dirs = readdirSync(this.backupDir, { withFileTypes: true }).filter(
+      (d) => d.isDirectory() && d.name.startsWith("backup-")
+    );
+    for (const dir of dirs) {
+      const manifestPath = join(this.backupDir, dir.name, "manifest.json");
+      if (existsSync(manifestPath)) {
+        backups.push(JSON.parse(readFileSync(manifestPath, "utf-8")));
+      }
+    }
+    return backups.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+  }
+  restore(backupId) {
+    const backupPath = join(this.backupDir, backupId);
+    const manifestPath = join(backupPath, "manifest.json");
+    if (!existsSync(manifestPath)) {
+      throw new Error(`Backup ${backupId} not found`);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    for (const file of manifest.files) {
+      if (existsSync(file.backup)) {
+        copyFileSync(file.backup, file.original);
+      }
+    }
+  }
+  deleteBackup(backupId) {
+    const backupPath = join(this.backupDir, backupId);
+    if (existsSync(backupPath)) {
+      rmSync(backupPath, { recursive: true });
+    }
+  }
+  cleanOldBackups(keepCount = 5) {
+    const backups = this.listBackups();
+    const toDelete = backups.slice(keepCount);
+    for (const backup of toDelete) {
+      this.deleteBackup(backup.id);
+    }
+  }
+};
+
+// src/git.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+var GitIntegration = class {
+  isGitRepo;
+  constructor() {
+    this.isGitRepo = existsSync2(".git");
+  }
+  isAvailable() {
+    if (!this.isGitRepo) return false;
+    try {
+      execSync("git --version", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCurrentBranch() {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8"
+    }).trim();
+  }
+  hasUncommittedChanges() {
+    const status = execSync("git status --porcelain", { encoding: "utf-8" });
+    return status.length > 0;
+  }
+  createBranch(name) {
+    execSync(`git checkout -b ${name}`, { stdio: "inherit" });
+  }
+  stageFiles(files) {
+    for (const file of files) {
+      execSync(`git add "${file}"`, { stdio: "ignore" });
+    }
+  }
+  commit(message) {
+    execSync(`git commit -m "${message}"`, { stdio: "inherit" });
+  }
+  generateBranchName(prefix, from, to) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return `${prefix}${from}-to-${to}-${timestamp}`;
+  }
+};
+
+// src/report.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+var ReportGenerator = class {
+  generateReport(results, from, to, startTime, customRules = []) {
+    const endTime = Date.now();
+    return {
+      summary: {
+        totalFiles: results.length,
+        successfulFiles: results.filter((r) => r.success).length,
+        failedFiles: results.filter((r) => !r.success).length,
+        totalWarnings: results.reduce((acc, r) => acc + r.warnings.length, 0),
+        from,
+        to,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration: endTime - startTime
+      },
+      files: results.map((r) => ({
+        path: r.filePath,
+        success: r.success,
+        errors: r.errors.map((e) => e.message),
+        warnings: r.warnings,
+        diff: r.transformedCode ? {
+          before: r.originalCode,
+          after: r.transformedCode
+        } : void 0
+      })),
+      customRulesApplied: customRules
+    };
+  }
+  writeJson(report, outputPath) {
+    writeFileSync2(outputPath, JSON.stringify(report, null, 2));
+  }
+  writeHtml(report, outputPath) {
+    const html = this.generateHtml(report);
+    writeFileSync2(outputPath, html);
+  }
+  generateHtml(report) {
+    const successRate = Math.round(
+      report.summary.successfulFiles / report.summary.totalFiles * 100
+    );
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SchemaShift Migration Report</title>
+  <style>
+    :root {
+      --success: #10b981;
+      --error: #ef4444;
+      --warning: #f59e0b;
+      --bg: #0f172a;
+      --surface: #1e293b;
+      --text: #e2e8f0;
+      --muted: #94a3b8;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.6;
+      padding: 2rem;
+    }
+    .container { max-width: 1200px; margin: 0 auto; }
+    h1 { font-size: 2rem; margin-bottom: 0.5rem; }
+    .subtitle { color: var(--muted); margin-bottom: 2rem; }
+    .summary {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1rem;
+      margin-bottom: 2rem;
+    }
+    .card {
+      background: var(--surface);
+      border-radius: 0.5rem;
+      padding: 1.5rem;
+    }
+    .card-label { color: var(--muted); font-size: 0.875rem; }
+    .card-value { font-size: 2rem; font-weight: bold; }
+    .card-value.success { color: var(--success); }
+    .card-value.error { color: var(--error); }
+    .card-value.warning { color: var(--warning); }
+    .progress-bar {
+      height: 8px;
+      background: var(--surface);
+      border-radius: 4px;
+      margin: 1rem 0;
+      overflow: hidden;
+    }
+    .progress-fill {
+      height: 100%;
+      background: var(--success);
+      transition: width 0.3s;
+    }
+    .file-list { list-style: none; }
+    .file-item {
+      background: var(--surface);
+      border-radius: 0.5rem;
+      padding: 1rem;
+      margin-bottom: 0.5rem;
+    }
+    .file-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .file-path { font-family: monospace; }
+    .badge {
+      padding: 0.25rem 0.5rem;
+      border-radius: 0.25rem;
+      font-size: 0.75rem;
+      font-weight: bold;
+    }
+    .badge.success { background: var(--success); color: white; }
+    .badge.error { background: var(--error); color: white; }
+    .warnings {
+      margin-top: 0.5rem;
+      padding-left: 1rem;
+      border-left: 2px solid var(--warning);
+      color: var(--warning);
+      font-size: 0.875rem;
+    }
+    .diff {
+      margin-top: 1rem;
+      background: #0d1117;
+      border-radius: 0.25rem;
+      padding: 1rem;
+      font-family: monospace;
+      font-size: 0.75rem;
+      overflow-x: auto;
+    }
+    details summary { cursor: pointer; color: var(--muted); }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>SchemaShift Migration Report</h1>
+    <p class="subtitle">${report.summary.from} \u2192 ${report.summary.to} | ${new Date(report.summary.timestamp).toLocaleString()}</p>
+    
+    <div class="summary">
+      <div class="card">
+        <div class="card-label">Total Files</div>
+        <div class="card-value">${report.summary.totalFiles}</div>
+      </div>
+      <div class="card">
+        <div class="card-label">Successful</div>
+        <div class="card-value success">${report.summary.successfulFiles}</div>
+      </div>
+      <div class="card">
+        <div class="card-label">Failed</div>
+        <div class="card-value error">${report.summary.failedFiles}</div>
+      </div>
+      <div class="card">
+        <div class="card-label">Warnings</div>
+        <div class="card-value warning">${report.summary.totalWarnings}</div>
+      </div>
+    </div>
+    
+    <div class="card">
+      <div class="card-label">Success Rate</div>
+      <div class="progress-bar">
+        <div class="progress-fill" style="width: ${successRate}%"></div>
+      </div>
+      <div class="card-value">${successRate}%</div>
+    </div>
+    
+    <h2 style="margin: 2rem 0 1rem;">Files</h2>
+    <ul class="file-list">
+      ${report.files.map(
+      (file) => `
+        <li class="file-item">
+          <div class="file-header">
+            <span class="file-path">${file.path}</span>
+            <span class="badge ${file.success ? "success" : "error"}">${file.success ? "Success" : "Failed"}</span>
+          </div>
+          ${file.errors.length > 0 ? `
+            <div class="warnings" style="border-color: var(--error); color: var(--error);">
+              ${file.errors.map((e) => `<div>${e}</div>`).join("")}
+            </div>
+          ` : ""}
+          ${file.warnings.length > 0 ? `
+            <div class="warnings">
+              ${file.warnings.map((w) => `<div>${w}</div>`).join("")}
+            </div>
+          ` : ""}
+          ${file.diff ? `
+            <details>
+              <summary>View diff</summary>
+              <div class="diff">
+                <pre>${this.escapeHtml(file.diff.after)}</pre>
+              </div>
+            </details>
+          ` : ""}
+        </li>
+      `
+    ).join("")}
+    </ul>
+    
+    <footer style="margin-top: 2rem; text-align: center; color: var(--muted);">
+      Generated by SchemaShift | Duration: ${report.summary.duration}ms
+    </footer>
+  </div>
+</body>
+</html>`;
+  }
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+};
+
+// src/watch.ts
+import { watch } from "fs";
+import { relative as relative2 } from "path";
+import { glob } from "glob";
+import pc from "picocolors";
+var WatchMode = class {
+  watchers = [];
+  debounceTimers = /* @__PURE__ */ new Map();
+  async start(options) {
+    const files = await glob(options.patterns, {
+      ignore: options.exclude
+    });
+    console.log(pc.cyan(`
+Watching ${files.length} files for changes...
+`));
+    console.log(pc.dim("Press Ctrl+C to stop\n"));
+    const directories = new Set(files.map((f) => f.split("/").slice(0, -1).join("/")));
+    for (const dir of directories) {
+      const watcher = watch(dir || ".", { recursive: true }, async (_event, filename) => {
+        if (!filename) return;
+        const fullPath = dir ? `${dir}/${filename}` : filename;
+        if (!this.matchesPatterns(fullPath, options.patterns, options.exclude)) {
+          return;
+        }
+        const existingTimer = this.debounceTimers.get(fullPath);
+        if (existingTimer) {
+          clearTimeout(existingTimer);
+        }
+        this.debounceTimers.set(
+          fullPath,
+          setTimeout(async () => {
+            console.log(pc.yellow(`
+Changed: ${relative2(process.cwd(), fullPath)}`));
+            try {
+              await options.onTransform(fullPath);
+              console.log(pc.green(`Transformed successfully
+`));
+            } catch (error) {
+              console.error(pc.red(`Transform failed: ${error}
+`));
+            }
+            this.debounceTimers.delete(fullPath);
+          }, 100)
+        );
+      });
+      this.watchers.push(watcher);
+    }
+  }
+  stop() {
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    this.watchers = [];
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  matchesPatterns(file, _include, _exclude) {
+    const isIncluded = file.endsWith(".ts") || file.endsWith(".tsx");
+    const isExcluded = file.includes("node_modules") || file.includes("dist");
+    return isIncluded && !isExcluded;
+  }
+};
+
+// src/cli.ts
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync2(join2(__dirname2, "..", "package.json"), "utf-8"));
+var program = new Command();
+var licenseManager = new LicenseManager();
+var engine = new TransformEngine();
+engine.registerHandler("yup", "zod", createYupToZodHandler());
+engine.registerHandler("joi", "zod", createJoiToZodHandler());
+engine.registerHandler("io-ts", "zod", createIoTsToZodHandler());
+engine.registerHandler("zod-v3", "v4", createZodV3ToV4Handler());
+var POLAR_URL = "https://schemashift.qwady.app";
+program.name("schemashift").version(pkg.version).description("TypeScript schema migration CLI");
+program.command("init").description("Create .schemashiftrc.json config file").option("-f, --force", "Overwrite existing config").action((options) => {
+  const configPath = ".schemashiftrc.json";
+  if (existsSync3(configPath) && !options.force) {
+    console.error(pc2.red("Config file already exists. Use --force to overwrite."));
+    process.exit(1);
+  }
+  const defaultConfig = {
+    include: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["**/node_modules/**", "**/dist/**", "**/*.d.ts", "**/*.test.ts"],
+    git: {
+      enabled: false,
+      createBranch: true,
+      branchPrefix: "schemashift/",
+      autoCommit: false,
+      commitMessage: "chore: migrate schemas with SchemaShift"
+    },
+    backup: {
+      enabled: true,
+      dir: ".schemashift-backup"
+    },
+    customRules: [],
+    ci: false
+  };
+  writeFileSync3(configPath, JSON.stringify(defaultConfig, null, 2));
+  console.log(pc2.green("Created .schemashiftrc.json"));
+  console.log(pc2.dim("Edit the file to customize your migration settings."));
+});
+program.command("analyze <path>").description("Analyze schemas in your project").option("--json", "Output as JSON").option("-v, --verbose", "Show detailed analysis").action(async (targetPath, options) => {
+  const analyzer = new SchemaAnalyzer();
+  const files = await glob2(join2(targetPath, "**/*.{ts,tsx}"), {
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  for (const file of files) {
+    analyzer.addSourceFiles([file]);
+  }
+  const result = analyzer.analyze();
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(pc2.bold("\nSchema Analysis\n"));
+  console.log(`Total files: ${pc2.cyan(result.totalFiles.toString())}`);
+  console.log(`Files with schemas: ${pc2.cyan(result.filesWithSchemas.toString())}`);
+  console.log(`Total schemas: ${pc2.cyan(result.schemas.length.toString())}`);
+  if (result.schemas.length > 0) {
+    console.log(pc2.bold("\nSchemas by library:\n"));
+    const byLibrary = /* @__PURE__ */ new Map();
+    for (const schema of result.schemas) {
+      byLibrary.set(schema.library, (byLibrary.get(schema.library) || 0) + 1);
+    }
+    for (const [lib, count] of byLibrary) {
+      console.log(`  ${lib}: ${count}`);
+    }
+    if (options.verbose) {
+      console.log(pc2.bold("\nDetailed schemas:\n"));
+      for (const schema of result.schemas.slice(0, 20)) {
+        console.log(`  ${pc2.cyan(schema.name)} (${schema.library})`);
+        console.log(`    ${pc2.dim(schema.filePath)}:${schema.lineNumber}`);
+      }
+      if (result.schemas.length > 20) {
+        console.log(pc2.dim(`  ... and ${result.schemas.length - 20} more`));
+      }
+    }
+  }
+});
+program.command("migrate <path>").description("Migrate schemas from one library to another").requiredOption("-f, --from <library>", "Source library (yup, joi, io-ts, zod-v3)").requiredOption("-t, --to <library>", "Target library (zod, v4, valibot)").option("-d, --dry-run", "Preview changes without writing files").option("-v, --verbose", "Show detailed transformation info").option("-c, --config <path>", "Path to config file").option("--report <format>", "Generate report (json, html)").option("--report-output <path>", "Report output path").option("--git-branch", "Create git branch for changes").option("--git-commit", "Auto-commit changes").option("--no-backup", "Skip backup creation").option("--ci", "CI mode (non-interactive, exit code on failure)").action(async (targetPath, options) => {
+  const startTime = Date.now();
+  let config;
+  try {
+    config = await loadConfig(options.config);
+  } catch {
+    config = {
+      include: ["**/*.ts", "**/*.tsx"],
+      exclude: ["**/node_modules/**", "**/dist/**"],
+      backup: { enabled: true, dir: ".schemashift-backup" },
+      git: { enabled: false }
+    };
+  }
+  const validation = await licenseManager.validate();
+  if (!validation.valid) {
+    console.error(pc2.red(`License error: ${validation.error}`));
+    process.exit(1);
+  }
+  const tier = validation.license?.tier || LicenseTier.FREE;
+  const features = validation.license?.features || TIER_FEATURES[LicenseTier.FREE];
+  const migrationPath = `${options.from}->${options.to}`;
+  if (!canUseMigration(tier, options.from, options.to)) {
+    console.error(pc2.red(`Migration ${migrationPath} requires a higher tier.`));
+    console.log(`Your tier: ${pc2.yellow(tier)}`);
+    console.log(`Upgrade at: ${pc2.cyan(POLAR_URL)}`);
+    process.exit(1);
+  }
+  if (!engine.hasHandler(options.from, options.to)) {
+    console.error(pc2.red(`No handler for ${migrationPath}`));
+    console.log(
+      "Supported migrations:",
+      engine.getSupportedPaths().map((p) => `${p.from}->${p.to}`).join(", ")
+    );
+    process.exit(1);
+  }
+  const files = await glob2(join2(targetPath, "**/*.{ts,tsx}"), {
+    ignore: config.exclude
+  });
+  if (files.length === 0) {
+    console.log(pc2.yellow("No files found matching patterns."));
+    process.exit(0);
+  }
+  if (files.length > features.maxFiles) {
+    console.error(
+      pc2.red(`File limit exceeded. Found ${files.length}, max ${features.maxFiles}.`)
+    );
+    console.log(`Upgrade at: ${pc2.cyan(POLAR_URL)}`);
+    process.exit(1);
+  }
+  console.log(pc2.bold(`
+Migrating ${options.from} to ${options.to}
+`));
+  console.log(`Files: ${files.length}`);
+  console.log(`Tier: ${tier}`);
+  if (options.dryRun) {
+    console.log(pc2.yellow("DRY RUN - no files will be modified\n"));
+  }
+  const git = new GitIntegration();
+  if (options.gitBranch && git.isAvailable()) {
+    if (git.hasUncommittedChanges()) {
+      console.error(pc2.red("Uncommitted changes detected. Commit or stash first."));
+      process.exit(1);
+    }
+    const branchName = git.generateBranchName(
+      config.git?.branchPrefix || "schemashift/",
+      options.from,
+      options.to
+    );
+    git.createBranch(branchName);
+    console.log(pc2.dim(`Created branch: ${branchName}`));
+  }
+  const backup = new BackupManager(config.backup?.dir);
+  let backupManifest;
+  if (options.backup !== false && config.backup?.enabled !== false && !options.dryRun) {
+    backupManifest = backup.createBackup(files, options.from, options.to);
+    console.log(pc2.dim(`Backup created: ${backupManifest.id}`));
+  }
+  const results = [];
+  const analyzer = new SchemaAnalyzer();
+  const tasks = new Listr(
+    files.map((file) => ({
+      title: file.replace(`${process.cwd()}/`, ""),
+      task: async () => {
+        analyzer.addSourceFiles([file]);
+        const sourceFile = analyzer.getProject().getSourceFileOrThrow(resolve(file));
+        const result = engine.transform(sourceFile, options.from, options.to, {
+          from: options.from,
+          to: options.to,
+          dryRun: options.dryRun,
+          preserveComments: true
+        });
+        results.push(result);
+        if (result.success && result.transformedCode && !options.dryRun) {
+          writeFileSync3(file, result.transformedCode);
+        }
+        if (!result.success) {
+          throw new Error(result.errors[0]?.message || "Transform failed");
+        }
+      }
+    })),
+    { concurrent: false, exitOnError: false }
+  );
+  try {
+    await tasks.run();
+  } catch {
+  }
+  if (options.gitCommit && git.isAvailable() && !options.dryRun) {
+    const successFiles = results.filter((r) => r.success).map((r) => r.filePath);
+    if (successFiles.length > 0) {
+      git.stageFiles(successFiles);
+      git.commit(config.git?.commitMessage || `chore: migrate ${options.from} to ${options.to}`);
+      console.log(pc2.dim("Changes committed"));
+    }
+  }
+  if (options.report) {
+    if (options.report === "html" && !features.htmlReports) {
+      console.error(pc2.red("HTML reports require Individual tier or higher."));
+      console.log(`Upgrade at: ${pc2.cyan(POLAR_URL)}`);
+    } else {
+      const reporter = new ReportGenerator();
+      const report = reporter.generateReport(
+        results,
+        options.from,
+        options.to,
+        startTime,
+        config.customRules?.map((r) => r.name) || []
+      );
+      const outputPath = options.reportOutput || `schemashift-report.${options.report}`;
+      if (options.report === "html") {
+        reporter.writeHtml(report, outputPath);
+      } else {
+        reporter.writeJson(report, outputPath);
+      }
+      console.log(pc2.green(`Report saved: ${outputPath}`));
+    }
+  }
+  const successful = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  const warnings = results.reduce((acc, r) => acc + r.warnings.length, 0);
+  console.log(pc2.bold("\nSummary\n"));
+  console.log(`Successful: ${pc2.green(successful.toString())}`);
+  console.log(`Failed: ${pc2.red(failed.toString())}`);
+  console.log(`Warnings: ${pc2.yellow(warnings.toString())}`);
+  console.log(`Duration: ${Date.now() - startTime}ms`);
+  if (options.verbose && warnings > 0) {
+    console.log(pc2.yellow("\nWarnings:\n"));
+    for (const result of results) {
+      for (const warning of result.warnings.slice(0, 5)) {
+        console.log(`  ${warning}`);
+      }
+    }
+  }
+  if (options.ci && failed > 0) {
+    process.exit(1);
+  }
+});
+program.command("watch <path>").description("Watch files and migrate on change").requiredOption("-f, --from <library>", "Source library").requiredOption("-t, --to <library>", "Target library").option("-c, --config <path>", "Path to config file").action(async (targetPath, options) => {
+  const validation = await licenseManager.validate();
+  if (!validation.license?.features.watchMode) {
+    console.error(pc2.red("Watch mode requires Pro tier or higher."));
+    console.log(`Upgrade at: ${pc2.cyan(POLAR_URL)}`);
+    process.exit(1);
+  }
+  const config = await loadConfig(options.config);
+  const watchMode = new WatchMode();
+  const analyzer = new SchemaAnalyzer();
+  await watchMode.start({
+    patterns: config.include.map((p) => join2(targetPath, p)),
+    exclude: config.exclude,
+    from: options.from,
+    to: options.to,
+    onTransform: async (file) => {
+      analyzer.addSourceFiles([file]);
+      const sourceFile = analyzer.getProject().getSourceFileOrThrow(resolve(file));
+      const result = engine.transform(sourceFile, options.from, options.to, {
+        from: options.from,
+        to: options.to,
+        dryRun: false,
+        preserveComments: true
+      });
+      if (result.success && result.transformedCode) {
+        writeFileSync3(file, result.transformedCode);
+      } else {
+        throw new Error(result.errors[0]?.message || "Transform failed");
+      }
+    }
+  });
+  process.on("SIGINT", () => {
+    watchMode.stop();
+    console.log(pc2.dim("\nStopped watching."));
+    process.exit(0);
+  });
+});
+program.command("rollback [backupId]").description("Restore files from a backup").option("-l, --list", "List available backups").option("--clean", "Remove old backups (keeps last 5)").action((backupId, options) => {
+  const backup = new BackupManager();
+  if (options.list) {
+    const backups = backup.listBackups();
+    if (backups.length === 0) {
+      console.log(pc2.yellow("No backups found."));
+      return;
+    }
+    console.log(pc2.bold("\nAvailable backups:\n"));
+    for (const b of backups) {
+      console.log(`  ${pc2.cyan(b.id)}`);
+      console.log(`    ${b.from} -> ${b.to} | ${b.files.length} files`);
+      console.log(`    ${pc2.dim(new Date(b.timestamp).toLocaleString())}
+`);
+    }
+    return;
+  }
+  if (options.clean) {
+    backup.cleanOldBackups(5);
+    console.log(pc2.green("Old backups cleaned."));
+    return;
+  }
+  if (!backupId) {
+    const backups = backup.listBackups();
+    if (backups.length === 0) {
+      console.error(pc2.red("No backups available."));
+      process.exit(1);
+    }
+    backupId = backups[0]?.id;
+  }
+  if (!backupId) {
+    console.error(pc2.red("No backup ID provided."));
+    process.exit(1);
+  }
+  try {
+    backup.restore(backupId);
+    console.log(pc2.green(`Restored from ${backupId}`));
+  } catch (error) {
+    console.error(pc2.red(error instanceof Error ? error.message : "Restore failed"));
+    process.exit(1);
+  }
+});
+program.command("license").description("Show license information").option("-a, --activate <key>", "Activate a license key").option("-d, --deactivate", "Deactivate current license").option("-s, --status", "Show license status").action(async (options) => {
+  if (options.activate) {
+    console.log(pc2.dim("Activating license..."));
+    const result = await licenseManager.activate(options.activate);
+    if (result.valid && result.license) {
+      console.log(pc2.green("\nLicense activated successfully!\n"));
+      console.log(`Tier: ${pc2.cyan(result.license.tier)}`);
+      console.log(`Migrations: ${result.license.features.migrations.join(", ")}`);
+      console.log(
+        `Max files: ${result.license.features.maxFiles === Infinity ? "Unlimited" : result.license.features.maxFiles}`
+      );
+    } else {
+      console.error(pc2.red(`
+Activation failed: ${result.error}`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (options.deactivate) {
+    const result = await licenseManager.deactivate();
+    if (result.success) {
+      console.log(pc2.green("License deactivated. You can now activate on another device."));
+    } else {
+      console.error(pc2.red(`Deactivation failed: ${result.error}`));
+      process.exit(1);
+    }
+    return;
+  }
+  const status = await licenseManager.getStatus();
+  console.log(pc2.bold("\nLicense Status\n"));
+  if (!status.activated) {
+    console.log(`Tier: ${pc2.yellow("FREE")}`);
+    console.log("Max files: 5");
+    console.log("Migrations: yup->zod only");
+    console.log("\nActivate a license: schemashift license --activate <key>");
+    console.log(`Purchase: ${pc2.cyan(POLAR_URL)}`);
+    return;
+  }
+  const features = TIER_FEATURES[status.tier];
+  console.log(`Tier: ${pc2.cyan(status.tier.toUpperCase())}`);
+  console.log(`Activated: ${pc2.green("Yes")}`);
+  if (status.email) console.log(`Email: ${status.email}`);
+  if (status.expiresAt) console.log(`Expires: ${status.expiresAt.toLocaleDateString()}`);
+  if (status.lastValidated)
+    console.log(`Last validated: ${status.lastValidated.toLocaleString()}`);
+  console.log("\nFeatures:");
+  console.log(`  Max files: ${features.maxFiles === Infinity ? "Unlimited" : features.maxFiles}`);
+  console.log(`  Migrations: ${features.migrations.join(", ")}`);
+  console.log(`  CI/CD: ${features.ciSupport ? pc2.green("Yes") : pc2.red("No")}`);
+  console.log(`  HTML reports: ${features.htmlReports ? pc2.green("Yes") : pc2.red("No")}`);
+  console.log(`  Watch mode: ${features.watchMode ? pc2.green("Yes") : pc2.red("No")}`);
+});
+program.command("pricing").description("Show pricing information").action(() => {
+  console.log(pc2.bold("\nSchemaShift Pricing\n"));
+  console.log(`${pc2.green("FREE")} - $0`);
+  console.log("  5 files per migration, Yup -> Zod only\n");
+  console.log(`${pc2.blue("INDIVIDUAL")} - $49 one-time`);
+  console.log("  Unlimited files, + Joi -> Zod, Zod v3 -> v4");
+  console.log("  HTML reports, 1 device\n");
+  console.log(`${pc2.magenta("PRO")} - $149 one-time`);
+  console.log("  All migrations including io-ts and Valibot");
+  console.log("  CI/CD support, watch mode, 4 devices\n");
+  console.log(`${pc2.yellow("TEAM")} - $29/month`);
+  console.log("  Everything in Pro, unlimited devices");
+  console.log("  Single key for whole organization\n");
+  console.log(`Purchase: ${pc2.cyan(POLAR_URL)}`);
+});
+program.parse(process.argv);