ai-localize-scanner 1.0.0

package/dist/index.mjs

@@ -0,0 +1,468 @@
+// src/ast-scanner.ts
+import * as parser from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import {
+  isHumanReadableText,
+  normalizeText,
+  TEXT_ATTRIBUTE_NAMES,
+  generateLocaleKey
+} from "@ai-localize/shared";
+var TRANSLATION_IMPORT_SOURCES = /* @__PURE__ */ new Set([
+  "react-i18next",
+  "i18next",
+  "vue-i18n",
+  "@ngx-translate/core"
+]);
+var AstScanner = class {
+  options;
+  detectedTexts = [];
+  translationFunctionNames = /* @__PURE__ */ new Set(["t", "$t", "i18n", "translate"]);
+  constructor(options) {
+    this.options = options;
+  }
+  scan() {
+    const { content } = this.options;
+    let ast;
+    try {
+      ast = parser.parse(content, {
+        sourceType: "module",
+        plugins: [
+          "jsx",
+          "typescript",
+          "decorators-legacy",
+          "classProperties",
+          "optionalChaining",
+          "nullishCoalescingOperator",
+          "dynamicImport",
+          "exportDefaultFrom"
+        ],
+        errorRecovery: true
+      });
+    } catch {
+      return this.regexFallbackScan();
+    }
+    this.collectTranslationImports(ast);
+    traverse(ast, {
+      JSXText: (nodePath) => {
+        const text = normalizeText(nodePath.node.value);
+        if (!isHumanReadableText(text)) return;
+        if (this.isInsideTranslationCall(nodePath)) return;
+        this.addDetected(
+          text,
+          nodePath.node.loc?.start.line ?? 0,
+          nodePath.node.loc?.start.column ?? 0,
+          "jsx-text",
+          "JSXText"
+        );
+      },
+      JSXAttribute: (nodePath) => {
+        const attrName = t.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
+        if (!TEXT_ATTRIBUTE_NAMES.has(attrName.toLowerCase())) return;
+        const valueNode = nodePath.node.value;
+        if (!t.isStringLiteral(valueNode)) return;
+        const text = normalizeText(valueNode.value);
+        if (!isHumanReadableText(text)) return;
+        if (this.isInsideTranslationCall(nodePath)) return;
+        const context = this.mapAttrToContext(attrName);
+        this.addDetected(
+          text,
+          valueNode.loc?.start.line ?? 0,
+          valueNode.loc?.start.column ?? 0,
+          context,
+          "JSXAttribute"
+        );
+      },
+      StringLiteral: (nodePath) => {
+        if (t.isImportDeclaration(nodePath.parent)) return;
+        if (t.isObjectProperty(nodePath.parent) && nodePath.parent.key === nodePath.node) return;
+        if (t.isJSXAttribute(nodePath.parent)) return;
+        if (this.isInsideTranslationCall(nodePath)) return;
+        if (/^[a-z][a-z0-9_.]+$/.test(nodePath.node.value)) return;
+        const text = normalizeText(nodePath.node.value);
+        if (!isHumanReadableText(text)) return;
+        this.addDetected(
+          text,
+          nodePath.node.loc?.start.line ?? 0,
+          nodePath.node.loc?.start.column ?? 0,
+          "string-literal",
+          "StringLiteral"
+        );
+      },
+      TemplateLiteral: (nodePath) => {
+        if (nodePath.node.expressions.length > 0) return;
+        if (this.isInsideTranslationCall(nodePath)) return;
+        const text = normalizeText(nodePath.node.quasis[0]?.value.cooked ?? "");
+        if (!isHumanReadableText(text)) return;
+        this.addDetected(
+          text,
+          nodePath.node.loc?.start.line ?? 0,
+          nodePath.node.loc?.start.column ?? 0,
+          "template-literal",
+          "TemplateLiteral"
+        );
+      }
+    });
+    return this.detectedTexts;
+  }
+  collectTranslationImports(ast) {
+    for (const node of ast.program.body) {
+      if (!t.isImportDeclaration(node)) continue;
+      if (!TRANSLATION_IMPORT_SOURCES.has(node.source.value)) continue;
+      for (const specifier of node.specifiers) {
+        if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.local)) {
+          this.translationFunctionNames.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  isInsideTranslationCall(nodePath) {
+    let current = nodePath.parentPath;
+    while (current) {
+      const node = current.node;
+      if (t.isCallExpression(node)) {
+        const callee = node.callee;
+        if (t.isIdentifier(callee) && this.translationFunctionNames.has(callee.name)) {
+          return true;
+        }
+        if (t.isMemberExpression(callee) && t.isIdentifier(callee.property) && this.translationFunctionNames.has(callee.property.name)) {
+          return true;
+        }
+      }
+      current = current.parentPath;
+    }
+    return false;
+  }
+  addDetected(text, line, column, context, nodeType) {
+    const key = generateLocaleKey(
+      this.options.filePath,
+      text,
+      this.options.sourceRoot || "src"
+    );
+    this.detectedTexts.push({
+      filePath: this.options.filePath,
+      line,
+      column,
+      text,
+      suggestedKey: key,
+      context,
+      nodeType,
+      alreadyTranslated: false
+    });
+  }
+  mapAttrToContext(attrName) {
+    const lower = attrName.toLowerCase();
+    if (lower === "placeholder") return "placeholder";
+    if (lower === "aria-label" || lower === "aria-placeholder") return "aria-label";
+    if (lower === "title") return "title";
+    if (lower === "alt") return "alt";
+    return "jsx-attribute";
+  }
+  regexFallbackScan() {
+    const results = [];
+    const jsxTextRegex = />([^<>{}\n]+)</g;
+    const lines = this.options.content.split("\n");
+    lines.forEach((line, idx) => {
+      let m;
+      jsxTextRegex.lastIndex = 0;
+      while ((m = jsxTextRegex.exec(line)) !== null) {
+        const text = normalizeText(m[1]);
+        if (!isHumanReadableText(text)) continue;
+        const key = generateLocaleKey(this.options.filePath, text, this.options.sourceRoot || "src");
+        results.push({
+          filePath: this.options.filePath,
+          line: idx + 1,
+          column: m.index,
+          text,
+          suggestedKey: key,
+          context: "jsx-text",
+          nodeType: "regex-fallback",
+          alreadyTranslated: false
+        });
+      }
+    });
+    return results;
+  }
+};
+
+// src/asset-scanner.ts
+import * as fs from "fs";
+import * as path from "path";
+import { ASSET_EXTENSIONS } from "@ai-localize/shared";
+var CDN_URL_PATTERN = /https?:\/\/[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}\/[^\s"'`\)\]>]+/g;
+var CSS_URL_PATTERN = /url\(['"\s]?([^'")]+)['"\s]?\)/g;
+var IMPORT_ASSET_PATTERN = /import\s+\w+\s+from\s+['"]([^'"]+\.(png|jpg|jpeg|svg|webp|gif|ico|woff|woff2|ttf|eot|mp4))['"];?/gi;
+var SRC_ATTR_PATTERN = /(?:src|href)=["']([^"']+\.(png|jpg|jpeg|svg|webp|gif|ico|mp4))["']/gi;
+var AssetScanner = class {
+  legacyCdnPattern = null;
+  constructor(legacyCdnPattern) {
+    if (legacyCdnPattern) {
+      try {
+        this.legacyCdnPattern = new RegExp(legacyCdnPattern, "g");
+      } catch {
+      }
+    }
+  }
+  scanFile(filePath) {
+    const assets = [];
+    const legacyCdnUrls = [];
+    let content;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return { assets, legacyCdnUrls };
+    }
+    let m;
+    IMPORT_ASSET_PATTERN.lastIndex = 0;
+    while ((m = IMPORT_ASSET_PATTERN.exec(content)) !== null) {
+      const assetPath = m[1];
+      assets.push({
+        filePath,
+        line: this.getLineNumber(content, m.index),
+        assetPath,
+        assetType: this.getAssetType(assetPath),
+        referenceType: "import"
+      });
+    }
+    CSS_URL_PATTERN.lastIndex = 0;
+    while ((m = CSS_URL_PATTERN.exec(content)) !== null) {
+      const assetPath = m[1];
+      if (assetPath.startsWith("data:")) continue;
+      assets.push({
+        filePath,
+        line: this.getLineNumber(content, m.index),
+        assetPath,
+        assetType: this.getAssetType(assetPath),
+        referenceType: "css-url"
+      });
+    }
+    SRC_ATTR_PATTERN.lastIndex = 0;
+    while ((m = SRC_ATTR_PATTERN.exec(content)) !== null) {
+      assets.push({
+        filePath,
+        line: this.getLineNumber(content, m.index),
+        assetPath: m[1],
+        assetType: this.getAssetType(m[1]),
+        referenceType: "src-attr"
+      });
+    }
+    if (this.legacyCdnPattern) {
+      this.legacyCdnPattern.lastIndex = 0;
+      while ((m = this.legacyCdnPattern.exec(content)) !== null) {
+        const url = m[0];
+        legacyCdnUrls.push({
+          filePath,
+          line: this.getLineNumber(content, m.index),
+          url,
+          assetPath: this.extractPathFromUrl(url)
+        });
+      }
+    }
+    CDN_URL_PATTERN.lastIndex = 0;
+    while ((m = CDN_URL_PATTERN.exec(content)) !== null) {
+      const url = m[0];
+      if (!ASSET_EXTENSIONS.some((ext) => url.includes(`.${ext}`))) continue;
+      const line = this.getLineNumber(content, m.index);
+      if (!legacyCdnUrls.find((u) => u.url === url && u.line === line)) {
+        legacyCdnUrls.push({ filePath, line, url, assetPath: this.extractPathFromUrl(url) });
+      }
+    }
+    return { assets, legacyCdnUrls };
+  }
+  getLineNumber(content, index) {
+    return content.slice(0, index).split("\n").length;
+  }
+  getAssetType(assetPath) {
+    const ext = path.extname(assetPath).toLowerCase().replace(".", "");
+    return ASSET_EXTENSIONS.includes(ext) ? ext : "other";
+  }
+  extractPathFromUrl(url) {
+    try {
+      return new URL(url).pathname;
+    } catch {
+      return url;
+    }
+  }
+};
+
+// src/incremental-scanner.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as crypto from "crypto";
+import { readJsonSafe, writeJson, ensureDir } from "@ai-localize/shared";
+var IncrementalScanCache = class {
+  cachePath;
+  cache;
+  constructor(cacheDir) {
+    ensureDir(cacheDir);
+    this.cachePath = path2.join(cacheDir, "scan-cache.json");
+    this.cache = this.load();
+  }
+  load() {
+    const existing = readJsonSafe(this.cachePath);
+    if (existing?.version === "1") return existing;
+    return { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), fileHashes: {}, processedFiles: {} };
+  }
+  isFileChanged(filePath) {
+    return this.hashFile(filePath) !== this.cache.fileHashes[filePath];
+  }
+  getCachedResult(filePath) {
+    const entry = this.cache.processedFiles[filePath];
+    if (!entry) return null;
+    if (entry.hash !== this.hashFile(filePath)) return null;
+    return entry.detectedTexts;
+  }
+  setCachedResult(filePath, texts) {
+    const hash = this.hashFile(filePath);
+    this.cache.fileHashes[filePath] = hash;
+    this.cache.processedFiles[filePath] = { hash, detectedTexts: texts, lastModified: Date.now() };
+  }
+  persist() {
+    this.cache.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+    writeJson(this.cachePath, this.cache);
+  }
+  hashFile(filePath) {
+    try {
+      return crypto.createHash("sha256").update(fs2.readFileSync(filePath)).digest("hex");
+    } catch {
+      return "";
+    }
+  }
+  clear() {
+    this.cache = { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), fileHashes: {}, processedFiles: {} };
+    this.persist();
+  }
+};
+
+// src/project-scanner.ts
+import * as path3 from "path";
+import * as os from "os";
+import { collectFiles, DEFAULT_IGNORE_DIRS, SOURCE_EXTENSIONS } from "@ai-localize/shared";
+var ProjectScanner = class {
+  config;
+  sourceRoot;
+  cache;
+  assetScanner;
+  constructor(config) {
+    this.config = config;
+    this.sourceRoot = path3.join(process.cwd(), config.sourceDir);
+    this.assetScanner = new AssetScanner(config.aws?.legacyCdnPattern);
+    if (config.incrementalCache) {
+      this.cache = new IncrementalScanCache(
+        path3.join(process.cwd(), config.cacheDir || ".ai-localize-cache")
+      );
+    }
+  }
+  async scan(options = {}) {
+    const startTime = Date.now();
+    const filesToScan = options.files?.length ? options.files : collectFiles(this.sourceRoot, SOURCE_EXTENSIONS, [
+      ...DEFAULT_IGNORE_DIRS,
+      ...this.config.ignorePatterns || []
+    ]);
+    const allTexts = [];
+    const allAssets = [];
+    const allLegacyUrls = [];
+    const chunkSize = Math.max(
+      1,
+      Math.min(50, Math.ceil(filesToScan.length / (os.cpus().length || 4)))
+    );
+    const chunks = this.chunkArray(filesToScan, chunkSize);
+    for (const chunk of chunks) {
+      const results = await Promise.all(chunk.map((f) => this.scanFile(f)));
+      for (const r of results) {
+        allTexts.push(...r.texts);
+        allAssets.push(...r.assets);
+        allLegacyUrls.push(...r.legacyUrls);
+      }
+    }
+    this.cache?.persist();
+    return {
+      framework: this.config.framework,
+      scannedFiles: filesToScan.length,
+      detectedTexts: allTexts,
+      assets: allAssets,
+      legacyCdnUrls: allLegacyUrls,
+      duration: Date.now() - startTime,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async scanFile(filePath) {
+    if (this.cache && !this.cache.isFileChanged(filePath)) {
+      const cached = this.cache.getCachedResult(filePath);
+      if (cached) return { texts: cached, assets: [], legacyUrls: [] };
+    }
+    let content;
+    try {
+      const { readFileSync: readFileSync3 } = await import("fs");
+      content = readFileSync3(filePath, "utf-8");
+    } catch {
+      return { texts: [], assets: [], legacyUrls: [] };
+    }
+    const scanner = new AstScanner({ filePath, content, sourceRoot: this.config.sourceDir });
+    const texts = scanner.scan();
+    const { assets, legacyCdnUrls } = this.assetScanner.scanFile(filePath);
+    this.cache?.setCachedResult(filePath, texts);
+    return { texts, assets, legacyUrls: legacyCdnUrls };
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+
+// src/git-scanner.ts
+import { execSync } from "child_process";
+import * as path4 from "path";
+var GitScanner = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  getStagedFiles(extensions = ["ts", "tsx", "js", "jsx", "vue"]) {
+    try {
+      const out = execSync("git diff --cached --name-only --diff-filter=ACM", {
+        cwd: this.cwd,
+        encoding: "utf-8"
+      });
+      return this.filter(out.trim().split("\n"), extensions);
+    } catch {
+      return [];
+    }
+  }
+  getChangedFiles(base = "main", extensions = ["ts", "tsx", "js", "jsx", "vue"]) {
+    try {
+      const out = execSync(`git diff --name-only --diff-filter=ACM ${base}...HEAD`, {
+        cwd: this.cwd,
+        encoding: "utf-8"
+      });
+      return this.filter(out.trim().split("\n"), extensions);
+    } catch {
+      return [];
+    }
+  }
+  getRecentlyChangedFiles(commits = 1, extensions = ["ts", "tsx", "js", "jsx", "vue"]) {
+    try {
+      const out = execSync(
+        `git diff --name-only --diff-filter=ACM HEAD~${commits}...HEAD`,
+        { cwd: this.cwd, encoding: "utf-8" }
+      );
+      return this.filter(out.trim().split("\n"), extensions);
+    } catch {
+      return [];
+    }
+  }
+  filter(files, extensions) {
+    return files.filter((f) => f && extensions.some((e) => f.endsWith(`.${e}`))).map((f) => path4.join(this.cwd, f));
+  }
+};
+export {
+  AssetScanner,
+  AstScanner,
+  GitScanner,
+  IncrementalScanCache,
+  ProjectScanner
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "ai-localize-scanner",
+  "version": "1.0.0",
+  "description": "AST-based hardcoded text scanner for frontend applications",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@babel/parser": "^7.23.9",
+    "@babel/traverse": "^7.23.9",
+    "@babel/types": "^7.23.9",
+    "glob": "^10.3.10",
+    "ai-localize-shared": "1.0.0",
+    "ai-localize-config": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.20.5",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src --ext .ts"
+  }
+}

package/src/__tests__/ast-scanner.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { AstScanner } from '../ast-scanner.js';
+
+describe('AstScanner', () => {
+  it('detects JSX text', () => {
+    const content = `
+      export default function Button() {
+        return <button>Save Campaign</button>;
+    }
+    `;
+    const scanner = new AstScanner({ filePath: 'src/Button.tsx', content, sourceRoot: 'src' });
+    const results = scanner.scan();
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].text).toBe('Save Campaign');
+    expect(results[0].context).toBe('jsx-text');
+  });
+
+  it('detects JSX attribute placeholder', () => {
+    const content = `
+      export default function Input() {
+    return <input placeholder="Enter your name" />;
+      }
+    `;
+    const scanner = new AstScanner({ filePath: 'src/Input.tsx', content, sourceRoot: 'src' });
+    const results = scanner.scan();
+    const placeholders = results.filter((r) => r.context === 'placeholder');
+    expect(placeholders.length).toBeGreaterThan(0);
+    expect(placeholders[0].text).toBe('Enter your name');
+  });
+
+  it('skips already-translated text', () => {
+    const content = `
+      import { useTranslation } from 'react-i18next';
+      export default function Button() {
+        const { t } = useTranslation();
+    return <button>{t('button.save')}</button>;
+      }
+    `;
+    const scanner = new AstScanner({ filePath: 'src/Button.tsx', content, sourceRoot: 'src' });
+    const results = scanner.scan();
+    expect(results.filter((r) => r.text === 'button.save').length).toBe(0);
+  });
+
+  it('skips import declarations', () => {
+  const content = `
+      import { something } from 'some-package';
+      export default function App() {
+     return <div>Hello World</div>;
+      }
+    `;
+    const scanner = new AstScanner({ filePath: 'src/App.tsx', content, sourceRoot: 'src' });
+    const results = scanner.scan();
+    const importResults = results.filter((r) => r.text === 'some-package');
+    expect(importResults.length).toBe(0);
+  });
+
+  it('generates deterministic locale keys', () => {
+    const content = `export default function Btn() { return <button>Save</button>; }`;
+    const scanner1 = new AstScanner({ filePath: 'src/Btn.tsx', content, sourceRoot: 'src' });
+    const scanner2 = new AstScanner({ filePath: 'src/Btn.tsx', content, sourceRoot: 'src' });
+    const results1 = scanner1.scan();
+    const results2 = scanner2.scan();
+    expect(results1[0]?.suggestedKey).toBe(results2[0]?.suggestedKey);
+  });
+});

