@synchronized-studio/cmsassets-agent 0.1.0

package/dist/chunk-N2FYSVFJ.js

@@ -0,0 +1,2296 @@
+// 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/findInjectionPoints.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { relative as relative2 } from "path";
+import fg2 from "fast-glob";
+var IGNORE_DIRS2 = [
+  "node_modules",
+  ".nuxt",
+  ".next",
+  ".output",
+  ".svelte-kit",
+  "dist",
+  "build",
+  ".git",
+  "coverage",
+  ".cache"
+];
+var TEST_PATTERNS = [
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/,
+  /__tests__\//,
+  /\/tests?\//,
+  /\.stories\.[jt]sx?$/,
+  /\/fixtures?\//,
+  /\/mocks?\//
+];
+var CMS_FETCH_PATTERNS = [
+  /prismic/i,
+  /contentful/i,
+  /sanity/i,
+  /shopify/i,
+  /cloudinary/i,
+  /imgix/i,
+  /ctfassets/i,
+  /cdn\.prismic/i,
+  /cdn\.sanity/i,
+  /myshopify/i,
+  /res\.cloudinary/i
+];
+function hasCmsFetchSignal(content) {
+  return CMS_FETCH_PATTERNS.some((p) => p.test(content));
+}
+function isTestFile(filePath) {
+  return TEST_PATTERNS.some((p) => p.test(filePath));
+}
+function computeScore(signals) {
+  let score = 0;
+  if (signals.hasCmsFetch) score += 40;
+  if (signals.isServerSide) score += 30;
+  if (signals.returnsJson) score += 20;
+  if (signals.isCentralLayer) score += 10;
+  if (signals.isTest) score -= 20;
+  return Math.max(0, Math.min(100, score));
+}
+function scoreToConfidence(score) {
+  if (score >= 80) return "high";
+  if (score >= 60) return "medium";
+  return "low";
+}
+function buildReasons(signals) {
+  const reasons = [];
+  if (signals.hasCmsFetch) reasons.push("File contains CMS SDK import or fetch to CMS domain");
+  if (signals.isServerSide) reasons.push("Server-side file (API route, loader, SSR handler)");
+  if (signals.returnsJson) reasons.push("Returns JSON data (return statement / res.json)");
+  if (signals.isCentralLayer) reasons.push("Centralized data layer (composable, service, helper)");
+  if (signals.isTest) reasons.push("Test/fixture file (score reduced)");
+  return reasons;
+}
+function getContextLines(content, line, range = 2) {
+  const lines = content.split("\n");
+  const start = Math.max(0, line - 1 - range);
+  const end = Math.min(lines.length, line + range);
+  return lines.slice(start, end).join("\n");
+}
+var NON_DATA_RETURN_PATTERNS = [
+  /^return\s+(true|false|null|undefined|void)\b/,
+  /^return\s+["'`]/,
+  // return "string"
+  /^return\s+\d/,
+  // return 42
+  /^return\s+\w+\s*(===|!==|==|!=|>|<|>=|<=)/,
+  // return x === "true"
+  /^return\s+!\w/,
+  // return !value
+  /^return\s*$/,
+  // bare return
+  /^return\s*;?\s*$/,
+  // return;
+  /^return\s+err\b/,
+  // return err / error
+  /^return\s+error\b/,
+  /^return\s+\[\s*\]/,
+  // return []
+  /^return\s+\{\s*\}/,
+  // return {}
+  /^return\s+dispatch\s*\(/,
+  // return dispatch(...) -- Vuex forwarding
+  /^return\s+commit\s*\(/,
+  // return commit(...)
+  /^return\s+_get\s*\(/,
+  // return _get(...) -- lodash getter
+  /^return\s+_\w+\s*\(/,
+  // return _clone(...) etc -- lodash util
+  /^return\s+\w+\s*\?\s*/,
+  // return x ? y : z -- ternary
+  /^return\s+\w+\.\w+\s*(===|!==|==|!=)/,
+  // return link.link_type === "Web"
+  /^return\s+(axios|fetch|http|request)\b/,
+  // return axios / return fetch (the promise, not data)
+  /^return\s+res\.(json|send|status)\s*\(/,
+  // return res.json(...) -- handled separately as res.json type
+  /^return\s+"#"/
+  // return "#"
+];
+var CALLBACK_PROPERTY_PATTERNS = [
+  /shouldBypassCache/,
+  /shouldInvalidateCache/,
+  /getKey/,
+  /onRequest/,
+  /onResponse/,
+  /onError/,
+  /transform\s*:/,
+  /validate\s*:/
+];
+function isInsideCallbackOption(lines, returnLineIdx) {
+  for (let i = returnLineIdx - 1; i >= Math.max(0, returnLineIdx - 15); i--) {
+    const line = lines[i].trim();
+    if (CALLBACK_PROPERTY_PATTERNS.some((p) => p.test(line))) return true;
+    if (/^(export\s+default|async\s+function|function\s)/.test(line)) break;
+    if (/^(export\s+default\s+)?define\w+Handler/.test(line)) break;
+  }
+  return false;
+}
+function looksLikeDataReturn(trimmed) {
+  if (NON_DATA_RETURN_PATTERNS.some((p) => p.test(trimmed))) return false;
+  if (/^return\s+\{\s*\w/.test(trimmed)) return true;
+  if (/^return\s+\[\s*\w/.test(trimmed)) return true;
+  if (/^return\s+await\s+\w+\.\w+/.test(trimmed)) return true;
+  if (/^return\s+[a-zA-Z_]\w*\s*;?\s*$/.test(trimmed)) return true;
+  if (/^return\s+Response\.json\s*\(/.test(trimmed)) return true;
+  if (/^return\s+json\s*\(/.test(trimmed)) return true;
+  if (/^return\s+new\s+Response/.test(trimmed)) return true;
+  return false;
+}
+function findReturnStatements(content, filePath, cms, root, opts) {
+  const candidates = [];
+  const lines = content.split("\n");
+  const hasCms = hasCmsFetchSignal(content);
+  const relPath = relative2(root, filePath);
+  const isTest = isTestFile(relPath);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^return\s/.test(trimmed)) {
+      if (!looksLikeDataReturn(trimmed)) continue;
+      if (isInsideCallbackOption(lines, i)) continue;
+      const signals = {
+        hasCmsFetch: hasCms,
+        isServerSide: opts.isServerSide,
+        returnsJson: true,
+        isCentralLayer: opts.isCentralLayer,
+        isTest
+      };
+      const score = computeScore(signals);
+      if (score < 50 || !signals.hasCmsFetch && !signals.isServerSide) {
+        continue;
+      }
+      candidates.push({
+        filePath: relative2(root, filePath),
+        line: i + 1,
+        type: "return",
+        score,
+        confidence: scoreToConfidence(score),
+        targetCode: trimmed,
+        context: getContextLines(content, i + 1),
+        reasons: buildReasons(signals)
+      });
+    }
+    if (/res\.json\s*\(/.test(trimmed)) {
+      if (isInsideCallbackOption(lines, i)) continue;
+      const signals = {
+        hasCmsFetch: hasCms,
+        isServerSide: true,
+        returnsJson: true,
+        isCentralLayer: opts.isCentralLayer,
+        isTest
+      };
+      const score = computeScore(signals);
+      if (score < 50) {
+        continue;
+      }
+      candidates.push({
+        filePath: relative2(root, filePath),
+        line: i + 1,
+        type: "res.json",
+        score,
+        confidence: scoreToConfidence(score),
+        targetCode: trimmed,
+        context: getContextLines(content, i + 1),
+        reasons: buildReasons(signals)
+      });
+    }
+  }
+  return candidates;
+}
+var nuxtStrategy = {
+  globs: ["server/api/**/*.ts", "server/api/**/*.js", "server/routes/**/*.ts", "composables/**/*.ts", "composables/**/*.js"],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative2(root, filePath);
+    const isServerApi = /server\/(api|routes)\//.test(filePath);
+    const isComposable = /composables\//.test(filePath);
+    const candidates = findReturnStatements(content, filePath, cms, root, {
+      isServerSide: isServerApi,
+      isCentralLayer: isComposable
+    });
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (/\buseFetch\s*\(/.test(trimmed) && !/transform\s*:/.test(content.substring(content.indexOf(trimmed)))) {
+        const hasCms = hasCmsFetchSignal(content);
+        if (!hasCms) continue;
+        const signals = {
+          hasCmsFetch: hasCms,
+          isServerSide: false,
+          returnsJson: true,
+          isCentralLayer: isComposable,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        if (score < 50) continue;
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "useFetch-transform",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1),
+          reasons: [...buildReasons(signals), "useFetch call without transform option"]
+        });
+      }
+      if (/\buseAsyncData\s*\(/.test(trimmed)) {
+        const hasCms = hasCmsFetchSignal(content);
+        if (!hasCms) continue;
+        const signals = {
+          hasCmsFetch: hasCms,
+          isServerSide: false,
+          returnsJson: true,
+          isCentralLayer: isComposable,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        if (score < 50) continue;
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "useAsyncData-transform",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1),
+          reasons: [...buildReasons(signals), "useAsyncData call"]
+        });
+      }
+    }
+    return candidates;
+  }
+};
+var nextStrategy = {
+  globs: [
+    "app/**/page.tsx",
+    "app/**/page.ts",
+    "app/**/page.jsx",
+    "app/**/page.js",
+    "app/api/**/route.ts",
+    "app/api/**/route.js",
+    "pages/**/*.tsx",
+    "pages/**/*.ts",
+    "pages/**/*.jsx",
+    "pages/**/*.js",
+    "src/app/**/page.tsx",
+    "src/app/api/**/route.ts",
+    "src/pages/**/*.tsx",
+    "src/pages/**/*.ts",
+    "lib/**/*.ts",
+    "lib/**/*.js",
+    "src/lib/**/*.ts",
+    "src/lib/**/*.js"
+  ],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative2(root, filePath);
+    const isApiRoute = /\/api\//.test(filePath) && /route\.[jt]sx?$/.test(filePath);
+    const isPage = /page\.[jt]sx?$/.test(filePath);
+    const isLib = /\blib\//.test(filePath);
+    const candidates = findReturnStatements(content, filePath, cms, root, {
+      isServerSide: isApiRoute || /getServerSideProps|getStaticProps/.test(content),
+      isCentralLayer: isLib
+    });
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (/export\s+(async\s+)?function\s+getServerSideProps/.test(trimmed)) {
+        const signals = {
+          hasCmsFetch: hasCmsFetchSignal(content),
+          isServerSide: true,
+          returnsJson: true,
+          isCentralLayer: false,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "getServerSideProps-return",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1),
+          reasons: buildReasons(signals)
+        });
+      }
+      if (/export\s+(async\s+)?function\s+getStaticProps/.test(trimmed)) {
+        const signals = {
+          hasCmsFetch: hasCmsFetchSignal(content),
+          isServerSide: true,
+          returnsJson: true,
+          isCentralLayer: false,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "getStaticProps-return",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1),
+          reasons: buildReasons(signals)
+        });
+      }
+    }
+    return candidates;
+  }
+};
+var remixStrategy = {
+  globs: ["app/routes/**/*.tsx", "app/routes/**/*.ts", "app/routes/**/*.jsx", "app/routes/**/*.js"],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative2(root, filePath);
+    const candidates = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (/export\s+(async\s+)?function\s+loader/.test(trimmed) || /export\s+const\s+loader/.test(trimmed)) {
+        const signals = {
+          hasCmsFetch: hasCmsFetchSignal(content),
+          isServerSide: true,
+          returnsJson: true,
+          isCentralLayer: false,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "loader-return",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1, 5),
+          reasons: [...buildReasons(signals), "Remix loader function"]
+        });
+      }
+    }
+    candidates.push(
+      ...findReturnStatements(content, filePath, cms, root, {
+        isServerSide: true,
+        isCentralLayer: false
+      })
+    );
+    return candidates;
+  }
+};
+var astroStrategy = {
+  globs: ["src/pages/**/*.astro", "src/pages/api/**/*.ts", "src/pages/api/**/*.js", "src/lib/**/*.ts"],
+  analyze(filePath, content, cms, root) {
+    const isApi = /\/api\//.test(filePath);
+    const isLib = /\blib\//.test(filePath);
+    if (filePath.endsWith(".astro")) {
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1];
+        if (hasCmsFetchSignal(frontmatter)) {
+          const assignmentPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+/g;
+          let m;
+          const candidates = [];
+          while ((m = assignmentPattern.exec(frontmatter)) !== null) {
+            const linesBefore = frontmatter.substring(0, m.index).split("\n").length;
+            const signals = {
+              hasCmsFetch: true,
+              isServerSide: true,
+              returnsJson: true,
+              isCentralLayer: false,
+              isTest: false
+            };
+            const score = computeScore(signals);
+            const matchedLine = frontmatter.split("\n")[linesBefore]?.trim() ?? m[0].trim();
+            candidates.push({
+              filePath: relative2(root, filePath),
+              line: linesBefore + 1,
+              type: "frontmatter-assignment",
+              score,
+              confidence: scoreToConfidence(score),
+              targetCode: matchedLine,
+              context: getContextLines(frontmatter, linesBefore + 1),
+              reasons: [...buildReasons(signals), "Astro frontmatter data fetch"]
+            });
+          }
+          return candidates;
+        }
+      }
+      return [];
+    }
+    return findReturnStatements(content, filePath, cms, root, {
+      isServerSide: isApi,
+      isCentralLayer: isLib
+    });
+  }
+};
+var sveltekitStrategy = {
+  globs: [
+    "src/routes/**/+page.server.ts",
+    "src/routes/**/+page.server.js",
+    "src/routes/**/+server.ts",
+    "src/routes/**/+server.js",
+    "src/routes/**/+layout.server.ts",
+    "src/routes/**/+layout.server.js",
+    "src/lib/**/*.ts",
+    "src/lib/**/*.js"
+  ],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative2(root, filePath);
+    const isServer = /\+(?:page|layout)\.server\.[jt]s$/.test(filePath) || /\+server\.[jt]s$/.test(filePath);
+    const isLib = /src\/lib\//.test(filePath);
+    const candidates = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (/export\s+(async\s+)?function\s+load/.test(trimmed) || /export\s+const\s+load/.test(trimmed)) {
+        const signals = {
+          hasCmsFetch: hasCmsFetchSignal(content),
+          isServerSide: isServer,
+          returnsJson: true,
+          isCentralLayer: isLib,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals);
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "load-return",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1, 5),
+          reasons: [...buildReasons(signals), "SvelteKit load function"]
+        });
+      }
+    }
+    candidates.push(
+      ...findReturnStatements(content, filePath, cms, root, {
+        isServerSide: isServer,
+        isCentralLayer: isLib
+      })
+    );
+    return candidates;
+  }
+};
+var nuxt2Strategy = {
+  globs: [
+    "store/**/*.js",
+    "store/**/*.ts",
+    "pages/**/*.vue",
+    "mixins/**/*.js",
+    "mixins/**/*.ts",
+    "services/**/*.js",
+    "services/**/*.ts",
+    "api/**/*.js",
+    "api/**/*.ts",
+    "plugins/**/*.js",
+    "plugins/**/*.ts"
+  ],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative2(root, filePath);
+    const isStore = /store\//.test(filePath);
+    const isService = /services\//.test(filePath);
+    const isApi = /\bapi\//.test(filePath);
+    const isPage = /pages\//.test(filePath);
+    const candidates = [];
+    const hasCms = hasCmsFetchSignal(content);
+    const isTest = isTestFile(relPath);
+    const lines = content.split("\n");
+    if (isPage && filePath.endsWith(".vue")) {
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (/async\s+asyncData\s*\(/.test(trimmed) || /asyncData\s*\(\s*\{/.test(trimmed)) {
+          const signals = {
+            hasCmsFetch: hasCms || /\$prismic|\$contentful|\$sanity/.test(content),
+            isServerSide: true,
+            returnsJson: true,
+            isCentralLayer: false,
+            isTest
+          };
+          const score = computeScore(signals);
+          if (score >= 50) {
+            candidates.push({
+              filePath: relPath,
+              line: i + 1,
+              type: "asyncData-return",
+              score,
+              confidence: scoreToConfidence(score),
+              targetCode: trimmed,
+              context: getContextLines(content, i + 1, 5),
+              reasons: [...buildReasons(signals), "Nuxt 2 asyncData hook"]
+            });
+          }
+        }
+      }
+    }
+    if (isStore) {
+      const cmsCallPatterns = [
+        /this\.\$prismic/,
+        /this\.\$contentful/,
+        /this\.\$sanity/,
+        /client\.get/,
+        /client\.getSingle/,
+        /client\.getByUID/,
+        /client\.getAllByType/,
+        /client\.fetch/
+      ];
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!/^async\s+\w+\s*\(/.test(trimmed)) continue;
+        let bodyHasCmsCall = false;
+        for (let j = i + 1; j < Math.min(lines.length, i + 50); j++) {
+          const bodyLine = lines[j];
+          if (/^\s*(async\s+)?\w+\s*\(/.test(bodyLine) && j > i + 1 && !bodyLine.trim().startsWith("//")) {
+            if (/^\s{0,4}(async\s+)?\w+\s*\(\s*\{/.test(bodyLine)) break;
+          }
+          if (cmsCallPatterns.some((p) => p.test(bodyLine))) {
+            bodyHasCmsCall = true;
+            break;
+          }
+        }
+        if (!bodyHasCmsCall) continue;
+        const signals = {
+          hasCmsFetch: true,
+          isServerSide: true,
+          returnsJson: true,
+          isCentralLayer: true,
+          isTest
+        };
+        const score = computeScore(signals);
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "vuex-action-return",
+          score,
+          confidence: scoreToConfidence(score),
+          targetCode: trimmed,
+          context: getContextLines(content, i + 1, 8),
+          reasons: [...buildReasons(signals), "Vuex store action with CMS fetch"]
+        });
+      }
+    }
+    if ((isService || isApi) && hasCms) {
+      candidates.push(
+        ...findReturnStatements(content, filePath, cms, root, {
+          isServerSide: isApi,
+          isCentralLayer: isService
+        })
+      );
+    }
+    return candidates;
+  }
+};
+var expressLikeStrategy = {
+  globs: [
+    "routes/**/*.ts",
+    "routes/**/*.js",
+    "src/routes/**/*.ts",
+    "src/routes/**/*.js",
+    "src/**/*.ts",
+    "src/**/*.js",
+    "api/**/*.ts",
+    "api/**/*.js"
+  ],
+  analyze(filePath, content, cms, root) {
+    const isRoute = /\broutes?\//.test(filePath) || /\bapi\//.test(filePath);
+    return findReturnStatements(content, filePath, cms, root, {
+      isServerSide: isRoute || /res\.json|res\.send|c\.json/.test(content),
+      isCentralLayer: /\b(services?|helpers?|utils?|lib)\b/.test(filePath)
+    });
+  }
+};
+var STRATEGIES = {
+  nuxt: nuxtStrategy,
+  nuxt2: nuxt2Strategy,
+  next: nextStrategy,
+  remix: remixStrategy,
+  astro: astroStrategy,
+  sveltekit: sveltekitStrategy,
+  express: expressLikeStrategy,
+  hono: expressLikeStrategy,
+  fastify: expressLikeStrategy
+};
+function findInjectionPoints(root, frameworkName, cms) {
+  const strategy = STRATEGIES[frameworkName] ?? expressLikeStrategy;
+  const files = fg2.sync(strategy.globs, {
+    cwd: root,
+    ignore: IGNORE_DIRS2.map((d) => `${d}/**`),
+    absolute: true,
+    onlyFiles: true,
+    deep: 8
+  });
+  const allCandidates = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync3(file, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes("@synchronized-studio/response-transformer") || content.includes("transformCmsAssetUrls") || content.includes("transformPrismicAssetUrls") || content.includes("transformContentfulAssetUrls") || content.includes("transformSanityAssetUrls") || content.includes("transformShopifyAssetUrls") || content.includes("transformCloudinaryAssetUrls") || content.includes("transformImgixAssetUrls") || content.includes("transformGenericAssetUrls")) {
+      continue;
+    }
+    const candidates = strategy.analyze(file, content, cms, root);
+    allCandidates.push(...candidates);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return allCandidates.sort((a, b) => b.score - a.score).filter((c) => {
+    const key = `${c.filePath}:${c.line}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// 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";
+
+// src/planner/templates.ts
+var PKG = "@synchronized-studio/response-transformer";
+var CMS_FUNCTION_MAP = {
+  prismic: "transformPrismicAssetUrls",
+  contentful: "transformContentfulAssetUrls",
+  sanity: "transformSanityAssetUrls",
+  shopify: "transformShopifyAssetUrls",
+  cloudinary: "transformCloudinaryAssetUrls",
+  imgix: "transformImgixAssetUrls",
+  generic: "transformGenericAssetUrls"
+};
+var UNIFIED_FUNCTION = "transformCmsAssetUrls";
+function getTransformFunctionName(cms) {
+  return CMS_FUNCTION_MAP[cms] ?? UNIFIED_FUNCTION;
+}
+function getImportStatement(cms) {
+  const fn = getTransformFunctionName(cms);
+  return `import { ${fn} } from '${PKG}'`;
+}
+var CMS_REQUIRED_PARAMS = {
+  prismic: [{ key: "repository", placeholder: "YOUR-REPO" }],
+  contentful: [{ key: "spaceId", placeholder: "YOUR-SPACE-ID" }],
+  sanity: [{ key: "projectId", placeholder: "YOUR-PROJECT-ID" }],
+  shopify: [{ key: "storeDomain", placeholder: "your-store.myshopify.com" }],
+  cloudinary: [{ key: "cloudName", placeholder: "YOUR-CLOUD-NAME" }],
+  imgix: [{ key: "imgixDomain", placeholder: "your-source.imgix.net" }],
+  generic: [{ key: "originUrl", placeholder: "https://your-origin.com" }]
+};
+function buildCmsOptions(cms, params) {
+  const entries = [];
+  const required = CMS_REQUIRED_PARAMS[cms] ?? [];
+  for (const { key, placeholder } of required) {
+    const value = params[key];
+    if (value) {
+      entries.push(`${key}: '${value}'`);
+    } else {
+      entries.push(`${key}: '${placeholder}'`);
+    }
+  }
+  if (cms === "sanity" && params.dataset && params.dataset !== "production") {
+    entries.push(`dataset: '${params.dataset}'`);
+  }
+  if (entries.length === 0) return "{}";
+  if (entries.length === 1) {
+    return `{ ${entries[0]} }`;
+  }
+  return `{
+    ${entries.join(",\n    ")},
+  }`;
+}
+function extractReturnVarName(code) {
+  const m = code.match(/^return\s+(?:await\s+)?(\w+)/);
+  if (m?.[1] && m[1] !== "await" && m[1] !== "new") return m[1];
+  return "data";
+}
+function extractResJsonVarName(code) {
+  const m = code.match(/res\.json\(\s*(\w+)/);
+  return m?.[1] ?? "data";
+}
+var returnWrap = {
+  transform(originalCode, cms, params) {
+    const varName = extractReturnVarName(originalCode);
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params);
+    return `return ${fn}(${varName}, ${opts})`;
+  },
+  description(cms) {
+    return `Wrap return value with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var resJsonWrap = {
+  transform(originalCode, cms, params) {
+    const varName = extractResJsonVarName(originalCode);
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params);
+    return originalCode.replace(
+      /res\.json\(\s*(\w+)\s*\)/,
+      `res.json(${fn}(${varName}, ${opts}))`
+    );
+  },
+  description(cms) {
+    return `Wrap res.json() argument with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var useFetchTransformWrap = {
+  transform(originalCode, cms, params) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params);
+    if (originalCode.includes(")")) {
+      const insertPos = originalCode.lastIndexOf(")");
+      const beforeClose = originalCode.substring(0, insertPos).trimEnd();
+      if (beforeClose.endsWith(",") || beforeClose.endsWith("(")) {
+        return `${beforeClose} { transform: (raw) => ${fn}(raw, ${opts}) })`;
+      }
+      return `${beforeClose}, { transform: (raw) => ${fn}(raw, ${opts}) })`;
+    }
+    return originalCode;
+  },
+  description(cms) {
+    return `Add transform option to useFetch() with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var useAsyncDataTransformWrap = {
+  transform(originalCode, cms, params) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params);
+    if (originalCode.includes(")")) {
+      const insertPos = originalCode.lastIndexOf(")");
+      const beforeClose = originalCode.substring(0, insertPos).trimEnd();
+      if (beforeClose.endsWith(",") || beforeClose.endsWith("(")) {
+        return `${beforeClose} { transform: (raw) => ${fn}(raw, ${opts}) })`;
+      }
+      return `${beforeClose}, { transform: (raw) => ${fn}(raw, ${opts}) })`;
+    }
+    return originalCode;
+  },
+  description(cms) {
+    return `Add transform option to useAsyncData() with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var loaderReturnWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap Remix loader return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var getServerSidePropsWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap getServerSideProps return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var getStaticPropsWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap getStaticProps return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var loadReturnWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap SvelteKit load() return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var frontmatterAssignmentWrap = {
+  transform(originalCode, cms, params) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params);
+    const m = originalCode.match(/((?:const|let)\s+\w+\s*=\s*)(await\s+.+)/);
+    if (m) {
+      return `${m[1]}${fn}(${m[2]}, ${opts})`;
+    }
+    return originalCode;
+  },
+  description(cms) {
+    return `Wrap Astro frontmatter assignment with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var asyncDataReturnWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap Nuxt 2 asyncData return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var vuexActionReturnWrap = {
+  transform(originalCode, cms, params) {
+    return returnWrap.transform(originalCode, cms, params);
+  },
+  description(cms) {
+    return `Wrap Vuex action return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var WRAP_TEMPLATES = {
+  "return": returnWrap,
+  "res.json": resJsonWrap,
+  "useFetch-transform": useFetchTransformWrap,
+  "useAsyncData-transform": useAsyncDataTransformWrap,
+  "loader-return": loaderReturnWrap,
+  "getServerSideProps-return": getServerSidePropsWrap,
+  "getStaticProps-return": getStaticPropsWrap,
+  "load-return": loadReturnWrap,
+  "frontmatter-assignment": frontmatterAssignmentWrap,
+  "asyncData-return": asyncDataReturnWrap,
+  "vuex-action-return": vuexActionReturnWrap,
+  "assignment": {
+    transform(originalCode, cms, params) {
+      const fn = getTransformFunctionName(cms);
+      const opts = buildCmsOptions(cms, params);
+      const m = originalCode.match(/((?:const|let|var)\s+\w+\s*=\s*)(.+)/);
+      if (m) return `${m[1]}${fn}(${m[2]}, ${opts})`;
+      return originalCode;
+    },
+    description(cms) {
+      return `Wrap assignment with ${getTransformFunctionName(cms)}()`;
+    }
+  }
+};
+
+// 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(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;
+    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: 5,
+      allowLlmFallback: false,
+      llmFallbackForAll: false,
+      llmOnly: false,
+      verifyProfile: "quick"
+    }
+  };
+}
+
+// src/types.ts
+import { z } from "zod";
+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(5),
+    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", "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()
+});
+
+// src/reporting/index.ts
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync5, mkdirSync } from "fs";
+import { join as join5 } from "path";
+import consola from "consola";
+function createReport(parts) {
+  return {
+    version: "1.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...parts
+  };
+}
+function saveReport(root, report) {
+  const dir = join5(root, ".cmsassets-agent");
+  if (!existsSync5(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const filename = `report-${Date.now()}.json`;
+  const filePath = join5(dir, filename);
+  writeFileSync(filePath, JSON.stringify(report, null, 2), "utf-8");
+  consola.info(`Report saved to ${filePath}`);
+  return filePath;
+}
+function savePlanFile(root, plan) {
+  const filePath = join5(root, "cmsassets-agent.plan.json");
+  writeFileSync(filePath, JSON.stringify(plan, null, 2), "utf-8");
+  consola.info(`Plan saved to ${filePath}`);
+  return filePath;
+}
+function loadPlanFile(filePath) {
+  try {
+    const raw = JSON.parse(readFileSync4(filePath, "utf-8"));
+    const result = PatchPlan.safeParse(raw);
+    if (result.success) return result.data;
+    consola.error("Plan file validation failed:", result.error.issues);
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    consola.error(`Failed to load plan file: ${msg}`);
+    return null;
+  }
+}
+
+// src/patcher/index.ts
+import { appendFileSync, existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+import consola2 from "consola";
+
+// src/patcher/astPatcher.ts
+import { Project, SyntaxKind } from "ts-morph";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6, extname } from "path";
+function applyAstPatch(root, patch, dryRun) {
+  const absPath = join6(root, patch.filePath);
+  const ext = extname(patch.filePath);
+  if ([".vue", ".svelte", ".astro"].includes(ext)) {
+    return applyStringPatch(root, patch, dryRun);
+  }
+  try {
+    const project = new Project({ useInMemoryFileSystem: false });
+    const sourceFile = project.addSourceFileAtPath(absPath);
+    const originalText = sourceFile.getFullText();
+    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 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(
+        SyntaxKind.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")) {
+          ret.replaceWithText(transformed);
+          patched = true;
+          break;
+        }
+      }
+      if (!patched) {
+        const expressions = sourceFile.getDescendantsOfKind(
+          SyntaxKind.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")) {
+            const expectedVar = original.match(/^return\s+(?:await\s+)?(\w+)/)?.[1];
+            const actualVar = retText.match(/^return\s+(?:await\s+)?(\w+)/)?.[1];
+            if (expectedVar && actualVar && expectedVar !== actualVar) 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) {
+        return { applied: false, reason: `Could not locate target code at line ${targetLine}` };
+      }
+    }
+    const newText = sourceFile.getFullText();
+    if (newText === originalText) {
+      return { applied: false, reason: "No changes needed (idempotent)" };
+    }
+    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 applyStringPatch(root, patch, dryRun) {
+  const absPath = join6(root, patch.filePath);
+  let content;
+  try {
+    content = readFileSync5(absPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `Cannot read file: ${msg}` };
+  }
+  const original = content;
+  const { originalCode, transformedCode } = patch.wrapTarget;
+  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 (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 (content === original) {
+    return { applied: false, reason: "No changes needed (idempotent)" };
+  }
+  if (!dryRun) {
+    writeFileSync2(absPath, content, "utf-8");
+  }
+  return { applied: true };
+}
+
+// src/patcher/llmFallback.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+
+// src/patcher/diffValidator.ts
+var ALLOWED_ADD_PATTERNS = [
+  /import\s+\{[^}]*transform/i,
+  /response-transformer/,
+  /transformCmsAssetUrls/,
+  /transformPrismicAssetUrls/,
+  /transformContentfulAssetUrls/,
+  /transformSanityAssetUrls/,
+  /transformShopifyAssetUrls/,
+  /transformCloudinaryAssetUrls/,
+  /transformImgixAssetUrls/,
+  /transformGenericAssetUrls/
+];
+function validateDiff(diff, allowedFiles) {
+  const errors = [];
+  const lines = diff.split("\n");
+  const fileHeaders = lines.filter((l) => l.startsWith("--- ") || l.startsWith("+++ "));
+  for (const header of fileHeaders) {
+    const filePath = header.replace(/^[+-]{3}\s+[ab]\//, "").trim();
+    if (filePath === "/dev/null") continue;
+    if (!allowedFiles.some((f) => filePath.endsWith(f) || f.endsWith(filePath))) {
+      errors.push(`Diff modifies disallowed file: ${filePath}`);
+    }
+  }
+  const addedLines = lines.filter((l) => l.startsWith("+") && !l.startsWith("+++"));
+  const removedLines = lines.filter((l) => l.startsWith("-") && !l.startsWith("---"));
+  for (const added of addedLines) {
+    const lineContent = added.substring(1).trim();
+    if (!lineContent) continue;
+    const isAllowed = ALLOWED_ADD_PATTERNS.some((p) => p.test(lineContent));
+    const hasMatchingRemoval = removedLines.some((r) => {
+      const removedContent = r.substring(1).trim();
+      return lineContent.includes(removedContent) || removedContent.includes(lineContent.replace(/transform\w+AssetUrls\([^)]+\)/, ""));
+    });
+    if (!isAllowed && !hasMatchingRemoval) {
+      if (/^[{}\[\](),;\s]*$/.test(lineContent)) continue;
+      errors.push(`Suspicious added line: ${lineContent.substring(0, 80)}`);
+    }
+  }
+  if (addedLines.length > 20) {
+    errors.push(`Too many additions (${addedLines.length}), expected <= 20`);
+  }
+  if (removedLines.length > 10) {
+    errors.push(`Too many removals (${removedLines.length}), expected <= 10`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/patcher/llmFallback.ts
+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 = readFileSync6(absPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `Cannot read file: ${msg}`, requiresReview: true };
+  }
+  let openai;
+  try {
+    openai = await import("./openai-E6ORPCAV.js");
+  } catch {
+    return {
+      applied: false,
+      reason: "openai package not installed. Install it with: npm install openai",
+      requiresReview: true
+    };
+  }
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return {
+      applied: false,
+      reason: "OPENAI_API_KEY environment variable not set",
+      requiresReview: true
+    };
+  }
+  const prompt = buildPrompt(fileContent, patch.filePath, cms, framework);
+  try {
+    const client = new openai.default({ apiKey });
+    const response = await client.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      max_tokens: 2e3
+    });
+    const diff = response.choices[0]?.message?.content?.trim() ?? "";
+    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
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { applied: false, reason: `LLM API error: ${msg}`, requiresReview: true };
+  }
+}
+
+// src/patcher/idempotency.ts
+import { readFileSync as readFileSync7 } 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 = 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;
+  for (const patch of plan.patches) {
+    const fileStart = Date.now();
+    if (isAlreadyTransformed(root, 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 (appliedCount >= maxFiles) {
+      files.push({
+        filePath: patch.filePath,
+        applied: false,
+        method: "skipped",
+        reason: `Max files threshold reached (${maxFiles})`,
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    if (plan.policies.llmOnly && plan.policies.allowLlmFallback) {
+      consola2.info(`LLM-only mode: ${patch.filePath}...`);
+      const llmResult = await applyLlmPatch(
+        root,
+        patch,
+        plan.scan.cms,
+        plan.scan.framework.name
+      );
+      files.push({
+        filePath: patch.filePath,
+        applied: llmResult.applied,
+        method: "llm",
+        reason: llmResult.reason,
+        durationMs: Date.now() - fileStart
+      });
+      if (llmResult.applied) appliedCount++;
+      continue;
+    }
+    const astResult = applyAstPatch(root, patch, dryRun);
+    if (astResult.applied) {
+      appliedCount++;
+      files.push({
+        filePath: patch.filePath,
+        applied: true,
+        method: "ast",
+        durationMs: Date.now() - fileStart
+      });
+      continue;
+    }
+    const shouldTryLlm = plan.policies.allowLlmFallback && (plan.policies.llmFallbackForAll || patch.confidence === "low");
+    if (shouldTryLlm) {
+      consola2.info(`AST failed for ${patch.filePath}, trying LLM fallback...`);
+      const llmResult = await applyLlmPatch(
+        root,
+        patch,
+        plan.scan.cms,
+        plan.scan.framework.name
+      );
+      files.push({
+        filePath: patch.filePath,
+        applied: llmResult.applied,
+        method: "llm",
+        reason: llmResult.reason,
+        durationMs: Date.now() - fileStart
+      });
+      if (llmResult.applied) appliedCount++;
+      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 = join9(root, envFile);
+      if (existsSync6(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 = join9(root, ".env.example");
+      writeFileSync4(
+        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/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,
+  FrameworkName,
+  CmsType,
+  PackageManager,
+  Confidence,
+  InjectionType,
+  VerifyProfile,
+  FrameworkInfo,
+  CmsInfo,
+  InjectionCandidate,
+  ScanResult,
+  FilePatch,
+  PatchPlan,
+  PatchedFileReport,
+  ApplyReport,
+  VerifyReport,
+  createReport,
+  saveReport,
+  savePlanFile,
+  loadPlanFile,
+  applyPlan,
+  gitOps,
+  verify
+};