@devcoda/lokal-cli 1.0.1

package/bin/lokal

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/index.js');

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@devcoda/lokal-cli",
+    "version": "1.0.1",
+    "description": "CLI tool for LOKAL - Automates string extraction and AI translations",
+    "main": "./dist/index.js",
+    "bin": {
+        "lokal": "./bin/lokal"
+    },
+    "scripts": {
+        "dev": "tsup --watch",
+        "clean": "rm -rf dist",
+        "lint": "echo 'Use root lint command'"
+    },
+    "dependencies": {
+        "lokal-core": "*",
+        "chalk": "^4.1.2",
+        "commander": "^11.1.0",
+        "ora": "^5.4.1"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "eslint": "^8.57.0",
+        "tsup": "^8.0.0",
+        "typescript": "^5.3.0"
+    },
+    "peerDependencies": {},
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}

package/src/commands/init.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+
+interface InitOptions {
+    locales?: string;
+    defaultLocale?: string;
+    force?: boolean;
+}
+
+/**
+ * Create the initial lokal config file and directory structure
+ */
+export async function initCommand(options: InitOptions): Promise<void> {
+    const spinner = ora('Initializing LOKAL...').start();
+
+    try {
+        const projectRoot = process.cwd();
+        const configPath = path.join(projectRoot, 'lokal.config.js');
+        const localesDir = path.join(projectRoot, 'locales');
+
+        // Parse locales
+        const locales = options.locales
+            ? options.locales.split(',').map(l => l.trim())
+            : ['en'];
+
+        const defaultLocale = options.defaultLocale || locales[0];
+
+        // Check if already initialized
+        if (fs.existsSync(configPath) && !options.force) {
+            spinner.warn(chalk.yellow('LOKAL is already initialized. Use --force to reinitialize.'));
+            return;
+        }
+
+        // Create config file
+        const configContent = `module.exports = {
+  // Supported locales
+  locales: ${JSON.stringify(locales)},
+  
+  // Default locale
+  defaultLocale: '${defaultLocale}',
+  
+  // Function name for translations (t("key"))
+  functionName: 't',
+  
+  // Component name for translations (<T>key</T>)
+  componentName: 'T',
+  
+  // Source directory to scan
+  sourceDir: './src',
+  
+  // Output directory for locale files
+  outputDir: './locales',
+  
+  // AI Translation settings (optional)
+  // ai: {
+  //   provider: 'openai', // or 'gemini'
+  //   apiKey: process.env.OPENAI_API_KEY,
+  //   model: 'gpt-4'
+  // }
+};
+`;
+
+        fs.writeFileSync(configPath, configContent, 'utf-8');
+        spinner.succeed(chalk.green(`Created ${chalk.bold('lokal.config.js')}`));
+
+        // Create locales directory with default locale
+        if (!fs.existsSync(localesDir)) {
+            fs.mkdirSync(localesDir, { recursive: true });
+        }
+
+        // Create default locale file
+        const defaultLocalePath = path.join(localesDir, `${defaultLocale}.json`);
+        if (!fs.existsSync(defaultLocalePath)) {
+            const initialData = {
+                _meta: {
+                    generated: new Date().toISOString(),
+                    description: 'Default locale file'
+                }
+            };
+            fs.writeFileSync(defaultLocalePath, JSON.stringify(initialData, null, 2), 'utf-8');
+            spinner.succeed(chalk.green(`Created ${chalk.bold(`locales/${defaultLocale}.json`)}`));
+        }
+
+        // Create .gitignore entry for locale files if .gitignore exists
+        const gitignorePath = path.join(projectRoot, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+            if (!gitignoreContent.includes('/locales/')) {
+                fs.appendFileSync(gitignorePath, '\n# LOKAL translations\nlocales/\n');
+                spinner.succeed(chalk.green('Updated .gitignore'));
+            }
+        }
+
+        console.log(chalk.bold('\n✓ LOKAL initialized successfully!'));
+        console.log(chalk.gray('\nNext steps:'));
+        console.log(chalk.gray('  1. Add translation strings to your code using t("key") or <T>key</T>'));
+        console.log(chalk.gray('  2. Run ') + chalk.cyan('npx lokal scan') + chalk.gray(' to extract strings'));
+        console.log(chalk.gray('  3. Run ') + chalk.cyan('npx lokal translate') + chalk.gray(' to translate with AI'));
+
+    } catch (error) {
+        spinner.fail(chalk.red(`Failed to initialize: ${error}`));
+        process.exit(1);
+    }
+}
+
+export function registerInitCommand(program: Command): void {
+    program
+        .command('init')
+        .description('Initialize LOKAL in your project')
+        .option('-l, --locales <locales>', 'Comma-separated list of locales', 'en')
+        .option('-d, --default-locale <locale>', 'Default locale', 'en')
+        .option('-f, --force', 'Force reinitialization', false)
+        .action(initCommand);
+}