package/src/asset-scanner.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import type { AssetReference, AssetType, LegacyCdnUrl } from '@ai-localize/shared';
+import { ASSET_EXTENSIONS } from '@ai-localize/shared';
+
+const CDN_URL_PATTERN = /https?:\/\/[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}\/[^\s"'`\)\]>]+/g;
+const CSS_URL_PATTERN = /url\(['"\s]?([^'")]+)['"\s]?\)/g;
+const IMPORT_ASSET_PATTERN =
+  /import\s+\w+\s+from\s+['"]([^'"]+\.(png|jpg|jpeg|svg|webp|gif|ico|woff|woff2|ttf|eot|mp4))['"];?/gi;
+const SRC_ATTR_PATTERN =
+  /(?:src|href)=["']([^"']+\.(png|jpg|jpeg|svg|webp|gif|ico|mp4))["']/gi;
+
+export class AssetScanner {
+  private legacyCdnPattern: RegExp | null = null;
+
+constructor(legacyCdnPattern?: string) {
+    if (legacyCdnPattern) {
+      try {
+    this.legacyCdnPattern = new RegExp(legacyCdnPattern, 'g');
+   } catch {
+        // Invalid regex, ignore
+      }
+    }
+  }
+
+  scanFile(filePath: string): { assets: AssetReference[]; legacyCdnUrls: LegacyCdnUrl[] } {
+    const assets: AssetReference[] = [];
+    const legacyCdnUrls: LegacyCdnUrl[] = [];
+
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      return { assets, legacyCdnUrls };
+    }
+
+    let m: RegExpExecArray | null;
+
+    IMPORT_ASSET_PATTERN.lastIndex = 0;
+    while ((m = IMPORT_ASSET_PATTERN.exec(content)) !== null) {
+      const assetPath = m[1];
+      assets.push({
+filePath,
+        line: this.getLineNumber(content, m.index),
+        assetPath,
+      assetType: this.getAssetType(assetPath),
+        referenceType: 'import',
+      });
+    }
+
+    CSS_URL_PATTERN.lastIndex = 0;
+    while ((m = CSS_URL_PATTERN.exec(content)) !== null) {
+   const assetPath = m[1];
+      if (assetPath.startsWith('data:')) continue;
+      assets.push({
+        filePath,
+        line: this.getLineNumber(content, m.index),
+      assetPath,
+        assetType: this.getAssetType(assetPath),
+        referenceType: 'css-url',
+      });
+    }
+
+ SRC_ATTR_PATTERN.lastIndex = 0;
+    while ((m = SRC_ATTR_PATTERN.exec(content)) !== null) {
+      assets.push({
+     filePath,
+   line: this.getLineNumber(content, m.index),
+      assetPath: m[1],
+ assetType: this.getAssetType(m[1]),
+        referenceType: 'src-attr',
+      });
+  }
+
+    if (this.legacyCdnPattern) {
+    this.legacyCdnPattern.lastIndex = 0;
+      while ((m = this.legacyCdnPattern.exec(content)) !== null) {
+        const url = m[0];
+        legacyCdnUrls.push({
+          filePath,
+          line: this.getLineNumber(content, m.index),
+          url,
+          assetPath: this.extractPathFromUrl(url),
+   });
+      }
+    }
+
+    CDN_URL_PATTERN.lastIndex = 0;
+    while ((m = CDN_URL_PATTERN.exec(content)) !== null) {
+   const url = m[0];
+      if (!ASSET_EXTENSIONS.some((ext) => url.includes(`.${ext}`))) continue;
+   const line = this.getLineNumber(content, m.index);
+      if (!legacyCdnUrls.find((u) => u.url === url && u.line === line)) {
+        legacyCdnUrls.push({ filePath, line, url, assetPath: this.extractPathFromUrl(url) });
+      }
+    }
+
+    return { assets, legacyCdnUrls };
+  }
+
+  private getLineNumber(content: string, index: number): number {
+    return content.slice(0, index).split('\n').length;
+  }
+
+  private getAssetType(assetPath: string): AssetType {
+    const ext = path.extname(assetPath).toLowerCase().replace('.', '') as AssetType;
+    return (ASSET_EXTENSIONS.includes(ext) ? ext : 'other') as AssetType;
+  }
+
+  private extractPathFromUrl(url: string): string {
+    try {
+      return new URL(url).pathname;
+    } catch {
+  return url;
+    }
+  }
+}