@rglabs/butterfly 2.0.1

package/dist/commands/setup.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { render, Box, Text } from 'ink';
+import { SetupForm } from '../components/SetupForm.js';
+import { saveAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { copyDocs } from '../utils/docs.js';
+const shared = { api: null, ink: null };
+const SetupCommand = ({ onExit }) => {
+    const [status, setStatus] = React.useState('input');
+    const [errorMessage, setErrorMessage] = React.useState('');
+    const handleSubmit = async (config) => {
+        setStatus('testing');
+        try {
+            await saveAuthConfig(config);
+            const api = new ButterflyAPI(config);
+            await api.authenticate();
+            if (api.needs2FA) {
+                shared.api = api;
+                if (shared.ink) {
+                    shared.ink.clear();
+                    shared.ink.unmount();
+                }
+                return;
+            }
+            await copyDocs();
+            setStatus('success');
+            setTimeout(() => onExit(0), 2000);
+        }
+        catch (error) {
+            setErrorMessage(error instanceof Error ? error.message : 'Unknown error');
+            setStatus('error');
+            setTimeout(() => onExit(1), 3000);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        status === 'input' && React.createElement(SetupForm, { onSubmit: handleSubmit }),
+        status === 'testing' && React.createElement(Text, { color: "yellow" }, "Testing connection..."),
+        status === 'success' && React.createElement(Text, { color: "green" }, "\u2713 Configuration saved successfully in .butterfly/config.json, docs copied to docs/ and commands to .claude/commands/"),
+        status === 'error' && React.createElement(Text, { color: "red" },
+            "\u2717 Error: ",
+            errorMessage)));
+};
+async function handlePending2FA() {
+    if (!shared.api)
+        return;
+    try {
+        await shared.api.complete2FA();
+        await copyDocs();
+        console.log('\n✓ Configuration saved and authenticated successfully!');
+    }
+    catch (error) {
+        console.error('\nAuthentication failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export default async () => {
+    shared.api = null;
+    shared.ink = render(React.createElement(SetupCommand, { onExit: (code) => {
+            if (shared.ink)
+                shared.ink.unmount();
+            process.exit(code);
+        } }));
+    await shared.ink.waitUntilExit();
+    await handlePending2FA();
+};
+//# sourceMappingURL=setup.js.map

package/dist/commands/start-poc.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => void;
+export default _default;
+//# sourceMappingURL=start-poc.d.ts.map

package/dist/commands/start-poc.js

@@ -0,0 +1,55 @@
+import React from 'react';
+import { render, Box, Text } from 'ink';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+const POC_REPO_URL = 'git@github.com:butterfly-team/POC-Generator.git';
+const REPO_FOLDER = 'POC-Generator';
+const StartPocCommand = () => {
+    const [status, setStatus] = React.useState('checking');
+    const [errorMessage, setErrorMessage] = React.useState('');
+    React.useEffect(() => {
+        const cloneRepo = async () => {
+            const targetPath = path.join(process.cwd(), REPO_FOLDER);
+            if (existsSync(targetPath)) {
+                setStatus('exists');
+                setTimeout(() => process.exit(0), 1500);
+                return;
+            }
+            setStatus('cloning');
+            try {
+                execSync(`git clone ${POC_REPO_URL}`, {
+                    stdio: 'inherit',
+                    cwd: process.cwd()
+                });
+                setStatus('success');
+                setTimeout(() => process.exit(0), 1000);
+            }
+            catch (error) {
+                let message = 'Failed to clone repository';
+                if (error && typeof error === 'object' && 'stderr' in error) {
+                    message = String(error.stderr);
+                }
+                else if (error instanceof Error) {
+                    message = error.message;
+                }
+                setErrorMessage(message);
+                setStatus('error');
+                setTimeout(() => process.exit(1), 2000);
+            }
+        };
+        cloneRepo();
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column" },
+        status === 'checking' && React.createElement(Text, { color: "yellow" }, "Checking..."),
+        status === 'cloning' && React.createElement(Text, { color: "yellow" }, "Cloning POC-Generator repository..."),
+        status === 'success' && React.createElement(Text, { color: "green" }, "POC-Generator cloned successfully!"),
+        status === 'exists' && React.createElement(Text, { color: "cyan" }, "POC-Generator folder already exists. Skipping clone."),
+        status === 'error' && React.createElement(Text, { color: "red" },
+            "Error: ",
+            errorMessage)));
+};
+export default () => {
+    render(React.createElement(StartPocCommand, null));
+};
+//# sourceMappingURL=start-poc.js.map

package/dist/commands/sync-docs.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=sync-docs.d.ts.map

package/dist/commands/sync-docs.js

@@ -0,0 +1,27 @@
+import { syncDocs } from '../utils/docs.js';
+export default async () => {
+    console.log('Syncing documentation and commands...');
+    const result = await syncDocs();
+    if (result.success) {
+        const docFiles = result.syncedFiles.filter(f => f.startsWith('docs/') || f === 'CLAUDE.md');
+        const commandFiles = result.syncedFiles.filter(f => f.startsWith('.claude/commands/'));
+        console.log(`\x1b[32m✓ Synced ${result.syncedFiles.length} file(s)\x1b[0m`);
+        if (docFiles.length > 0) {
+            console.log(`\n\x1b[36mDocumentation (${docFiles.length}):\x1b[0m`);
+            for (const file of docFiles) {
+                console.log(`  - ${file}`);
+            }
+        }
+        if (commandFiles.length > 0) {
+            console.log(`\n\x1b[36mSlash Commands (${commandFiles.length}):\x1b[0m`);
+            for (const file of commandFiles) {
+                console.log(`  - ${file}`);
+            }
+        }
+    }
+    else {
+        console.log(`\x1b[31m✗ Failed to sync: ${result.error}\x1b[0m`);
+        process.exit(1);
+    }
+};
+//# sourceMappingURL=sync-docs.js.map

package/dist/commands/translate.d.ts

@@ -0,0 +1,13 @@
+interface TranslateCommandOptions {
+    lang?: string;
+    langId?: string;
+    source?: string;
+    sourceId?: string;
+    text?: string;
+    file?: string;
+    format?: 'json' | 'table';
+    limit?: string;
+}
+export default function translateCommand(operation: string, options: TranslateCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=translate.d.ts.map

package/dist/commands/translate.js

@@ -0,0 +1,401 @@
+import { promises as fs } from 'fs';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+async function getUntranslated(api, options) {
+    const languageId = await resolveLanguageId(api, options);
+    if (!languageId) {
+        console.error('ERROR: Language not found. Use --lang (iso_code) or --lang-id');
+        process.exit(1);
+    }
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+    const code = `
+{% set existing = db().from('bfy_translations').where('bfy_language_id', ${languageId}).column('bfy_translation_text_id') %}
+{% set untranslated = db().from('bfy_translation_texts').whereNotIn('id', existing)${limit ? `.limit(${limit})` : ''}.get() %}
+{{ untranslated|json_encode }}
+  `.trim();
+    const result = await api.executeCode(code);
+    if (!result.success) {
+        console.error(`ERROR: ${result.error || 'Failed to fetch untranslated texts'}`);
+        process.exit(1);
+    }
+    let untranslated = [];
+    try {
+        untranslated = JSON.parse(result.output || '[]');
+    }
+    catch {
+        console.error('ERROR: Failed to parse response');
+        process.exit(1);
+    }
+    if (untranslated.length === 0) {
+        console.log('All texts are translated for this language.');
+        process.exit(0);
+    }
+    if (options.format === 'table') {
+        console.log('\nUntranslated texts:\n');
+        console.log('ID\t| Source');
+        console.log('-'.repeat(60));
+        for (const text of untranslated) {
+            const truncated = text.source.length > 50 ? text.source.substring(0, 47) + '...' : text.source;
+            console.log(`${text.id}\t| ${truncated}`);
+        }
+        console.log(`\nTotal: ${untranslated.length} untranslated texts`);
+    }
+    else {
+        console.log(JSON.stringify(untranslated, null, 2));
+    }
+}
+async function addTranslation(api, options) {
+    if (!options.text) {
+        console.error('ERROR: --text is required for add operation');
+        process.exit(1);
+    }
+    const languageId = await resolveLanguageId(api, options);
+    if (!languageId) {
+        console.error('ERROR: Language not found. Use --lang (iso_code) or --lang-id');
+        process.exit(1);
+    }
+    const sourceTextId = await resolveSourceTextId(api, options);
+    if (!sourceTextId) {
+        console.error('ERROR: Source text not found. Use --source (text) or --source-id');
+        process.exit(1);
+    }
+    const checkCode = `
+{% set t = db().from('bfy_translations')
+  .where('bfy_language_id', ${languageId})
+  .where('bfy_translation_text_id', ${sourceTextId})
+  .first() %}
+{{ t ? t.id : 'null' }}
+  `.trim();
+    const checkResult = await api.executeCode(checkCode);
+    const existingId = checkResult.output && checkResult.output !== 'null'
+        ? parseInt(checkResult.output, 10)
+        : null;
+    if (existingId) {
+        const result = await api.performOperation('bfy_translations', 'edit', {
+            id: existingId,
+            text: options.text
+        });
+        if (result.success) {
+            console.log(`SUCCESS: Translation updated (ID: ${existingId})`);
+        }
+        else {
+            console.error(`ERROR: ${result.error || result.message || 'Failed to update translation'}`);
+            process.exit(1);
+        }
+    }
+    else {
+        const result = await api.performOperation('bfy_translations', 'add', {
+            bfy_language_id: languageId,
+            bfy_translation_text_id: sourceTextId,
+            text: options.text
+        });
+        if (result.success) {
+            console.log(`SUCCESS: Translation added (ID: ${result.id})`);
+        }
+        else {
+            console.error(`ERROR: ${result.error || result.message || 'Failed to add translation'}`);
+            process.exit(1);
+        }
+    }
+}
+function parseCSVLine(line) {
+    const fields = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const nextChar = line[i + 1];
+        if (char === '"' && !inQuotes) {
+            inQuotes = true;
+        }
+        else if (char === '"' && inQuotes) {
+            if (nextChar === '"') {
+                current += '"';
+                i++;
+            }
+            else {
+                inQuotes = false;
+            }
+        }
+        else if (char === '\t' && !inQuotes) {
+            fields.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+async function bulkTranslate(api, options) {
+    if (!options.file) {
+        console.error('ERROR: --file is required for bulk operation');
+        process.exit(1);
+    }
+    const languageId = await resolveLanguageId(api, options);
+    if (!languageId) {
+        console.error('ERROR: Language not found. Use --lang (iso_code) or --lang-id');
+        process.exit(1);
+    }
+    let translations;
+    try {
+        const fileContent = await fs.readFile(options.file, 'utf-8');
+        const lines = fileContent.split('\n').filter(line => line.trim() !== '');
+        if (lines.length === 0) {
+            console.error('ERROR: File is empty');
+            process.exit(1);
+        }
+        const firstLine = lines[0].toLowerCase();
+        const startIndex = (firstLine.includes('source') && firstLine.includes('text')) ? 1 : 0;
+        translations = [];
+        for (let i = startIndex; i < lines.length; i++) {
+            const fields = parseCSVLine(lines[i]);
+            if (fields.length < 2) {
+                console.error(`WARNING: Skipping line ${i + 1} - expected 2 columns (source, text), got ${fields.length}`);
+                continue;
+            }
+            const source = fields[0].trim();
+            const text = fields[1].trim();
+            if (source && text) {
+                translations.push({ source, text });
+            }
+        }
+    }
+    catch (error) {
+        console.error(`ERROR: Failed to read/parse file: ${error.message}`);
+        process.exit(1);
+    }
+    if (translations.length === 0) {
+        console.error('ERROR: No valid translations found in file');
+        process.exit(1);
+    }
+    console.log(`Processing ${translations.length} translations...`);
+    const sourcesCode = `
+{% set texts = db().from('bfy_translation_texts').get() %}
+{% set map = {} %}
+{% for t in texts %}
+  {% set map = map|merge({('s_' ~ t.id): t.source}) %}
+{% endfor %}
+{{ map|json_encode }}
+  `.trim();
+    const sourcesResult = await api.executeCode(sourcesCode);
+    let sourceTextMap = {};
+    try {
+        sourceTextMap = JSON.parse(sourcesResult.output || '{}');
+    }
+    catch {
+        console.error('ERROR: Failed to fetch source texts');
+        process.exit(1);
+    }
+    const sourceToId = {};
+    for (const [key, source] of Object.entries(sourceTextMap)) {
+        const id = parseInt(key.replace('s_', ''), 10);
+        sourceToId[source] = id;
+    }
+    const existingCode = `
+{% set t = db().from('bfy_translations').where('bfy_language_id', ${languageId}).get() %}
+{% set map = {} %}
+{% for tr in t %}
+  {% set map = map|merge({('t_' ~ tr.bfy_translation_text_id): tr.id}) %}
+{% endfor %}
+{{ map|json_encode }}
+  `.trim();
+    const existingResult = await api.executeCode(existingCode);
+    let existingMap = {};
+    try {
+        existingMap = JSON.parse(existingResult.output || '{}');
+    }
+    catch {
+        console.error('ERROR: Failed to fetch existing translations');
+        process.exit(1);
+    }
+    let added = 0;
+    let updated = 0;
+    let skipped = 0;
+    let errors = 0;
+    const missingSourceTexts = [];
+    for (const entry of translations) {
+        let sourceTextId;
+        if (entry.sourceId) {
+            sourceTextId = entry.sourceId;
+        }
+        else if (entry.source) {
+            sourceTextId = sourceToId[entry.source];
+        }
+        if (!sourceTextId) {
+            if (entry.source) {
+                const createResult = await api.performOperation('bfy_translation_texts', 'add', {
+                    source: entry.source
+                });
+                if (createResult.success && createResult.id) {
+                    sourceTextId = createResult.id;
+                    sourceToId[entry.source] = sourceTextId;
+                    console.log(`  Created source text: "${entry.source.substring(0, 30)}..." (ID: ${sourceTextId})`);
+                }
+                else {
+                    missingSourceTexts.push(entry.source);
+                    errors++;
+                    continue;
+                }
+            }
+            else {
+                skipped++;
+                continue;
+            }
+        }
+        const existingTranslationId = existingMap[`t_${sourceTextId}`];
+        if (existingTranslationId) {
+            const result = await api.performOperation('bfy_translations', 'edit', {
+                id: existingTranslationId,
+                text: entry.text
+            });
+            if (result.success) {
+                updated++;
+            }
+            else {
+                errors++;
+                console.error(`  ERROR updating translation for source ID ${sourceTextId}: ${result.error || result.message}`);
+            }
+        }
+        else {
+            const result = await api.performOperation('bfy_translations', 'add', {
+                bfy_language_id: languageId,
+                bfy_translation_text_id: sourceTextId,
+                text: entry.text
+            });
+            if (result.success) {
+                added++;
+                existingMap[`t_${sourceTextId}`] = result.id;
+            }
+            else {
+                errors++;
+                console.error(`  ERROR adding translation for source ID ${sourceTextId}: ${result.error || result.message}`);
+            }
+        }
+    }
+    console.log('\n--- Summary ---');
+    console.log(`Added: ${added}`);
+    console.log(`Updated: ${updated}`);
+    console.log(`Skipped: ${skipped}`);
+    console.log(`Errors: ${errors}`);
+    if (missingSourceTexts.length > 0) {
+        console.log(`\nMissing source texts that couldn't be created:`);
+        for (const text of missingSourceTexts.slice(0, 10)) {
+            console.log(`  - ${text.substring(0, 50)}...`);
+        }
+        if (missingSourceTexts.length > 10) {
+            console.log(`  ... and ${missingSourceTexts.length - 10} more`);
+        }
+    }
+    process.exit(errors > 0 ? 1 : 0);
+}
+async function listLanguages(api, options) {
+    const code = `
+{% set langs = db().from('bfy_languages').get() %}
+{% set result = [] %}
+{% for l in langs %}
+  {% set total = db().from('bfy_translation_texts').count() %}
+  {% set translated = db().from('bfy_translations').where('bfy_language_id', l.id).count() %}
+  {% set result = result|merge([{
+    "id": l.id,
+    "name": l.name,
+    "iso_code": l.iso_code,
+    "total": total,
+    "translated": translated,
+    "untranslated": total - translated
+  }]) %}
+{% endfor %}
+{{ result|json_encode }}
+  `.trim();
+    const result = await api.executeCode(code);
+    if (!result.success) {
+        console.error(`ERROR: ${result.error || 'Failed to fetch languages'}`);
+        process.exit(1);
+    }
+    let languages = [];
+    try {
+        languages = JSON.parse(result.output || '[]');
+    }
+    catch {
+        console.error('ERROR: Failed to parse response');
+        process.exit(1);
+    }
+    if (options.format === 'table' || !options.format) {
+        console.log('\nAvailable languages:\n');
+        console.log('ID\t| ISO\t| Name\t\t| Translated\t| Untranslated');
+        console.log('-'.repeat(70));
+        for (const lang of languages) {
+            const name = lang.name.padEnd(12);
+            console.log(`${lang.id}\t| ${lang.iso_code}\t| ${name}\t| ${lang.translated}/${lang.total}\t\t| ${lang.untranslated}`);
+        }
+    }
+    else {
+        console.log(JSON.stringify(languages, null, 2));
+    }
+}
+async function resolveLanguageId(api, options) {
+    if (options.langId) {
+        return parseInt(options.langId, 10);
+    }
+    if (options.lang) {
+        const code = `{% set l = db().from('bfy_languages').where('iso_code', '${options.lang}').first() %}{{ l ? l.id : 'null' }}`;
+        const result = await api.executeCode(code);
+        if (result.success && result.output && result.output !== 'null') {
+            return parseInt(result.output, 10);
+        }
+    }
+    return null;
+}
+async function resolveSourceTextId(api, options) {
+    if (options.sourceId) {
+        return parseInt(options.sourceId, 10);
+    }
+    if (options.source) {
+        const escapedSource = options.source.replace(/'/g, "\\'");
+        const code = `{% set t = db().from('bfy_translation_texts').where('source', '${escapedSource}').first() %}{{ t ? t.id : 'null' }}`;
+        const result = await api.executeCode(code);
+        if (result.success && result.output && result.output !== 'null') {
+            return parseInt(result.output, 10);
+        }
+    }
+    return null;
+}
+export default async function translateCommand(operation, options) {
+    try {
+        const validOperations = ['get-untranslated', 'add', 'bulk', 'languages'];
+        if (!validOperations.includes(operation)) {
+            console.error(`ERROR: Invalid operation: ${operation}`);
+            console.error(`Valid operations: ${validOperations.join(', ')}`);
+            process.exit(1);
+        }
+        const config = await loadAuthConfig();
+        if (!config) {
+            console.error('ERROR: No authentication configured. Run "butterfly-cli setup" first.');
+            process.exit(1);
+        }
+        const api = new ButterflyAPI(config);
+        await api.authenticate();
+        if (api.needs2FA)
+            await api.complete2FA();
+        switch (operation) {
+            case 'get-untranslated':
+                await getUntranslated(api, options);
+                break;
+            case 'add':
+                await addTranslation(api, options);
+                break;
+            case 'bulk':
+                await bulkTranslate(api, options);
+                break;
+            case 'languages':
+                await listLanguages(api, options);
+                break;
+        }
+    }
+    catch (error) {
+        console.error(`ERROR: ${error.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=translate.js.map

package/dist/commands/upload.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (targets: string[]) => Promise<void>;
+export default _default;
+//# sourceMappingURL=upload.d.ts.map