@rglabs/butterfly 2.0.1

package/dist/commands/create-object.js

@@ -0,0 +1,293 @@
+import React from 'react';
+import { render, Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { ButterflyAPI } from '../utils/api.js';
+import { loadAuthConfig } from '../utils/auth.js';
+const CreateObjectCommand = ({ options }) => {
+    const [status, setStatus] = React.useState('loading');
+    const [errorMessage, setErrorMessage] = React.useState('');
+    const [quotes, setQuotes] = React.useState([]);
+    const [currentQuoteIndex, setCurrentQuoteIndex] = React.useState(0);
+    const [title, setTitle] = React.useState('');
+    const [resultMessage, setResultMessage] = React.useState('');
+    const [logs, setLogs] = React.useState([]);
+    const [pollCount, setPollCount] = React.useState(0);
+    const [pendingExecute, setPendingExecute] = React.useState(null);
+    const [previewData, setPreviewData] = React.useState(null);
+    const addLog = (message, type = 'info') => {
+        const timestamp = new Date().toLocaleTimeString();
+        setLogs(prev => [...prev.slice(-10), { timestamp, message, type }]);
+    };
+    useInput((input, key) => {
+        if (status !== 'confirming')
+            return;
+        if (input.toLowerCase() === 'y' || key.return) {
+            executeAction();
+        }
+        else if (input.toLowerCase() === 'n' || key.escape) {
+            addLog('Cancelled by user', 'warning');
+            setStatus('cancelled');
+            setTimeout(() => process.exit(0), 1000);
+        }
+    });
+    const executeAction = async () => {
+        if (!pendingExecute)
+            return;
+        try {
+            setStatus('executing');
+            addLog('POST /admin/bfy_ai_task/executeAction', 'info');
+            const executeResponse = await pendingExecute.api.aiTaskExecuteAction('create-objects', {
+                objects: pendingExecute.message.objects,
+                specs: pendingExecute.message.specs,
+                response_message: pendingExecute.message.response_message || pendingExecute.message.specs
+            });
+            if (executeResponse.success) {
+                addLog('Action executed successfully!', 'success');
+                setResultMessage('Objects created successfully!');
+                setStatus('success');
+            }
+            else {
+                throw new Error(executeResponse.message || 'Failed to execute action');
+            }
+            setTimeout(() => process.exit(0), 2000);
+        }
+        catch (error) {
+            addLog(`Error: ${error.message}`, 'error');
+            setErrorMessage(error.message || 'Unknown error');
+            setStatus('error');
+            setTimeout(() => process.exit(1), 3000);
+        }
+    };
+    React.useEffect(() => {
+        if (quotes.length === 0)
+            return;
+        const interval = setInterval(() => {
+            setCurrentQuoteIndex(prev => (prev + 1) % quotes.length);
+        }, 3000);
+        return () => clearInterval(interval);
+    }, [quotes]);
+    React.useEffect(() => {
+        const run = async () => {
+            try {
+                const filePath = path.isAbsolute(options.file)
+                    ? options.file
+                    : path.join(process.cwd(), options.file);
+                if (!existsSync(filePath)) {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                addLog(`Reading file: ${filePath}`, 'info');
+                const promptContent = readFileSync(filePath, 'utf-8');
+                addLog(`File loaded (${promptContent.length} bytes)`, 'success');
+                setStatus('authenticating');
+                addLog('Loading authentication config...', 'info');
+                const authConfig = await loadAuthConfig();
+                if (!authConfig) {
+                    throw new Error('Not authenticated. Run "butterfly-cli setup" first.');
+                }
+                const api = new ButterflyAPI(authConfig);
+                addLog(`Connecting to: ${authConfig.endpoint}`, 'info');
+                await api.authenticate();
+                addLog('Authentication successful', 'success');
+                setStatus('generating-quotes');
+                addLog('POST /admin/bfy_ai_task/response (generate-waiting-quotes)', 'info');
+                const quotesResponse = await api.aiTaskResponse('generate-waiting-quotes', {
+                    title: 'Create Objects',
+                    prompt: promptContent
+                });
+                if (!quotesResponse.success) {
+                    throw new Error(quotesResponse.message || 'Failed to generate quotes');
+                }
+                addLog(`Quotes generated: ${quotesResponse.message?.quotes?.length || 0} messages`, 'success');
+                if (quotesResponse.message?.quotes) {
+                    setQuotes(quotesResponse.message.quotes);
+                    setTitle(quotesResponse.message.title || 'Processing');
+                }
+                setStatus('waiting-quotes');
+                let aiLogId;
+                let pollAttempt = 0;
+                addLog('POST /admin/bfy_ai_task/status (waiting for task ID)', 'info');
+                while (true) {
+                    pollAttempt++;
+                    setPollCount(pollAttempt);
+                    const statusResponse = await api.aiTaskStatus();
+                    addLog(`Status response: ${JSON.stringify(statusResponse)}`, 'info');
+                    if (statusResponse.success && statusResponse.id) {
+                        aiLogId = statusResponse.id;
+                        addLog(`Task ID received: ${aiLogId}`, 'success');
+                        break;
+                    }
+                    addLog(`Status check #${pollAttempt}: Not ready yet, waiting...`, 'warning');
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                }
+                setStatus('creating-objects');
+                addLog(`POST /admin/bfy_ai_task/response (create-objects, request_ai_log_id: ${aiLogId})`, 'info');
+                await api.aiTaskResponse('create-objects', {
+                    prompt: promptContent,
+                    response: '',
+                    ai_model_id: '1'
+                }, { requestAiLogId: aiLogId });
+                addLog('Create objects request sent', 'success');
+                setStatus('waiting-create');
+                pollAttempt = 0;
+                addLog(`POST /admin/bfy_ai_task/status (ai_log_id: ${aiLogId})`, 'info');
+                while (true) {
+                    pollAttempt++;
+                    setPollCount(pollAttempt);
+                    const statusResponse = await api.aiTaskStatus(aiLogId);
+                    addLog(`Status response: ${JSON.stringify(statusResponse)}`, 'info');
+                    if (statusResponse.success) {
+                        addLog('AI task completed!', 'success');
+                        break;
+                    }
+                    addLog(`Status check #${pollAttempt}: AI is still working...`, 'warning');
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                }
+                setStatus('fetching-result');
+                addLog(`POST /admin/bfy_ai_task/response (fetching result, ai_log_id: ${aiLogId})`, 'info');
+                const resultResponse = await api.aiTaskResponse('create-objects', {
+                    response: '',
+                    ai_model_id: '1'
+                }, { aiLogId });
+                if (!resultResponse.success) {
+                    throw new Error(resultResponse.message || 'Failed to get AI response');
+                }
+                addLog('AI response received', 'success');
+                const message = resultResponse.message;
+                addLog(`Objects: ${message.objects?.length || 0}, Specs: ${message.specs?.length || 0}`, 'info');
+                setPreviewData({
+                    objects: message.objects || [],
+                    specs: message.specs || []
+                });
+                setPendingExecute({ api, message });
+                setStatus('confirming');
+            }
+            catch (error) {
+                addLog(`Error: ${error.message}`, 'error');
+                setErrorMessage(error.message || 'Unknown error');
+                setStatus('error');
+                setTimeout(() => process.exit(1), 3000);
+            }
+        };
+        run();
+    }, [options.file]);
+    const getStatusText = () => {
+        switch (status) {
+            case 'loading': return 'Loading...';
+            case 'authenticating': return 'Authenticating...';
+            case 'generating-quotes': return 'Generating loading messages...';
+            case 'waiting-quotes': return `${title || 'Processing...'} (poll #${pollCount})`;
+            case 'creating-objects': return title || 'Creating objects...';
+            case 'waiting-create': return `${title || 'AI is working...'} (poll #${pollCount})`;
+            case 'fetching-result': return 'Fetching results...';
+            case 'confirming': return 'Waiting for confirmation...';
+            case 'executing': return 'Executing action...';
+            case 'success': return resultMessage;
+            case 'cancelled': return 'Operation cancelled.';
+            case 'error': return `Error: ${errorMessage}`;
+            default: return 'Processing...';
+        }
+    };
+    const isProcessing = ['waiting-quotes', 'creating-objects', 'waiting-create'].includes(status);
+    const currentQuote = quotes[currentQuoteIndex];
+    const getLogColor = (type) => {
+        switch (type) {
+            case 'success': return 'green';
+            case 'warning': return 'yellow';
+            case 'error': return 'red';
+            default: return 'gray';
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, null,
+            status !== 'success' && status !== 'error' && status !== 'cancelled' && status !== 'confirming' && (React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" }),
+                ' ')),
+            status === 'success' && React.createElement(Text, { color: "green" }, "\u2713 "),
+            status === 'error' && React.createElement(Text, { color: "red" }, "\u2717 "),
+            status === 'cancelled' && React.createElement(Text, { color: "yellow" }, "\u2298 "),
+            status === 'confirming' && React.createElement(Text, { color: "magenta" }, "? "),
+            React.createElement(Text, { color: status === 'error' ? 'red' : status === 'success' ? 'green' : status === 'cancelled' ? 'yellow' : 'yellow' }, getStatusText())),
+        isProcessing && currentQuote && (React.createElement(Box, { marginTop: 1, marginLeft: 2 },
+            React.createElement(Text, { color: "cyan", italic: true }, currentQuote))),
+        status === 'confirming' && previewData && (React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "double", borderColor: "magenta", paddingX: 1 },
+            React.createElement(Text, { color: "magenta", bold: true }, "Onizleme - Olusturulacak Tablolar:"),
+            (() => {
+                const parseBacktickData = (data) => {
+                    if (Array.isArray(data))
+                        return data;
+                    if (typeof data !== 'string')
+                        return [];
+                    const lines = data.split('\n').filter(l => l.trim());
+                    if (lines.length < 2)
+                        return [];
+                    const headers = lines[0].split('`');
+                    return lines.slice(1).map(line => {
+                        const values = line.split('`');
+                        const obj = {};
+                        headers.forEach((h, i) => {
+                            obj[h] = values[i] || '';
+                        });
+                        return obj;
+                    });
+                };
+                const objects = parseBacktickData(previewData.objects);
+                const specs = parseBacktickData(previewData.specs);
+                const specsByTable = {};
+                specs.forEach(spec => {
+                    const tableName = spec.table_name || spec.object_id || 'unknown';
+                    if (!specsByTable[tableName]) {
+                        specsByTable[tableName] = [];
+                    }
+                    specsByTable[tableName].push(spec);
+                });
+                return objects.map((obj, index) => {
+                    const tableName = obj.table_name || '';
+                    const tableSpecs = specsByTable[tableName] || [];
+                    return (React.createElement(Box, { key: index, flexDirection: "column", marginTop: 1 },
+                        React.createElement(Box, null,
+                            React.createElement(Text, { color: "green", bold: true }, "Tablo: "),
+                            React.createElement(Text, { color: "white", bold: true }, obj.name || tableName),
+                            React.createElement(Text, { color: "gray" },
+                                " (",
+                                tableName,
+                                ")")),
+                        obj.menu_path && (React.createElement(Box, { marginLeft: 2 },
+                            React.createElement(Text, { color: "gray" },
+                                "Menu: ",
+                                obj.menu_path))),
+                        tableSpecs.length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginTop: 0 },
+                            React.createElement(Text, { color: "yellow" }, "Alanlar:"),
+                            tableSpecs.slice(0, 8).map((spec, specIndex) => (React.createElement(Box, { key: specIndex, marginLeft: 2 },
+                                React.createElement(Text, { color: "cyan" },
+                                    "- ",
+                                    spec.name || spec.column_name || '-'),
+                                React.createElement(Text, { color: "gray" },
+                                    " (",
+                                    spec.type || '-',
+                                    ")"),
+                                spec.required === '1' && React.createElement(Text, { color: "red" }, " *")))),
+                            tableSpecs.length > 8 && (React.createElement(Box, { marginLeft: 2 },
+                                React.createElement(Text, { color: "gray" },
+                                    "... ve ",
+                                    tableSpecs.length - 8,
+                                    " alan daha")))))));
+                });
+            })(),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "yellow", bold: true }, "Onaylamak icin Y, iptal icin N tusuna basin: ")))),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1 },
+            React.createElement(Text, { color: "white", bold: true }, "Logs:"),
+            logs.map((log, index) => (React.createElement(Box, { key: index },
+                React.createElement(Text, { color: "gray" },
+                    "[",
+                    log.timestamp,
+                    "] "),
+                React.createElement(Text, { color: getLogColor(log.type) }, log.message)))),
+            logs.length === 0 && React.createElement(Text, { color: "gray" }, "No logs yet..."))));
+};
+export default (options) => {
+    render(React.createElement(CreateObjectCommand, { options: options }));
+};
+//# sourceMappingURL=create-object.js.map