package/src/commands/scan.ts

@@ -0,0 +1,131 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ASTParser, ConfigLoader, FileStorage, type ExtractedString } from 'lokal-core';
+
+interface ScanOptions {
+    config?: string;
+    output?: string;
+    verbose?: boolean;
+}
+
+/**
+ * Scan source files for translation strings and update locale files
+ */
+export async function scanCommand(options: ScanOptions): Promise<void> {
+    const spinner = ora('Scanning for translation strings...').start();
+
+    try {
+        // Load config
+        const configLoader = new ConfigLoader();
+        let config;
+
+        if (options.config) {
+            config = configLoader.loadSync(options.config);
+        } else {
+            config = await configLoader.load();
+        }
+
+        const projectRoot = process.cwd();
+        const sourceDir = path.resolve(projectRoot, config.sourceDir);
+        const outputDir = options.output
+            ? path.resolve(projectRoot, options.output)
+            : path.resolve(projectRoot, config.outputDir);
+
+        spinner.text = `Scanning ${chalk.cyan(sourceDir)}...`;
+
+        // Create parser
+        const parser = new ASTParser({
+            filePath: sourceDir,
+            functionName: config.functionName,
+            componentName: config.componentName,
+        });
+
+        // Scan directory
+        const result = parser.scanDirectory(sourceDir);
+
+        if (result.errors.length > 0 && options.verbose) {
+            for (const error of result.errors) {
+                spinner.warn(chalk.yellow(error));
+            }
+        }
+
+        spinner.succeed(chalk.green(`Found ${chalk.bold(result.strings.length)} translation strings`));
+
+        if (result.strings.length === 0) {
+            spinner.info(chalk.gray('No strings found. Make sure to use t("key") or <T>key</T> in your code.'));
+            return;
+        }
+
+        // Create storage
+        const storage = new FileStorage(outputDir);
+
+        // Create unique key-value map
+        const uniqueStrings = new Map<string, ExtractedString>();
+        for (const str of result.strings) {
+            uniqueStrings.set(str.key, str);
+        }
+
+        // Get the default locale
+        const defaultLocale = config.defaultLocale;
+        const existingLocale = storage.loadLocale(defaultLocale);
+
+        // Merge with existing keys
+        let existingData: Record<string, any> = {};
+        if (existingLocale) {
+            existingData = existingLocale.data as Record<string, any>;
+        }
+
+        // Convert extracted strings to flat key-value object
+        const newData: Record<string, string> = {};
+        for (const [key, value] of uniqueStrings) {
+            // Use the key itself as the translation value for now
+            newData[key] = existingData[key] || value.value;
+        }
+
+        // Save the merged data
+        const mergedData = storage.mergeLocaleData(defaultLocale, newData);
+        storage.saveLocale(defaultLocale, mergedData);
+
+        spinner.succeed(chalk.green(`Updated ${chalk.bold(`locales/${defaultLocale}.json`)}`));
+
+        // Show sample of extracted strings
+        if (options.verbose) {
+            console.log(chalk.bold('\nExtracted strings:'));
+            const sampleKeys = Array.from(uniqueStrings.keys()).slice(0, 10);
+            for (const key of sampleKeys) {
+                console.log(chalk.gray(`  • ${key}`));
+            }
+            if (uniqueStrings.size > 10) {
+                console.log(chalk.gray(`  ... and ${uniqueStrings.size - 10} more`));
+            }
+        }
+
+        // Check for other locales that need translation
+        const locales = storage.getAvailableLocales();
+        const otherLocales = locales.filter(l => l !== defaultLocale);
+
+        if (otherLocales.length > 0) {
+            console.log(chalk.gray(`\nOther locales detected: ${otherLocales.join(', ')}`));
+            console.log(chalk.gray('Run ') + chalk.cyan('npx lokal translate') + chalk.gray(' to translate missing strings'));
+        }
+
+    } catch (error) {
+        spinner.fail(chalk.red(`Scan failed: ${error}`));
+        if (options.verbose) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}
+
+export function registerScanCommand(program: Command): void {
+    program
+        .command('scan')
+        .description('Scan source files for translation strings')
+        .option('-c, --config <path>', 'Path to config file')
+        .option('-o, --output <path>', 'Output directory for locale files')
+        .option('-v, --verbose', 'Verbose output', false)
+        .action(scanCommand);
+}

package/src/commands/translate.ts

@@ -0,0 +1,153 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+    ConfigLoader,
+    FileStorage,
+    AITranslator,
+    TranslationProviderFactory,
+    type LocaleData
+} from 'lokal-core';
+
+interface TranslateOptions {
+    config?: string;
+    locale?: string;
+    all?: boolean;
+    verbose?: boolean;
+}
+
+/**
+ * Translate missing strings using AI
+ */
+export async function translateCommand(options: TranslateOptions): Promise<void> {
+    const spinner = ora('Loading configuration...').start();
+
+    try {
+        // Load config
+        const configLoader = new ConfigLoader();
+        let config;
+
+        if (options.config) {
+            config = configLoader.loadSync(options.config);
+        } else {
+            config = await configLoader.load();
+        }
+
+        // Check if AI is configured
+        if (!config.ai) {
+            spinner.fail(chalk.red('AI provider not configured. Add ai configuration to lokal.config.js'));
+            console.log(chalk.gray('\nExample configuration:'));
+            console.log(chalk.gray('  ai: {'));
+            console.log(chalk.gray('    provider: "openai",'));
+            console.log(chalk.gray('    apiKey: process.env.OPENAI_API_KEY'));
+            console.log(chalk.gray('  }'));
+            process.exit(1);
+        }
+
+        const apiKey = config.ai.apiKey || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            spinner.fail(chalk.red('No API key found. Set ai.apiKey in config or environment variable.'));
+            process.exit(1);
+        }
+
+        spinner.text = 'Initializing AI translator...';
+
+        // Create provider
+        const provider = TranslationProviderFactory.create(
+            config.ai.provider,
+            apiKey,
+            config.ai.model
+        );
+
+        // Create translator
+        const translator = new AITranslator(provider);
+
+        const projectRoot = process.cwd();
+        const outputDir = path.resolve(projectRoot, config.outputDir);
+        const storage = new FileStorage(outputDir);
+
+        spinner.succeed('AI translator ready');
+
+        // Determine which locales to translate
+        let targetLocales: string[] = [];
+        const availableLocales = config.locales || [];
+
+        if (options.all) {
+            targetLocales = availableLocales.filter(l => l !== config.defaultLocale);
+        } else if (options.locale) {
+            targetLocales = [options.locale];
+        } else {
+            // Default: translate to first non-default locale
+            targetLocales = availableLocales.filter(l => l !== config.defaultLocale).slice(0, 1);
+        }
+
+        if (targetLocales.length === 0) {
+            spinner.warn(chalk.yellow('No target locales to translate. Add more locales to your config.'));
+            return;
+        }
+
+        // Load source locale data
+        const sourceLocale = config.defaultLocale;
+        const sourceData = storage.loadLocale(sourceLocale);
+
+        if (!sourceData) {
+            spinner.fail(chalk.red(`Source locale ${sourceLocale} not found. Run 'lokal scan' first.`));
+            process.exit(1);
+        }
+
+        // Translate to each target locale
+        for (const targetLocale of targetLocales) {
+            const translateSpinner = ora(`Translating to ${chalk.cyan(targetLocale)}...`).start();
+
+            // Load existing target data (if any)
+            const targetLocaleFile = storage.loadLocale(targetLocale);
+            const targetData: LocaleData = targetLocaleFile ? targetLocaleFile.data : {};
+
+            // Translate missing keys
+            const translatedData = await translator.translateMissingKeys(
+                sourceData.data,
+                targetData,
+                sourceLocale,
+                targetLocale
+            );
+
+            // Save translated data
+            storage.saveLocale(targetLocale, translatedData);
+
+            translateSpinner.succeed(chalk.green(`Translated to ${chalk.bold(targetLocale)}`));
+
+            if (options.verbose) {
+                // Show sample translations
+                const keys = Object.keys(translatedData).slice(0, 5);
+                for (const key of keys) {
+                    const value = translatedData[key];
+                    if (typeof value === 'string') {
+                        console.log(chalk.gray(`  ${key}: ${value}`));
+                    }
+                }
+            }
+        }
+
+        console.log(chalk.bold('\n✓ Translation complete!'));
+        console.log(chalk.gray(`\nRun `) + chalk.cyan('npx lokal scan') + chalk.gray(' to see updated translations'));
+
+    } catch (error) {
+        spinner.fail(chalk.red(`Translation failed: ${error}`));
+        if (options.verbose) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}
+
+export function registerTranslateCommand(program: Command): void {
+    program
+        .command('translate')
+        .description('Translate missing strings using AI')
+        .option('-c, --config <path>', 'Path to config file')
+        .option('-l, --locale <locale>', 'Specific locale to translate')
+        .option('-a, --all', 'Translate all locales', false)
+        .option('-v, --verbose', 'Verbose output', false)
+        .action(translateCommand);
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { registerInitCommand } from './commands/init';
+import { registerScanCommand } from './commands/scan';
+import { registerTranslateCommand } from './commands/translate';
+
+const program = new Command();
+
+program
+    .name('lokal')
+    .description('AI-powered localization ecosystem for React and React Native')
+    .version('1.0.0');
+
+// Register commands
+registerInitCommand(program);
+registerScanCommand(program);
+registerTranslateCommand(program);
+
+// Global options
+program
+    .option('-v, --verbose', 'Verbose output')
+    .hook('preAction', (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.verbose) {
+            process.env.LOKAL_VERBOSE = 'true';
+        }
+    });
+
+// Handle unknown commands
+program.on('command:*', () => {
+    console.error(chalk.red(`Invalid command: ${program.args.join(' ')}`));
+    console.log(chalk.gray(`See ${chalk.cyan('--help')} for a list of available commands.`));
+    process.exit(1);
+});
+
+// Run the program
+program.parse(process.argv);

