@synchronized-studio/cmsassets-agent 0.6.0 → 0.6.2

package/dist/chunk-XXNYL6ZI.js

@@ -0,0 +1,2002 @@
+import {
+  WRAP_TEMPLATES,
+  buildCmsOptions,
+  findInjectionPoints,
+  getImportStatement,
+  getTransformFunctionName
+} from "./chunk-W7TNFULQ.js";
+import {
+  chatCompletion,
+  isOpenAiError
+} from "./chunk-3D6MPYQN.js";
+
+// src/scanner/index.ts
+import { resolve } from "path";
+
+// src/scanner/detectFramework.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var FRAMEWORK_SIGNATURES = {
+  nuxt: {
+    packages: ["nuxt"],
+    configFiles: ["nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"]
+  },
+  next: {
+    packages: ["next"],
+    configFiles: ["next.config.js", "next.config.mjs", "next.config.ts"]
+  },
+  remix: {
+    packages: ["@remix-run/react", "@remix-run/node", "@remix-run/dev"],
+    configFiles: ["remix.config.js", "remix.config.ts"]
+  },
+  astro: {
+    packages: ["astro"],
+    configFiles: ["astro.config.mjs", "astro.config.ts", "astro.config.js"]
+  },
+  sveltekit: {
+    packages: ["@sveltejs/kit"],
+    configFiles: ["svelte.config.js", "svelte.config.ts"]
+  },
+  hono: {
+    packages: ["hono"],
+    configFiles: []
+  },
+  fastify: {
+    packages: ["fastify"],
+    configFiles: []
+  },
+  express: {
+    packages: ["express"],
+    configFiles: []
+  }
+};
+var DETECTION_ORDER = [
+  "nuxt",
+  "next",
+  "remix",
+  "astro",
+  "sveltekit",
+  "hono",
+  "fastify",
+  "express"
+];
+function readPackageJson(root) {
+  const pkgPath = join(root, "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return {
+      dependencies: pkg.dependencies ?? {},
+      devDependencies: pkg.devDependencies ?? {}
+    };
+  } catch {
+    return null;
+  }
+}
+function getVersionFromPkg(allDeps, packages) {
+  for (const pkg of packages) {
+    if (allDeps[pkg]) return allDeps[pkg];
+  }
+  return "";
+}
+function detectFramework(root) {
+  const pkg = readPackageJson(root);
+  const allDeps = {
+    ...pkg?.dependencies ?? {},
+    ...pkg?.devDependencies ?? {}
+  };
+  for (const name of DETECTION_ORDER) {
+    const sig = FRAMEWORK_SIGNATURES[name];
+    const hasPackage = sig.packages.some((p) => p in allDeps);
+    const configFile = sig.configFiles.find((f) => existsSync(join(root, f))) ?? null;
+    if (hasPackage || configFile) {
+      let resolvedName = name;
+      const version = getVersionFromPkg(allDeps, sig.packages);
+      if (name === "nuxt") {
+        const majorVersion = parseMajorVersion(version);
+        if (majorVersion !== null && majorVersion < 3) {
+          resolvedName = "nuxt2";
+        }
+      }
+      return {
+        name: resolvedName,
+        version,
+        configFile
+      };
+    }
+  }
+  return { name: "unknown", version: "", configFile: null };
+}
+function parseMajorVersion(versionRange) {
+  const cleaned = versionRange.replace(/^[\^~>=<\s]+/, "");
+  const major = parseInt(cleaned, 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+// src/scanner/detectCms.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, relative } from "path";
+import fg from "fast-glob";
+var CMS_SIGNATURES = {
+  prismic: {
+    packages: [
+      "@prismicio/client",
+      "@prismicio/vue",
+      "@prismicio/react",
+      "@prismicio/next",
+      "@prismicio/svelte",
+      "@nuxtjs/prismic"
+    ],
+    urlPatterns: [
+      /https?:\/\/([a-z0-9-]+)\.cdn\.prismic\.io/gi,
+      /https?:\/\/images\.prismic\.io\/([a-z0-9-]+)/gi
+    ],
+    paramExtractors: {
+      repository: (match) => {
+        const m1 = match.match(/https?:\/\/([a-z0-9-]+)\.cdn\.prismic\.io/);
+        if (m1) return m1[1];
+        const m2 = match.match(/https?:\/\/images\.prismic\.io\/([a-z0-9-]+)/);
+        if (m2) return m2[1];
+        return null;
+      }
+    }
+  },
+  contentful: {
+    packages: ["contentful"],
+    urlPatterns: [
+      /https?:\/\/images\.ctfassets\.net\/([a-z0-9]+)/gi,
+      /https?:\/\/videos\.ctfassets\.net\/([a-z0-9]+)/gi,
+      /https?:\/\/cdn\.contentful\.com\/spaces\/([a-z0-9]+)/gi
+    ],
+    paramExtractors: {
+      spaceId: (match) => {
+        const m = match.match(/ctfassets\.net\/([a-z0-9]+)/) || match.match(/spaces\/([a-z0-9]+)/);
+        return m?.[1] ?? null;
+      }
+    }
+  },
+  sanity: {
+    packages: ["@sanity/client", "next-sanity", "@nuxtjs/sanity", "sanity"],
+    urlPatterns: [
+      /https?:\/\/cdn\.sanity\.io\/(images|files)\/([a-z0-9]+)\/([a-z0-9-]+)/gi
+    ],
+    paramExtractors: {
+      projectId: (match) => {
+        const m = match.match(/cdn\.sanity\.io\/(?:images|files)\/([a-z0-9]+)/);
+        return m?.[1] ?? null;
+      },
+      dataset: (match) => {
+        const m = match.match(
+          /cdn\.sanity\.io\/(?:images|files)\/[a-z0-9]+\/([a-z0-9-]+)/
+        );
+        return m?.[1] ?? null;
+      }
+    }
+  },
+  shopify: {
+    packages: [
+      "@shopify/storefront-api-client",
+      "@shopify/hydrogen",
+      "@shopify/shopify-api"
+    ],
+    urlPatterns: [
+      /https?:\/\/([a-z0-9-]+)\.myshopify\.com\/cdn\//gi,
+      /https?:\/\/([a-z0-9-]+)\.myshopify\.com\/api\//gi
+    ],
+    paramExtractors: {
+      storeDomain: (match) => {
+        const m = match.match(/https?:\/\/([a-z0-9-]+\.myshopify\.com)/);
+        return m?.[1] ?? null;
+      }
+    }
+  },
+  cloudinary: {
+    packages: ["cloudinary", "@cloudinary/url-gen", "@cloudinary/react"],
+    urlPatterns: [/https?:\/\/res\.cloudinary\.com\/([a-z0-9_-]+)/gi],
+    paramExtractors: {
+      cloudName: (match) => {
+        const m = match.match(/res\.cloudinary\.com\/([a-z0-9_-]+)/);
+        return m?.[1] ?? null;
+      }
+    }
+  },
+  imgix: {
+    packages: ["@imgix/js-core", "react-imgix", "vue-imgix"],
+    urlPatterns: [/https?:\/\/([a-z0-9-]+)\.imgix\.net/gi],
+    paramExtractors: {
+      imgixDomain: (match) => {
+        const m = match.match(/https?:\/\/([a-z0-9-]+\.imgix\.net)/);
+        return m?.[1] ?? null;
+      }
+    }
+  }
+};
+var CMS_DETECTION_ORDER = [
+  "prismic",
+  "contentful",
+  "sanity",
+  "shopify",
+  "cloudinary",
+  "imgix"
+];
+var SOURCE_GLOBS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.vue",
+  "**/*.svelte",
+  "**/*.astro",
+  "**/*.mjs",
+  "**/*.mts"
+];
+var IGNORE_DIRS = [
+  "node_modules",
+  ".nuxt",
+  ".next",
+  ".output",
+  ".svelte-kit",
+  "dist",
+  "build",
+  ".git",
+  "coverage",
+  ".cache"
+];
+function detectCms(root) {
+  const pkgPath = join2(root, "package.json");
+  let allDeps = {};
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    } catch {
+    }
+  }
+  for (const cmsName of CMS_DETECTION_ORDER) {
+    const sig = CMS_SIGNATURES[cmsName];
+    if (sig.packages.some((p) => p in allDeps)) {
+      const params = extractParamsFromSource(root, cmsName);
+      return {
+        type: cmsName,
+        params,
+        detectedFrom: ["package.json"]
+      };
+    }
+  }
+  const sourceFiles = fg.sync(SOURCE_GLOBS, {
+    cwd: root,
+    ignore: IGNORE_DIRS.map((d) => `${d}/**`),
+    absolute: true,
+    onlyFiles: true,
+    deep: 6
+  });
+  for (const cmsName of CMS_DETECTION_ORDER) {
+    const sig = CMS_SIGNATURES[cmsName];
+    const matchingFiles = [];
+    const foundParams = {};
+    for (const file of sourceFiles) {
+      let content;
+      try {
+        content = readFileSync2(file, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const pattern of sig.urlPatterns) {
+        pattern.lastIndex = 0;
+        const matches = content.match(pattern);
+        if (matches && matches.length > 0) {
+          matchingFiles.push(relative(root, file));
+          for (const m of matches) {
+            for (const [paramName, extractor] of Object.entries(sig.paramExtractors)) {
+              if (!foundParams[paramName]) {
+                const val = extractor(m);
+                if (val) foundParams[paramName] = val;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (matchingFiles.length > 0) {
+      return {
+        type: cmsName,
+        params: foundParams,
+        detectedFrom: [...new Set(matchingFiles)]
+      };
+    }
+  }
+  const genericPatterns = [
+    /https?:\/\/[a-z0-9-]+\.s3[.-][a-z0-9-]*\.amazonaws\.com/gi,
+    /https?:\/\/storage\.googleapis\.com\/[a-z0-9-]+/gi,
+    /https?:\/\/[a-z0-9-]+\.r2\.cloudflarestorage\.com/gi
+  ];
+  for (const file of sourceFiles) {
+    let content;
+    try {
+      content = readFileSync2(file, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const pattern of genericPatterns) {
+      pattern.lastIndex = 0;
+      const m = content.match(pattern);
+      if (m && m.length > 0) {
+        return {
+          type: "generic",
+          params: { originUrl: m[0] },
+          detectedFrom: [relative(root, file)]
+        };
+      }
+    }
+  }
+  return { type: "unknown", params: {}, detectedFrom: [] };
+}
+var CONFIG_FILES = [
+  "slicemachine.config.json",
+  "prismicio.config.ts",
+  "prismicio.config.js",
+  "sm.json",
+  ".slicemachine.config.json",
+  "nuxt.config.ts",
+  "nuxt.config.js",
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "sanity.config.ts",
+  "sanity.config.js",
+  "sanity.cli.ts",
+  "sanity.cli.js"
+];
+var CONFIG_PARAM_PATTERNS = {
+  prismic: [
+    { param: "repository", patterns: [
+      /["']?repositoryName["']?\s*[:=]\s*["']([a-z0-9-]+)["']/i,
+      /https?:\/\/([a-z0-9-]+)\.cdn\.prismic\.io/i,
+      /["']?apiEndpoint["']?\s*[:=]\s*["']https?:\/\/([a-z0-9-]+)\.cdn\.prismic\.io/i
+    ] }
+  ],
+  contentful: [
+    { param: "spaceId", patterns: [
+      /["']?space["']?\s*[:=]\s*["']([a-z0-9]+)["']/i,
+      /["']?spaceId["']?\s*[:=]\s*["']([a-z0-9]+)["']/i
+    ] }
+  ],
+  sanity: [
+    { param: "projectId", patterns: [
+      /["']?projectId["']?\s*[:=]\s*["']([a-z0-9]+)["']/i
+    ] },
+    { param: "dataset", patterns: [
+      /["']?dataset["']?\s*[:=]\s*["']([a-z0-9-]+)["']/i
+    ] }
+  ],
+  shopify: [
+    { param: "storeDomain", patterns: [
+      /["']?storeDomain["']?\s*[:=]\s*["']([a-z0-9-]+\.myshopify\.com)["']/i
+    ] }
+  ],
+  cloudinary: [
+    { param: "cloudName", patterns: [
+      /["']?cloud_name["']?\s*[:=]\s*["']([a-z0-9_-]+)["']/i,
+      /["']?cloudName["']?\s*[:=]\s*["']([a-z0-9_-]+)["']/i
+    ] }
+  ],
+  imgix: [
+    { param: "imgixDomain", patterns: [
+      /["']?domain["']?\s*[:=]\s*["']([a-z0-9-]+\.imgix\.net)["']/i
+    ] }
+  ]
+};
+function extractParamsFromSource(root, cmsName) {
+  const sig = CMS_SIGNATURES[cmsName];
+  if (!sig) return {};
+  const params = {};
+  const configPatterns = CONFIG_PARAM_PATTERNS[cmsName];
+  if (configPatterns) {
+    for (const cfgFile of CONFIG_FILES) {
+      const cfgPath = join2(root, cfgFile);
+      if (!existsSync2(cfgPath)) continue;
+      let content;
+      try {
+        content = readFileSync2(cfgPath, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const { param, patterns } of configPatterns) {
+        if (params[param]) continue;
+        for (const pattern of patterns) {
+          const m = content.match(pattern);
+          if (m?.[1]) {
+            params[param] = m[1];
+            break;
+          }
+        }
+      }
+    }
+    if (Object.keys(params).length === Object.keys(sig.paramExtractors).length) {
+      return params;
+    }
+  }
+  const sourceFiles = fg.sync(SOURCE_GLOBS, {
+    cwd: root,
+    ignore: IGNORE_DIRS.map((d) => `${d}/**`),
+    absolute: true,
+    onlyFiles: true,
+    deep: 6
+  });
+  for (const file of sourceFiles) {
+    let content;
+    try {
+      content = readFileSync2(file, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const pattern of sig.urlPatterns) {
+      pattern.lastIndex = 0;
+      const matches = content.match(pattern);
+      if (!matches) continue;
+      for (const m of matches) {
+        for (const [paramName, extractor] of Object.entries(sig.paramExtractors)) {
+          if (!params[paramName]) {
+            const val = extractor(m);
+            if (val) params[paramName] = val;
+          }
+        }
+      }
+    }
+    if (Object.keys(params).length === Object.keys(sig.paramExtractors).length) {
+      break;
+    }
+  }
+  return params;
+}
+
+// src/scanner/detectPackageManager.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var LOCKFILE_MAP = [
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+function detectPackageManager(root) {
+  for (const [lockfile, pm] of LOCKFILE_MAP) {
+    if (existsSync3(join3(root, lockfile))) return pm;
+  }
+  return "npm";
+}
+
+// src/scanner/index.ts
+function scan(projectRoot) {
+  const root = resolve(projectRoot ?? process.cwd());
+  const framework = detectFramework(root);
+  const cms = detectCms(root);
+  const packageManager = detectPackageManager(root);
+  const { candidates: injectionPoints, candidateGraph } = findInjectionPoints(root, framework.name, cms);
+  return {
+    framework,
+    cms,
+    injectionPoints,
+    candidateGraph,
+    packageManager,
+    projectRoot: root
+  };
+}
+
+// src/planner/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+
+// src/patcher/structuralValidator.ts
+import { Project, SyntaxKind, ScriptKind } from "ts-morph";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, extname } from "path";
+var TRANSFORMER_PKG = "@synchronized-studio/response-transformer";
+function takeSnapshot(root, filePath) {
+  const absPath = join4(root, filePath);
+  const ext = extname(filePath);
+  let content;
+  try {
+    content = readFileSync3(absPath, "utf-8");
+  } catch {
+    return { exports: [], functions: [], variables: [], imports: [], content: "", syntaxValid: false };
+  }
+  if ([".vue", ".svelte", ".astro"].includes(ext)) {
+    return takeSnapshotFromString(content, ext);
+  }
+  return takeSnapshotFromAst(content, filePath);
+}
+function takeSnapshotFromAst(content, filePath) {
+  try {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const ext = extname(filePath);
+    const scriptKind = ext === ".tsx" || ext === ".jsx" ? ScriptKind.TSX : ScriptKind.TS;
+    const sourceFile = project.createSourceFile("__snapshot__.tsx", content, { scriptKind });
+    const exports = sourceFile.getExportedDeclarations();
+    const exportNames = [...exports.keys()];
+    const functions = sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration).map((f) => f.getName()).filter((n) => !!n);
+    const arrowFunctions = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration).filter((v) => v.getInitializerIfKind(SyntaxKind.ArrowFunction)).map((v) => v.getName());
+    const allFunctions = [.../* @__PURE__ */ new Set([...functions, ...arrowFunctions])];
+    const variables = sourceFile.getVariableDeclarations().map((v) => v.getName()).filter((name) => !allFunctions.includes(name));
+    const imports = sourceFile.getImportDeclarations().map((i) => i.getModuleSpecifierValue());
+    return {
+      exports: exportNames,
+      functions: allFunctions,
+      variables,
+      imports,
+      content,
+      syntaxValid: true
+    };
+  } catch {
+    return {
+      exports: [],
+      functions: [],
+      variables: [],
+      imports: [],
+      content,
+      syntaxValid: false
+    };
+  }
+}
+function takeSnapshotFromString(content, ext) {
+  const scriptContent = extractScriptBlock(content, ext);
+  if (!scriptContent) {
+    return { exports: [], functions: [], variables: [], imports: [], content, syntaxValid: true };
+  }
+  const exports = extractPatterns(scriptContent, /export\s+(?:default\s+)?(?:async\s+)?(?:function|const|let|var|class)\s+(\w+)/g);
+  const functions = extractPatterns(scriptContent, /(?:async\s+)?function\s+(\w+)\s*\(/g);
+  const arrowFns = extractPatterns(scriptContent, /(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/g);
+  const variables = extractPatterns(scriptContent, /(?:const|let|var)\s+(\w+)\s*=/g).filter((v) => !functions.includes(v) && !arrowFns.includes(v));
+  const imports = extractPatterns(scriptContent, /from\s+['"]([^'"]+)['"]/g);
+  return {
+    exports,
+    functions: [.../* @__PURE__ */ new Set([...functions, ...arrowFns])],
+    variables,
+    imports,
+    content,
+    syntaxValid: true
+  };
+}
+function extractScriptBlock(content, ext) {
+  if (ext === ".astro") {
+    const match2 = content.match(/^---\n([\s\S]*?)\n---/);
+    return match2?.[1] ?? null;
+  }
+  const match = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  return match?.[1] ?? null;
+}
+function extractPatterns(content, pattern) {
+  const names = [];
+  let m;
+  while ((m = pattern.exec(content)) !== null) {
+    if (m[1]) names.push(m[1]);
+  }
+  return names;
+}
+function checkFunctionValueWrapping(originalCode, snapshot) {
+  const match = originalCode.match(/^return\s+\{([^}]+)\}\s*;?\s*$/);
+  if (!match) return { valid: true, errors: [] };
+  const inner = match[1].trim();
+  const parts = inner.split(",").map((p) => p.trim()).filter(Boolean);
+  const shorthandNames = [];
+  for (const part of parts) {
+    if (/^\w+$/.test(part)) {
+      shorthandNames.push(part);
+    }
+  }
+  if (shorthandNames.length === 0) return { valid: true, errors: [] };
+  const functionProps = shorthandNames.filter(
+    (name) => snapshot.functions.includes(name)
+  );
+  if (functionProps.length > 0) {
+    return {
+      valid: false,
+      errors: [
+        `Wrapping object containing function references (${functionProps.join(", ")}) with JSON-serializing transform would destroy them at runtime`
+      ]
+    };
+  }
+  return { valid: true, errors: [] };
+}
+var NON_CMS_RETURN_PATTERNS = [
+  /^return\s+\{\s*query\s*[,:}]/,
+  // return { query: ... } or { query }
+  /^return\s+\{\s*path\s*:/,
+  // return { path: '...' }
+  /^return\s+\{\s*redirect\s*:/,
+  // return { redirect: ... }
+  /^return\s+\{\s*statusCode\s*:/,
+  // return { statusCode: 301 }
+  /^return\s+\{\s*headers\s*:/,
+  // return { headers: ... }
+  /^return\s+\{\s*\.\.\.\w[\w.]*[Qq]uery\b/,
+  // return { ...route.query }
+  /^return\s+\{\s*\.\.\.\w[\w.]*[Pp]arams\b/
+  // return { ...route.params }
+];
+function checkNonCmsReturnWrapping(originalCode) {
+  const trimmed = originalCode.trim();
+  const matched = NON_CMS_RETURN_PATTERNS.find((p) => p.test(trimmed));
+  if (matched) {
+    return {
+      valid: false,
+      errors: [
+        `Cannot wrap router/navigation/HTTP object with CMS transformer \u2014 this return produces routing state, not CMS data: ${trimmed.substring(0, 80)}`
+      ]
+    };
+  }
+  return { valid: true, errors: [] };
+}
+function validateContentAgainstSnapshot(newContent, filePath, snapshot) {
+  const ext = extname(filePath);
+  const errors = [];
+  let newSnapshot;
+  if ([".vue", ".svelte", ".astro"].includes(ext)) {
+    newSnapshot = takeSnapshotFromString(newContent, ext);
+  } else {
+    newSnapshot = takeSnapshotFromAst(newContent, filePath);
+  }
+  if (!newSnapshot.syntaxValid) {
+    errors.push("Patched file has syntax errors and cannot be parsed");
+    return { valid: false, errors };
+  }
+  const missingExports = snapshot.exports.filter((e) => !newSnapshot.exports.includes(e));
+  if (missingExports.length > 0) {
+    errors.push(`Missing exports after patch: ${missingExports.join(", ")}`);
+  }
+  const missingFunctions = snapshot.functions.filter((f) => !newSnapshot.functions.includes(f));
+  if (missingFunctions.length > 0) {
+    errors.push(`Missing functions after patch: ${missingFunctions.join(", ")}`);
+  }
+  const missingVariables = snapshot.variables.filter((v) => !newSnapshot.variables.includes(v));
+  if (missingVariables.length > 0) {
+    errors.push(`Missing variables after patch: ${missingVariables.join(", ")}`);
+  }
+  const removedImports = snapshot.imports.filter(
+    (i) => i !== TRANSFORMER_PKG && !newSnapshot.imports.includes(i)
+  );
+  if (removedImports.length > 0) {
+    errors.push(`Removed imports after patch: ${removedImports.join(", ")}`);
+  }
+  const addedImports = newSnapshot.imports.filter((i) => !snapshot.imports.includes(i));
+  const unexpectedImports = addedImports.filter((i) => i !== TRANSFORMER_PKG);
+  if (unexpectedImports.length > 0) {
+    errors.push(`Unexpected new imports: ${unexpectedImports.join(", ")}`);
+  }
+  const unreachable = detectUnreachableCode(newContent, filePath);
+  if (unreachable.length > 0) {
+    errors.push(`Unreachable code after return: ${unreachable.join("; ")}`);
+  }
+  const unresolvedRefs = detectUnresolvedPlaceholders(newContent);
+  if (unresolvedRefs.length > 0) {
+    errors.push(`Unresolved placeholders: ${unresolvedRefs.join("; ")}`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function detectUnresolvedPlaceholders(content) {
+  const issues = [];
+  if (content.includes("__runtimeConfig")) {
+    const hasDeclared = /(?:const|let|var)\s+__runtimeConfig\s*=/.test(content);
+    if (!hasDeclared) {
+      issues.push(
+        "__runtimeConfig is used but never declared \u2014 useRuntimeConfig() injection is missing"
+      );
+    }
+  }
+  return issues;
+}
+function detectUnreachableCode(content, filePath) {
+  const issues = [];
+  const ext = extname(filePath);
+  const { code, lineOffset } = getCodeForControlFlowValidation(content, ext);
+  if (!code.trim()) return issues;
+  try {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const scriptKind = ext === ".js" ? ScriptKind.JS : ScriptKind.TS;
+    const sourceFile = project.createSourceFile("__unreachable_check__.ts", code, { scriptKind });
+    const blocks = sourceFile.getDescendantsOfKind(SyntaxKind.Block);
+    for (const block of blocks) {
+      const statements = block.getStatements();
+      let returnLine = null;
+      for (const stmt of statements) {
+        if (returnLine !== null) {
+          const stmtLine = stmt.getStartLineNumber() + lineOffset;
+          const retLine = returnLine + lineOffset;
+          issues.push(`line ${stmtLine} is unreachable after return at line ${retLine}`);
+          break;
+        }
+        if (stmt.getKind() === SyntaxKind.ReturnStatement) {
+          returnLine = stmt.getStartLineNumber();
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return issues;
+}
+function getCodeForControlFlowValidation(content, ext) {
+  if (ext === ".astro") {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match || typeof match.index !== "number") return { code: content, lineOffset: 0 };
+    const before = content.slice(0, match.index);
+    const startLine = before.split("\n").length + 1;
+    return { code: match[1], lineOffset: startLine - 1 };
+  }
+  if (ext === ".vue" || ext === ".svelte") {
+    const match = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    if (!match || typeof match.index !== "number") return { code: "", lineOffset: 0 };
+    const scriptTag = match[0];
+    const bodyStartInTag = scriptTag.indexOf(">") + 1;
+    const bodyStartInFile = match.index + bodyStartInTag;
+    const before = content.slice(0, bodyStartInFile);
+    const startLine = before.split("\n").length;
+    return { code: match[1], lineOffset: startLine - 1 };
+  }
+  return { code: content, lineOffset: 0 };
+}
+
+// src/planner/index.ts
+function resolveInstallCommand(scan2) {
+  const pkg = "@synchronized-studio/response-transformer";
+  switch (scan2.packageManager) {
+    case "pnpm":
+      return `pnpm add ${pkg}`;
+    case "yarn":
+      return `yarn add ${pkg}`;
+    case "bun":
+      return `bun add ${pkg}`;
+    default:
+      return `npm install ${pkg}`;
+  }
+}
+function resolveEnvFiles(root) {
+  const candidates = [".env", ".env.local", ".env.example", ".env.development"];
+  return candidates.filter((f) => existsSync4(join5(root, f)));
+}
+function createPlan(scan2) {
+  const patches = [];
+  for (const candidate of scan2.injectionPoints) {
+    const template = WRAP_TEMPLATES[candidate.type];
+    if (!template) continue;
+    const importStatement = getImportStatement(scan2.cms.type);
+    const originalCode = candidate.targetCode;
+    if (!originalCode) continue;
+    if (/\.push\s*\(/.test(originalCode.trim())) continue;
+    if (!checkNonCmsReturnWrapping(originalCode).valid) continue;
+    const isNuxt3ClientSide = scan2.framework.name === "nuxt" && !/^server\//.test(candidate.filePath);
+    const runtimeUrlExpr = isNuxt3ClientSide ? "__runtimeConfig.public.cmsAssetsUrl" : void 0;
+    const transformedCode = template.transform(
+      originalCode,
+      scan2.cms.type,
+      scan2.cms.params,
+      void 0,
+      runtimeUrlExpr
+    );
+    if (transformedCode === originalCode) continue;
+    patches.push({
+      filePath: candidate.filePath,
+      description: template.description(scan2.cms.type),
+      importToAdd: importStatement,
+      wrapTarget: {
+        line: candidate.line,
+        originalCode,
+        transformedCode
+      },
+      confidence: candidate.confidence,
+      reasons: candidate.reasons
+    });
+  }
+  const envFiles = resolveEnvFiles(scan2.projectRoot);
+  return {
+    schemaVersion: "1.0",
+    scan: scan2,
+    install: {
+      package: "@synchronized-studio/response-transformer",
+      command: resolveInstallCommand(scan2)
+    },
+    env: {
+      key: "CMS_ASSETS_URL",
+      placeholder: "https://YOUR-SLUG.cmsassets.com",
+      files: envFiles
+    },
+    patches,
+    policies: {
+      maxFilesAutoApply: 20,
+      patchMode: "hybrid",
+      verifyProfile: "quick"
+    }
+  };
+}
+
+// src/patcher/index.ts
+import { appendFileSync, existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+import consola from "consola";
+import pc from "picocolors";
+
+// src/patcher/astPatcher.ts
+import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
+import { readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join6, extname as extname2 } from "path";
+var RUNTIME_CONFIG_PLACEHOLDER = "__runtimeConfig";
+var RUNTIME_CONFIG_DECL = `const ${RUNTIME_CONFIG_PLACEHOLDER} = useRuntimeConfig()`;
+function detectRuntimeConfigVar(content) {
+  const match = content.match(/(?:const|let|var)\s+(\w+)\s*=\s*useRuntimeConfig\s*\(/);
+  return match?.[1] ?? null;
+}
+function resolveRuntimeConfigRef(fileContent, transformedCode) {
+  if (!transformedCode.includes(RUNTIME_CONFIG_PLACEHOLDER)) {
+    return { resolved: transformedCode, needsDecl: false };
+  }
+  const existing = detectRuntimeConfigVar(fileContent);
+  if (existing) {
+    return {
+      resolved: transformedCode.replaceAll(RUNTIME_CONFIG_PLACEHOLDER, existing),
+      needsDecl: false
+    };
+  }
+  return { resolved: transformedCode, needsDecl: true };
+}
+function injectRuntimeConfigDecl(content) {
+  const lines = content.split("\n");
+  let scriptStart = -1;
+  let scriptEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/<script[^>]*>/.test(lines[i])) scriptStart = i;
+    if (/<\/script>/.test(lines[i])) {
+      scriptEnd = i;
+      break;
+    }
+  }
+  const searchStart = scriptStart >= 0 ? scriptStart : 0;
+  const searchEnd = scriptEnd >= 0 ? scriptEnd : lines.length;
+  for (let i = searchStart; i < searchEnd; i++) {
+    if (/\b(useAsyncData|useFetch)\s*\(/.test(lines[i])) {
+      let insertIdx = i;
+      if (/^\s*\}\s*=\s*await\s+(useAsyncData|useFetch)\b/.test(lines[i])) {
+        for (let j = i - 1; j >= searchStart; j--) {
+          if (/^\s*(const|let|var)\s*\{/.test(lines[j])) {
+            insertIdx = j;
+            break;
+          }
+        }
+      }
+      const indent2 = lines[insertIdx].match(/^(\s*)/)?.[1] ?? "  ";
+      lines.splice(insertIdx, 0, `${indent2}${RUNTIME_CONFIG_DECL}`);
+      return lines.join("\n");
+    }
+  }
+  let lastImport = searchStart;
+  for (let i = searchStart; i < searchEnd; i++) {
+    if (/^\s*import\s/.test(lines[i])) lastImport = i;
+  }
+  const indent = lines[lastImport + 1]?.match(/^(\s*)/)?.[1] ?? "  ";
+  lines.splice(lastImport + 1, 0, `${indent}${RUNTIME_CONFIG_DECL}`);
+  return lines.join("\n");
+}
+function applyAstPatch(root, patch, dryRun, snapshot) {
+  const absPath = join6(root, patch.filePath);
+  const ext = extname2(patch.filePath);
+  if ([".vue", ".svelte", ".astro"].includes(ext)) {
+    return applyStringPatch(root, patch, dryRun, snapshot);
+  }
+  try {
+    const project = new Project2({ useInMemoryFileSystem: false });
+    const sourceFile = project.addSourceFileAtPath(absPath);
+    const originalText = sourceFile.getFullText();
+    const targetLine = patch.wrapTarget.line;
+    const original = patch.wrapTarget.originalCode.trim();
+    const transformed = patch.wrapTarget.transformedCode.trim();
+    if (original && transformed && original !== transformed) {
+      let patched = false;
+      const returnStatements = sourceFile.getDescendantsOfKind(
+        SyntaxKind2.ReturnStatement
+      );
+      for (const ret of returnStatements) {
+        const retLine = ret.getStartLineNumber();
+        if (retLine !== targetLine) continue;
+        const retText = ret.getText().trim();
+        if (retText.includes(original) || original.startsWith("return") && retText.startsWith("return") && normalizeReturnExpr(retText) === normalizeReturnExpr(original)) {
+          ret.replaceWithText(transformed);
+          patched = true;
+          break;
+        }
+      }
+      if (!patched) {
+        const expressions = sourceFile.getDescendantsOfKind(
+          SyntaxKind2.ExpressionStatement
+        );
+        for (const expr of expressions) {
+          const exprLine = expr.getStartLineNumber();
+          if (exprLine !== targetLine) continue;
+          const exprText = expr.getText().trim();
+          if (exprText.includes("res.json") || exprText.includes("c.json")) {
+            expr.replaceWithText(transformed);
+            patched = true;
+            break;
+          }
+        }
+      }
+      if (!patched) {
+        for (const ret of returnStatements) {
+          const retLine = ret.getStartLineNumber();
+          if (Math.abs(retLine - targetLine) > 1) continue;
+          const retText = ret.getText().trim();
+          if (original.startsWith("return") && retText.startsWith("return")) {
+            if (normalizeReturnExpr(retText) !== normalizeReturnExpr(original)) continue;
+            ret.replaceWithText(transformed);
+            patched = true;
+            break;
+          }
+        }
+      }
+      if (!patched) {
+        const currentText = sourceFile.getFullText();
+        const lines = currentText.split("\n");
+        const targetLineContent = lines[targetLine - 1];
+        if (targetLineContent && targetLineContent.trim() === original) {
+          const indent = targetLineContent.match(/^(\s*)/)?.[1] ?? "";
+          const newContent = currentText.replace(
+            targetLineContent,
+            indent + transformed
+          );
+          if (newContent !== currentText) {
+            sourceFile.replaceWithText(newContent);
+            patched = true;
+          }
+        }
+      }
+      if (!patched) {
+        const currentText = sourceFile.getFullText();
+        const lines = currentText.split("\n");
+        const targetIdx = Math.max(0, targetLine - 1);
+        const start = Math.max(0, targetIdx - 5);
+        const end = Math.min(lines.length - 1, targetIdx + 5);
+        for (let idx = start; idx <= end; idx++) {
+          const line = lines[idx];
+          const trimmed = line.trim();
+          if (trimmed === original || trimmed === original.replace(/;\s*$/, "")) {
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            lines[idx] = indent + transformed;
+            sourceFile.replaceWithText(lines.join("\n"));
+            patched = true;
+            break;
+          }
+        }
+      }
+      if (!patched) {
+        return { applied: false, reason: `Could not locate target code at line ${targetLine}` };
+      }
+    }
+    const existingImports = sourceFile.getImportDeclarations();
+    const hasImport = existingImports.some(
+      (i) => i.getModuleSpecifierValue() === "@synchronized-studio/response-transformer"
+    );
+    if (!hasImport && patch.importToAdd) {
+      const importMatch = patch.importToAdd.match(
+        /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/
+      );
+      if (importMatch) {
+        const namedImports = importMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+        sourceFile.addImportDeclaration({
+          moduleSpecifier: importMatch[2],
+          namedImports
+        });
+      }
+    }
+    const newText = sourceFile.getFullText();
+    if (newText === originalText) {
+      return { applied: false, reason: "No changes needed (idempotent)" };
+    }
+    if (snapshot) {
+      const validation = validateContentAgainstSnapshot(newText, patch.filePath, snapshot);
+      if (!validation.valid) {
+        return {
+          applied: false,
+          validationFailed: true,
+          reason: `Structural validation failed: ${validation.errors.join("; ")}`
+        };
+      }
+    }
+    if (!dryRun) {
+      sourceFile.saveSync();
+    }
+    return { applied: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `AST patch failed: ${msg}` };
+  }
+}
+function normalizeReturnExpr(value) {
+  return value.replace(/^return\s+/, "").replace(/;$/, "").replace(/\s+/g, " ").trim();
+}
+function applyStringPatch(root, patch, dryRun, snapshot) {
+  const absPath = join6(root, patch.filePath);
+  let content;
+  try {
+    content = readFileSync4(absPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `Cannot read file: ${msg}` };
+  }
+  const originalContent = content;
+  const { originalCode } = patch.wrapTarget;
+  let { transformedCode } = patch.wrapTarget;
+  const { resolved, needsDecl } = resolveRuntimeConfigRef(content, transformedCode);
+  transformedCode = resolved;
+  if (originalCode && transformedCode && originalCode !== transformedCode) {
+    if (content.includes(originalCode.trim())) {
+      content = content.replace(originalCode.trim(), transformedCode.trim());
+    } else {
+      return {
+        applied: false,
+        reason: "Original code not found in file (string match)"
+      };
+    }
+  }
+  if (needsDecl && content.includes(RUNTIME_CONFIG_PLACEHOLDER)) {
+    content = injectRuntimeConfigDecl(content);
+  }
+  if (patch.importToAdd && !content.includes("@synchronized-studio/response-transformer")) {
+    const scriptMatch = content.match(
+      /(<script[^>]*>)\s*\n/
+    );
+    if (scriptMatch) {
+      const insertAfter = scriptMatch[0];
+      content = content.replace(
+        insertAfter,
+        `${insertAfter}${patch.importToAdd}
+`
+      );
+    } else if (patch.filePath.endsWith(".astro")) {
+      const fmMatch = content.match(/^(---\n)/);
+      if (fmMatch) {
+        content = content.replace(
+          "---\n",
+          `---
+${patch.importToAdd}
+`
+        );
+      }
+    }
+  }
+  if (content === originalContent) {
+    return { applied: false, reason: "No changes needed (idempotent)" };
+  }
+  if (snapshot) {
+    const validation = validateContentAgainstSnapshot(content, patch.filePath, snapshot);
+    if (!validation.valid) {
+      return {
+        applied: false,
+        validationFailed: true,
+        reason: `Structural validation failed: ${validation.errors.join("; ")}`
+      };
+    }
+  }
+  if (!dryRun) {
+    writeFileSync(absPath, content, "utf-8");
+  }
+  return { applied: true };
+}
+
+// src/patcher/aiFilePatch.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
+async function applyAiFilePatch(root, filePath, patches, cms, framework, snapshot, model = "gpt-4o") {
+  const absPath = join7(root, filePath);
+  let fileContent;
+  try {
+    fileContent = readFileSync5(absPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `Cannot read file: ${msg}` };
+  }
+  const fn = getTransformFunctionName(cms.type);
+  const opts = buildCmsOptions(cms.type, cms.params);
+  const importStatement = `import { ${fn} } from '@synchronized-studio/response-transformer'`;
+  const resolvedPatches = patches.map((p) => {
+    const { resolved, needsDecl } = resolveRuntimeConfigRef(fileContent, p.wrapTarget.transformedCode);
+    return { ...p, wrapTarget: { ...p.wrapTarget, transformedCode: resolved }, needsDecl };
+  });
+  const needsRuntimeConfigDecl = resolvedPatches.some((p) => p.needsDecl);
+  const wraps = resolvedPatches.map(
+    (p, i) => `${i + 1}. Near line ${p.wrapTarget.line}:
+   BEFORE: ${p.wrapTarget.originalCode}
+   AFTER:  ${p.wrapTarget.transformedCode}`
+  ).join("\n\n");
+  const prompt = `You are a precise code integration agent. You must modify the file below to add CMS asset URL transformation.
+
+TASK:
+1. Add this import at the top (with the other imports), if not already present:
+   ${importStatement}
+
+2. Apply these wraps:
+
+${wraps}
+
+${needsRuntimeConfigDecl ? `3. INJECT RUNTIME CONFIG: The wraps use \`__runtimeConfig.public.cmsAssetsUrl\`.
+   Since no \`useRuntimeConfig()\` variable was found in this file, you MUST add:
+   \`const __runtimeConfig = useRuntimeConfig()\`
+   as a NEW LINE in the outer <script setup> scope, BEFORE the first \`useAsyncData\`/\`useFetch\` call.
+   CRITICAL: NEVER call \`useRuntimeConfig()\` directly inside a callback.` : `3. RUNTIME CONFIG: The \`__runtimeConfig\` placeholder has already been resolved to the correct variable name in the wraps above. Do NOT modify it.`}
+
+CRITICAL RULES:
+- Return the COMPLETE modified file \u2014 every single line
+- Do NOT change, remove, rename, or restructure ANY other code
+- Do NOT add comments explaining your changes
+- Do NOT change formatting, indentation, or whitespace of untouched lines
+- Every function, variable, export, and import that exists in the original MUST remain intact
+- If a return statement returns an object that contains any FUNCTIONS (e.g. { getPage, fn } or { getPrimary, items }), do NOT wrap it \u2014 the transform uses JSON.stringify and would destroy function references at runtime
+- Only wrap returns that produce pure CMS DATA (plain objects/arrays with data, no function properties)
+- If unsure whether a return is data or functions, do NOT wrap it
+- ONLY modify the EXACT lines listed in the wraps above. Do NOT modify any other functions or lines
+- NEVER create unreachable code \u2014 do NOT add any statement after a return statement
+- NEVER place a return statement before existing side effects (commit(), setState(), dispatch(), store mutations). If a function commits data and does NOT return, wrap the data BEFORE the commit and pass the transformed value to the commit \u2014 do NOT add a new return that makes the commit unreachable
+- \`return dispatch(...)\` is delegation to another action \u2014 do NOT wrap it, the target action handles the transform
+- For Vuex/Pinia actions that commit but don't return: transform the data, then pass it to commit. Example:
+  WRONG: return ${fn}(data, ${opts})  // \u2190 makes commit below unreachable!
+         commit('SET_STATE', { prop: 'x', value: data })
+  RIGHT: const transformed = ${fn}(data, ${opts})
+         commit('SET_STATE', { prop: 'x', value: transformed })
+- When a Vuex action BOTH commits AND returns the same data, transform ONCE and use for both:
+  const transformed = ${fn}(data, ${opts})
+  commit('SET_STATE', { prop: 'x', value: transformed })
+  return transformed
+- NEVER put ${fn}() inside loop/iteration callbacks (_each, forEach, map, reduce, for...of). Transform the FINAL result AFTER the loop, not each iteration
+- NEVER wrap returns that produce navigation/routing objects (e.g. \`{ query: ... }\`, \`{ path: ... }\`, \`{ redirect: ... }\`). These are Vue Router / framework navigation objects, NOT CMS data. If a wrap listed above targets such a return, SKIP that wrap entirely
+
+CMS: ${cms.type}
+Framework: ${framework}
+Transform function: ${fn}
+Options: ${opts}
+
+File: ${filePath}
+\`\`\`
+${fileContent}
+\`\`\`
+
+Return ONLY the complete modified file content. No markdown fences, no explanation \u2014 just the raw file content.`;
+  const result = await chatCompletion(prompt, {
+    model,
+    maxTokens: 16e3,
+    temperature: 0
+  });
+  if (isOpenAiError(result)) {
+    return { applied: false, reason: result.error };
+  }
+  let newContent = result.content;
+  if (!newContent) {
+    return { applied: false, reason: "AI returned empty response" };
+  }
+  newContent = stripCodeFences(newContent);
+  if (newContent.trim() === fileContent.trim()) {
+    return { applied: false, reason: "AI returned unchanged file" };
+  }
+  if (!newContent.includes(fn)) {
+    return { applied: false, reason: "AI output missing transform function call" };
+  }
+  if (!newContent.includes("@synchronized-studio/response-transformer")) {
+    return { applied: false, reason: "AI output missing transformer import" };
+  }
+  const fnGuard = checkFunctionValueWrapping(
+    patches[0]?.wrapTarget.originalCode ?? "",
+    snapshot
+  );
+  if (!fnGuard.valid) {
+    return { applied: false, reason: fnGuard.errors[0] };
+  }
+  const validation = validateContentAgainstSnapshot(newContent, filePath, snapshot);
+  if (!validation.valid) {
+    return {
+      applied: false,
+      reason: `AI output failed structural validation: ${validation.errors.join("; ")}`
+    };
+  }
+  writeFileSync2(absPath, newContent, "utf-8");
+  return { applied: true };
+}
+function stripCodeFences(content) {
+  const fenceStart = /^```\w*\n/;
+  const fenceEnd = /\n```\s*$/;
+  if (fenceStart.test(content) && fenceEnd.test(content)) {
+    return content.replace(fenceStart, "").replace(fenceEnd, "");
+  }
+  return content;
+}
+
+// src/patcher/idempotency.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+var TRANSFORMER_IMPORTS = [
+  "@synchronized-studio/response-transformer",
+  "transformCmsAssetUrls",
+  "transformPrismicAssetUrls",
+  "transformContentfulAssetUrls",
+  "transformSanityAssetUrls",
+  "transformShopifyAssetUrls",
+  "transformCloudinaryAssetUrls",
+  "transformImgixAssetUrls",
+  "transformGenericAssetUrls"
+];
+function isAlreadyTransformed(root, filePath) {
+  const absPath = join8(root, filePath);
+  let content;
+  try {
+    content = readFileSync6(absPath, "utf-8");
+  } catch {
+    return false;
+  }
+  return TRANSFORMER_IMPORTS.some((sig) => content.includes(sig));
+}
+function isTestOrFixtureFile(filePath) {
+  return /\.(test|spec)\.[jt]sx?$/.test(filePath) || /__tests__\//.test(filePath) || /(^|\/)tests?\//.test(filePath) || /(^|\/)fixtures?\//.test(filePath) || /(^|\/)mocks?\//.test(filePath) || /\.stories\.[jt]sx?$/.test(filePath);
+}
+function isGeneratedFile(filePath) {
+  return /\.generated\.[jt]sx?$/.test(filePath) || /\.g\.[jt]sx?$/.test(filePath) || /(^|\/)\.nuxt\//.test(filePath) || /(^|\/)\.next\//.test(filePath) || /(^|\/)\.svelte-kit\//.test(filePath) || /(^|\/)dist\//.test(filePath) || /(^|\/)build\//.test(filePath);
+}
+
+// src/patcher/index.ts
+function groupPatchesByFile(patches) {
+  const map = /* @__PURE__ */ new Map();
+  for (const patch of patches) {
+    const list = map.get(patch.filePath) ?? [];
+    list.push(patch);
+    map.set(patch.filePath, list);
+  }
+  return map;
+}
+async function applyPlan(plan, opts = {}) {
+  const startTime = Date.now();
+  const root = plan.scan.projectRoot;
+  const dryRun = opts.dryRun ?? false;
+  const includeTests = opts.includeTests ?? false;
+  const maxFiles = opts.maxFiles ?? plan.policies.maxFilesAutoApply;
+  const patchMode = opts.patchMode ?? plan.policies.patchMode ?? "hybrid";
+  const aiMode = patchMode !== "ast" && (opts.aiMode ?? false);
+  const files = [];
+  let appliedCount = 0;
+  const patchedFiles = /* @__PURE__ */ new Set();
+  const alreadyTransformedAtStart = new Set(
+    plan.patches.map((patch) => patch.filePath).filter((filePath, index, all) => all.indexOf(filePath) === index).filter((filePath) => isAlreadyTransformed(root, filePath))
+  );
+  const eligiblePatches = [];
+  for (const patch of plan.patches) {
+    if (alreadyTransformedAtStart.has(patch.filePath)) {
+      files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: "Transformer already present in file", durationMs: 0 });
+      continue;
+    }
+    if (!includeTests && isTestOrFixtureFile(patch.filePath)) {
+      files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: "Test/fixture file excluded", durationMs: 0 });
+      continue;
+    }
+    if (isGeneratedFile(patch.filePath)) {
+      files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: "Generated file excluded", durationMs: 0 });
+      continue;
+    }
+    eligiblePatches.push(patch);
+  }
+  if (aiMode && patchMode === "ai") {
+    const byFile = groupPatchesByFile(eligiblePatches);
+    for (const [filePath, filePatches] of byFile) {
+      const fileStart = Date.now();
+      if (!patchedFiles.has(filePath) && appliedCount >= maxFiles) {
+        for (const p of filePatches) {
+          files.push({ filePath: p.filePath, applied: false, method: "skipped", reason: `Max files threshold reached (${maxFiles})`, durationMs: 0 });
+        }
+        continue;
+      }
+      const snapshot = takeSnapshot(root, filePath);
+      const safePatches = filePatches.filter((p) => {
+        const fnGuard = checkFunctionValueWrapping(p.wrapTarget.originalCode, snapshot);
+        if (!fnGuard.valid) {
+          consola.warn(`  ${pc.yellow("skip")} ${filePath}:${p.wrapTarget.line} \u2014 ${fnGuard.errors[0]}`);
+          files.push({ filePath, applied: false, method: "skipped", reason: fnGuard.errors[0], durationMs: 0 });
+          return false;
+        }
+        const nonCmsGuard = checkNonCmsReturnWrapping(p.wrapTarget.originalCode);
+        if (!nonCmsGuard.valid) {
+          consola.warn(`  ${pc.yellow("skip")} ${filePath}:${p.wrapTarget.line} \u2014 ${nonCmsGuard.errors[0]}`);
+          files.push({ filePath, applied: false, method: "skipped", reason: nonCmsGuard.errors[0], durationMs: 0 });
+          return false;
+        }
+        return true;
+      });
+      if (safePatches.length === 0) continue;
+      consola.info(`${pc.cyan("AI patch:")} ${filePath} (${safePatches.length} targets)`);
+      if (dryRun) {
+        for (const p of safePatches) {
+          files.push({ filePath, applied: false, method: "skipped", reason: "Dry run", durationMs: 0 });
+        }
+        continue;
+      }
+      const aiResult = await applyAiFilePatch(
+        root,
+        filePath,
+        safePatches,
+        plan.scan.cms,
+        plan.scan.framework.name,
+        snapshot,
+        opts.aiModel ?? "gpt-4o"
+      );
+      if (aiResult.applied) {
+        if (!patchedFiles.has(filePath)) {
+          patchedFiles.add(filePath);
+          appliedCount++;
+        }
+        for (const p of safePatches) {
+          files.push({ filePath, applied: true, method: "ai-complete", durationMs: Date.now() - fileStart });
+        }
+        consola.info(`  ${pc.green("done")} ${filePath}`);
+      } else {
+        consola.warn(`  ${pc.yellow("AI failed")} ${filePath}: ${aiResult.reason}`);
+        for (const p of safePatches) {
+          const patchStart = Date.now();
+          const astResult = applyAstPatch(root, p, false, snapshot);
+          if (astResult.applied) {
+            if (!patchedFiles.has(filePath)) {
+              patchedFiles.add(filePath);
+              appliedCount++;
+            }
+            files.push({ filePath, applied: true, method: "ast", durationMs: Date.now() - patchStart });
+          } else {
+            files.push({ filePath, applied: false, method: "skipped", reason: astResult.reason ?? "AST fallback failed after AI", durationMs: Date.now() - patchStart });
+          }
+        }
+      }
+    }
+  } else {
+    for (const patch of eligiblePatches) {
+      const fileStart = Date.now();
+      if (!patchedFiles.has(patch.filePath) && appliedCount >= maxFiles) {
+        files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: `Max files threshold reached (${maxFiles})`, durationMs: 0 });
+        continue;
+      }
+      if (patch.confidence === "low") {
+        files.push({
+          filePath: patch.filePath,
+          applied: false,
+          method: "manual-review",
+          reason: `Low confidence candidate \u2014 requires manual review (line ${patch.wrapTarget.line})`,
+          durationMs: 0
+        });
+        continue;
+      }
+      const snapshot = takeSnapshot(root, patch.filePath);
+      const fnGuard = checkFunctionValueWrapping(patch.wrapTarget.originalCode, snapshot);
+      if (!fnGuard.valid) {
+        files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: fnGuard.errors[0], durationMs: Date.now() - fileStart });
+        continue;
+      }
+      const nonCmsGuard = checkNonCmsReturnWrapping(patch.wrapTarget.originalCode);
+      if (!nonCmsGuard.valid) {
+        files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: nonCmsGuard.errors[0], durationMs: Date.now() - fileStart });
+        continue;
+      }
+      if (dryRun) {
+        files.push({ filePath: patch.filePath, applied: false, method: "skipped", reason: "Dry run", durationMs: 0 });
+        continue;
+      }
+      const astResult = applyAstPatch(root, patch, false, snapshot);
+      if (astResult.applied) {
+        if (!patchedFiles.has(patch.filePath)) {
+          patchedFiles.add(patch.filePath);
+          appliedCount++;
+        }
+        files.push({ filePath: patch.filePath, applied: true, method: "ast", durationMs: Date.now() - fileStart });
+      } else {
+        files.push({
+          filePath: patch.filePath,
+          applied: false,
+          method: "manual-review",
+          reason: `AST patch failed, requires manual review: ${astResult.reason}`,
+          durationMs: Date.now() - fileStart
+        });
+      }
+    }
+  }
+  let envUpdated = false;
+  if (!dryRun) {
+    for (const envFile of plan.env.files) {
+      const envPath = join9(root, envFile);
+      if (existsSync5(envPath)) {
+        const content = readFileSync7(envPath, "utf-8");
+        if (!content.includes(plan.env.key)) {
+          appendFileSync(envPath, `
+${plan.env.key}=${plan.env.placeholder}
+`);
+          envUpdated = true;
+        }
+      }
+    }
+    if (plan.env.files.length === 0) {
+      const envExamplePath = join9(root, ".env.example");
+      writeFileSync3(envExamplePath, `${plan.env.key}=${plan.env.placeholder}
+`, "utf-8");
+      envUpdated = true;
+    }
+  }
+  const summary = {
+    candidatesFound: plan.patches.length,
+    patchedByAi: files.filter((f) => f.applied && f.method === "ai-complete").length,
+    patchedByAst: files.filter((f) => f.applied && f.method === "ast").length,
+    manualReviewRequired: files.filter((f) => f.method === "manual-review").length,
+    skipped: files.filter((f) => !f.applied && f.method === "skipped").length
+  };
+  const decisionLog = files.map((f) => {
+    const reason = f.reason ?? "";
+    let reasonCode = "SKIP_GUARD_REJECTED";
+    if (f.applied && f.method === "ast") reasonCode = "PATCHED_AST";
+    else if (f.applied && f.method === "ai-complete") reasonCode = "PATCHED_AI";
+    else if (f.method === "manual-review" && reason.includes("Low confidence")) reasonCode = "MANUAL_LOW_CONFIDENCE";
+    else if (f.method === "manual-review") reasonCode = "MANUAL_AST_FAILED";
+    else if (reason.includes("Transformer already present")) reasonCode = "SKIP_ALREADY_TRANSFORMED";
+    else if (reason.includes("Test/fixture")) reasonCode = "SKIP_TEST_OR_FIXTURE";
+    else if (reason.includes("Generated file")) reasonCode = "SKIP_GENERATED_FILE";
+    else if (reason.includes("Max files threshold")) reasonCode = "SKIP_MAX_FILES";
+    else if (reason.includes("Dry run")) reasonCode = "SKIP_DRY_RUN";
+    else if (reason.includes("AST fallback failed after AI")) reasonCode = "SKIP_AI_FALLBACK_FAILED";
+    return {
+      filePath: f.filePath,
+      method: f.method,
+      applied: f.applied,
+      reasonCode,
+      reason: f.reason
+    };
+  });
+  return {
+    schemaVersion: "2.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot: root,
+    gitBranch: null,
+    gitCommit: null,
+    installed: false,
+    envUpdated,
+    files,
+    summary,
+    decisionLog,
+    totalDurationMs: Date.now() - startTime
+  };
+}
+
+// src/types.ts
+import { z } from "zod/v3";
+var FrameworkName = z.enum([
+  "nuxt",
+  "nuxt2",
+  "next",
+  "remix",
+  "astro",
+  "sveltekit",
+  "express",
+  "hono",
+  "fastify",
+  "unknown"
+]);
+var CmsType = z.enum([
+  "prismic",
+  "contentful",
+  "sanity",
+  "shopify",
+  "cloudinary",
+  "imgix",
+  "generic",
+  "unknown"
+]);
+var PackageManager = z.enum(["npm", "yarn", "pnpm", "bun"]);
+var Confidence = z.enum(["high", "medium", "low"]);
+var InjectionType = z.enum([
+  "return",
+  "res.json",
+  "assignment",
+  "useFetch-transform",
+  "useAsyncData-transform",
+  "loader-return",
+  "getServerSideProps-return",
+  "getStaticProps-return",
+  "load-return",
+  "frontmatter-assignment",
+  "asyncData-return",
+  "vuex-action-return",
+  "vuex-commit"
+]);
+var VerifyProfile = z.enum(["quick", "full"]);
+var PatchMode = z.enum(["ast", "ai", "hybrid"]);
+var FrameworkInfo = z.object({
+  name: FrameworkName,
+  version: z.string(),
+  configFile: z.string().nullable()
+});
+var CmsInfo = z.object({
+  type: CmsType,
+  params: z.record(z.string()),
+  detectedFrom: z.array(z.string())
+});
+var InjectionCandidate = z.object({
+  filePath: z.string(),
+  line: z.number(),
+  type: InjectionType,
+  score: z.number().min(0).max(100),
+  confidence: Confidence,
+  detectedConfidence: Confidence.optional(),
+  autoPatchConfidence: Confidence.optional(),
+  regionId: z.string().optional(),
+  targetCode: z.string(),
+  context: z.string(),
+  reasons: z.array(z.string())
+});
+var CandidateRegionType = z.enum([
+  "function",
+  "hook",
+  "action",
+  "loader",
+  "route-handler",
+  "unknown"
+]);
+var CandidateRegion = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  type: CandidateRegionType,
+  startLine: z.number(),
+  endLine: z.number(),
+  parentRegionId: z.string().nullable()
+});
+var CandidateGraph = z.object({
+  regions: z.array(CandidateRegion),
+  candidates: z.array(InjectionCandidate)
+});
+var ScanResult = z.object({
+  framework: FrameworkInfo,
+  cms: CmsInfo,
+  injectionPoints: z.array(InjectionCandidate),
+  candidateGraph: CandidateGraph.optional(),
+  packageManager: PackageManager,
+  projectRoot: z.string()
+});
+var FilePatch = z.object({
+  filePath: z.string(),
+  description: z.string(),
+  importToAdd: z.string(),
+  wrapTarget: z.object({
+    line: z.number(),
+    originalCode: z.string(),
+    transformedCode: z.string()
+  }),
+  confidence: Confidence,
+  reasons: z.array(z.string())
+});
+var PatchPlan = z.object({
+  schemaVersion: z.literal("1.0"),
+  scan: ScanResult,
+  install: z.object({
+    package: z.literal("@synchronized-studio/response-transformer"),
+    command: z.string()
+  }),
+  env: z.object({
+    key: z.literal("CMS_ASSETS_URL"),
+    placeholder: z.string(),
+    files: z.array(z.string())
+  }),
+  patches: z.array(FilePatch),
+  policies: z.object({
+    maxFilesAutoApply: z.number().default(20),
+    patchMode: PatchMode.default("hybrid"),
+    verifyProfile: VerifyProfile.default("quick")
+  })
+});
+var PatchMethod = z.enum(["ast", "ai-complete", "skipped", "manual-review"]);
+var DecisionReasonCode = z.enum([
+  "PATCHED_AST",
+  "PATCHED_AI",
+  "SKIP_ALREADY_TRANSFORMED",
+  "SKIP_TEST_OR_FIXTURE",
+  "SKIP_GENERATED_FILE",
+  "SKIP_MAX_FILES",
+  "SKIP_GUARD_REJECTED",
+  "SKIP_DRY_RUN",
+  "MANUAL_LOW_CONFIDENCE",
+  "MANUAL_AST_FAILED",
+  "SKIP_AI_FALLBACK_FAILED"
+]);
+var DecisionLogEntry = z.object({
+  filePath: z.string(),
+  method: PatchMethod,
+  applied: z.boolean(),
+  reasonCode: DecisionReasonCode,
+  reason: z.string().optional()
+});
+var PatchedFileReport = z.object({
+  filePath: z.string(),
+  applied: z.boolean(),
+  method: PatchMethod,
+  reason: z.string().optional(),
+  durationMs: z.number()
+});
+var ApplyReport = z.object({
+  schemaVersion: z.literal("2.0"),
+  timestamp: z.string(),
+  projectRoot: z.string(),
+  gitBranch: z.string().nullable(),
+  gitCommit: z.string().nullable(),
+  installed: z.boolean(),
+  envUpdated: z.boolean(),
+  files: z.array(PatchedFileReport),
+  summary: z.object({
+    candidatesFound: z.number(),
+    patchedByAi: z.number(),
+    patchedByAst: z.number(),
+    manualReviewRequired: z.number(),
+    skipped: z.number()
+  }).optional(),
+  decisionLog: z.array(DecisionLogEntry).default([]),
+  totalDurationMs: z.number()
+});
+var VerifyStepLog = z.object({
+  name: z.string(),
+  command: z.string(),
+  passed: z.boolean(),
+  required: z.boolean(),
+  output: z.string()
+});
+var VerifyReport = z.object({
+  schemaVersion: z.literal("2.0"),
+  profile: VerifyProfile,
+  lintPassed: z.boolean().nullable(),
+  buildPassed: z.boolean().nullable(),
+  testsPassed: z.boolean().nullable(),
+  patchedFiles: z.array(z.string()),
+  warnings: z.array(z.string()),
+  steps: z.array(VerifyStepLog).default([]),
+  durationMs: z.number()
+});
+var AiFileResult = z.object({
+  filePath: z.string(),
+  passed: z.boolean(),
+  issues: z.array(z.string()),
+  fixAttempted: z.boolean(),
+  fixApplied: z.boolean(),
+  iterations: z.number()
+});
+var AiReviewReport = z.object({
+  schemaVersion: z.literal("1.0"),
+  filesReviewed: z.number(),
+  filesPassed: z.number(),
+  filesFixed: z.number(),
+  filesFailed: z.number(),
+  results: z.array(AiFileResult),
+  totalDurationMs: z.number(),
+  tokensUsed: z.number()
+});
+
+// src/reporting/index.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync } from "fs";
+import { join as join10 } from "path";
+import consola2 from "consola";
+function createReport(parts) {
+  return {
+    version: "2.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...parts
+  };
+}
+function saveReport(root, report) {
+  const dir = join10(root, ".cmsassets-agent");
+  if (!existsSync6(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const filename = `report-${Date.now()}.json`;
+  const filePath = join10(dir, filename);
+  writeFileSync4(filePath, JSON.stringify(report, null, 2), "utf-8");
+  consola2.info(`Report saved to ${filePath}`);
+  return filePath;
+}
+function savePlanFile(root, plan) {
+  const filePath = join10(root, "cmsassets-agent.plan.json");
+  writeFileSync4(filePath, JSON.stringify(plan, null, 2), "utf-8");
+  consola2.info(`Plan saved to ${filePath}`);
+  return filePath;
+}
+function loadPlanFile(filePath) {
+  try {
+    const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+    const result = PatchPlan.safeParse(raw);
+    if (result.success) return result.data;
+    consola2.error("Plan file validation failed:", result.error.issues);
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    consola2.error(`Failed to load plan file: ${msg}`);
+    return null;
+  }
+}
+
+// src/git/index.ts
+import { execSync } from "child_process";
+import consola3 from "consola";
+function exec(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+  } catch {
+    return "";
+  }
+}
+var gitOps = {
+  isGitRepo(cwd) {
+    return exec("git rev-parse --is-inside-work-tree", cwd) === "true";
+  },
+  isClean(cwd) {
+    return exec("git diff --quiet && git diff --cached --quiet && echo clean", cwd) === "clean";
+  },
+  getCurrentBranch(cwd) {
+    const branch = exec("git branch --show-current", cwd);
+    return branch || null;
+  },
+  getHeadCommit(cwd) {
+    const hash = exec("git rev-parse --short HEAD", cwd);
+    return hash || null;
+  },
+  createBranch(cwd, name) {
+    try {
+      execSync(`git checkout -b ${name}`, { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      consola3.warn(`Failed to create branch: ${name}`);
+      return false;
+    }
+  },
+  stageAll(cwd) {
+    execSync("git add -A", { cwd, stdio: "pipe" });
+  },
+  commit(cwd, message) {
+    try {
+      execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+        cwd,
+        stdio: "pipe"
+      });
+      return exec("git rev-parse --short HEAD", cwd);
+    } catch {
+      consola3.warn("Failed to create commit");
+      return null;
+    }
+  },
+  hardResetToCommit(cwd, commitHash) {
+    try {
+      execSync(`git reset --hard ${commitHash}`, { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      consola3.error(`Failed to hard reset to ${commitHash}`);
+      return false;
+    }
+  },
+  revertCommit(cwd, commitHash) {
+    try {
+      execSync(`git revert --no-edit ${commitHash}`, { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      consola3.error(`Failed to revert commit ${commitHash}`);
+      return false;
+    }
+  },
+  getLastCommitByAgent(cwd) {
+    const log = exec(
+      'git log --oneline --all --grep="cmsassets-agent" -n 1 --format="%H"',
+      cwd
+    );
+    return log || null;
+  },
+  getCommitBefore(cwd, commitHash) {
+    const parent = exec(`git rev-parse ${commitHash}~1`, cwd);
+    return parent || null;
+  },
+  push(cwd, remote = "origin") {
+    try {
+      const branch = exec("git branch --show-current", cwd);
+      execSync(`git push -u ${remote} ${branch}`, { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      consola3.warn("Failed to push to remote");
+      return false;
+    }
+  }
+};
+
+// src/verifier/index.ts
+import { execSync as execSync2 } from "child_process";
+import consola4 from "consola";
+
+// src/verifier/profiles.ts
+function runScript(pm, script) {
+  if (pm === "pnpm") return `pnpm run ${script}`;
+  if (pm === "yarn") return `yarn run ${script}`;
+  if (pm === "bun") return `bun run ${script}`;
+  return `npm run ${script}`;
+}
+function runBin(pm, binAndArgs) {
+  if (pm === "pnpm") return `pnpm exec ${binAndArgs}`;
+  if (pm === "yarn") return `yarn ${binAndArgs}`;
+  if (pm === "bun") return `bunx ${binAndArgs}`;
+  return `npx ${binAndArgs}`;
+}
+function getQuickSteps(framework, pm) {
+  const steps = [];
+  switch (framework) {
+    case "nuxt":
+    case "nuxt2":
+      steps.push({
+        name: "nuxt-prepare",
+        command: runBin(pm, "nuxt prepare"),
+        required: false
+      });
+      break;
+    case "next":
+      steps.push({
+        name: "tsc-noEmit",
+        command: runBin(pm, "tsc --noEmit"),
+        required: false
+      });
+      break;
+    case "astro":
+      steps.push({
+        name: "astro-check",
+        command: runBin(pm, "astro check"),
+        required: false
+      });
+      break;
+    case "sveltekit":
+      steps.push({
+        name: "svelte-check",
+        command: runBin(pm, "svelte-check"),
+        required: false
+      });
+      break;
+    default:
+      steps.push({
+        name: "tsc-noEmit",
+        command: runBin(pm, "tsc --noEmit"),
+        required: false
+      });
+  }
+  return steps;
+}
+function getFullSteps(framework, pm) {
+  const steps = getQuickSteps(framework, pm);
+  steps.push({
+    name: "lint",
+    command: runScript(pm, "lint"),
+    required: false
+  });
+  switch (framework) {
+    case "nuxt":
+    case "nuxt2":
+      steps.push({ name: "build", command: runScript(pm, "build"), required: true });
+      break;
+    case "next":
+      steps.push({ name: "build", command: runScript(pm, "build"), required: true });
+      break;
+    case "astro":
+      steps.push({ name: "build", command: runScript(pm, "build"), required: true });
+      break;
+    case "sveltekit":
+      steps.push({ name: "build", command: runScript(pm, "build"), required: true });
+      break;
+    default:
+      steps.push({ name: "build", command: runScript(pm, "build"), required: false });
+  }
+  steps.push({
+    name: "test",
+    command: runScript(pm, "test"),
+    required: false
+  });
+  return steps;
+}
+function getVerifySteps(profile, framework, packageManager) {
+  return profile === "full" ? getFullSteps(framework, packageManager) : getQuickSteps(framework, packageManager);
+}
+
+// src/verifier/index.ts
+function verify(root, opts = {}) {
+  const startTime = Date.now();
+  const profile = opts.profile ?? "quick";
+  const framework = opts.framework ?? "unknown";
+  const packageManager = opts.packageManager ?? "npm";
+  const patchedFiles = opts.patchedFiles ?? [];
+  const warnings = [];
+  const steps = getVerifySteps(profile, framework, packageManager);
+  let lintPassed = null;
+  let buildPassed = null;
+  let testsPassed = null;
+  const stepLogs = [];
+  for (const step of steps) {
+    consola4.info(`Running: ${step.name} (${step.command})`);
+    try {
+      const output = execSync2(step.command, {
+        cwd: root,
+        stdio: "pipe",
+        timeout: 12e4
+      }).toString();
+      if (step.name === "lint") lintPassed = true;
+      if (step.name === "build") buildPassed = true;
+      if (step.name === "test") testsPassed = true;
+      consola4.success(`${step.name} passed`);
+      stepLogs.push({
+        name: step.name,
+        command: step.command,
+        passed: true,
+        required: step.required,
+        output: output.substring(0, 2e3)
+      });
+    } catch (err) {
+      const stderr = typeof err === "object" && err && "stderr" in err ? String(err.stderr ?? "") : "";
+      const stdout = typeof err === "object" && err && "stdout" in err ? String(err.stdout ?? "") : "";
+      const message = [stderr, stdout, err instanceof Error ? err.message : String(err)].filter(Boolean).join("\n");
+      const truncated = message.substring(0, 500);
+      if (step.name === "lint") lintPassed = false;
+      if (step.name === "build") buildPassed = false;
+      if (step.name === "test") testsPassed = false;
+      if (step.required) {
+        consola4.error(`${step.name} FAILED: ${truncated}`);
+        warnings.push(`${step.name} failed (required): ${truncated}`);
+      } else {
+        consola4.warn(`${step.name} failed (optional): ${truncated}`);
+        warnings.push(`${step.name} failed (optional): ${truncated}`);
+      }
+      stepLogs.push({
+        name: step.name,
+        command: step.command,
+        passed: false,
+        required: step.required,
+        output: truncated.substring(0, 2e3)
+      });
+    }
+  }
+  return {
+    schemaVersion: "2.0",
+    profile,
+    lintPassed,
+    buildPassed,
+    testsPassed,
+    patchedFiles,
+    warnings,
+    steps: stepLogs,
+    durationMs: Date.now() - startTime
+  };
+}
+
+export {
+  scan,
+  createPlan,
+  applyPlan,
+  FrameworkName,
+  CmsType,
+  PackageManager,
+  Confidence,
+  InjectionType,
+  VerifyProfile,
+  PatchMode,
+  FrameworkInfo,
+  CmsInfo,
+  InjectionCandidate,
+  CandidateRegionType,
+  CandidateRegion,
+  CandidateGraph,
+  ScanResult,
+  FilePatch,
+  PatchPlan,
+  PatchMethod,
+  DecisionReasonCode,
+  DecisionLogEntry,
+  PatchedFileReport,
+  ApplyReport,
+  VerifyStepLog,
+  VerifyReport,
+  AiFileResult,
+  AiReviewReport,
+  createReport,
+  saveReport,
+  savePlanFile,
+  loadPlanFile,
+  gitOps,
+  verify
+};