@synchronized-studio/cmsassets-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,960 @@
+#!/usr/bin/env node
+import {
+  applyPlan,
+  createPlan,
+  createReport,
+  gitOps,
+  loadPlanFile,
+  savePlanFile,
+  saveReport,
+  scan,
+  verify
+} from "./chunk-J6E3CMX6.js";
+import "./chunk-645ASJ55.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as pathDirname, resolve as resolve6 } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand as defineCommand8, runMain } from "citty";
+import { config as dotenvConfig } from "dotenv";
+
+// src/commands/init.ts
+import { createInterface } from "readline";
+import { resolve } from "path";
+import { defineCommand } from "citty";
+import consola2 from "consola";
+import pc from "picocolors";
+
+// src/patcher/injectScript.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import consola from "consola";
+var SCRIPT_NAME = "cmsassets:transform";
+var SCRIPT_VALUE = "npx @synchronized-studio/cmsassets-agent apply";
+function injectNpmScript(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { added: false, reason: "No package.json found" };
+  }
+  const raw = readFileSync(pkgPath, "utf-8");
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return { added: false, reason: "Could not parse package.json" };
+  }
+  if (!pkg.scripts) pkg.scripts = {};
+  if (pkg.scripts[SCRIPT_NAME]) {
+    return { added: false, reason: "Script already exists" };
+  }
+  pkg.scripts[SCRIPT_NAME] = SCRIPT_VALUE;
+  const indentMatch = raw.match(/^(\s+)"/m);
+  const indent = indentMatch?.[1] ?? "  ";
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, indent) + "\n", "utf-8");
+  consola.success(`Added "${SCRIPT_NAME}" script to package.json`);
+  return { added: true };
+}
+
+// src/commands/init.ts
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve7) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve7(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "One-command setup: scan project, install transformer, patch files, add npm script."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without writing files",
+      default: false
+    },
+    slug: {
+      type: "string",
+      description: "Tenant slug for CMS_ASSETS_URL"
+    },
+    cms: {
+      type: "string",
+      description: "Override CMS type"
+    },
+    repository: {
+      type: "string",
+      description: "Override Prismic repository name"
+    },
+    spaceId: {
+      type: "string",
+      description: "Override Contentful space ID"
+    },
+    "no-install": {
+      type: "boolean",
+      description: "Skip installing @synchronized-studio/response-transformer",
+      default: false
+    },
+    "no-script": {
+      type: "boolean",
+      description: "Skip adding cmsassets:transform npm script",
+      default: false
+    },
+    llm: {
+      type: "boolean",
+      description: "Enable LLM fallback for low-confidence patches when AST fails",
+      default: false
+    },
+    "include-tests": {
+      type: "boolean",
+      description: "Also patch test/fixture files",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const root = resolve(args.dir);
+    consola2.log("");
+    consola2.log(pc.bold("  CMS Assets Agent \u2014 Init"));
+    consola2.log(pc.dim("  \u2500".repeat(25)));
+    consola2.log("");
+    const scanResult = scan(root);
+    if (args.cms) scanResult.cms.type = args.cms;
+    if (args.repository) scanResult.cms.params.repository = args.repository;
+    if (args.spaceId) scanResult.cms.params.spaceId = args.spaceId;
+    consola2.log(`  ${pc.cyan("Framework:")}   ${scanResult.framework.name} ${pc.dim(scanResult.framework.version)}`);
+    consola2.log(`  ${pc.cyan("CMS:")}         ${scanResult.cms.type}`);
+    consola2.log(`  ${pc.cyan("Package mgr:")} ${scanResult.packageManager}`);
+    consola2.log("");
+    if (scanResult.injectionPoints.length === 0) {
+      consola2.warn("  No injection points found. Nothing to do.");
+      return;
+    }
+    consola2.log(`  ${pc.bold("Injection points:")} ${scanResult.injectionPoints.length} found`);
+    consola2.log("");
+    for (const point of scanResult.injectionPoints) {
+      const color = point.confidence === "high" ? pc.green : point.confidence === "medium" ? pc.yellow : pc.red;
+      consola2.log(
+        `  ${color("\u25CF")} ${point.filePath} ${pc.dim(`[${point.confidence}]`)}`
+      );
+    }
+    consola2.log("");
+    if (!args.yes && !args["dry-run"]) {
+      const ok = await confirm(`  Proceed with integration? ${pc.dim("(y/N)")} `);
+      if (!ok) {
+        consola2.log("  Aborted.");
+        return;
+      }
+      consola2.log("");
+    }
+    const plan = createPlan(scanResult);
+    if (args.slug) plan.env.placeholder = `https://${args.slug}.cmsassets.com`;
+    if (args.llm) plan.policies.allowLlmFallback = true;
+    if (args["dry-run"]) {
+      consola2.log(pc.bold("  Dry Run \u2014 planned changes:"));
+      consola2.log("");
+      consola2.log(`  ${pc.cyan("Install:")} ${plan.install.command}`);
+      consola2.log(`  ${pc.cyan("Env:")}     ${plan.env.key}=${plan.env.placeholder}`);
+      consola2.log("");
+      for (const patch of plan.patches) {
+        const color = patch.confidence === "high" ? pc.green : patch.confidence === "medium" ? pc.yellow : pc.red;
+        consola2.log(`  ${color("\u25CF")} ${patch.filePath} ${pc.dim(`[${patch.confidence}]`)}`);
+        consola2.log(`    ${pc.dim(patch.wrapTarget.originalCode)}`);
+        consola2.log(`    ${pc.green("\u2192 " + patch.wrapTarget.transformedCode)}`);
+      }
+      consola2.log("");
+      consola2.log(`  ${pc.dim("Run without --dry-run to apply.")}`);
+      return;
+    }
+    let installed = false;
+    if (!args["no-install"]) {
+      consola2.info(`Installing: ${plan.install.command}`);
+      try {
+        const { execSync } = await import("child_process");
+        execSync(plan.install.command, { cwd: root, stdio: "inherit" });
+        installed = true;
+      } catch {
+        consola2.warn("Package install failed. You can install it manually later.");
+      }
+    }
+    consola2.info("Applying patches...");
+    const applyReport = await applyPlan(plan, {
+      dryRun: false,
+      includeTests: args["include-tests"]
+    });
+    applyReport.installed = installed;
+    let scriptAdded = false;
+    if (!args["no-script"]) {
+      const result = injectNpmScript(root);
+      scriptAdded = result.added;
+    }
+    const report = createReport({ apply: applyReport, plan, scan: scanResult });
+    saveReport(root, report);
+    const applied = applyReport.files.filter((f) => f.applied);
+    const skipped = applyReport.files.filter((f) => !f.applied);
+    consola2.log("");
+    consola2.log(pc.bold("  CMS Assets Agent \u2014 Init Complete"));
+    consola2.log(pc.dim("  \u2500".repeat(25)));
+    consola2.log("");
+    consola2.log(`  ${pc.green("Applied:")}  ${applied.length} files`);
+    consola2.log(`  ${pc.yellow("Skipped:")}  ${skipped.length} files`);
+    if (installed) consola2.log(`  ${pc.green("Installed:")} @synchronized-studio/response-transformer`);
+    if (scriptAdded) consola2.log(`  ${pc.green("Script:")}    Added "cmsassets:transform" to package.json`);
+    consola2.log("");
+    for (const file of applied) {
+      consola2.log(`  ${pc.green("\u2713")} ${file.filePath} ${pc.dim(`(${file.method}, ${file.durationMs}ms)`)}`);
+    }
+    for (const file of skipped) {
+      consola2.log(`  ${pc.yellow("\u25CB")} ${file.filePath} ${pc.dim(`\u2014 ${file.reason}`)}`);
+    }
+    consola2.log("");
+    if (!installed) {
+      consola2.log(`  ${pc.dim("Don't forget to install:")} ${pc.cyan(plan.install.command)}`);
+    }
+    if (!applyReport.envUpdated) {
+      consola2.log(`  ${pc.dim("Set your env var:")} ${pc.cyan(`${plan.env.key}=${plan.env.placeholder}`)}`);
+    }
+    if (scriptAdded) {
+      consola2.log(`  ${pc.dim("Re-run later with:")} ${pc.cyan("npm run cmsassets:transform")}`);
+    }
+    consola2.log("");
+  }
+});
+
+// src/commands/scan.ts
+import { defineCommand as defineCommand2 } from "citty";
+import consola3 from "consola";
+import pc2 from "picocolors";
+var scanCommand = defineCommand2({
+  meta: {
+    name: "scan",
+    description: "Scan current project for framework, CMS, and injection points."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON instead of formatted text",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const result = scan(args.dir);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    consola3.log("");
+    consola3.log(pc2.bold("  CMS Assets Agent \u2014 Scan Results"));
+    consola3.log(pc2.dim("  \u2500".repeat(25)));
+    consola3.log("");
+    consola3.log(`  ${pc2.cyan("Framework:")}   ${result.framework.name} ${pc2.dim(result.framework.version)}`);
+    if (result.framework.configFile) {
+      consola3.log(`  ${pc2.dim("Config:")}      ${result.framework.configFile}`);
+    }
+    consola3.log(`  ${pc2.cyan("CMS:")}         ${result.cms.type}`);
+    if (Object.keys(result.cms.params).length > 0) {
+      for (const [key, val] of Object.entries(result.cms.params)) {
+        consola3.log(`  ${pc2.dim(key + ":")}  ${val}`);
+      }
+    }
+    if (result.cms.detectedFrom.length > 0) {
+      consola3.log(`  ${pc2.dim("Detected from:")} ${result.cms.detectedFrom.slice(0, 3).join(", ")}`);
+    }
+    consola3.log(`  ${pc2.cyan("Package mgr:")} ${result.packageManager}`);
+    consola3.log("");
+    if (result.injectionPoints.length === 0) {
+      consola3.warn("  No injection points found.");
+      return;
+    }
+    consola3.log(`  ${pc2.bold("Injection points:")} ${result.injectionPoints.length} found`);
+    consola3.log("");
+    for (let i = 0; i < result.injectionPoints.length; i++) {
+      const point = result.injectionPoints[i];
+      const confidenceColor = point.confidence === "high" ? pc2.green : point.confidence === "medium" ? pc2.yellow : pc2.red;
+      consola3.log(
+        `  ${pc2.bold(String(i + 1) + ".")} ${point.filePath}  ${confidenceColor(`[${point.confidence.toUpperCase()}]`)}  ${pc2.dim(`score: ${point.score}`)}`
+      );
+      consola3.log(`     ${pc2.dim(`Line ${point.line}:`)} ${point.type}`);
+      for (const reason of point.reasons) {
+        consola3.log(`     ${pc2.dim("\u2022")} ${reason}`);
+      }
+      consola3.log("");
+    }
+  }
+});
+
+// src/commands/plan.ts
+import { defineCommand as defineCommand3 } from "citty";
+import consola4 from "consola";
+import pc3 from "picocolors";
+var planCommand = defineCommand3({
+  meta: {
+    name: "plan",
+    description: "Generate a plan file (cmsassets-agent.plan.json) for review before applying."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON to stdout instead of saving a file",
+      default: false
+    },
+    cms: {
+      type: "string",
+      description: "Override CMS type (prismic, contentful, sanity, shopify, cloudinary, imgix, generic)"
+    },
+    repository: {
+      type: "string",
+      description: "Override Prismic repository name"
+    },
+    spaceId: {
+      type: "string",
+      description: "Override Contentful space ID"
+    },
+    slug: {
+      type: "string",
+      description: "Your cmsassets.com tenant slug (for CMS_ASSETS_URL placeholder)"
+    }
+  },
+  async run({ args }) {
+    const scanResult = scan(args.dir);
+    if (args.cms) {
+      scanResult.cms.type = args.cms;
+    }
+    if (args.repository) {
+      scanResult.cms.params.repository = args.repository;
+    }
+    if (args.spaceId) {
+      scanResult.cms.params.spaceId = args.spaceId;
+    }
+    const plan = createPlan(scanResult);
+    if (args.slug) {
+      plan.env.placeholder = `https://${args.slug}.cmsassets.com`;
+    }
+    if (args.json) {
+      console.log(JSON.stringify(plan, null, 2));
+      return;
+    }
+    const filePath = savePlanFile(scanResult.projectRoot, plan);
+    consola4.log("");
+    consola4.log(pc3.bold("  CMS Assets Agent \u2014 Plan Generated"));
+    consola4.log(pc3.dim("  \u2500".repeat(25)));
+    consola4.log("");
+    consola4.log(`  ${pc3.cyan("Plan file:")}  ${filePath}`);
+    consola4.log(`  ${pc3.cyan("Install:")}    ${plan.install.command}`);
+    consola4.log(`  ${pc3.cyan("Env var:")}    ${plan.env.key}=${plan.env.placeholder}`);
+    consola4.log(`  ${pc3.cyan("Patches:")}    ${plan.patches.length} files`);
+    consola4.log("");
+    for (let i = 0; i < plan.patches.length; i++) {
+      const patch = plan.patches[i];
+      const confidenceColor = patch.confidence === "high" ? pc3.green : patch.confidence === "medium" ? pc3.yellow : pc3.red;
+      consola4.log(`  ${pc3.bold(String(i + 1) + ".")} ${patch.filePath}  ${confidenceColor(`[${patch.confidence.toUpperCase()}]`)}`);
+      consola4.log(`     ${patch.description}`);
+      consola4.log(`     ${pc3.dim("Line " + patch.wrapTarget.line + ":")} ${pc3.red(patch.wrapTarget.originalCode)}`);
+      consola4.log(`     ${pc3.dim("         \u2192")} ${pc3.green(patch.wrapTarget.transformedCode)}`);
+      consola4.log("");
+    }
+    consola4.log(`  ${pc3.dim("Review the plan, then run:")} ${pc3.cyan("cmsassets-agent apply")}`);
+    consola4.log("");
+  }
+});
+
+// src/commands/apply.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { defineCommand as defineCommand4 } from "citty";
+import consola5 from "consola";
+import pc4 from "picocolors";
+var applyCommand = defineCommand4({
+  meta: {
+    name: "apply",
+    description: "Apply the transformer integration (install package, patch files, update env)."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    plan: {
+      type: "string",
+      description: "Path to a plan file (skips scan+plan phases)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without writing files",
+      default: false
+    },
+    "include-tests": {
+      type: "boolean",
+      description: "Also patch test/fixture files",
+      default: false
+    },
+    "allow-dirty": {
+      type: "boolean",
+      description: "Allow running on a dirty git worktree",
+      default: false
+    },
+    install: {
+      type: "boolean",
+      description: "Install the transformer package (use --no-install to skip)",
+      default: true
+    },
+    "no-script": {
+      type: "boolean",
+      description: "Skip adding cmsassets:transform npm script",
+      default: false
+    },
+    "max-files": {
+      type: "string",
+      description: "Max number of files to auto-apply"
+    },
+    force: {
+      type: "boolean",
+      description: "Apply all detected patches (ignore max files threshold)",
+      default: false
+    },
+    cms: {
+      type: "string",
+      description: "Override CMS type"
+    },
+    repository: {
+      type: "string",
+      description: "Override Prismic repository name"
+    },
+    spaceId: {
+      type: "string",
+      description: "Override Contentful space ID"
+    },
+    slug: {
+      type: "string",
+      description: "Tenant slug for CMS_ASSETS_URL"
+    },
+    "create-pr": {
+      type: "boolean",
+      description: "Create a GitHub PR after applying",
+      default: false
+    },
+    "github-token": {
+      type: "string",
+      description: "GitHub token for PR creation"
+    },
+    llm: {
+      type: "boolean",
+      description: "Enable LLM fallback for low-confidence patches when AST fails",
+      default: false
+    },
+    "llm-all": {
+      type: "boolean",
+      description: "Try LLM for any failed AST patch (for testing). Requires --llm and OPENAI_API_KEY.",
+      default: false
+    },
+    "llm-only": {
+      type: "boolean",
+      description: "Skip AST, use LLM for all patches (testing only). Requires --llm and OPENAI_API_KEY.",
+      default: false
+    },
+    "ai-verify": {
+      type: "boolean",
+      description: "Run AI verification after patching to catch missed transforms. Requires OPENAI_API_KEY.",
+      default: false
+    },
+    "ai-model": {
+      type: "string",
+      description: "OpenAI model for AI verification",
+      default: "gpt-4o"
+    },
+    "ai-max-iterations": {
+      type: "string",
+      description: "Max AI fix attempts per file",
+      default: "3"
+    }
+  },
+  async run({ args }) {
+    const root = resolve2(args.dir);
+    if (gitOps.isGitRepo(root) && !args["allow-dirty"] && !gitOps.isClean(root)) {
+      consola5.error(
+        "Git worktree is dirty. Commit or stash changes first, or use --allow-dirty."
+      );
+      process.exit(1);
+    }
+    let plan;
+    if (args.plan) {
+      const planPath = resolve2(args.plan);
+      const loaded = loadPlanFile(planPath);
+      if (!loaded) {
+        consola5.error(`Invalid plan file: ${planPath}`);
+        process.exit(1);
+      }
+      plan = loaded;
+    } else {
+      const defaultPlanPath = join2(root, "cmsassets-agent.plan.json");
+      if (existsSync2(defaultPlanPath)) {
+        consola5.info(`Found existing plan file: ${defaultPlanPath}`);
+        const loaded = loadPlanFile(defaultPlanPath);
+        if (loaded) {
+          plan = loaded;
+        } else {
+          consola5.warn("Plan file invalid, regenerating...");
+          plan = generatePlan(root, args);
+        }
+      } else {
+        plan = generatePlan(root, args);
+      }
+    }
+    if (args.llm || args["llm-only"]) plan.policies.allowLlmFallback = true;
+    if (args["llm-all"]) plan.policies.llmFallbackForAll = true;
+    if (args["llm-only"]) plan.policies.llmOnly = true;
+    if (args["max-files"]) plan.policies.maxFilesAutoApply = parseInt(args["max-files"], 10);
+    if (args.force) plan.policies.maxFilesAutoApply = Number.MAX_SAFE_INTEGER;
+    if (args["dry-run"]) {
+      consola5.log("");
+      consola5.log(pc4.bold("  CMS Assets Agent \u2014 Dry Run"));
+      consola5.log(pc4.dim("  \u2500".repeat(25)));
+      consola5.log("");
+      consola5.log(`  ${pc4.cyan("Install:")} ${plan.install.command}`);
+      consola5.log(`  ${pc4.cyan("Env:")}     ${plan.env.key}=${plan.env.placeholder}`);
+      consola5.log("");
+      for (const patch of plan.patches) {
+        const color = patch.confidence === "high" ? pc4.green : patch.confidence === "medium" ? pc4.yellow : pc4.red;
+        consola5.log(`  ${color("\u25CF")} ${patch.filePath} ${pc4.dim(`[${patch.confidence}]`)}`);
+        consola5.log(`    ${pc4.dim(patch.wrapTarget.originalCode)}`);
+        consola5.log(`    ${pc4.green("\u2192 " + patch.wrapTarget.transformedCode)}`);
+      }
+      consola5.log("");
+      consola5.log(`  ${pc4.dim("Run without --dry-run to apply these changes.")}`);
+      return;
+    }
+    let branchCreated = false;
+    let previousCommit = null;
+    if (gitOps.isGitRepo(root)) {
+      previousCommit = gitOps.getHeadCommit(root);
+      const branchName = `cmsassets-agent/integrate-${Date.now()}`;
+      branchCreated = gitOps.createBranch(root, branchName);
+    }
+    let installed = false;
+    if (args.install) {
+      consola5.info(`Installing: ${plan.install.command}`);
+      try {
+        const { execSync } = await import("child_process");
+        execSync(plan.install.command, { cwd: root, stdio: "inherit" });
+        installed = true;
+      } catch {
+        consola5.warn("Package install failed. You can install it manually later.");
+      }
+    }
+    consola5.info("Applying patches...");
+    const applyReport = await applyPlan(plan, {
+      dryRun: false,
+      includeTests: args["include-tests"],
+      maxFiles: args.force ? Number.MAX_SAFE_INTEGER : args["max-files"] ? parseInt(args["max-files"], 10) : void 0
+    });
+    applyReport.installed = installed;
+    if (gitOps.isGitRepo(root) && branchCreated) {
+      gitOps.stageAll(root);
+      const appliedFiles = applyReport.files.filter((f) => f.applied).length;
+      const commitHash = gitOps.commit(
+        root,
+        `chore(cmsassets-agent): integrate response transformer (${appliedFiles} files)`
+      );
+      if (commitHash) {
+        applyReport.gitBranch = gitOps.getCurrentBranch(root);
+        applyReport.gitCommit = commitHash;
+      }
+    }
+    let aiReviewReport;
+    if (args["ai-verify"]) {
+      const appliedPaths = applyReport.files.filter((f) => f.applied).map((f) => f.filePath);
+      if (appliedPaths.length > 0) {
+        consola5.log("");
+        consola5.log(pc4.bold("  CMS Assets Agent \u2014 AI Verification"));
+        consola5.log(pc4.dim("  \u2500".repeat(25)));
+        consola5.log("");
+        const { aiReviewAll } = await import("./aiReview-HZKRPSUV.js");
+        aiReviewReport = await aiReviewAll(root, appliedPaths, plan, {
+          model: args["ai-model"] ?? "gpt-4o",
+          maxIterations: parseInt(args["ai-max-iterations"] ?? "3", 10)
+        });
+        consola5.log("");
+        consola5.log(`  ${pc4.green("Passed:")} ${aiReviewReport.filesPassed} files`);
+        if (aiReviewReport.filesFixed > 0) {
+          consola5.log(`  ${pc4.blue("Fixed:")}  ${aiReviewReport.filesFixed} files`);
+        }
+        if (aiReviewReport.filesFailed > 0) {
+          consola5.log(`  ${pc4.red("Failed:")} ${aiReviewReport.filesFailed} files`);
+        }
+        consola5.log(`  ${pc4.dim(`Tokens used: ${aiReviewReport.tokensUsed}`)}`);
+        consola5.log("");
+        if (aiReviewReport.filesFixed > 0 && gitOps.isGitRepo(root) && branchCreated) {
+          gitOps.stageAll(root);
+          gitOps.commit(root, "chore(cmsassets-agent): AI-verified fixes for missed transforms");
+        }
+      }
+    }
+    let scriptAdded = false;
+    if (!args["no-script"]) {
+      const scriptResult = injectNpmScript(root);
+      scriptAdded = scriptResult.added;
+    }
+    const report = createReport({ apply: applyReport, plan, scan: plan.scan, aiReview: aiReviewReport });
+    saveReport(root, report);
+    const applied = applyReport.files.filter((f) => f.applied);
+    const skipped = applyReport.files.filter((f) => !f.applied);
+    consola5.log("");
+    consola5.log(pc4.bold("  CMS Assets Agent \u2014 Apply Complete"));
+    consola5.log(pc4.dim("  \u2500".repeat(25)));
+    consola5.log("");
+    consola5.log(`  ${pc4.green("Applied:")}  ${applied.length} files`);
+    consola5.log(`  ${pc4.yellow("Skipped:")}  ${skipped.length} files`);
+    consola5.log(`  ${pc4.cyan("Duration:")} ${applyReport.totalDurationMs}ms`);
+    if (applyReport.gitBranch) {
+      consola5.log(`  ${pc4.cyan("Branch:")}   ${applyReport.gitBranch}`);
+    }
+    if (applyReport.gitCommit) {
+      consola5.log(`  ${pc4.cyan("Commit:")}   ${applyReport.gitCommit}`);
+    }
+    consola5.log("");
+    for (const file of applied) {
+      consola5.log(`  ${pc4.green("\u2713")} ${file.filePath} ${pc4.dim(`(${file.method}, ${file.durationMs}ms)`)}`);
+    }
+    for (const file of skipped) {
+      consola5.log(`  ${pc4.yellow("\u25CB")} ${file.filePath} ${pc4.dim(`\u2014 ${file.reason}`)}`);
+    }
+    consola5.log("");
+    if (scriptAdded) {
+      consola5.log(`  ${pc4.green("Script:")}    Added "cmsassets:transform" to package.json`);
+    }
+    if (!installed) {
+      consola5.log(`  ${pc4.dim("Don't forget to install:")} ${pc4.cyan(plan.install.command)}`);
+    }
+    if (!applyReport.envUpdated) {
+      consola5.log(`  ${pc4.dim("Set your env var:")} ${pc4.cyan(`${plan.env.key}=${plan.env.placeholder}`)}`);
+    }
+    if (scriptAdded) {
+      consola5.log(`  ${pc4.dim("Re-run later with:")} ${pc4.cyan("npm run cmsassets:transform")}`);
+    }
+    consola5.log("");
+    if (args["create-pr"] && gitOps.isGitRepo(root)) {
+      const token = args["github-token"] ?? process.env.GITHUB_TOKEN;
+      if (!token) {
+        consola5.warn("No GitHub token provided. Use --github-token or set GITHUB_TOKEN.");
+        return;
+      }
+      consola5.info("Pushing branch and creating PR...");
+      const pushed = gitOps.push(root);
+      if (pushed) {
+        try {
+          const { execSync } = await import("child_process");
+          const prTitle = `chore: integrate CMS Assets response transformer`;
+          const prBody = `Automated integration by \`@synchronized-studio/cmsassets-agent\`.
+
+**CMS:** ${plan.scan.cms.type}
+**Framework:** ${plan.scan.framework.name}
+**Files patched:** ${applied.length}`;
+          execSync(
+            `gh pr create --title "${prTitle}" --body "${prBody}"`,
+            { cwd: root, stdio: "inherit", env: { ...process.env, GITHUB_TOKEN: token } }
+          );
+        } catch {
+          consola5.warn("PR creation failed. Push was successful, create PR manually.");
+        }
+      }
+    }
+  }
+});
+function generatePlan(root, args) {
+  const scanResult = scan(root);
+  if (args.cms) scanResult.cms.type = args.cms;
+  if (args.repository) scanResult.cms.params.repository = args.repository;
+  if (args.spaceId) scanResult.cms.params.spaceId = args.spaceId;
+  const plan = createPlan(scanResult);
+  if (args.slug) plan.env.placeholder = `https://${args.slug}.cmsassets.com`;
+  return plan;
+}
+
+// src/commands/verify.ts
+import { resolve as resolve3 } from "path";
+import { defineCommand as defineCommand5 } from "citty";
+import consola6 from "consola";
+import pc5 from "picocolors";
+var verifyCommand = defineCommand5({
+  meta: {
+    name: "verify",
+    description: "Verify the project builds/lints/tests correctly after patching."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    profile: {
+      type: "string",
+      description: "Verify profile: quick or full",
+      default: "quick"
+    }
+  },
+  async run({ args }) {
+    const root = resolve3(args.dir);
+    const scanResult = scan(root);
+    consola6.log("");
+    consola6.log(pc5.bold(`  CMS Assets Agent \u2014 Verify (${args.profile})`));
+    consola6.log(pc5.dim("  \u2500".repeat(25)));
+    consola6.log("");
+    const report = verify(root, {
+      profile: args.profile,
+      framework: scanResult.framework.name
+    });
+    consola6.log("");
+    const pass = pc5.green("PASS");
+    const fail = pc5.red("FAIL");
+    const skip = pc5.dim("SKIP");
+    consola6.log(`  Lint:   ${report.lintPassed === null ? skip : report.lintPassed ? pass : fail}`);
+    consola6.log(`  Build:  ${report.buildPassed === null ? skip : report.buildPassed ? pass : fail}`);
+    consola6.log(`  Tests:  ${report.testsPassed === null ? skip : report.testsPassed ? pass : fail}`);
+    consola6.log(`  ${pc5.dim(`Duration: ${report.durationMs}ms`)}`);
+    if (report.warnings.length > 0) {
+      consola6.log("");
+      consola6.log(pc5.yellow("  Warnings:"));
+      for (const w of report.warnings) {
+        consola6.log(`  ${pc5.dim("\u2022")} ${w.substring(0, 120)}`);
+      }
+    }
+    consola6.log("");
+  }
+});
+
+// src/commands/doctor.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4, join as join3 } from "path";
+import { defineCommand as defineCommand6 } from "citty";
+import consola7 from "consola";
+import pc6 from "picocolors";
+var doctorCommand = defineCommand6({
+  meta: {
+    name: "doctor",
+    description: "Diagnose project setup and readiness for transformer integration."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    const root = resolve4(args.dir);
+    const checks = [];
+    checks.push({
+      label: "package.json",
+      ok: existsSync3(join3(root, "package.json")),
+      detail: existsSync3(join3(root, "package.json")) ? "Found" : "Missing \u2014 this may not be a JS/TS project"
+    });
+    const isGit = gitOps.isGitRepo(root);
+    checks.push({
+      label: "Git repository",
+      ok: isGit,
+      detail: isGit ? "Initialized" : "Not a git repo (rollback via git will not work)"
+    });
+    if (isGit) {
+      const clean = gitOps.isClean(root);
+      checks.push({
+        label: "Git worktree clean",
+        ok: clean,
+        detail: clean ? "Clean" : "Dirty \u2014 commit or stash before running apply"
+      });
+    }
+    const scanResult = scan(root);
+    checks.push({
+      label: "Framework detected",
+      ok: scanResult.framework.name !== "unknown",
+      detail: scanResult.framework.name !== "unknown" ? `${scanResult.framework.name} ${scanResult.framework.version}` : "Could not detect framework \u2014 agent will use generic strategies"
+    });
+    checks.push({
+      label: "CMS detected",
+      ok: scanResult.cms.type !== "unknown",
+      detail: scanResult.cms.type !== "unknown" ? `${scanResult.cms.type} (${Object.entries(scanResult.cms.params).map(([k, v]) => `${k}: ${v}`).join(", ")})` : "Could not detect CMS \u2014 use --cms flag to specify"
+    });
+    checks.push({
+      label: "Injection points found",
+      ok: scanResult.injectionPoints.length > 0,
+      detail: scanResult.injectionPoints.length > 0 ? `${scanResult.injectionPoints.length} candidates` : "None found \u2014 transformer may need manual integration"
+    });
+    const highConfidence = scanResult.injectionPoints.filter((p) => p.confidence === "high");
+    checks.push({
+      label: "High-confidence points",
+      ok: highConfidence.length > 0,
+      detail: highConfidence.length > 0 ? `${highConfidence.length} auto-eligible for patching` : "No high-confidence points \u2014 patches will need manual confirmation"
+    });
+    let pkgJson = {};
+    try {
+      pkgJson = JSON.parse(readFileSync3(join3(root, "package.json"), "utf-8"));
+    } catch {
+    }
+    const allDeps = { ...pkgJson.dependencies ?? {}, ...pkgJson.devDependencies ?? {} };
+    const hasTransformer = "@synchronized-studio/response-transformer" in allDeps;
+    checks.push({
+      label: "Transformer package",
+      ok: true,
+      detail: hasTransformer ? `Already installed (${allDeps["@synchronized-studio/response-transformer"]})` : "Not installed \u2014 will need: " + (scanResult.packageManager === "pnpm" ? "pnpm add" : scanResult.packageManager === "yarn" ? "yarn add" : "npm install") + " @synchronized-studio/response-transformer"
+    });
+    const envFiles = [".env", ".env.local", ".env.development"];
+    let hasEnvVar = false;
+    for (const f of envFiles) {
+      const p = join3(root, f);
+      if (existsSync3(p)) {
+        const content = readFileSync3(p, "utf-8");
+        if (content.includes("CMS_ASSETS_URL")) {
+          hasEnvVar = true;
+          break;
+        }
+      }
+    }
+    checks.push({
+      label: "CMS_ASSETS_URL env var",
+      ok: true,
+      detail: hasEnvVar ? "Set in .env file" : "Not set \u2014 you will need to add CMS_ASSETS_URL=https://YOUR-SLUG.cmsassets.com"
+    });
+    consola7.log("");
+    consola7.log(pc6.bold("  CMS Assets Agent \u2014 Doctor"));
+    consola7.log(pc6.dim("  \u2500".repeat(25)));
+    consola7.log("");
+    for (const check of checks) {
+      const icon = check.ok ? pc6.green("\u2713") : pc6.yellow("!");
+      consola7.log(`  ${icon} ${pc6.bold(check.label)}`);
+      consola7.log(`    ${pc6.dim(check.detail)}`);
+    }
+    consola7.log("");
+    const issues = checks.filter((c) => !c.ok);
+    if (issues.length === 0) {
+      consola7.log(pc6.green("  All checks passed. Ready to run: cmsassets-agent plan"));
+    } else {
+      consola7.log(pc6.yellow(`  ${issues.length} issue(s) found. Fix them before running apply.`));
+    }
+    consola7.log("");
+  }
+});
+
+// src/commands/rollback.ts
+import { resolve as resolve5 } from "path";
+import { defineCommand as defineCommand7 } from "citty";
+import consola8 from "consola";
+import pc7 from "picocolors";
+var rollbackCommand = defineCommand7({
+  meta: {
+    name: "rollback",
+    description: "Rollback the last agent apply by reverting the git commit."
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "Project root directory",
+      default: "."
+    },
+    commit: {
+      type: "string",
+      description: "Specific commit hash to rollback to (otherwise finds last agent commit)"
+    }
+  },
+  async run({ args }) {
+    const root = resolve5(args.dir);
+    if (!gitOps.isGitRepo(root)) {
+      consola8.error("Not a git repository. Cannot rollback.");
+      process.exit(1);
+    }
+    consola8.log("");
+    consola8.log(pc7.bold("  CMS Assets Agent \u2014 Rollback"));
+    consola8.log(pc7.dim("  \u2500".repeat(25)));
+    consola8.log("");
+    let targetCommit = null;
+    if (args.commit) {
+      targetCommit = args.commit;
+    } else {
+      const agentCommit = gitOps.getLastCommitByAgent(root);
+      if (!agentCommit) {
+        consola8.error("No agent commit found in git history.");
+        process.exit(1);
+      }
+      targetCommit = gitOps.getCommitBefore(root, agentCommit);
+      if (!targetCommit) {
+        consola8.error("Cannot find parent commit for rollback.");
+        process.exit(1);
+      }
+    }
+    consola8.info(`Rolling back to commit: ${targetCommit}`);
+    const success = gitOps.rollbackToCommit(root, targetCommit);
+    if (success) {
+      consola8.success(`Rollback complete. HEAD is now at ${targetCommit}`);
+    } else {
+      consola8.error("Rollback failed. Check your git state manually.");
+      process.exit(1);
+    }
+    consola8.log("");
+  }
+});
+
+// src/cli.ts
+var main = defineCommand8({
+  meta: {
+    name: "cmsassets-agent",
+    version: "0.1.0",
+    description: "Auto-integrate @synchronized-studio/response-transformer into any JS/TS project."
+  },
+  subCommands: {
+    init: initCommand,
+    scan: scanCommand,
+    plan: planCommand,
+    apply: applyCommand,
+    verify: verifyCommand,
+    doctor: doctorCommand,
+    rollback: rollbackCommand
+  }
+});
+var cwd = process.cwd();
+var cliDir = typeof __dirname !== "undefined" ? __dirname : pathDirname(fileURLToPath(import.meta.url));
+function findProjectRootEnv(startDir) {
+  let dir = resolve6(startDir);
+  for (let i = 0; i < 6; i++) {
+    const envPath = resolve6(dir, ".env");
+    if (existsSync4(envPath)) return envPath;
+    const parent = pathDirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+var envPaths = [];
+var explicitEnv = process.env.DOTENV_CONFIG_PATH || process.env.CMSASSETS_ENV_FILE;
+if (explicitEnv) envPaths.push(resolve6(cwd, explicitEnv));
+envPaths.push(resolve6(cwd, ".env"));
+var projectRootEnv = findProjectRootEnv(cliDir);
+if (projectRootEnv && !envPaths.includes(projectRootEnv)) envPaths.push(projectRootEnv);
+for (const p of envPaths) {
+  if (existsSync4(p)) {
+    dotenvConfig({ path: p });
+    if (process.env.OPENAI_API_KEY) break;
+  }
+}
+runMain(main);