@synchronized-studio/cmsassets-agent 0.3.10 → 0.4.0

package/dist/chunk-MMNQQM5Y.js

@@ -0,0 +1,1178 @@
+// 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, runtimeUrlExpr) {
+  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 (runtimeUrlExpr) {
+    entries.push(`cmsAssetsUrl: ${runtimeUrlExpr}`);
+  }
+  if (entries.length === 0) return "{}";
+  if (entries.length === 1) {
+    return `{ ${entries[0]} }`;
+  }
+  return `{
+    ${entries.join(",\n    ")},
+  }`;
+}
+function extractResJsonVarName(code) {
+  const m = code.match(/res\.json\(\s*(\w+)/);
+  return m?.[1] ?? "data";
+}
+var returnWrap = {
+  transform(originalCode, cms, params, _varName, runtimeUrlExpr) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    const lines = originalCode.split("\n");
+    lines[0] = lines[0].replace(/^return\s+/, "");
+    let expr = lines.join("\n").replace(/;?\s*$/, "").trim();
+    if (!expr) return originalCode;
+    return `return ${fn}(${expr}, ${opts})`;
+  },
+  description(cms) {
+    return `Wrap return value with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var resJsonWrap = {
+  transform(originalCode, cms, params, _varName, runtimeUrlExpr) {
+    const varName = extractResJsonVarName(originalCode);
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    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, _varName, runtimeUrlExpr) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    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, _varName, runtimeUrlExpr) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    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, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap Remix loader return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var getServerSidePropsWrap = {
+  transform(originalCode, cms, params, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap getServerSideProps return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var getStaticPropsWrap = {
+  transform(originalCode, cms, params, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap getStaticProps return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var loadReturnWrap = {
+  transform(originalCode, cms, params, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap SvelteKit load() return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var frontmatterAssignmentWrap = {
+  transform(originalCode, cms, params, _varName, runtimeUrlExpr) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    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, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap Nuxt 2 asyncData return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var vuexActionReturnWrap = {
+  transform(originalCode, cms, params, _v, runtimeUrlExpr) {
+    return returnWrap.transform(originalCode, cms, params, void 0, runtimeUrlExpr);
+  },
+  description(cms) {
+    return `Wrap Vuex action return with ${getTransformFunctionName(cms)}()`;
+  }
+};
+var vuexCommitWrap = {
+  transform(originalCode, cms, params, _varName, runtimeUrlExpr) {
+    const fn = getTransformFunctionName(cms);
+    const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+    const valueMatch = originalCode.match(/(value\s*:\s*)([^,}]+)/);
+    if (!valueMatch) return originalCode;
+    const valueExpr = valueMatch[2].trim();
+    return originalCode.replace(
+      valueMatch[0],
+      `${valueMatch[1]}${fn}(${valueExpr}, ${opts})`
+    );
+  },
+  description(cms) {
+    return `Wrap Vuex commit value 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,
+  "vuex-commit": vuexCommitWrap,
+  "assignment": {
+    transform(originalCode, cms, params, _varName, runtimeUrlExpr) {
+      const fn = getTransformFunctionName(cms);
+      const opts = buildCmsOptions(cms, params, runtimeUrlExpr);
+      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/scanner/findInjectionPoints.ts
+import { readFileSync } from "fs";
+import { relative } from "path";
+import fg from "fast-glob";
+var IGNORE_DIRS = [
+  "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) {
+  const stripped = content.split("\n").map((line) => {
+    if (/^\s*(import\s|.*\brequire\s*\()/.test(line)) return line;
+    return line.replace(/(['"`])(?:(?!\1)[^\\]|\\.)*?\1/g, "$1$1");
+  }).join("\n");
+  return CMS_FETCH_PATTERNS.some((p) => p.test(stripped));
+}
+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");
+}
+function findReturnLineInBody(lines, startLineIndex) {
+  let braceDepth = 0;
+  for (let i = startLineIndex; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    for (const c of line) {
+      if (c === "{") braceDepth++;
+      else if (c === "}") braceDepth--;
+    }
+    if (braceDepth > 0 && /^return\s/.test(trimmed) && looksLikeDataReturn(trimmed)) {
+      if (isFactoryReturn(lines, i, trimmed)) continue;
+      if (/[;}]\s*$/.test(trimmed) || trimmed.includes("}") && trimmed.indexOf("}") > trimmed.indexOf("{")) {
+        return { lineIndex: i, trimmed };
+      }
+      let returnBrace = 0;
+      const parts = [];
+      for (let j = i; j < lines.length; j++) {
+        const ln = lines[j];
+        parts.push(ln);
+        for (const c of ln) {
+          if (c === "{") returnBrace++;
+          else if (c === "}") returnBrace--;
+        }
+        if (returnBrace === 0) {
+          return { lineIndex: i, trimmed: parts.join("\n").trim() };
+        }
+      }
+      return { lineIndex: i, trimmed };
+    }
+    if (braceDepth === 0 && i > startLineIndex) break;
+  }
+  return null;
+}
+function expandToFullCall(lines, startLineIndex) {
+  const pattern = /\b(useAsyncData|useFetch)\s*\(/;
+  const firstLine = lines[startLineIndex];
+  const match = firstLine.match(pattern);
+  if (!match) return firstLine.trim();
+  const fnName = match[1];
+  const openParenIdx = firstLine.indexOf("(", firstLine.indexOf(fnName));
+  if (openParenIdx === -1) return firstLine.trim();
+  let depth = 1;
+  const parts = [];
+  for (let i = startLineIndex; i < lines.length; i++) {
+    const line = lines[i];
+    parts.push(line);
+    const full = parts.join("\n");
+    const scanStart = i === startLineIndex ? openParenIdx + 1 : full.length - line.length;
+    for (let k = scanStart; k < full.length; k++) {
+      const c = full[k];
+      if (c === "(") depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0) return full.substring(0, k + 1);
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
+function findCallEndLine(lines, startLineIndex) {
+  const pattern = /\b(useAsyncData|useFetch)\s*\(/;
+  const firstLine = lines[startLineIndex];
+  const match = firstLine.match(pattern);
+  if (!match) return startLineIndex + 1;
+  const fnName = match[1];
+  const openParenIdx = firstLine.indexOf("(", firstLine.indexOf(fnName));
+  if (openParenIdx === -1) return startLineIndex + 1;
+  let depth = 1;
+  for (let i = startLineIndex; i < lines.length; i++) {
+    const line = lines[i];
+    const startCol = i === startLineIndex ? openParenIdx + 1 : 0;
+    for (let k = startCol; k < line.length; k++) {
+      const c = line[k];
+      if (c === "(") depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0) return i + 1;
+      }
+    }
+  }
+  return startLineIndex + 1;
+}
+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+(?:this\.\$store\.)?dispatch\s*\(/,
+  // return this.$store.dispatch(...)
+  /^return\s+store\.dispatch\s*\(/,
+  // return store.dispatch(...)
+  /^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*$/.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+\(?[a-zA-Z_]\w*\)?\s+as\s+[\w<>{}\[\]|&.,\s]+;?\s*$/.test(trimmed)) return true;
+  if (/^return\s+\(\s*[a-zA-Z_]\w*\s+as\s+[\w<>{}\[\]|&.,\s]+\s*\)\s*;?\s*$/.test(trimmed)) return true;
+  if (/\.push\s*\(|\.splice\s*\(|\.concat\s*\(/.test(trimmed)) return false;
+  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 extractShorthandProps(returnCode) {
+  const match = returnCode.match(/^return\s+\{([^}]+)\}\s*;?\s*$/);
+  if (!match) return null;
+  const inner = match[1].trim();
+  const parts = inner.split(",").map((p) => p.trim()).filter(Boolean);
+  const names = [];
+  for (const part of parts) {
+    if (/^\w+$/.test(part)) {
+      names.push(part);
+    } else {
+      return null;
+    }
+  }
+  return names.length > 0 ? names : null;
+}
+var FUNCTION_DECLARATION_PATTERNS = [
+  /^(?:const|let)\s+NAME\s*=\s*cache\s*\(/,
+  /^(?:const|let)\s+NAME\s*=\s*(?:async\s+)?\(/,
+  /^(?:const|let)\s+NAME\s*=\s*(?:async\s+)?(?:\w+\s*=>\s*|function)/,
+  /^(?:async\s+)?function\s+NAME\s*\(/,
+  // Vue reactive wrappers: computed/ref/reactive produce non-serializable objects
+  /^(?:const|let)\s+NAME\s*=\s*(?:computed|ref|reactive|shallowRef|shallowReactive|toRef|toRefs)\s*\(/
+];
+function isFactoryReturn(lines, returnLineIdx, returnCode) {
+  const props = extractShorthandProps(returnCode);
+  if (!props || props.length === 0) return false;
+  const searchStart = Math.max(0, returnLineIdx - 200);
+  const scope = lines.slice(searchStart, returnLineIdx);
+  return props.every((name) => {
+    const patterns = FUNCTION_DECLARATION_PATTERNS.map(
+      (p) => new RegExp(p.source.replace("NAME", name))
+    );
+    return scope.some((line) => {
+      const trimmed = line.trim();
+      return patterns.some((p) => p.test(trimmed));
+    });
+  });
+}
+function findCommitInBody(lines, startLineIndex) {
+  let braceDepth = 0;
+  for (let i = startLineIndex; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    for (const c of line) {
+      if (c === "{") braceDepth++;
+      else if (c === "}") braceDepth--;
+    }
+    if (braceDepth === 0 && i > startLineIndex) break;
+    if (braceDepth > 0 && /\bcommit\s*\(/.test(trimmed) && /\bvalue\s*:/.test(trimmed)) {
+      if (/[)]\s*$/.test(trimmed)) {
+        return { lineIndex: i, fullStatement: trimmed };
+      }
+      let parenDepth = 0;
+      const parts = [];
+      for (let j = i; j < lines.length; j++) {
+        parts.push(lines[j]);
+        for (const c of lines[j]) {
+          if (c === "(") parenDepth++;
+          else if (c === ")") parenDepth--;
+        }
+        if (parenDepth <= 0) {
+          return { lineIndex: i, fullStatement: parts.join("\n").trim() };
+        }
+      }
+      return { lineIndex: i, fullStatement: trimmed };
+    }
+    if (braceDepth > 0 && (/\bcommit\s*\(\s*$/.test(trimmed) || /\bcommit\s*\(\s*["']/.test(trimmed))) {
+      let parenDepth = 0;
+      const parts = [];
+      let hasValue = false;
+      for (let j = i; j < Math.min(lines.length, i + 20); j++) {
+        parts.push(lines[j]);
+        if (/\bvalue\s*:/.test(lines[j])) hasValue = true;
+        for (const c of lines[j]) {
+          if (c === "(") parenDepth++;
+          else if (c === ")") parenDepth--;
+        }
+        if (parenDepth <= 0) {
+          if (hasValue) {
+            return { lineIndex: i, fullStatement: parts.join("\n").trim() };
+          }
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}
+function findReturnStatements(content, filePath, cms, root, opts) {
+  const candidates = [];
+  const lines = content.split("\n");
+  const hasCms = hasCmsFetchSignal(content);
+  const relPath = relative(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;
+      let fullReturn = trimmed;
+      if (/^return\s+\{\s*$/.test(trimmed)) {
+        let braceCount = 0;
+        const parts = [];
+        for (let j = i; j < lines.length; j++) {
+          parts.push(lines[j]);
+          for (const c of lines[j]) {
+            if (c === "{") braceCount++;
+            else if (c === "}") braceCount--;
+          }
+          if (braceCount === 0) break;
+        }
+        fullReturn = parts.join("\n").trim();
+      }
+      if (isFactoryReturn(lines, i, fullReturn)) continue;
+      if (/^return\s+\{/.test(fullReturn) && !hasCms && !opts.isServerSide) 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: relative(root, filePath),
+        line: i + 1,
+        type: "return",
+        score,
+        confidence: scoreToConfidence(score),
+        targetCode: fullReturn,
+        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: relative(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",
+    "pages/**/*.vue",
+    "pages/**/*.ts"
+  ],
+  analyze(filePath, content, cms, root) {
+    const relPath = relative(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");
+    const callbackReturnRanges = [];
+    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: expandToFullCall(lines, i),
+          context: getContextLines(content, i + 1),
+          reasons: [...buildReasons(signals), "useFetch call without transform option"]
+        });
+      }
+      if (/\buseAsyncData\s*\(/.test(trimmed)) {
+        const fullCall = expandToFullCall(lines, i);
+        if (/transform\s*:/.test(fullCall)) continue;
+        const hasCms = hasCmsFetchSignal(content);
+        if (!hasCms) continue;
+        callbackReturnRanges.push({
+          start: i + 1,
+          end: findCallEndLine(lines, i)
+        });
+        const signals = {
+          hasCmsFetch: hasCms,
+          isServerSide: false,
+          returnsJson: true,
+          isCentralLayer: isComposable,
+          isTest: isTestFile(relPath)
+        };
+        const score = computeScore(signals) + (/pages\//.test(filePath) ? 10 : 0);
+        if (score < 50) continue;
+        candidates.push({
+          filePath: relPath,
+          line: i + 1,
+          type: "useAsyncData-transform",
+          score: Math.min(100, score),
+          confidence: scoreToConfidence(score),
+          targetCode: fullCall,
+          context: getContextLines(content, i + 1),
+          reasons: [...buildReasons(signals), "useAsyncData call"]
+        });
+      }
+    }
+    const filteredByCallback = callbackReturnRanges.length === 0 ? candidates : candidates.filter((candidate) => {
+      if (candidate.type !== "return") return true;
+      return !callbackReturnRanges.some(
+        (range) => candidate.line > range.start && candidate.line <= range.end
+      );
+    });
+    if (filePath.endsWith(".vue")) {
+      const hasDataTransformTarget = filteredByCallback.some(
+        (candidate) => candidate.type === "useAsyncData-transform" || candidate.type === "useFetch-transform"
+      );
+      if (hasDataTransformTarget) {
+        return filteredByCallback.filter((candidate) => candidate.type !== "return");
+      }
+    }
+    return filteredByCallback;
+  }
+};
+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 = relative(root, filePath);
+    const isApiRoute = /\/api\//.test(filePath) && /route\.[jt]sx?$/.test(filePath);
+    const isAppRouterPage = /(^|\/)(src\/)?app\/(?:.*\/)?page\.[jt]sx?$/.test(relPath);
+    const isLib = /\blib\//.test(filePath);
+    const candidates = isAppRouterPage ? [] : 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 = relative(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: relative(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 = relative(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 = relative(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 ret = findReturnLineInBody(lines, i);
+          if (!ret) continue;
+          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: ret.lineIndex + 1,
+              type: "asyncData-return",
+              score,
+              confidence: scoreToConfidence(score),
+              targetCode: ret.trimmed,
+              context: getContextLines(content, ret.lineIndex + 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);
+        const ret = findReturnLineInBody(lines, i);
+        const commitCall = findCommitInBody(lines, i);
+        if (ret) {
+          candidates.push({
+            filePath: relPath,
+            line: ret.lineIndex + 1,
+            type: "vuex-action-return",
+            score,
+            confidence: scoreToConfidence(score),
+            targetCode: ret.trimmed,
+            context: getContextLines(content, ret.lineIndex + 1, 8),
+            reasons: [...buildReasons(signals), "Vuex store action with CMS fetch"]
+          });
+        }
+        if (commitCall) {
+          candidates.push({
+            filePath: relPath,
+            line: commitCall.lineIndex + 1,
+            type: "vuex-commit",
+            score,
+            confidence: scoreToConfidence(score),
+            targetCode: commitCall.fullStatement,
+            context: getContextLines(content, commitCall.lineIndex + 1, 8),
+            reasons: [
+              ...buildReasons(signals),
+              ret ? "Vuex store action commits CMS data (also has return)" : "Vuex store action commits CMS data (no return)"
+            ]
+          });
+        }
+        if (!ret && !commitCall) continue;
+      }
+    }
+    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 computeAutoPatchConfidence(candidate) {
+  if (candidate.score >= 85) return "high";
+  if (candidate.score >= 65) return "medium";
+  return "low";
+}
+function buildCandidateGraph(candidates) {
+  const roots = /* @__PURE__ */ new Map();
+  const regions = [];
+  const graphCandidates = candidates.map((candidate, idx) => {
+    const rootId = `${candidate.filePath}:root`;
+    if (!roots.has(rootId)) {
+      const rootRegion = {
+        id: rootId,
+        filePath: candidate.filePath,
+        type: "unknown",
+        startLine: 1,
+        endLine: Number.MAX_SAFE_INTEGER,
+        parentRegionId: null
+      };
+      roots.set(rootId, rootRegion);
+      regions.push(rootRegion);
+    }
+    const regionId = `${candidate.filePath}:region:${idx + 1}`;
+    regions.push({
+      id: regionId,
+      filePath: candidate.filePath,
+      type: "unknown",
+      startLine: Math.max(1, candidate.line - 2),
+      endLine: candidate.line + 2,
+      parentRegionId: rootId
+    });
+    return {
+      ...candidate,
+      detectedConfidence: candidate.detectedConfidence ?? candidate.confidence,
+      autoPatchConfidence: candidate.autoPatchConfidence ?? computeAutoPatchConfidence(candidate),
+      regionId
+    };
+  });
+  return {
+    regions,
+    candidates: graphCandidates
+  };
+}
+function findInjectionPoints(root, frameworkName, cms) {
+  const strategy = STRATEGIES[frameworkName] ?? expressLikeStrategy;
+  const files = fg.sync(strategy.globs, {
+    cwd: root,
+    ignore: IGNORE_DIRS.map((d) => `${d}/**`),
+    absolute: true,
+    onlyFiles: true,
+    deep: 8
+  });
+  const allCandidates = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const candidates = strategy.analyze(file, content, cms, root);
+    allCandidates.push(...candidates);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sortedCandidates = 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;
+  }).map((candidate) => ({
+    ...candidate,
+    detectedConfidence: candidate.confidence,
+    autoPatchConfidence: computeAutoPatchConfidence(candidate)
+  }));
+  const candidateGraph = buildCandidateGraph(sortedCandidates);
+  return {
+    candidates: candidateGraph.candidates,
+    candidateGraph
+  };
+}
+
+export {
+  findInjectionPoints,
+  getTransformFunctionName,
+  getImportStatement,
+  buildCmsOptions,
+  WRAP_TEMPLATES
+};