package/src/types/lokal-core.d.ts

@@ -0,0 +1,127 @@
+declare module 'lokal-core' {
+    export class ASTParser {
+        constructor(options: {
+            filePath: string;
+            functionName?: string;
+            componentName?: string;
+        });
+        scanDirectory(dirPath: string): ScanResult;
+    }
+
+    export interface ExtractedString {
+        key: string;
+        value: string;
+        location?: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    }
+
+    export interface ScanResult {
+        strings: ExtractedString[];
+        errors: string[];
+    }
+
+    export interface ScanOptions {
+        filePath: string;
+        functionName?: string;
+        componentName?: string;
+    }
+
+    export class ConfigLoader {
+        load(configPath?: string): Promise<LokalConfig>;
+        loadSync(configPath?: string): LokalConfig;
+    }
+
+    export interface LokalConfig {
+        sourceDir: string;
+        outputDir: string;
+        defaultLocale: string;
+        functionName: string;
+        componentName: string;
+        locales?: string[];
+        ai?: {
+            provider: 'openai' | 'gemini';
+            apiKey: string;
+            model?: string;
+        };
+    }
+
+    export const defaultConfig: LokalConfig;
+
+    export class FileStorage {
+        constructor(outputDir: string);
+        loadLocale(locale: string): LocaleFile | null;
+        saveLocale(locale: string, data: LocaleData): void;
+        mergeLocaleData(locale: string, newData: Record<string, string>): LocaleData;
+        getAvailableLocales(): string[];
+    }
+
+    export interface LocaleData {
+        [key: string]: string;
+    }
+
+    export interface LocaleFile {
+        locale: string;
+        data: LocaleData;
+    }
+
+    export class ContentHasher {
+        static hash(content: string): string;
+    }
+
+    export class AITranslator {
+        constructor(provider: TranslationProvider, options?: {
+            batchSize?: number;
+        });
+        translateBatch(request: TranslationBatch): Promise<TranslationResult[]>;
+        translateMissingKeys(
+            sourceData: Record<string, string>,
+            targetData: Record<string, string>,
+            sourceLocale: string,
+            targetLocale: string
+        ): Promise<Record<string, string>>;
+    }
+
+    export interface TranslationProvider {
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export interface TranslationRequest {
+        text: string;
+        sourceLocale: string;
+        targetLocale: string;
+        context?: string;
+    }
+
+    export interface TranslationResult {
+        translatedText: string;
+        success: boolean;
+        error?: string;
+    }
+
+    export interface TranslationBatch {
+        items: TranslationRequest[];
+    }
+
+    export class OpenAIProvider implements TranslationProvider {
+        constructor(apiKey: string, options?: {
+            model?: string;
+            temperature?: number;
+        });
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export class GeminiProvider implements TranslationProvider {
+        constructor(apiKey: string, options?: {
+            model?: string;
+            temperature?: number;
+        });
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export class TranslationProviderFactory {
+        static create(provider: 'openai' | 'gemini', apiKey: string, model?: string): TranslationProvider;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "module": "ESNext",
+        "target": "ES2020"
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}