langctl 0.0.1 → 0.1.1

package/dist/commands/pull.js

@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { getSupabase } from '../supabase.js';
+import { isAuthenticated, getOrganizationId } from '../auth.js';
+import { exportTranslations } from '../exporters/index.js';
+/**
+ * Get platform-specific output directory
+ */
+function getPlatformDirectory(format) {
+    const platformDirs = {
+        'json': 'i18n',
+        'json-nested': 'i18n',
+        'ios': 'ios',
+        'android': 'android',
+        'flutter': 'flutter'
+    };
+    return platformDirs[format] || 'i18n';
+}
+/**
+ * Resolve project identifier (name, slug, or UUID) to project UUID
+ */
+async function resolveProjectId(identifier, organizationId) {
+    const supabase = getSupabase();
+    // Check if it's already a UUID (format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(identifier)) {
+        // Verify it exists
+        const { data } = await supabase
+            .from('projects')
+            .select('id')
+            .eq('id', identifier)
+            .eq('organization_id', organizationId)
+            .is('deleted_at', null)
+            .single();
+        return data ? identifier : null;
+    }
+    // Try to match by slug (case-insensitive)
+    const { data: bySlug } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('organization_id', organizationId)
+        .ilike('slug', identifier)
+        .is('deleted_at', null)
+        .single();
+    if (bySlug) {
+        return bySlug.id;
+    }
+    // Try to match by name (case-insensitive)
+    const { data: byName } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('organization_id', organizationId)
+        .ilike('name', identifier)
+        .is('deleted_at', null)
+        .single();
+    if (byName) {
+        return byName.id;
+    }
+    return null;
+}
+export async function pullCommand(projectIdentifier, options) {
+    // Check authentication
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        return;
+    }
+    const organizationId = getOrganizationId();
+    if (!organizationId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl init" again.\n'));
+        return;
+    }
+    // Set defaults
+    const format = (options.format || 'json');
+    const publishedOnly = options.publishedOnly !== false; // Default to true
+    const specificLanguage = options.language; // If not specified, pull all languages
+    const baseDir = options.dir || './translations'; // Default to ./translations
+    // Validate format
+    const validFormats = ['json', 'json-nested', 'ios', 'android', 'flutter'];
+    if (!validFormats.includes(format)) {
+        console.log(chalk.red(`✗ Invalid format: ${format}`));
+        console.log(chalk.yellow(`Valid formats: ${validFormats.join(', ')}\n`));
+        return;
+    }
+    const spinner = ora('Resolving project...').start();
+    try {
+        const supabase = getSupabase();
+        // Resolve project identifier to UUID
+        const projectId = await resolveProjectId(projectIdentifier, organizationId);
+        if (!projectId) {
+            spinner.fail(chalk.red(`Project "${projectIdentifier}" not found`));
+            console.log(chalk.yellow('\nRun "langctl projects list" to see available projects.\n'));
+            return;
+        }
+        // Fetch project details
+        spinner.text = 'Fetching project...';
+        const { data: project, error: projectError } = await supabase
+            .from('projects')
+            .select('id, name, slug, languages, default_language')
+            .eq('id', projectId)
+            .eq('organization_id', organizationId)
+            .is('deleted_at', null)
+            .single();
+        if (projectError || !project) {
+            spinner.fail(chalk.red('Project not found or access denied'));
+            return;
+        }
+        // Determine which languages to pull
+        let languagesToPull;
+        if (specificLanguage) {
+            // Check if specified language exists in project
+            if (!project.languages.includes(specificLanguage)) {
+                spinner.fail(chalk.red(`Language "${specificLanguage}" not found in project`));
+                console.log(chalk.yellow(`Available languages: ${project.languages.join(', ')}\n`));
+                return;
+            }
+            languagesToPull = [specificLanguage];
+        }
+        else {
+            // Pull all languages
+            languagesToPull = project.languages;
+        }
+        spinner.text = `Fetching translations for "${project.name}"...`;
+        // Fetch translation keys
+        let query = supabase
+            .from('translation_keys')
+            .select('key, translations, description, module')
+            .eq('project_id', projectId)
+            .is('deleted_at', null);
+        if (publishedOnly) {
+            query = query.eq('published', true);
+        }
+        const { data: keys, error: keysError } = await query;
+        if (keysError) {
+            spinner.fail(chalk.red('Failed to fetch translations'));
+            console.error(chalk.red(`Error: ${keysError.message}\n`));
+            return;
+        }
+        if (!keys || keys.length === 0) {
+            spinner.fail(chalk.yellow('No translations found'));
+            console.log(chalk.yellow(`\nNo ${publishedOnly ? 'published ' : ''}translations found for this project.\n`));
+            return;
+        }
+        spinner.succeed(chalk.green(`Found ${keys.length} translation keys`));
+        // Get platform directory
+        const platformDir = getPlatformDirectory(format);
+        // Export translations for each language
+        const exportedFiles = [];
+        for (const language of languagesToPull) {
+            spinner.start(`Exporting ${language}...`);
+            const result = exportTranslations(keys, language, format);
+            // Determine output path
+            let outputPath;
+            if (options.output) {
+                // If custom output is specified and multiple languages, append language code
+                if (languagesToPull.length > 1) {
+                    const ext = result.filename.split('.').pop();
+                    const base = options.output.replace(/\.[^.]+$/, '');
+                    outputPath = `${base}-${language}.${ext}`;
+                }
+                else {
+                    outputPath = options.output;
+                }
+            }
+            else {
+                // Default output path: <baseDir>/<platform>/<language>.<ext>
+                const ext = result.filename.split('.').pop();
+                outputPath = join(baseDir, platformDir, `${language}.${ext}`);
+            }
+            // Create directory if it doesn't exist
+            const dir = dirname(outputPath);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(outputPath, result.content, 'utf-8');
+            exportedFiles.push(outputPath);
+            spinner.succeed(chalk.green(`Exported ${language} → ${outputPath}`));
+        }
+        // Summary
+        console.log(chalk.hex('#10b981').bold('\n📦 Export Summary:'));
+        console.log(chalk.white(`  Project: ${project.name}`));
+        console.log(chalk.white(`  Format: ${format}`));
+        console.log(chalk.white(`  Platform: ${platformDir}`));
+        console.log(chalk.white(`  Output: ${baseDir}`));
+        console.log(chalk.white(`  Keys: ${keys.length}`));
+        console.log(chalk.white(`  Languages: ${languagesToPull.join(', ')}`));
+        console.log(chalk.white(`  Files: ${exportedFiles.length}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to pull translations'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+    }
+}
+//# sourceMappingURL=pull.js.map

package/dist/config.d.ts

@@ -0,0 +1,47 @@
+export interface LangctlConfig {
+    apiKey?: string;
+    organizationId?: string;
+    organizationName?: string;
+    defaultProject?: string;
+    defaultLanguage?: string;
+}
+declare class ConfigManager {
+    private config;
+    private configDir;
+    constructor();
+    /**
+     * Get a configuration value
+     */
+    get<K extends keyof LangctlConfig>(key: K): LangctlConfig[K] | undefined;
+    /**
+     * Set a configuration value
+     */
+    set<K extends keyof LangctlConfig>(key: K, value: LangctlConfig[K]): void;
+    /**
+     * Get all configuration
+     */
+    getAll(): LangctlConfig;
+    /**
+     * Set multiple configuration values
+     */
+    setAll(config: Partial<LangctlConfig>): void;
+    /**
+     * Delete a configuration value
+     */
+    delete(key: keyof LangctlConfig): void;
+    /**
+     * Clear all configuration
+     */
+    clear(): void;
+    /**
+     * Check if user is authenticated
+     */
+    isConfigured(): boolean;
+    /**
+     * Get the configuration file path
+     */
+    getConfigPath(): string;
+}
+export declare const config: ConfigManager;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,69 @@
+import Conf from 'conf';
+import { join } from 'path';
+import { homedir } from 'os';
+class ConfigManager {
+    constructor() {
+        this.configDir = join(homedir(), '.langctl');
+        this.config = new Conf({
+            projectName: 'langctl',
+            cwd: this.configDir,
+            configName: 'config'
+        });
+    }
+    /**
+     * Get a configuration value
+     */
+    get(key) {
+        return this.config.get(key);
+    }
+    /**
+     * Set a configuration value
+     */
+    set(key, value) {
+        this.config.set(key, value);
+    }
+    /**
+     * Get all configuration
+     */
+    getAll() {
+        return this.config.store;
+    }
+    /**
+     * Set multiple configuration values
+     */
+    setAll(config) {
+        Object.entries(config).forEach(([key, value]) => {
+            if (value !== undefined) {
+                this.config.set(key, value);
+            }
+        });
+    }
+    /**
+     * Delete a configuration value
+     */
+    delete(key) {
+        this.config.delete(key);
+    }
+    /**
+     * Clear all configuration
+     */
+    clear() {
+        this.config.clear();
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isConfigured() {
+        return !!(this.config.get('apiKey') &&
+            this.config.get('organizationId'));
+    }
+    /**
+     * Get the configuration file path
+     */
+    getConfigPath() {
+        return this.config.path;
+    }
+}
+// Singleton instance
+export const config = new ConfigManager();
+//# sourceMappingURL=config.js.map

package/dist/exporters/index.d.ts

@@ -0,0 +1,36 @@
+export interface TranslationKey {
+    key: string;
+    translations: Record<string, string>;
+    description?: string;
+    module?: string;
+}
+export type ExportFormat = 'json' | 'json-nested' | 'ios' | 'android' | 'flutter';
+export interface ExportResult {
+    content: string;
+    filename: string;
+}
+/**
+ * Export as flat JSON (simple key-value pairs)
+ */
+export declare function exportFlatJson(keys: TranslationKey[], languageCode: string): ExportResult;
+/**
+ * Export as nested JSON (organized by key structure)
+ */
+export declare function exportNestedJson(keys: TranslationKey[], languageCode: string): ExportResult;
+/**
+ * Export as iOS .strings format
+ */
+export declare function exportIosStrings(keys: TranslationKey[], languageCode: string): ExportResult;
+/**
+ * Export as Android XML format
+ */
+export declare function exportAndroidXml(keys: TranslationKey[], languageCode: string): ExportResult;
+/**
+ * Export as Flutter ARB format
+ */
+export declare function exportFlutterArb(keys: TranslationKey[], languageCode: string): ExportResult;
+/**
+ * Export translations in the specified format
+ */
+export declare function exportTranslations(keys: TranslationKey[], languageCode: string, format: ExportFormat): ExportResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/exporters/index.js

@@ -0,0 +1,214 @@
+/**
+ * Helper: Set nested value in object based on dot-notation key
+ */
+function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!current[key] || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+}
+/**
+ * Helper: Convert i18n format {{param}} to Android format %1$s, %2$s, etc.
+ */
+function convertToAndroidFormat(text) {
+    const matches = text.match(/\{\{([^}]+)\}\}/g);
+    if (!matches)
+        return text;
+    let result = text;
+    matches.forEach((match, index) => {
+        const paramNum = index + 1;
+        result = result.replace(match, `%${paramNum}$s`);
+    });
+    return result;
+}
+/**
+ * Helper: Convert i18n format {{param}} to iOS format %1$@, %2$@, etc.
+ */
+function convertToIosFormat(text) {
+    const matches = text.match(/\{\{([^}]+)\}\}/g);
+    if (!matches)
+        return text;
+    let result = text;
+    matches.forEach((match, index) => {
+        const paramNum = index + 1;
+        result = result.replace(match, `%${paramNum}$@`);
+    });
+    return result;
+}
+/**
+ * Helper: Convert i18n format {{param}} to Flutter format {param}
+ */
+function convertToFlutterFormat(text) {
+    return text.replace(/\{\{([^}]+)\}\}/g, '{$1}');
+}
+/**
+ * Helper: Extract placeholder names from Flutter format {param}
+ */
+function extractPlaceholders(text) {
+    const matches = text.match(/\{([^}]+)\}/g);
+    if (!matches)
+        return [];
+    return matches.map(match => match.slice(1, -1));
+}
+/**
+ * Helper: Escape XML special characters
+ */
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Helper: Escape .strings special characters
+ */
+function escapeStrings(text) {
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+/**
+ * Export as flat JSON (simple key-value pairs)
+ */
+export function exportFlatJson(keys, languageCode) {
+    const translations = {};
+    keys.forEach(key => {
+        const translation = key.translations[languageCode];
+        if (translation) {
+            translations[key.key] = translation;
+        }
+    });
+    return {
+        content: JSON.stringify(translations, null, 2),
+        filename: `${languageCode}.json`
+    };
+}
+/**
+ * Export as nested JSON (organized by key structure)
+ */
+export function exportNestedJson(keys, languageCode) {
+    const translations = {};
+    keys.forEach(key => {
+        const translation = key.translations[languageCode];
+        if (translation) {
+            setNestedValue(translations, key.key, translation);
+        }
+    });
+    return {
+        content: JSON.stringify(translations, null, 2),
+        filename: `${languageCode}.json`
+    };
+}
+/**
+ * Export as iOS .strings format
+ */
+export function exportIosStrings(keys, languageCode) {
+    let content = '';
+    keys.forEach(key => {
+        const translation = key.translations[languageCode];
+        if (translation) {
+            const iosTranslation = convertToIosFormat(translation);
+            const escapedTranslation = escapeStrings(iosTranslation);
+            if (key.description) {
+                content += `/* ${key.description} */\n`;
+            }
+            content += `"${key.key}" = "${escapedTranslation}";\n\n`;
+        }
+    });
+    return {
+        content,
+        filename: `Localizable.strings`
+    };
+}
+/**
+ * Export as Android XML format
+ */
+export function exportAndroidXml(keys, languageCode) {
+    let xml = '<?xml version="1.0" encoding="utf-8"?>\n';
+    xml += '<resources>\n';
+    keys.forEach(key => {
+        const translation = key.translations[languageCode];
+        if (translation) {
+            const androidTranslation = convertToAndroidFormat(translation);
+            const escapedTranslation = escapeXml(androidTranslation);
+            if (key.description) {
+                xml += `  <!-- ${escapeXml(key.description)} -->\n`;
+            }
+            xml += `  <string name="${key.key}">${escapedTranslation}</string>\n`;
+        }
+    });
+    xml += '</resources>\n';
+    return {
+        content: xml,
+        filename: `strings.xml`
+    };
+}
+/**
+ * Export as Flutter ARB format
+ */
+export function exportFlutterArb(keys, languageCode) {
+    const arb = {
+        '@@locale': languageCode,
+        '@@last_modified': new Date().toISOString()
+    };
+    keys.forEach(key => {
+        const translation = key.translations[languageCode];
+        if (translation) {
+            const flutterTranslation = convertToFlutterFormat(translation);
+            arb[key.key] = flutterTranslation;
+            // Add metadata
+            const metadata = {};
+            if (key.description) {
+                metadata.description = key.description;
+            }
+            // Extract placeholders from translation
+            const placeholders = extractPlaceholders(flutterTranslation);
+            if (placeholders.length > 0) {
+                metadata.placeholders = {};
+                placeholders.forEach(placeholder => {
+                    metadata.placeholders[placeholder] = {
+                        type: 'String'
+                    };
+                });
+            }
+            if (Object.keys(metadata).length > 0) {
+                arb[`@${key.key}`] = metadata;
+            }
+        }
+    });
+    return {
+        content: JSON.stringify(arb, null, 2),
+        filename: `intl_${languageCode}.arb`
+    };
+}
+/**
+ * Export translations in the specified format
+ */
+export function exportTranslations(keys, languageCode, format) {
+    switch (format) {
+        case 'json':
+            return exportFlatJson(keys, languageCode);
+        case 'json-nested':
+            return exportNestedJson(keys, languageCode);
+        case 'ios':
+            return exportIosStrings(keys, languageCode);
+        case 'android':
+            return exportAndroidXml(keys, languageCode);
+        case 'flutter':
+            return exportFlutterArb(keys, languageCode);
+        default:
+            throw new Error(`Unsupported export format: ${format}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map