@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/lockfile/schema.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockfileDataSchema = exports.lockfileEntrySchema = void 0;
+exports.createEmptyLockfile = createEmptyLockfile;
+const zod_1 = require("zod");
+// ─────────────────────────────────────────────────────────────
+// Lockfile entry (per translation key)
+// ─────────────────────────────────────────────────────────────
+exports.lockfileEntrySchema = zod_1.z.object({
+    /** SHA-256 hex digest of the source string */
+    sourceHash: zod_1.z.string(),
+    /** ISO-8601 timestamp of last translation */
+    translatedAt: zod_1.z.string(),
+    /** Translated values keyed by locale code */
+    languages: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+    /** Metadata per locale */
+    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        fromMemory: zod_1.z.boolean().optional(),
+        sourceHash: zod_1.z.string().optional(),
+        /** This key's translation for the locale is known to be in TM; skip backfill. */
+        inTm: zod_1.z.boolean().optional(),
+        /** Pseudo-localized (`--provider pseudo`), not a translation: any real run re-translates it. */
+        pseudo: zod_1.z.boolean().optional(),
+        /**
+         * Fingerprint of the glossary rules that applied to this key's source
+         * for the locale (see glossaryFingerprint). Absent: none applied.
+         * A run whose rules give a different fingerprint re-translates it.
+         */
+        glossaryHash: zod_1.z.string().optional(),
+        /**
+         * The translation came from the project's own files (e.g. a .po
+         * catalogue), not from Babelize: glossary edits don't overwrite it.
+         */
+        external: zod_1.z.boolean().optional(),
+    })).optional(),
+});
+// ─────────────────────────────────────────────────────────────
+// Top-level lockfile
+// ─────────────────────────────────────────────────────────────
+exports.lockfileDataSchema = zod_1.z.object({
+    version: zod_1.z.string().default('1.0'),
+    projectId: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+    keys: zod_1.z.record(zod_1.z.string(), exports.lockfileEntrySchema),
+});
+// ─────────────────────────────────────────────────────────────
+// Empty lockfile factory
+// ─────────────────────────────────────────────────────────────
+function createEmptyLockfile(projectId) {
+    return {
+        version: '1.0',
+        projectId,
+        updatedAt: new Date().toISOString(),
+        keys: {},
+    };
+}

package/dist/modules/parser/index.d.ts

@@ -0,0 +1,2 @@
+import type { File } from '@babel/types';
+export declare function parseFile(content: string, language: 'ts' | 'tsx' | 'js' | 'jsx'): File;

package/dist/modules/parser/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = parseFile;
+const ast_helpers_1 = require("../../utils/ast-helpers");
+function parseFile(content, language) {
+    const isTypeScript = language === 'ts' || language === 'tsx';
+    const options = { isTypeScript, isJSX: language.endsWith('x') };
+    return (0, ast_helpers_1.parseCode)(content, options);
+}

package/dist/modules/summary/index.d.ts

@@ -0,0 +1 @@
+export { generateSummary, generateReadableSummary, formatProcessingTime } from './summary';

package/dist/modules/summary/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProcessingTime = exports.generateReadableSummary = exports.generateSummary = void 0;
+var summary_1 = require("./summary");
+Object.defineProperty(exports, "generateSummary", { enumerable: true, get: function () { return summary_1.generateSummary; } });
+Object.defineProperty(exports, "generateReadableSummary", { enumerable: true, get: function () { return summary_1.generateReadableSummary; } });
+Object.defineProperty(exports, "formatProcessingTime", { enumerable: true, get: function () { return summary_1.formatProcessingTime; } });

package/dist/modules/summary/summary.d.ts

