ai-localize-scanner 2.0.3 → 2.0.5

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "ai-localize-scanner",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "AST-based hardcoded text scanner for frontend applications",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,13 +17,30 @@
       "require": "./dist/index.js"
     }
   },
+  "keywords": [
+    "i18n",
+    "localization",
+    "l10n",
+    "internationalization",
+    "ai-localize",
+    "ast",
+    "scanner",
+    "babel",
+    "hardcoded-strings",
+    "react",
+    "vue",
+    "angular"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "@babel/parser": "^7.23.9",
     "@babel/traverse": "^7.23.9",
     "@babel/types": "^7.23.9",
     "glob": "^10.3.10",
-    "ai-localize-shared": "2.0.3",
-    "ai-localize-config": "2.0.3"
+    "ai-localize-shared": "2.0.5",
+    "ai-localize-config": "2.0.5"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.20.5",

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

@@ -1,65 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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;
-    }
-  }
-}

package/src/ast-scanner.ts

@@ -1,413 +0,0 @@
-import * as parser from '@babel/parser';
-import traverse from '@babel/traverse';
-import * as t from '@babel/types';
-
-import type { DetectedText, TextContext, CodemodConfig, KeyStyle } from 'ai-localize-shared';
-import {
-  isHumanReadableText,
-  normalizeText,
-  TEXT_ATTRIBUTE_NAMES,
-  generateKeyByStyle,
-} from 'ai-localize-shared';
-
-export interface AstScanOptions {
-  filePath: string;
-  content: string;
-  sourceRoot?: string;
-  /**
-   * Controls the format of the generated locale key for each detected text.
- *
-   * - `"path"` (default) — hierarchical dot-notation key derived from file path + text:
-   *     `settings.settings_page.save_changes`
-   *
-   * - `"screaming_snake"` — UPPER_SNAKE_CASE key derived solely from the text value:
-   *     "Save Changes" → `SAVE_CHANGES`
-   *     "Max Count"  → `MAX_COUNT`
-   */
-  keyStyle?: KeyStyle;
-  /**
-   * Optional codemod config from ai-localize.config.json.
-   *
-   * The scanner uses this to recognise already-translated strings even when
-   * the project uses a custom i18n library or a locally-defined hook:
-   *
-   *   importPackage — matched against import source strings. Supports:
-   *     - npm package names:    "react-i18next", "my-i18n-lib"
-   *     - path aliases:    "@/hooks/useTranslation", "@/i18n"
-   *  - relative paths:       "../../hooks/useTranslation"
-   *     Matching is done by checking whether the import source equals the value
-   *     OR ends with the last path segment(s) of the value (normalised).
-   *
-   *   hookName — the hook identifier (e.g. "useTranslation", "useI18n").
-   *   Added directly to the translation-function names set regardless of
-   *     how the hook is imported.  This means even default imports, re-exports
-   *     or barrel aliases are handled correctly:
-   *       import useT from '../../hooks/useT'  (default import, hookName="useT")
-   *
-   *   translationFunction — the accessor returned by the hook (e.g. "t").
-   *     Added directly to the translation-function names set.
-   */
-  codemodConfig?: CodemodConfig;
-}
-
-/** Well-known i18n library import sources (npm package names). */
-const BUILTIN_TRANSLATION_IMPORT_SOURCES = new Set([
-  'react-i18next',
-  'i18next',
-  'vue-i18n',
-  '@ngx-translate/core',
-]);
-
-/**
- * Scans a JS/TS/JSX/TSX file using Babel AST to find hardcoded text.
- */
-export class AstScanner {
-  private options: AstScanOptions;
-  private detectedTexts: DetectedText[] = [];
-
-  /** Identifiers whose call/bracket expressions contain already-translated strings. */
-  private translationFunctionNames: Set<string>;
-
-  /**
-   * Import source matchers.
-   * Each entry is either an exact string (npm package) or a path-suffix matcher
-   * function built from a relative/alias path.
-   */
-  private importSourceMatchers: Array<(source: string) => boolean>;
-
-  constructor(options: AstScanOptions) {
-    this.options = options;
-
-    // Seed default translation function names
-    this.translationFunctionNames = new Set<string>(['t', '$t', 'i18n', 'translate']);
-
-    // Build import-source matchers from builtin list
-    this.importSourceMatchers = Array.from(BUILTIN_TRANSLATION_IMPORT_SOURCES).map(
-      (pkg) => (src: string) => src === pkg
-    );
-
-    const cc = options.codemodConfig;
-    if (cc) {
-      // translationFunction — seed directly; no import lookup needed
-      if (cc.translationFunction) {
-        this.translationFunctionNames.add(cc.translationFunction);
-      }
-
-      // hookName — seed directly so the hook identifier is always recognised
-      // regardless of how it is imported (named, default, aliased, re-exported).
-   if (cc.hookName) {
-        this.translationFunctionNames.add(cc.hookName);
-      }
-
-      // importPackage — build a matcher that handles:
-      //   1. exact npm package name  "react-i18next"
-      //   2. path alias"@/hooks/useTranslation"
-      //   3. relative path      "../../hooks/useTranslation"
-      if (cc.importPackage) {
-        this.importSourceMatchers.push(buildImportMatcher(cc.importPackage));
-      }
-    }
-  }
-
-  scan(): DetectedText[] {
-    const { content } = this.options;
-
-    let ast: t.File;
-    try {
-      ast = parser.parse(content, {
-  sourceType: 'module',
-        plugins: [
-          'jsx',
- 'typescript',
-      'decorators-legacy',
-          'classProperties',
-     'optionalChaining',
-     'nullishCoalescingOperator',
-       'dynamicImport',
-    'exportDefaultFrom',
-        ],
-        errorRecovery: true,
-      });
- } catch {
-      return this.regexFallbackScan();
-    }
-
-    // Collect translation function names from imports before scanning text
-    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;
-
-        // Ignore className and similar CSS-class attributes
-        if (t.isJSXAttribute(nodePath.parent)) {
-          const attrName = t.isJSXIdentifier(nodePath.parent.name)
-        ? nodePath.parent.name.name.toLowerCase()
-            : '';
-      if (attrName === 'classname' || attrName === 'class') return;
-          return;
-        }
-
-        if (this.isInsideTranslationCall(nodePath)) return;
-
-        const val = nodePath.node.value;
-        if (
-    /^[a-z][a-z0-9_.-]*$/.test(val) ||
-          /^#?[0-9a-fA-F]+$/.test(val) ||
-          (/^[\w-]+\s[\w- ]+$/.test(val) && !val.includes(','))
-        ) {
-          return; // Likely a CSS class, ID, hex colour, or plain word pair
-  }
-
-        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;
-  }
-
-  /**
-   * Walk import declarations; when the source matches a known translation
-   * import, collect all named/default imports as translation function names.
-   */
-  private collectTranslationImports(ast: t.File): void {
-    for (const node of ast.program.body) {
-      if (!t.isImportDeclaration(node)) continue;
-      const source = node.source.value;
-      if (!this.isTranslationImportSource(source)) continue;
-   for (const specifier of node.specifiers) {
-        if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.local)) {
-          this.translationFunctionNames.add(specifier.local.name);
- }
-        // Default import: import useT from '../../hooks/useT'
-        if (t.isImportDefaultSpecifier(specifier) && t.isIdentifier(specifier.local)) {
-          this.translationFunctionNames.add(specifier.local.name);
-        }
-        // Namespace import: import * as i18n from '...'
-        if (t.isImportNamespaceSpecifier(specifier) && t.isIdentifier(specifier.local)) {
-       this.translationFunctionNames.add(specifier.local.name);
-   }
-      }
-    }
-  }
-
-  /** Returns true if the import source string should be treated as a translation library. */
-  private isTranslationImportSource(source: string): boolean {
-    return this.importSourceMatchers.some((match) => match(source));
-}
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private isInsideTranslationCall(nodePath: any): boolean {
-    let current = nodePath.parentPath;
-    while (current) {
-      const node = current.node;
-
-      // Function-call style: t('key')
-    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;
-        }
-  }
-
-      // Bracket-notation accessor: t['key']  (MemberExpression, computed=true)
-      if (t.isMemberExpression(node) && node.computed) {
-   const obj = node.object;
-        if (t.isIdentifier(obj) && this.translationFunctionNames.has(obj.name)) {
-    return true;
-        }
-      }
-
-      current = current.parentPath;
-    }
-    return false;
-  }
-
-  private addDetected(
-    text: string,
-    line: number,
-    column: number,
-    context: TextContext,
-    nodeType: string
-  ): void {
-    const key = generateKeyByStyle(
-  this.options.filePath,
-      text,
-      this.options.sourceRoot || 'src',
-      this.options.keyStyle || 'path'
-    );
-    this.detectedTexts.push({
-      filePath: this.options.filePath,
-      line,
-      column,
-      text,
-    suggestedKey: key,
-      context,
-      nodeType,
- alreadyTranslated: false,
-    });
-  }
-
-  private mapAttrToContext(attrName: string): TextContext {
-    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';
-  }
-
-  private regexFallbackScan(): DetectedText[] {
-    const results: DetectedText[] = [];
-    const jsxTextRegex = />([^<>{}\n]+)</g;
-    const lines = this.options.content.split('\n');
-    lines.forEach((line, idx) => {
-    let m: RegExpExecArray | null;
-  jsxTextRegex.lastIndex = 0;
-      while ((m = jsxTextRegex.exec(line)) !== null) {
-        const text = normalizeText(m[1]);
-        if (!isHumanReadableText(text)) continue;
-        const key = generateKeyByStyle(
-          this.options.filePath,
-    text,
-          this.options.sourceRoot || 'src',
-          this.options.keyStyle || 'path'
- );
-        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;
-  }
-}
-
-/**
- * Builds an import-source matcher function for the given `importPackage` value.
- *
- * Handles three cases:
- *
- * 1. Exact npm package name — "react-i18next", "my-i18n-lib"
- *    Matches when the import source string equals the value exactly.
- *
- * 2. Path alias — "@/hooks/useTranslation", "@/i18n"
- *    Matches when the import source equals the value OR ends with the
- *    normalised path suffix (with or without the alias prefix).
- *
- * 3. Relative path — "../../hooks/useTranslation", "./i18n/hook"
- *    Because relative paths resolve differently per file, we match by
- *    comparing the **last N segments** of the import source with the
- *    last N segments of the configured value (case-insensitive, stripping
- *    leading dots and slashes).  This is intentionally lenient so that
- *    `hooks/useTranslation` matches both `../../hooks/useTranslation` and
- *    `./hooks/useTranslation`.
- *
- * Examples:
- *   importPackage="../../hooks/useTranslation"
- *     matches  "../../hooks/useTranslation"  ✓
- *     matches  "./hooks/useTranslation"     ✓  (same tail segments)
- *     matches  "../hooks/useTranslation"      ✓
- *   importPackage="@/i18n/hook"
- *     matches  "@/i18n/hook"✓
- *     matches  "i18n/hook"       ✓
- */
-function buildImportMatcher(importPackage: string): (source: string) => boolean {
-  // Normalise: strip leading ./ ../ @ and collapse slashes
-  const normalisedPkg = normalisePath(importPackage);
-  const pkgSegments = normalisedPkg.split('/').filter(Boolean);
-
-  return (source: string): boolean => {
-  // 1. Exact match (covers plain npm package names and exact alias paths)
-    if (source === importPackage) return true;
-
-    // 2. Suffix / tail-segment match
-    const normSource = normalisePath(source);
- const srcSegments = normSource.split('/').filter(Boolean);
-
-    if (pkgSegments.length === 0) return false;
-
-// Check if the source ends with the same N tail segments as the package
-    const n = pkgSegments.length;
- if (srcSegments.length < n) return false;
-    const tail = srcSegments.slice(-n);
- return tail.every((seg, i) => seg.toLowerCase() === pkgSegments[i].toLowerCase());
-  };
-}
-
-/** Strips leading dots, slashes and @ from a path string for comparison purposes. */
-function normalisePath(p: string): string {
-  return p
-    .replace(/\\/g, '/')
-    .replace(/^(@\/|\.{1,2}\/)+/, '') // strip leading ./ ../ @/
- .replace(/^@/, ''); // strip bare @ prefix
-}

package/src/git-scanner.ts

@@ -1,52 +0,0 @@
-import { execSync } from 'child_process';
-import * as path from 'path';
-
-export class GitScanner {
-  private cwd: string;
-
-  constructor(cwd = process.cwd()) {
-    this.cwd = cwd;
-  }
-
-  getStagedFiles(extensions = ['ts', 'tsx', 'js', 'jsx', 'vue']): string[] {
-    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']): string[] {
-    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']): string[] {
-    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 [];
-    }
-  }
-
-  private filter(files: string[], extensions: string[]): string[] {
-    return files
-      .filter((f) => f && extensions.some((e) => f.endsWith(`.${e}`)))
-      .map((f) => path.join(this.cwd, f));
-  }
-}

package/src/incremental-scanner.ts

@@ -1,58 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-
-import type { IncrementalCache, DetectedText } from 'ai-localize-shared';
-import { readJsonSafe, writeJson, ensureDir } from 'ai-localize-shared';
-
-export class IncrementalScanCache {
-  private cachePath: string;
-  private cache: IncrementalCache;
-
-  constructor(cacheDir: string) {
-    ensureDir(cacheDir);
-    this.cachePath = path.join(cacheDir, 'scan-cache.json');
-    this.cache = this.load();
-}
-
-  private load(): IncrementalCache {
-    const existing = readJsonSafe<IncrementalCache>(this.cachePath);
-    if (existing?.version === '1') return existing;
-    return { version: '1', lastRun: new Date().toISOString(), fileHashes: {}, processedFiles: {} };
-  }
-
-  isFileChanged(filePath: string): boolean {
-    return this.hashFile(filePath) !== this.cache.fileHashes[filePath];
-  }
-
-  getCachedResult(filePath: string): DetectedText[] | null {
-    const entry = this.cache.processedFiles[filePath];
-    if (!entry) return null;
-    if (entry.hash !== this.hashFile(filePath)) return null;
-return entry.detectedTexts;
-  }
-
-  setCachedResult(filePath: string, texts: DetectedText[]): void {
-    const hash = this.hashFile(filePath);
-    this.cache.fileHashes[filePath] = hash;
-    this.cache.processedFiles[filePath] = { hash, detectedTexts: texts, lastModified: Date.now() };
-  }
-
-  persist(): void {
-    this.cache.lastRun = new Date().toISOString();
-    writeJson(this.cachePath, this.cache);
-  }
-
-  private hashFile(filePath: string): string {
-    try {
-      return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
-    } catch {
- return '';
-    }
-  }
-
-  clear(): void {
-    this.cache = { version: '1', lastRun: new Date().toISOString(), fileHashes: {}, processedFiles: {} };
-    this.persist();
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './ast-scanner.js';
-export * from './asset-scanner.js';
-export * from './incremental-scanner.js';
-export * from './project-scanner.js';
-export * from './git-scanner.js';

package/src/project-scanner.ts

@@ -1,142 +0,0 @@
-import * as path from 'path';
-import * as os from 'os';
-
-import type {
-  DetectedText,
-  AssetReference,
-  LegacyCdnUrl,
-  ScanResult,
-  LocalizationConfig,
-} from 'ai-localize-shared';
-import { collectFiles, DEFAULT_IGNORE_DIRS, SOURCE_EXTENSIONS } from 'ai-localize-shared';
-
-import { AstScanner } from './ast-scanner.js';
-import { AssetScanner } from './asset-scanner.js';
-import { IncrementalScanCache } from './incremental-scanner.js';
-
-export interface ScanOptions {
-  files?: string[];
-  incremental?: boolean;
-}
-
-export class ProjectScanner {
-  private config: LocalizationConfig;
-  private sourceRoot: string;
-  private cache?: IncrementalScanCache;
-  private assetScanner: AssetScanner;
-
-  constructor(config: LocalizationConfig) {
-    this.config = config;
-    // Resolve to absolute path so key-generator can use path.relative()
-    // and never produce keys that include ancestor directory segments.
-    this.sourceRoot = path.resolve(process.cwd(), config.sourceDir);
-    this.assetScanner = new AssetScanner(config.aws?.legacyCdnPattern);
-    if (config.incrementalCache) {
-    this.cache = new IncrementalScanCache(
-        path.join(process.cwd(), config.cacheDir || '.ai-localize-cache')
-      );
-    }
-  }
-
-  async scan(options: ScanOptions = {}): Promise<ScanResult> {
-    const startTime = Date.now();
-    let filesToScan: string[] = [];
-
-    if (options.files?.length) {
-      filesToScan = options.files;
-    } else {
-      const allFiles = collectFiles(this.sourceRoot, SOURCE_EXTENSIONS, [
-        ...DEFAULT_IGNORE_DIRS,
-     ...(this.config.ignorePatterns || []),
-      ]);
-
-   if (this.config.includePatterns && this.config.includePatterns.length > 0) {
-      filesToScan = allFiles.filter(file => {
-      return this.config.includePatterns!.some(pattern => {
-   const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
-       return new RegExp(regexPattern).test(file);
-          });
-        });
-      } else {
-  filesToScan = allFiles;
-      }
-    }
-
-    const allTexts: DetectedText[] = [];
-    const allAssets: AssetReference[] = [];
-    const allLegacyUrls: LegacyCdnUrl[] = [];
-
-    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: new Date().toISOString(),
-    };
-  }
-
-  private async scanFile(filePath: string): Promise<{
-    texts: DetectedText[];
-    assets: AssetReference[];
-    legacyUrls: LegacyCdnUrl[];
-  }> {
-    if (this.cache && !this.cache.isFileChanged(filePath)) {
-      const cached = this.cache.getCachedResult(filePath);
-      if (cached) return { texts: cached, assets: [], legacyUrls: [] };
-    }
-
-    let content: string;
-    try {
-   const { readFileSync } = await import('fs');
-   content = readFileSync(filePath, 'utf-8');
-    } catch {
-      return { texts: [], assets: [], legacyUrls: [] };
-    }
-
-    // Pass the absolute sourceRoot so normalizePath uses path.relative()
-    // and strips only the project source directory — not ancestor segments.
-    // Also pass codemods config so the scanner recognises user-defined
-    // translation functions/hooks and skips already-translated strings.
-    // keyStyle controls whether keys are path-based (default) or SCREAMING_SNAKE.
-    const scanner = new AstScanner({
-      filePath,
-      content,
-      sourceRoot: this.sourceRoot,
-      codemodConfig: this.config.codemods,
-      keyStyle: this.config.keyStyle ?? 'path',
-    });
-  const texts = scanner.scan();
-    const { assets, legacyCdnUrls } = this.assetScanner.scanFile(filePath);
-
-    this.cache?.setCachedResult(filePath, texts);
-
-    return { texts, assets, legacyUrls: legacyCdnUrls };
-  }
-
-  private chunkArray<T>(array: T[], size: number): T[][] {
-    const chunks: T[][] = [];
-    for (let i = 0; i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-  }
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}