@synchronized-studio/cmsassets-agent 0.1.3 → 0.2.1

package/dist/chunk-XHL55FTA.js

@@ -0,0 +1,1745 @@
+import {
+  WRAP_TEMPLATES,
+  buildCmsOptions,
+  findInjectionPoints,
+  getImportStatement,
+  getTransformFunctionName,
+  validateDiff
+} from "./chunk-MW74S44G.js";
+import {
+  chatCompletion,
+  isOpenAiError
+} from "./chunk-E74TGIFQ.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 injectionPoints = findInjectionPoints(root, framework.name, cms);
+  return {
+    framework,
+    cms,
+    injectionPoints,
+    packageManager,
+    projectRoot: root
+  };
+}
+
+// src/planner/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+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(join4(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;
+    const transformedCode = template.transform(
+      originalCode,
+      scan2.cms.type,
+      scan2.cms.params
+    );
+    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,
+      allowLlmFallback: false,
+      llmFallbackForAll: false,
+      llmOnly: false,
+      verifyProfile: "quick"
+    }
+  };
+}
+
+// src/patcher/index.ts
+import { appendFileSync, existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
+import consola from "consola";
+
+// 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";
+
+// src/patcher/structuralValidator.ts
+import { Project, SyntaxKind, ScriptKind } from "ts-morph";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join5, extname } from "path";
+var TRANSFORMER_PKG = "@synchronized-studio/response-transformer";
+function takeSnapshot(root, filePath) {
+  const absPath = join5(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);
+    } else {
+      return { valid: true, errors: [] };
+    }
+  }
+  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: [] };
+}
+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(", ")}`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/patcher/astPatcher.ts
+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, transformedCode } = patch.wrapTarget;
+  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 (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/llmFallback.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+function buildPrompt(fileContent, filePath, cms, framework) {
+  const fn = getTransformFunctionName(cms.type);
+  const opts = buildCmsOptions(cms.type, cms.params);
+  return `You are a code integration agent. Given the following file, add the
+@synchronized-studio/response-transformer to transform CMS asset URLs.
+
+CMS: ${cms.type}
+Transform function: ${fn}
+Options: ${opts}
+Framework: ${framework}
+
+File: ${filePath}
+\`\`\`
+${fileContent}
+\`\`\`
+
+Return ONLY a unified diff that:
+1. Adds the import: import { ${fn} } from '@synchronized-studio/response-transformer'
+2. Wraps the CMS data return/assignment with ${fn}(data, ${opts})
+3. Does NOT change any other code
+
+Output ONLY the diff, nothing else.`;
+}
+async function applyLlmPatch(root, patch, cms, framework) {
+  const absPath = join7(root, patch.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}`, requiresReview: true };
+  }
+  const prompt = buildPrompt(fileContent, patch.filePath, cms, framework);
+  const result = await chatCompletion(prompt, { model: "gpt-4o-mini", maxTokens: 2e3 });
+  if (isOpenAiError(result)) {
+    return { applied: false, reason: result.error, requiresReview: true };
+  }
+  const diff = result.content;
+  if (!diff) {
+    return { applied: false, reason: "LLM returned empty response", requiresReview: true };
+  }
+  const validation = validateDiff(diff, [patch.filePath]);
+  if (!validation.valid) {
+    return {
+      applied: false,
+      reason: `LLM diff failed validation: ${validation.errors.join("; ")}`,
+      diff,
+      requiresReview: true
+    };
+  }
+  return {
+    applied: false,
+    reason: "LLM patch generated, requires manual review before applying",
+    diff,
+    requiresReview: true
+  };
+}
+
+// src/patcher/llmCompletePatch.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
+function buildPrompt2(fileContent, filePath, patch, cms, framework) {
+  const fn = getTransformFunctionName(cms.type);
+  const opts = buildCmsOptions(cms.type, cms.params);
+  const importStatement = `import { ${fn} } from '@synchronized-studio/response-transformer'`;
+  return `You are a precise code integration agent. Your task is to make EXACTLY TWO changes to the file below:
+
+1. Add this import at the top (with the other imports):
+   ${importStatement}
+
+2. Wrap the target code near line ${patch.wrapTarget.line}:
+   BEFORE: ${patch.wrapTarget.originalCode}
+   AFTER:  ${patch.wrapTarget.transformedCode}
+
+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
+- If unsure about a change, do NOT make it \u2014 only make the two changes above
+
+CMS: ${cms.type}
+Framework: ${framework}
+
+File: ${filePath}
+\`\`\`
+${fileContent}
+\`\`\`
+
+Return ONLY the complete modified file content. No markdown fences, no explanation \u2014 just the raw file content.`;
+}
+async function applyLlmCompletePatch(root, patch, cms, framework, snapshot) {
+  const absPath = join8(root, patch.filePath);
+  let fileContent;
+  try {
+    fileContent = readFileSync6(absPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `Cannot read file: ${msg}` };
+  }
+  const prompt = buildPrompt2(fileContent, patch.filePath, patch, cms, framework);
+  const result = await chatCompletion(prompt, {
+    model: "gpt-4o",
+    maxTokens: 16e3,
+    temperature: 0
+  });
+  if (isOpenAiError(result)) {
+    return { applied: false, reason: result.error };
+  }
+  let newContent = result.content;
+  if (!newContent) {
+    return { applied: false, reason: "LLM returned empty response" };
+  }
+  newContent = stripCodeFences(newContent);
+  if (newContent.trim() === fileContent.trim()) {
+    return { applied: false, reason: "LLM returned unchanged file" };
+  }
+  const fn = getTransformFunctionName(cms.type);
+  if (!newContent.includes(fn)) {
+    return { applied: false, reason: "LLM output missing transform function call" };
+  }
+  if (!newContent.includes("@synchronized-studio/response-transformer")) {
+    return { applied: false, reason: "LLM output missing transformer import" };
+  }
+  const validation = validateContentAgainstSnapshot(newContent, patch.filePath, snapshot);
+  if (!validation.valid) {
+    return {
+      applied: false,
+      validationFailed: true,
+      reason: `LLM 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 readFileSync7 } from "fs";
+import { join as join9 } from "path";
+var TRANSFORMER_IMPORTS = [
+  "@synchronized-studio/response-transformer",
+  "transformCmsAssetUrls",
+  "transformPrismicAssetUrls",
+  "transformContentfulAssetUrls",
+  "transformSanityAssetUrls",
+  "transformShopifyAssetUrls",
+  "transformCloudinaryAssetUrls",
+  "transformImgixAssetUrls",
+  "transformGenericAssetUrls"
+];
+function isAlreadyTransformed(root, filePath) {
+  const absPath = join9(root, filePath);
+  let content;
+  try {
+    content = readFileSync7(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
+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 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))
+  );
+  for (const patch of plan.patches) {
+    const fileStart = Date.now();
+    if (alreadyTransformedAtStart.has(patch.filePath)) {
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: "Transformer already present in file",
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    if (!includeTests && isTestOrFixtureFile(patch.filePath)) {
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: "Test/fixture file excluded (use --include-tests to include)",
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    if (isGeneratedFile(patch.filePath)) {
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: "Generated file excluded",
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    if (!patchedFiles.has(patch.filePath) && appliedCount >= maxFiles) {
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: `Max files threshold reached (${maxFiles})`,
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    const snapshot = takeSnapshot(root, patch.filePath);
+    const fnGuard = checkFunctionValueWrapping(patch.wrapTarget.originalCode, snapshot);
+    if (!fnGuard.valid) {
+      consola.warn(`Skipping ${patch.filePath}: ${fnGuard.errors[0]}`);
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: fnGuard.errors[0],
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    if (plan.policies.llmOnly && plan.policies.allowLlmFallback) {
+      consola.info(`LLM-only mode: ${patch.filePath}...`);
+      const llmResult = await applyLlmCompletePatch(
+        root,
+        patch,
+        plan.scan.cms,
+        plan.scan.framework.name,
+        snapshot
+      );
+      files.push({
+        filePath: patch.filePath,
+        applied: llmResult.applied,
+        method: llmResult.applied ? "llm-complete" : "skipped",
+        reason: llmResult.reason,
+        durationMs: Date.now() - fileStart
+      });
+      if (llmResult.applied && !patchedFiles.has(patch.filePath)) {
+        patchedFiles.add(patch.filePath);
+        appliedCount++;
+      }
+      continue;
+    }
+    const astResult = applyAstPatch(root, patch, dryRun, 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
+      });
+      continue;
+    }
+    const shouldTryLlmComplete = astResult.validationFailed || plan.policies.allowLlmFallback && (plan.policies.llmFallbackForAll || patch.confidence === "low");
+    if (shouldTryLlmComplete) {
+      const reason = astResult.validationFailed ? "AST validation failed" : "AST patch failed";
+      consola.info(`${reason} for ${patch.filePath}, trying LLM complete-file fallback...`);
+      if (snapshot.content) {
+        const absPath = join10(root, patch.filePath);
+        try {
+          const currentContent = readFileSync8(absPath, "utf-8");
+          if (currentContent !== snapshot.content) {
+            writeFileSync3(absPath, snapshot.content, "utf-8");
+          }
+        } catch {
+        }
+      }
+      const llmResult = await applyLlmCompletePatch(
+        root,
+        patch,
+        plan.scan.cms,
+        plan.scan.framework.name,
+        snapshot
+      );
+      if (llmResult.applied) {
+        if (!patchedFiles.has(patch.filePath)) {
+          patchedFiles.add(patch.filePath);
+          appliedCount++;
+        }
+        files.push({
+          filePath: patch.filePath,
+          applied: true,
+          method: "llm-complete",
+          durationMs: Date.now() - fileStart
+        });
+        continue;
+      }
+      if (plan.policies.allowLlmFallback) {
+        const legacyResult = await applyLlmPatch(
+          root,
+          patch,
+          plan.scan.cms,
+          plan.scan.framework.name
+        );
+        files.push({
+          filePath: patch.filePath,
+          applied: legacyResult.applied,
+          method: legacyResult.applied ? "llm" : "skipped",
+          reason: legacyResult.reason,
+          durationMs: Date.now() - fileStart
+        });
+        if (legacyResult.applied && !patchedFiles.has(patch.filePath)) {
+          patchedFiles.add(patch.filePath);
+          appliedCount++;
+        }
+        continue;
+      }
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: llmResult.reason ?? "Both AST and LLM complete-file patch failed",
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    files.push({
+      filePath: patch.filePath,
+      applied: false,
+      method: "skipped",
+      reason: astResult.reason ?? "AST patch could not be applied",
+      durationMs: Date.now() - fileStart
+    });
+  }
+  let envUpdated = false;
+  if (!dryRun) {
+    for (const envFile of plan.env.files) {
+      const envPath = join10(root, envFile);
+      if (existsSync5(envPath)) {
+        const content = readFileSync8(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 = join10(root, ".env.example");
+      writeFileSync3(
+        envExamplePath,
+        `${plan.env.key}=${plan.env.placeholder}
+`,
+        "utf-8"
+      );
+      envUpdated = true;
+    }
+  }
+  return {
+    schemaVersion: "1.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot: root,
+    gitBranch: null,
+    gitCommit: null,
+    installed: false,
+    envUpdated,
+    files,
+    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"
+]);
+var VerifyProfile = z.enum(["quick", "full"]);
+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,
+  targetCode: z.string(),
+  context: z.string(),
+  reasons: z.array(z.string())
+});
+var ScanResult = z.object({
+  framework: FrameworkInfo,
+  cms: CmsInfo,
+  injectionPoints: z.array(InjectionCandidate),
+  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),
+    allowLlmFallback: z.boolean().default(false),
+    /** When true, try LLM for any failed AST patch (not just low confidence). Useful for testing. */
+    llmFallbackForAll: z.boolean().default(false),
+    /** When true, skip AST entirely and use LLM for all patches (testing only). */
+    llmOnly: z.boolean().default(false),
+    verifyProfile: VerifyProfile.default("quick")
+  })
+});
+var PatchedFileReport = z.object({
+  filePath: z.string(),
+  applied: z.boolean(),
+  method: z.enum(["ast", "llm", "llm-complete", "skipped"]),
+  reason: z.string().optional(),
+  durationMs: z.number()
+});
+var ApplyReport = z.object({
+  schemaVersion: z.literal("1.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),
+  totalDurationMs: z.number()
+});
+var VerifyReport = z.object({
+  schemaVersion: z.literal("1.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()),
+  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 readFileSync9, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync } from "fs";
+import { join as join11 } from "path";
+import consola2 from "consola";
+function createReport(parts) {
+  return {
+    version: "1.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...parts
+  };
+}
+function saveReport(root, report) {
+  const dir = join11(root, ".cmsassets-agent");
+  if (!existsSync6(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const filename = `report-${Date.now()}.json`;
+  const filePath = join11(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 = join11(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(readFileSync9(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;
+    }
+  },
+  rollbackToCommit(cwd, commitHash) {
+    try {
+      execSync(`git reset --hard ${commitHash}`, { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      consola3.error(`Failed to rollback to ${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 getQuickSteps(framework) {
+  const steps = [];
+  switch (framework) {
+    case "nuxt":
+    case "nuxt2":
+      steps.push({
+        name: "nuxt-prepare",
+        command: "npx nuxt prepare",
+        required: false
+      });
+      break;
+    case "next":
+      steps.push({
+        name: "tsc-noEmit",
+        command: "npx tsc --noEmit",
+        required: false
+      });
+      break;
+    case "astro":
+      steps.push({
+        name: "astro-check",
+        command: "npx astro check",
+        required: false
+      });
+      break;
+    case "sveltekit":
+      steps.push({
+        name: "svelte-check",
+        command: "npx svelte-check",
+        required: false
+      });
+      break;
+    default:
+      steps.push({
+        name: "tsc-noEmit",
+        command: "npx tsc --noEmit",
+        required: false
+      });
+  }
+  return steps;
+}
+function getFullSteps(framework) {
+  const steps = getQuickSteps(framework);
+  steps.push({
+    name: "lint",
+    command: "npm run lint",
+    required: false
+  });
+  switch (framework) {
+    case "nuxt":
+    case "nuxt2":
+      steps.push({ name: "build", command: "npm run build", required: true });
+      break;
+    case "next":
+      steps.push({ name: "build", command: "npm run build", required: true });
+      break;
+    case "astro":
+      steps.push({ name: "build", command: "npm run build", required: true });
+      break;
+    case "sveltekit":
+      steps.push({ name: "build", command: "npm run build", required: true });
+      break;
+    default:
+      steps.push({ name: "build", command: "npm run build", required: false });
+  }
+  steps.push({
+    name: "test",
+    command: "npm test",
+    required: false
+  });
+  return steps;
+}
+function getVerifySteps(profile, framework) {
+  return profile === "full" ? getFullSteps(framework) : getQuickSteps(framework);
+}
+
+// src/verifier/index.ts
+function verify(root, opts = {}) {
+  const startTime = Date.now();
+  const profile = opts.profile ?? "quick";
+  const framework = opts.framework ?? "unknown";
+  const patchedFiles = opts.patchedFiles ?? [];
+  const warnings = [];
+  const steps = getVerifySteps(profile, framework);
+  let lintPassed = null;
+  let buildPassed = null;
+  let testsPassed = null;
+  for (const step of steps) {
+    consola4.info(`Running: ${step.name} (${step.command})`);
+    try {
+      execSync2(step.command, {
+        cwd: root,
+        stdio: "pipe",
+        timeout: 12e4
+      });
+      if (step.name === "lint") lintPassed = true;
+      if (step.name === "build") buildPassed = true;
+      if (step.name === "test") testsPassed = true;
+      consola4.success(`${step.name} passed`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      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}`);
+      }
+    }
+  }
+  return {
+    schemaVersion: "1.0",
+    profile,
+    lintPassed,
+    buildPassed,
+    testsPassed,
+    patchedFiles,
+    warnings,
+    durationMs: Date.now() - startTime
+  };
+}
+
+export {
+  scan,
+  createPlan,
+  applyPlan,
+  FrameworkName,
+  CmsType,
+  PackageManager,
+  Confidence,
+  InjectionType,
+  VerifyProfile,
+  FrameworkInfo,
+  CmsInfo,
+  InjectionCandidate,
+  ScanResult,
+  FilePatch,
+  PatchPlan,
+  PatchedFileReport,
+  ApplyReport,
+  VerifyReport,
+  AiFileResult,
+  AiReviewReport,
+  createReport,
+  saveReport,
+  savePlanFile,
+  loadPlanFile,
+  gitOps,
+  verify
+};