ai-localize-codemods 2.0.3 → 2.0.5

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "ai-localize-codemods",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "AST-based codemods to inject i18n wrappers into frontend source code",
   "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,6 +17,23 @@
       "require": "./dist/index.js"
     }
   },
+  "keywords": [
+    "i18n",
+    "localization",
+    "l10n",
+    "internationalization",
+    "ai-localize",
+    "codemod",
+    "ast",
+    "babel",
+    "jscodeshift",
+    "react",
+    "vue",
+    "angular"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "@babel/parser": "^7.23.9",
     "@babel/traverse": "^7.23.9",
@@ -19,7 +41,7 @@
     "@babel/generator": "^7.23.9",
     "recast": "^0.23.4",
     "jscodeshift": "^0.15.2",
-    "ai-localize-shared": "2.0.3"
+    "ai-localize-shared": "2.0.5"
   },
   "devDependencies": {
     "@types/babel__generator": "^7.6.8",

package/src/angular-codemod.ts

@@ -1,112 +0,0 @@
-import * as fs from 'fs';
-
-import type { DetectedText, CodemodConfig } from 'ai-localize-shared';
-import type { CodemodResult } from './react-codemod.js';
-
-const DEFAULT_TS_SERVICE = 'this.translateService.instant';
-const DEFAULT_TEMPLATE_PIPE = 'translate';
-
-/**
- * Angular ngx-translate codemod:
- * - In templates: wraps text with {{ 'key' | translate }}
- * - In TS: replaces string literals with this.translateService.instant('key')
- *
- * The pipe name used in templates can be overridden via
- * `codemods.translationFunction` (default: "translate").
- * The TS service call can be overridden via `codemods.hookName`
- * (default: "this.translateService.instant").
- */
-export class AngularCodemod {
-  private filePath: string;
-  private content: string;
-  private texts: DetectedText[];
-  private templatePipe: string;
-  private tsServiceCall: string;
-
-  constructor(filePath: string, content: string, texts: DetectedText[], codemodConfig?: CodemodConfig) {
-    this.filePath = filePath;
-  this.content = content;
-    this.texts = texts;
-    // translationFunction maps to the Angular template pipe name
-    this.templatePipe = codemodConfig?.translationFunction ?? DEFAULT_TEMPLATE_PIPE;
-    // hookName maps to the TS service call expression
-this.tsServiceCall = codemodConfig?.hookName ?? DEFAULT_TS_SERVICE;
-  }
-
-transform(): CodemodResult {
-    if (this.texts.length === 0) return this.unchanged();
-
-    const textKeyMap = new Map<string, string>();
-    for (const dt of this.texts) {
-      textKeyMap.set(dt.text, dt.suggestedKey);
-    }
-
-    let transformedContent = this.content;
-    let replacedTexts = 0;
-    const isTemplate = this.filePath.endsWith('.html');
-    const pipe = this.templatePipe;
-    const svc = this.tsServiceCall;
-
-for (const [text, key] of textKeyMap) {
-      const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      if (isTemplate) {
-        // Template: >Some Text< => >{{ 'key' | translate }}<
-      const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, 'g');
-        transformedContent = transformedContent.replace(re, `$1{{ '${key}' | ${pipe} }}$2`);
-        // attribute: [attr]="'Some Text'" => [attr]="'key' | translate"
-        const attrRe = new RegExp(`\\[(?:placeholder|label|title|alt)\\]="'${escaped}'"`, 'g');
-        transformedContent = transformedContent.replace(
-attrRe,
-          `[placeholder]="'${key}' | ${pipe}"`
-        );
-      } else {
-        // TS file: 'Some Text' => this.translateService.instant('key')
-   const tsRe = new RegExp(`'${escaped}'`, 'g');
-        transformedContent = transformedContent.replace(
-          tsRe,
-          `${svc}('${key}')`
-   );
-      }
-      replacedTexts++;
-    }
-
-    if (replacedTexts === 0) return this.unchanged();
-
-    return {
-      filePath: this.filePath,
-      originalContent: this.content,
-      transformedContent,
-      changed: true,
-      injectedImport: false,
-      injectedHook: false,
-      replacedTexts,
-    };
-  }
-
-  private unchanged(): CodemodResult {
-    return {
-      filePath: this.filePath,
-      originalContent: this.content,
-      transformedContent: this.content,
-    changed: false,
-      injectedImport: false,
-      injectedHook: false,
- replacedTexts: 0,
-    };
-  }
-}
-
-export function applyAngularCodemod(
-  filePath: string,
-  texts: DetectedText[],
-  dryRun = false,
-  codemodConfig?: CodemodConfig
-): CodemodResult {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const codemod = new AngularCodemod(filePath, content, texts, codemodConfig);
-  const result = codemod.transform();
-  if (result.changed && !dryRun) {
-    fs.writeFileSync(filePath, result.transformedContent, 'utf-8');
-  }
-  return result;
-}