@@ -0,0 +1,9 @@
+import type { DiffMetadata, ExtractionResult, InjectionResult, KeyGenerationResult, LocaleHandlingResult, ProcessingStats, TranslationResult, Warning } from '../../runtime/types';
+import type { LockfileStats } from '../lockfile';
+export declare function generateSummary(extraction: ExtractionResult, keyGeneration: KeyGenerationResult, localeHandling: LocaleHandlingResult, translation: TranslationResult, injection: InjectionResult, processingStartTime: number, lockfileStats?: LockfileStats, tmHits?: number): {
+    stats: ProcessingStats;
+    warnings: Warning[];
+    diffs: DiffMetadata[];
+};
+export declare function formatProcessingTime(ms: number): string;
+export declare function generateReadableSummary(stats: ProcessingStats): string;

package/dist/modules/summary/summary.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSummary = generateSummary;
+exports.formatProcessingTime = formatProcessingTime;
+exports.generateReadableSummary = generateReadableSummary;
+function generateSummary(extraction, keyGeneration, localeHandling, translation, injection, processingStartTime, lockfileStats, tmHits = 0) {
+    const processingTimeMs = Date.now() - processingStartTime;
+    const stats = {
+        filesScanned: extraction.filesAnalyzed.length,
+        filesWithStrings: countFilesWithStrings(extraction),
+        stringsExtracted: extraction.strings.length,
+        keysGenerated: keyGeneration.keys.length,
+        filesModified: injection.modifiedFiles.length,
+        injectionsApplied: injection.totalInjections,
+        localeFilesCreated: translation.locales.length + (localeHandling.sourceLocale.isNew ? 1 : 0),
+        processingTimeMs,
+        translationsFromLockfile: lockfileStats?.reused ?? 0,
+        translationsFromMemory: tmHits,
+        lockfileUsed: lockfileStats != null,
+        lockfileKeysTranslated: lockfileStats?.translated,
+        lockfileKeysChanged: lockfileStats?.changed,
+    };
+    const warnings = [
+        ...collectExtractionWarnings(extraction),
+        ...collectKeyGenWarnings(keyGeneration),
+        ...collectTranslationWarnings(translation),
+        ...collectInjectionWarnings(injection),
+    ];
+    const diffs = [...generateLocaleDiffs(localeHandling, translation), ...generateInjectionDiffs(injection)];
+    return { stats, warnings, diffs };
+}
+function countFilesWithStrings(extraction) {
+    const filesWithStrings = new Set();
+    for (const str of extraction.strings)
+        filesWithStrings.add(str.file);
+    return filesWithStrings.size;
+}
+function collectExtractionWarnings(extraction) {
+    const warnings = [];
+    if (extraction.warnings) {
+        warnings.push(...extraction.warnings);
+    }
+    for (const skipped of extraction.skippedFiles) {
+        warnings.push({
+            type: 'parse-warning',
+            file: skipped.file,
+            message: `File skipped: ${skipped.reason}${skipped.details ? ` - ${skipped.details}` : ''}`,
+        });
+    }
+    return warnings;
+}
+function collectKeyGenWarnings(keyGeneration) {
+    const warnings = [];
+    for (const dup of keyGeneration.duplicates) {
+        warnings.push({
+            type: 'duplicate-key',
+            file: '',
+            message: `Key "${dup.original}" was renamed to "${dup.renamed}" to avoid collision`,
+        });
+    }
+    return warnings;
+}
+function collectTranslationWarnings(translation) {
+    const warnings = [];
+    for (const error of translation.errors) {
+        warnings.push({
+            type: 'parse-warning',
+            file: `locales/${error.locale}.json`,
+            message: `Translation failed: ${error.error}`,
+        });
+    }
+    return warnings;
+}
+function collectInjectionWarnings(injection) {
+    const warnings = [];
+    for (const skipped of injection.skippedFiles) {
+        warnings.push({
+            type: 'parse-warning',
+            file: skipped.file,
+            message: `Injection skipped: ${skipped.reason}${skipped.details ? ` - ${skipped.details}` : ''}`,
+        });
+    }
+    for (const file of injection.modifiedFiles) {
+        for (const inj of file.injections) {
+            if (inj.confidence < 90) {
+                warnings.push({
+                    type: 'low-confidence',
+                    file: inj.file,
+                    line: inj.line,
+                    message: `Low confidence (${inj.confidence}%) injection: "${inj.original}" -> "${inj.replacement}"`,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+function generateLocaleDiffs(localeHandling, translation) {
+    const diffs = [];
+    diffs.push({
+        file: localeHandling.sourceLocale.path,
+        changeType: localeHandling.sourceLocale.isNew ? 'created' : 'modified',
+        linesAdded: localeHandling.newKeysCount,
+        linesRemoved: 0,
+    });
+    for (const locale of translation.locales) {
+        const keyCount = countNestedKeys(locale.data);
+        diffs.push({
+            file: locale.path,
+            changeType: 'created',
+            linesAdded: keyCount,
+            linesRemoved: 0,
+        });
+    }
+    return diffs;
+}
+function generateInjectionDiffs(injection) {
+    const diffs = [];
+    for (const file of injection.modifiedFiles) {
+        const originalLines = file.originalContent.split('\n').length;
+        const modifiedLines = file.modifiedContent.split('\n').length;
+        const lineDiff = modifiedLines - originalLines;
+        diffs.push({
+            file: file.file,
+            changeType: 'modified',
+            linesAdded: Math.max(0, lineDiff) + file.injections.length,
+            linesRemoved: file.injections.length,
+            diff: generateUnifiedDiff(file),
+        });
+    }
+    return diffs;
+}
+function countNestedKeys(data) {
+    let count = 0;
+    for (const value of Object.values(data)) {
+        if (typeof value === 'string')
+            count++;
+        else if (typeof value === 'object' && value !== null)
+            count += countNestedKeys(value);
+    }
+    return count;
+}
+function generateUnifiedDiff(file) {
+    const lines = [];
+    lines.push(`--- a/${file.file}`);
+    lines.push(`+++ b/${file.file}`);
+    if (file.importAdded) {
+        lines.push(`@@ +1,1 @@`);
+        lines.push(`+<i18n import added>`);
+    }
+    if (file.hookAdded) {
+        lines.push(`++ <i18n hook added>`);
+    }
+    for (const inj of file.injections) {
+        lines.push(`@@ -${inj.line},1 +${inj.line},1 @@`);
+        lines.push(`-${inj.original}`);
+        lines.push(`+${inj.replacement}`);
+    }
+    return lines.join('\n');
+}
+function formatProcessingTime(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = (ms / 1000).toFixed(1);
+    return `${seconds}s`;
+}
+function generateReadableSummary(stats) {
+    const lines = [
+        '=== Babelize Processing Summary ===',
+        '',
+        `📁 Files scanned: ${stats.filesScanned}`,
+        `📝 Files with translatable strings: ${stats.filesWithStrings}`,
+        `🔤 Strings extracted: ${stats.stringsExtracted}`,
+        `🔑 Keys generated: ${stats.keysGenerated}`,
+        `✏️  Files modified: ${stats.filesModified}`,
+        `💉 Injections applied: ${stats.injectionsApplied}`,
+        `🌍 Locale files created: ${stats.localeFilesCreated}`,
+        `⏱️  Processing time: ${formatProcessingTime(stats.processingTimeMs)}`,
+    ];
+    if (stats.lockfileUsed) {
+        const translated = stats.lockfileKeysTranslated ?? 0;
+        const reused = stats.translationsFromLockfile ?? 0;
+        const changed = stats.lockfileKeysChanged ?? 0;
+        const parts = [];
+        parts.push(`${translated.toLocaleString()} translated`);
+        parts.push(`${reused.toLocaleString()} reused from lockfile`);
+        if (changed > 0) {
+            parts.push(`${changed.toLocaleString()} source updates`);
+        }
+        lines.push(`🔒 Lockfile: ${parts.join(' · ')}`);
+    }
+    if (stats.translationsFromMemory && stats.translationsFromMemory > 0) {
+        lines.push(`🧠 Memory: ${stats.translationsFromMemory.toLocaleString()} strings reused from translation memory`);
+    }
+    return lines.join('\n');
+}

package/dist/modules/sync-detector/index.d.ts

@@ -0,0 +1,2 @@
+export { detectSyncIssues, type SyncDetectionResult, type SyncDetectedString, type SyncMissingLocaleKey } from './sync-detector';
+export { formatSyncNotificationMessage } from './reporter';

package/dist/modules/sync-detector/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSyncNotificationMessage = exports.detectSyncIssues = void 0;
+var sync_detector_1 = require("./sync-detector");
+Object.defineProperty(exports, "detectSyncIssues", { enumerable: true, get: function () { return sync_detector_1.detectSyncIssues; } });
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "formatSyncNotificationMessage", { enumerable: true, get: function () { return reporter_1.formatSyncNotificationMessage; } });

package/dist/modules/sync-detector/reporter.d.ts

@@ -0,0 +1,3 @@
+import type { SyncDetectionResult } from './sync-detector';
+export type { SyncDetectionResult };
+export declare function formatSyncNotificationMessage(result: SyncDetectionResult): string;

package/dist/modules/sync-detector/reporter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSyncNotificationMessage = formatSyncNotificationMessage;
+function formatSyncNotificationMessage(result) {
+    const parts = [];
+    if (result.newStrings.length > 0) {
+        parts.push(`${result.newStrings.length} new string${result.newStrings.length === 1 ? '' : 's'}`);
+    }
+    if (result.changedStrings.length > 0) {
+        parts.push(`${result.changedStrings.length} changed string${result.changedStrings.length === 1 ? '' : 's'}`);
+    }
+    if (result.missingLocaleKeys.length > 0) {
+        parts.push(`${result.missingLocaleKeys.length} missing locale key${result.missingLocaleKeys.length === 1 ? '' : 's'}`);
+    }
+    return `${parts.join(', ')} detected in your last commit`;
+}

package/dist/modules/sync-detector/sync-detector.d.ts

@@ -0,0 +1,39 @@
+import type { WorkspaceInfo } from '../../runtime/types';
+export interface SyncDetectionOptions {
+    /** The project's runs use an LLM translator (BYOK / hosted LLM); default false (NLLB). */
+    llmTranslator?: boolean;
+    /** Framework of the project, when the caller knows it; otherwise guessed from package.json. */
+    framework?: WorkspaceInfo['framework'];
+}
+export interface SyncDetectedString {
+    key: string;
+    value: string;
+    file: string;
+    line: number;
+}
+export interface SyncMissingLocaleKey {
+    key: string;
+    presentIn: string[];
+    missingFrom: string[];
+}
+export interface SyncDetectionResult {
+    newStrings: SyncDetectedString[];
+    changedStrings: SyncDetectedString[];
+    missingLocaleKeys: SyncMissingLocaleKey[];
+    totalIssues: number;
+    commitSha: string;
+    checkedAt: string;
+    filesChecked: string[];
+    filesSkipped: string[];
+}
+/**
+ * Detect sync issues by comparing extracted strings from changed files
+ * against the lockfile and locale files.
+ *
+ * @param projectId      The project identifier (for lockfile lookup)
+ * @param workspacePath  Absolute path to the project workspace
+ * @param changedFiles   List of file paths changed in the push (relative to repo root)
+ * @param commitSha      The commit SHA that triggered this check
+ * @param targetLocales  Target locales configured for this project
+ */
+export declare function detectSyncIssues(projectId: string, workspacePath: string, changedFiles: string[], commitSha: string, targetLocales: string[], options?: SyncDetectionOptions): Promise<SyncDetectionResult>;