package/dist/commands/create-report.d.ts

@@ -0,0 +1,6 @@
+interface CreateReportOptions {
+    file: string;
+}
+declare const _default: (options: CreateReportOptions) => void;
+export default _default;
+//# sourceMappingURL=create-report.d.ts.map

package/dist/commands/create-report.js

@@ -0,0 +1,154 @@
+import React from 'react';
+import { render, Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { ButterflyAPI } from '../utils/api.js';
+import { loadAuthConfig } from '../utils/auth.js';
+const CreateReportCommand = ({ options }) => {
+    const [status, setStatus] = React.useState('loading');
+    const [errorMessage, setErrorMessage] = React.useState('');
+    const [logs, setLogs] = React.useState([]);
+    const [reportUrl, setReportUrl] = React.useState('');
+    const addLog = (message, type = 'info') => {
+        const timestamp = new Date().toLocaleTimeString();
+        setLogs(prev => [...prev.slice(-15), { timestamp, message, type }]);
+    };
+    React.useEffect(() => {
+        const run = async () => {
+            try {
+                const folderPath = path.isAbsolute(options.file)
+                    ? options.file
+                    : path.join(process.cwd(), options.file);
+                addLog(`Checking folder: ${folderPath}`, 'info');
+                if (!existsSync(folderPath)) {
+                    throw new Error(`Folder not found: ${folderPath}`);
+                }
+                setStatus('checking-files');
+                const queryCodePath = path.join(folderPath, 'query_code.twig');
+                const scriptJsPath = path.join(folderPath, 'script.js');
+                if (!existsSync(queryCodePath)) {
+                    throw new Error(`Required file not found: query_code.twig`);
+                }
+                addLog('Found: query_code.twig', 'success');
+                if (!existsSync(scriptJsPath)) {
+                    throw new Error(`Required file not found: script.js`);
+                }
+                addLog('Found: script.js', 'success');
+                const queryCode = readFileSync(queryCodePath, 'utf-8');
+                const jsCode = readFileSync(scriptJsPath, 'utf-8');
+                addLog(`Files loaded (query: ${queryCode.length} bytes, js: ${jsCode.length} bytes)`, 'success');
+                const folderName = path.basename(folderPath);
+                const alias = folderName;
+                const friendlyName = folderName
+                    .split('-')
+                    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                    .join(' ');
+                addLog(`Report name: ${friendlyName}, alias: ${alias}`, 'info');
+                setStatus('authenticating');
+                addLog('Loading authentication config...', 'info');
+                const authConfig = await loadAuthConfig();
+                if (!authConfig) {
+                    throw new Error('Not authenticated. Run "butterfly-cli setup" first.');
+                }
+                const api = new ButterflyAPI(authConfig);
+                addLog(`Connecting to: ${authConfig.endpoint}`, 'info');
+                await api.authenticate();
+                addLog('Authentication successful', 'success');
+                setStatus('creating-report');
+                addLog('POST /admin/ajax/cms_object/operation?do=cms_reports__add', 'info');
+                const reportResponse = await api.createReport({
+                    name: friendlyName,
+                    alias: alias,
+                    type: '0',
+                    cache_duration: '',
+                    cms_report_category_id: '0',
+                    detail_query: '',
+                    others: '',
+                    bfy_workspace_id: '0',
+                    object_id: '0',
+                    permission_level: '',
+                    hide_in_list: '0'
+                });
+                addLog(`Response: ${JSON.stringify(reportResponse)}`, 'info');
+                if (!reportResponse.success) {
+                    throw new Error(reportResponse.message || 'Failed to create report');
+                }
+                const reportId = reportResponse.data?.id || reportResponse.id;
+                addLog(`Report created with ID: ${reportId}`, 'success');
+                setStatus('creating-query');
+                addLog('POST /admin/ajax/cms_object/operation?do=cms_report_queries__add', 'info');
+                const queryResponse = await api.createReportQuery({
+                    cms_report_id: reportId,
+                    title: friendlyName,
+                    query: queryCode,
+                    column_size: '1',
+                    system_name: alias,
+                    js_code: jsCode,
+                    show_title: '1'
+                });
+                addLog(`Response: ${JSON.stringify(queryResponse)}`, 'info');
+                if (!queryResponse.success) {
+                    throw new Error(queryResponse.message || 'Failed to create report query');
+                }
+                addLog('Report query created successfully', 'success');
+                const fullUrl = `${authConfig.endpoint}admin/cms_report/view/${reportId}`;
+                setReportUrl(fullUrl);
+                addLog(`Report ready: ${fullUrl}`, 'success');
+                setStatus('success');
+                setTimeout(() => process.exit(0), 3000);
+            }
+            catch (error) {
+                addLog(`Error: ${error.message}`, 'error');
+                setErrorMessage(error.message || 'Unknown error');
+                setStatus('error');
+                setTimeout(() => process.exit(1), 3000);
+            }
+        };
+        run();
+    }, [options.file]);
+    const getStatusText = () => {
+        switch (status) {
+            case 'loading': return 'Loading...';
+            case 'authenticating': return 'Authenticating...';
+            case 'checking-files': return 'Checking required files...';
+            case 'creating-report': return 'Creating report...';
+            case 'creating-query': return 'Creating report query...';
+            case 'success': return 'Report created successfully!';
+            case 'error': return `Error: ${errorMessage}`;
+            default: return 'Processing...';
+        }
+    };
+    const getLogColor = (type) => {
+        switch (type) {
+            case 'success': return 'green';
+            case 'warning': return 'yellow';
+            case 'error': return 'red';
+            default: return 'gray';
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, null,
+            status !== 'success' && status !== 'error' && (React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" }),
+                ' ')),
+            status === 'success' && React.createElement(Text, { color: "green" }, "\u2713 "),
+            status === 'error' && React.createElement(Text, { color: "red" }, "\u2717 "),
+            React.createElement(Text, { color: status === 'error' ? 'red' : status === 'success' ? 'green' : 'yellow' }, getStatusText())),
+        status === 'success' && reportUrl && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "cyan", bold: true }, "Report URL: "),
+            React.createElement(Text, { color: "white" }, reportUrl))),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1 },
+            React.createElement(Text, { color: "white", bold: true }, "Logs:"),
+            logs.map((log, index) => (React.createElement(Box, { key: index },
+                React.createElement(Text, { color: "gray" },
+                    "[",
+                    log.timestamp,
+                    "] "),
+                React.createElement(Text, { color: getLogColor(log.type) }, log.message)))),
+            logs.length === 0 && React.createElement(Text, { color: "gray" }, "No logs yet..."))));
+};
+export default (options) => {
+    render(React.createElement(CreateReportCommand, { options: options }));
+};
+//# sourceMappingURL=create-report.js.map

package/dist/commands/diff.d.ts

@@ -0,0 +1,4 @@
+import { DiffOptions } from '../diff/types.js';
+declare const _default: (options: DiffOptions) => Promise<void>;
+export default _default;
+//# sourceMappingURL=diff.d.ts.map