package/src/cdn-replacer.ts

@@ -1,102 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-import type { LegacyCdnUrl, CloudFrontAsset } from 'ai-localize-shared';
-
-export interface CdnReplacementResult {
-  filePath: string;
-  replacedCount: number;
-  changed: boolean;
-  originalContent: string;
-  transformedContent: string;
-}
-
-/**
- * Replaces legacy CDN URLs with CloudFront URLs in source files.
- * Supports: TS/JS/JSX/TSX/CSS/HTML/Vue
- */
-export class CdnReplacer {
-  private assetMap: Map<string, CloudFrontAsset>;
-
-  constructor(assets: CloudFrontAsset[]) {
-    this.assetMap = new Map();
-  for (const asset of assets) {
-      this.assetMap.set(asset.localPath, asset);
-      // Also index by asset path without leading slash
-      this.assetMap.set(asset.s3Key, asset);
-    }
-  }
-
-  replaceInFile(
-    filePath: string,
-    legacyUrls: LegacyCdnUrl[],
-    dryRun = false
-  ): CdnReplacementResult {
-    let content: string;
-    try {
-      content = fs.readFileSync(filePath, 'utf-8');
-    } catch {
-      return { filePath, replacedCount: 0, changed: false, originalContent: '', transformedContent: '' };
-    }
-
-    let transformedContent = content;
-    let replacedCount = 0;
-
-    for (const legacyUrl of legacyUrls) {
-      // Find the corresponding CloudFront asset
-      const asset = this.findAsset(legacyUrl.assetPath);
-    if (!asset) continue;
-
-      const escapedUrl = legacyUrl.url.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const re = new RegExp(escapedUrl, 'g');
-      const newCount = (transformedContent.match(re) || []).length;
-      transformedContent = transformedContent.replace(re, asset.cloudfrontUrl);
-      replacedCount += newCount;
-    }
-
-    if (replacedCount > 0 && !dryRun) {
-      fs.writeFileSync(filePath, transformedContent, 'utf-8');
-    }
-
-    return {
-  filePath,
-      replacedCount,
-      changed: replacedCount > 0,
-      originalContent: content,
-      transformedContent,
-    };
-  }
-
-  private findAsset(assetPath: string): CloudFrontAsset | undefined {
-    // Normalize path
-    const normalized = assetPath.replace(/^\//, '');
-    return (
-  this.assetMap.get(assetPath) ||
-      this.assetMap.get(normalized) ||
-      this.assetMap.get('/' + normalized) ||
-      // fuzzy match by filename
-      Array.from(this.assetMap.values()).find((a) =>
-   path.basename(a.localPath) === path.basename(assetPath)
-      )
- );
-  }
-}
-
-/**
- * Batch replace CDN URLs across multiple files.
- */
-export async function batchReplaceCdnUrls(
-  fileUrlMap: Map<string, LegacyCdnUrl[]>,
-  assets: CloudFrontAsset[],
-  dryRun = false
-): Promise<CdnReplacementResult[]> {
-  const replacer = new CdnReplacer(assets);
-  const results: CdnReplacementResult[] = [];
-
-  for (const [filePath, legacyUrls] of fileUrlMap) {
-  const result = replacer.replaceInFile(filePath, legacyUrls, dryRun);
-    results.push(result);
-  }
-
-  return results;
-}

package/src/codemod-runner.ts

@@ -1,132 +0,0 @@
-import * as path from 'path';
-import type { Framework, DetectedText, LocalizationConfig } from 'ai-localize-shared';
-import type { CodemodResult } from './react-codemod.js';
-import { applyReactCodemod } from './react-codemod.js';
-import { applyVueCodemod } from './vue-codemod.js';
-import { applyAngularCodemod } from './angular-codemod.js';
-
-export interface CodemodRunOptions {
-  dryRun?: boolean;
-  onProgress?: (filePath: string, result: CodemodResult) => void;
-}
-
-export interface CodemodRunSummary {
-  totalFiles: number;
-  changedFiles: number;
-  totalReplacements: number;
-  importInjections: number;
-  hookInjections: number;
-  results: CodemodResult[];
-  duration: number;
-}
-
-/**
- * Orchestrates codemods across all detected files.
- *
- * Groups detected texts by file and applies the appropriate codemod based on
- * the project framework.  Codemod behaviour (import package, hook name,
- * translation function, namespace, accessor style) is driven by `config.codemods`
- * so the user can override defaults in their ai-localize.config.json.
- *
- * ### Local hook import path resolution
- * When `config.codemods.importPackage` is a project-relative path (e.g.
- * `"src/Locales/translate"`), `cwd` is forwarded to `applyReactCodemod` so it
- * can compute the correct relative import path for each individual file:
- *   src/components/Button.tsx      → `"../../Locales/translate"`
- *   src/pages/dashboard/Header.tsx → `"../../../Locales/translate"`
- */
-export class CodemodRunner {
-  private config: LocalizationConfig;
-  private cwd: string;
-
-  constructor(config: LocalizationConfig, cwd = process.cwd()) {
-    this.config = config;
-    this.cwd = cwd;
-  }
-
-  async run(
-    detectedTexts: DetectedText[],
-    options: CodemodRunOptions = {}
-  ): Promise<CodemodRunSummary> {
-    const startTime = Date.now();
-const { dryRun = false, onProgress } = options;
-
-    // Group texts by file
-    const fileTextMap = new Map<string, DetectedText[]>();
-    for (const dt of detectedTexts) {
-      const existing = fileTextMap.get(dt.filePath) || [];
-      existing.push(dt);
-  fileTextMap.set(dt.filePath, existing);
-    }
-
-    const results: CodemodResult[] = [];
-    let totalReplacements = 0;
-    let importInjections = 0;
-    let hookInjections = 0;
-
- for (const [filePath, texts] of fileTextMap) {
-      let result: CodemodResult;
-      const framework = this.config.framework;
-
-      try {
-        result = this.applyCodemod(filePath, texts, framework, dryRun);
-      } catch (err) {
-        result = {
-   filePath,
-          originalContent: '',
-       transformedContent: '',
-          changed: false,
- injectedImport: false,
-          injectedHook: false,
- replacedTexts: 0,
-        };
-      }
-
-      results.push(result);
-      totalReplacements += result.replacedTexts;
-if (result.injectedImport) importInjections++;
-      if (result.injectedHook) hookInjections++;
-
-      onProgress?.(filePath, result);
-    }
-
-    return {
-      totalFiles: fileTextMap.size,
-      changedFiles: results.filter((r) => r.changed).length,
-      totalReplacements,
-      importInjections,
-    hookInjections,
-      results,
-  duration: Date.now() - startTime,
-    };
-  }
-
-  private applyCodemod(
-    filePath: string,
-    texts: DetectedText[],
-    framework: Framework,
-    dryRun: boolean
-  ): CodemodResult {
-    const ext = path.extname(filePath).toLowerCase();
-    const codemodConfig = this.config.codemods;
-
-    // Vue SFCs
-    if (ext === '.vue') {
-      return applyVueCodemod(filePath, texts, dryRun, codemodConfig);
-    }
-
-    // Angular templates or TS
-  if (
-      framework === 'angular' ||
-      framework === 'angular-ngx' ||
-      framework === 'angular-i18n'
-  ) {
-      return applyAngularCodemod(filePath, texts, dryRun, codemodConfig);
-    }
-
-    // React (default for .tsx, .ts, .jsx, .js)
-    // Pass cwd so the codemod can resolve per-file relative import paths
-    // for local hook files (e.g. "src/Locales/translate").
-    return applyReactCodemod(filePath, texts, dryRun, codemodConfig, this.cwd);
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './react-codemod.js';
-export * from './vue-codemod.js';
-export * from './angular-codemod.js';
-export * from './cdn-replacer.js';
-export * from './codemod-runner.js';

package/src/react-codemod.ts

@@ -1,416 +0,0 @@
-import * as fs from 'fs';
-import * as nodePath from 'path';
-import * as parser from '@babel/parser';
-import traverse from '@babel/traverse';
-import generate from '@babel/generator';
-import * as t from '@babel/types';
-
-import type { DetectedText, CodemodConfig } from 'ai-localize-shared';
-
-export interface CodemodResult {
-  filePath: string;
-  originalContent: string;
-  transformedContent: string;
-  changed: boolean;
-  injectedImport: boolean;
-  injectedHook: boolean;
-  replacedTexts: number;
-}
-
-const DEFAULT_IMPORT_PACKAGE = 'react-i18next';
-const DEFAULT_HOOK_NAME = 'useTranslation';
-const DEFAULT_TRANSLATION_FN = 't';
-const DEFAULT_ACCESSOR_STYLE = 'function';
-
-/**
- * React i18n codemod: wraps hardcoded JSX text / string literals with t() or t[''] calls.
- * Preserves formatting, comments, and import order.
- *
- * ### Local hook import paths
- *
- * When `codemodConfig.importPackage` is a project-relative path (e.g. `"src/Locales/translate"`),
- * the codemod computes the correct **relative import path for each file** it transforms:
- *
- *   src/components/Button.tsx      → `"../../Locales/translate"`
- *   src/pages/dashboard/Header.tsx → `"../../../Locales/translate"`
- *
- * npm package names (no `/` prefix, not starting with `.`) are injected verbatim.
- *
- * ### Accessor styles
- *   accessorStyle "function" (default) → t('key')
- *   accessorStyle "bracket"  → t['key']
- */
-export class ReactCodemod {
-  private filePath: string;
-  private content: string;
-  private texts: DetectedText[];
-  /** Resolved import specifier string (may differ per file for local paths) */
-  private importSpecifier: string;
-  private hookName: string;
-  private translationFn: string;
-  private namespace?: string;
-  private accessorStyle: 'function' | 'bracket';
-
-  constructor(
-  filePath: string,
-    content: string,
-    texts: DetectedText[],
-    codemodConfig?: CodemodConfig,
-    cwd = process.cwd()
-  ) {
-    this.filePath = filePath;
-    this.content = content;
-    this.texts = texts;
-      this.hookName = codemodConfig?.hookName ?? DEFAULT_HOOK_NAME;
-    this.translationFn = codemodConfig?.translationFunction ?? DEFAULT_TRANSLATION_FN;
-    this.namespace = codemodConfig?.namespace;
-    this.accessorStyle = codemodConfig?.accessorStyle ?? DEFAULT_ACCESSOR_STYLE;
-
-    // Resolve import specifier: npm package → verbatim, local path → per-file relative
-    const pkg = codemodConfig?.importPackage ?? DEFAULT_IMPORT_PACKAGE;
-    this.importSpecifier = resolveImportSpecifier(pkg, filePath, cwd);
-}
-
-  transform(): CodemodResult {
-    if (this.texts.length === 0) {
-      return {
-      filePath: this.filePath,
-originalContent: this.content,
-        transformedContent: this.content,
-        changed: false,
-   injectedImport: false,
-        injectedHook: false,
-        replacedTexts: 0,
-      };
-}
-
-    let ast: t.File;
-    try {
-    ast = parser.parse(this.content, {
-        sourceType: 'module',
-        plugins: [
-  'jsx',
-     'typescript',
-          'decorators-legacy',
-          'classProperties',
-          'optionalChaining',
-          'nullishCoalescingOperator',
-        ],
-        errorRecovery: true,
-      });
-    } catch {
-      return {
-        filePath: this.filePath,
-        originalContent: this.content,
- transformedContent: this.content,
-        changed: false,
-        injectedImport: false,
-      injectedHook: false,
-        replacedTexts: 0,
- };
-    }
-
-    // Build a map of text -> key for fast lookup
-    const textKeyMap = new Map<string, string>();
-    for (const dt of this.texts) {
-      textKeyMap.set(dt.text, dt.suggestedKey);
-    }
-
-    let replacedTexts = 0;
-    let hasImport = false;
-    let hasHook = false;
-    let injectedImport = false;
-    let injectedHook = false;
-
-    const translationFn = this.translationFn;
-    const hookName = this.hookName;
-    const importSpecifier = this.importSpecifier;
-    const accessorStyle = this.accessorStyle;
-
-    /**
-     * Builds the translation expression for a key.
- *   "function" style: t('some.key')
- *   "bracket"  style: t['some.key']
-     */
-    const buildTranslationExpr = (key: string): t.Expression => {
-      if (accessorStyle === 'bracket') {
-        return t.memberExpression(
-          t.identifier(translationFn),
-          t.stringLiteral(key),
-          true /* computed */
-        );
-      }
-    return t.callExpression(t.identifier(translationFn), [t.stringLiteral(key)]);
- };
-
-    // First pass: detect existing imports and hook usage
- traverse(ast, {
-      ImportDeclaration(nodePath) {
-        if (nodePath.node.source.value === importSpecifier) {
-          hasImport = true;
-        }
-      },
-      VariableDeclarator(nodePath) {
-        const id = nodePath.node.id;
-        if (
-   t.isObjectPattern(id) &&
-          id.properties.some(
-  (p) =>
-        t.isObjectProperty(p) &&
-     t.isIdentifier(p.key) &&
-   p.key.name === translationFn
-          )
-        ) {
-          hasHook = true;
-   }
-      },
-    });
-
-    // Second pass: replace hardcoded texts
-    traverse(ast, {
-      JSXText(nodePath) {
-        const text = nodePath.node.value.trim();
-        if (!text) return;
-        const key = textKeyMap.get(text);
-        if (!key) return;
-      nodePath.replaceWith(t.jsxExpressionContainer(buildTranslationExpr(key)));
-        replacedTexts++;
-      },
-
-    StringLiteral(nodePath) {
-        const text = nodePath.node.value;
-     const key = textKeyMap.get(text);
-        if (!key) return;
-        if (t.isImportDeclaration(nodePath.parent)) return;
-  if (t.isObjectProperty(nodePath.parent) && nodePath.parent.key === nodePath.node) return;
-        if (t.isJSXAttribute(nodePath.parent)) return;
-     nodePath.replaceWith(buildTranslationExpr(key));
-        replacedTexts++;
-      },
-
-      JSXAttribute(nodePath) {
-        const valueNode = nodePath.node.value;
-        if (!t.isStringLiteral(valueNode)) return;
-        const text = valueNode.value;
-        const key = textKeyMap.get(text);
-        if (!key) return;
-        nodePath.node.value = t.jsxExpressionContainer(buildTranslationExpr(key));
-  replacedTexts++;
-      },
-    });
-
-  if (replacedTexts === 0) {
-      return {
- filePath: this.filePath,
-        originalContent: this.content,
-        transformedContent: this.content,
-     changed: false,
- injectedImport: false,
-        injectedHook: false,
-      replacedTexts: 0,
-      };
-    }
-
-  // Inject import if needed (uses the per-file resolved import specifier)
-    if (!hasImport) {
-      const importDecl = t.importDeclaration(
- [t.importSpecifier(t.identifier(hookName), t.identifier(hookName))],
-        t.stringLiteral(importSpecifier)
-      );
-      ast.program.body.unshift(importDecl);
-      injectedImport = true;
-    }
-
-    // Inject hook at the top of function components
-    if (!hasHook) {
-this.injectHook(ast);
-   injectedHook = true;
-    }
-
-    // Generate output preserving formatting
-    const output = generate(
-      ast,
-      { retainLines: false, comments: true, compact: false },
-    this.content
-    );
-
-    return {
-      filePath: this.filePath,
-      originalContent: this.content,
-      transformedContent: output.code,
-      changed: true,
-      injectedImport,
-      injectedHook,
-      replacedTexts,
-    };
-  }
-
-  private injectHook(ast: t.File): void {
-    const hookName = this.hookName;
-    const translationFn = this.translationFn;
-    const namespace = this.namespace;
-
-    traverse(ast, {
-      FunctionDeclaration(nodePath) {
-        if (!isReactComponent(nodePath.node.id?.name)) return;
-        injectHookIntoBody(nodePath.node.body, hookName, translationFn, namespace);
-        nodePath.stop();
-      },
-  ArrowFunctionExpression(nodePath) {
-        if (!isReactComponentParent(nodePath)) return;
-   const body = nodePath.node.body;
-        if (t.isBlockStatement(body)) {
-          injectHookIntoBody(body, hookName, translationFn, namespace);
-          nodePath.stop();
-        }
-  },
-    });
-  }
-}
-
-function isReactComponent(name?: string): boolean {
-  if (!name) return false;
-  return /^[A-Z]/.test(name);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isReactComponentParent(nodePath: any): boolean {
-  const parent = nodePath.parent;
-  if (t.isVariableDeclarator(parent)) {
-    const id = parent.id;
-  if (t.isIdentifier(id) && /^[A-Z]/.test(id.name)) return true;
-  }
-  return false;
-}
-
-function injectHookIntoBody(
-  body: t.BlockStatement,
-  hookName: string,
-  translationFn: string,
-  namespace?: string
-): void {
-  const hookArgs: t.Expression[] = namespace ? [t.stringLiteral(namespace)] : [];
-  const hookDecl = t.variableDeclaration('const', [
-    t.variableDeclarator(
-      t.objectPattern([
-        t.objectProperty(t.identifier(translationFn), t.identifier(translationFn), false, true),
-      ]),
-      t.callExpression(t.identifier(hookName), hookArgs)
-    ),
-  ]);
-  body.body.unshift(hookDecl);
-}
-
-/**
- * Determines the import specifier string to inject for a given `importPackage`
- * config value and the file being transformed.
- *
- * Rules:
- *   1. If `importPackage` looks like an npm package name (no leading `.` or `/`
- *      and no path separators in a way that suggests a local path starting with
- *      a known directory like `src/`) → return verbatim.
- *
- *   2. If `importPackage` is an absolute path → compute `path.relative(fileDir, importPackage)`
- *  and ensure it starts with `./` or `../`.
- *
- *   3. If `importPackage` is a project-relative path (starts with `src/`, `app/`,
- *      `lib/`, `hooks/`, `utils/`, or any path without a leading `.`) that is NOT
- *      a bare npm package name → resolve it relative to `cwd` first, then compute
- *      `path.relative(fileDir, resolvedPath)`.
- *
- *   4. If `importPackage` starts with `./` or `../` → treat as a path relative to
- *    `cwd` (config file location), resolve it, then compute relative to each file.
- */
-export function resolveImportSpecifier(
-  importPackage: string,
-  filePath: string,
-  cwd: string
-): string {
-  // Bare npm package name — no slashes that indicate a local path, or scoped @org/pkg
-  if (isNpmPackage(importPackage)) {
-    return importPackage;
-  }
-
-  // Resolve the hook file to an absolute path
-  let absoluteHookPath: string;
-  if (nodePath.isAbsolute(importPackage)) {
-    absoluteHookPath = importPackage;
-  } else {
-    // Project-relative (e.g. "src/Locales/translate") or relative (e.g. "../../hooks/t")
-    absoluteHookPath = nodePath.resolve(cwd, importPackage);
-  }
-
-  // Compute relative path from the directory of the file being transformed
-  const fileDir = nodePath.dirname(filePath);
-  let rel = nodePath.relative(fileDir, absoluteHookPath).replace(/\\/g, '/');
-
-  // Ensure it starts with ./ or ../
-  if (!rel.startsWith('.')) {
-    rel = `./${rel}`;
-  }
-
-  return rel;
-}
-
-/**
- * Returns true if the string looks like a bare npm package name rather than a
- * local file path.
- *
- * npm package names:
- *   - Do not start with `.` or `/`
- *   - Scoped packages start with `@` followed by `org/pkg`
- *   - Do NOT look like project-relative source paths such as `src/...`, `app/...`
- *
- * We consider a string a local path if it:
- *   - Starts with `.` (relative: `./hooks/t`, `../../hooks/t`)
- *- Starts with `/` (absolute)
- *   - Contains a `/` AND its first segment looks like a source directory
- *     (`src`, `app`, `lib`, `hooks`, `utils`, `pages`, `components`, `features`,
- *      `shared`, `common`, `locales`, `i18n`, `services`, `store`)
- */
-function isNpmPackage(pkg: string): boolean {
-  if (pkg.startsWith('.') || pkg.startsWith('/')) return false;
-
-  // Scoped npm package: @scope/name — always npm
-  if (pkg.startsWith('@') && pkg.includes('/')) {
-    // @/alias paths used in bundlers (e.g. "@/hooks/useT") are NOT npm packages
-    if (pkg.startsWith('@/')) return false;
-    return true;
-  }
-
-  // If no slash at all → bare npm package name (e.g. "i18next", "react-i18next")
-  if (!pkg.includes('/')) return true;
-
-  // Has a slash — check if the first segment is a known source directory name
-  const firstSegment = pkg.split('/')[0].toLowerCase();
-  const sourceDirectories = new Set([
-    'src', 'app', 'lib', 'hooks', 'utils', 'pages', 'components',
-    'features', 'shared', 'common', 'locales', 'i18n', 'services',
-    'store', 'helpers', 'core', 'modules',
-  ]);
-  if (sourceDirectories.has(firstSegment)) return false;
-
-  // Everything else (e.g. "lodash/fp", "date-fns/locale") → npm package
-  return true;
-}
-
-/**
- * Applies the React codemod to a file in-place.
- */
-export function applyReactCodemod(
-  filePath: string,
-  texts: DetectedText[],
-  dryRun = false,
-  codemodConfig?: CodemodConfig,
-  cwd = process.cwd()
-): CodemodResult {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const codemod = new ReactCodemod(filePath, content, texts, codemodConfig, cwd);
-  const result = codemod.transform();
-
-  if (result.changed && !dryRun) {
- fs.writeFileSync(filePath, result.transformedContent, 'utf-8');
-  }
-
-  return result;
-}

package/src/vue-codemod.ts

@@ -1,106 +0,0 @@
-import * as fs from 'fs';
-
-import type { DetectedText, CodemodConfig } from 'ai-localize-shared';
-import type { CodemodResult } from './react-codemod.js';
-
-const DEFAULT_TRANSLATION_FN = '$t';
-
-/**
- * Vue i18n codemod: wraps hardcoded text with $t() / t() calls in Vue SFCs.
- * Handles both Options API (global $t) and Composition API (useI18n / useTranslation).
- *
- * The translation function name can be overridden via the `codemods.translationFunction`
- * config field (default: "$t").
- */
-export class VueCodemod {
-  private filePath: string;
-  private content: string;
-  private texts: DetectedText[];
-  private translationFn: string;
-
-  constructor(filePath: string, content: string, texts: DetectedText[], codemodConfig?: CodemodConfig) {
-    this.filePath = filePath;
-    this.content = content;
- this.texts = texts;
-    this.translationFn = codemodConfig?.translationFunction ?? DEFAULT_TRANSLATION_FN;
-  }
-
-  transform(): CodemodResult {
-    if (this.texts.length === 0) {
- return this.unchanged();
-    }
-
-    // Parse <template> and <script> sections separately
-    const templateMatch = this.content.match(/<template[^>]*>([\s\S]*?)<\/template>/);
-    const scriptMatch = this.content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
-
-    if (!templateMatch && !scriptMatch) {
-      return this.unchanged();
-    }
-
-    const textKeyMap = new Map<string, string>();
-    for (const dt of this.texts) {
-  textKeyMap.set(dt.text, dt.suggestedKey);
-  }
-
-    let transformedContent = this.content;
-    let replacedTexts = 0;
-    const fn = this.translationFn;
-
-  // Replace in template: >text< => >{{ $t('key') }}<
-    if (templateMatch) {
-      let template = templateMatch[1];
-      for (const [text, key] of textKeyMap) {
-    const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, 'g');
-        template = template.replace(re, `$1{{ ${fn}('${key}') }}$2`);
-   // Also replace in attribute values: title="text" => :title="$t('key')"
-        const attrRe = new RegExp(`((?:title|placeholder|alt|label)=)"(${escaped})"`, 'g');
-        template = template.replace(attrRe, `:$1"${fn}('${key}')"`);
-      replacedTexts++;
-      }
-      transformedContent = transformedContent.replace(templateMatch[1], template);
-    }
-
-  if (replacedTexts === 0) {
-      return this.unchanged();
-    }
-
-    return {
-      filePath: this.filePath,
-      originalContent: this.content,
-      transformedContent,
-      changed: true,
-      injectedImport: false, // vue-i18n is globally injected
-      injectedHook: false,
-   replacedTexts,
-    };
-  }
-
-  private unchanged(): CodemodResult {
-    return {
-      filePath: this.filePath,
-      originalContent: this.content,
-      transformedContent: this.content,
-      changed: false,
-      injectedImport: false,
-      injectedHook: false,
-      replacedTexts: 0,
-    };
-  }
-}
-
-export function applyVueCodemod(
-  filePath: string,
-  texts: DetectedText[],
-  dryRun = false,
-  codemodConfig?: CodemodConfig
-): CodemodResult {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const codemod = new VueCodemod(filePath, content, texts, codemodConfig);
-  const result = codemod.transform();
-  if (result.changed && !dryRun) {
-    fs.writeFileSync(filePath, result.transformedContent, 'utf-8');
-  }
-  return result;
-}

package/tsconfig.json

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