galaxy-code 0.1.2 → 0.1.5

package/dist/utils/message-formatters.js

@@ -0,0 +1,590 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2025-01-10
+ * @desc Message formatters for rich tool output display
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+/**
+ * Get terminal width with fallback
+ */
+const getTerminalWidth = () => {
+    const width = process.stdout?.columns;
+    return typeof width === 'number' && Number.isFinite(width) ? width : 80;
+};
+/**
+ * Truncate long lines to fit terminal width
+ */
+const truncateLine = (line, maxWidth) => {
+    if (line.length <= maxWidth)
+        return line;
+    return line.slice(0, maxWidth - 3) + '...';
+};
+/**
+ * Parse tool result to detect format type
+ */
+export function detectMessageType(content, toolName) {
+    // Plan task outputs todos
+    if (toolName === 'plan_task') {
+        return 'todos';
+    }
+    // File operations show diffs
+    if (toolName === 'file_write' || toolName === 'code_generate') {
+        // Check if content has diff markers
+        if (content.includes('---') ||
+            content.includes('+++') ||
+            content.includes('@@')) {
+            return 'diff';
+        }
+    }
+    // Code blocks
+    if (content.includes('```')) {
+        return 'code';
+    }
+    return 'plain';
+}
+/**
+ * Generate simple diff between two texts
+ */
+function generateDiff(oldText, newText) {
+    const oldLines = oldText.split('\n');
+    const newLines = newText.split('\n');
+    const diffLines = [];
+    let oldIdx = 0;
+    let newIdx = 0;
+    // Simple line-by-line comparison
+    while (oldIdx < oldLines.length || newIdx < newLines.length) {
+        const oldLine = oldLines[oldIdx];
+        const newLine = newLines[newIdx];
+        if (oldLine === newLine) {
+            // Context line
+            diffLines.push({
+                type: 'context',
+                oldLineNum: oldIdx + 1,
+                newLineNum: newIdx + 1,
+                content: oldLine || '',
+            });
+            oldIdx++;
+            newIdx++;
+        }
+        else if (oldIdx < oldLines.length && oldLine !== undefined && !newLines.includes(oldLine)) {
+            // Line removed
+            diffLines.push({
+                type: 'remove',
+                oldLineNum: oldIdx + 1,
+                content: oldLine || '',
+            });
+            oldIdx++;
+        }
+        else if (newIdx < newLines.length && newLine !== undefined && !oldLines.includes(newLine)) {
+            // Line added
+            diffLines.push({
+                type: 'add',
+                newLineNum: newIdx + 1,
+                content: newLine || '',
+            });
+            newIdx++;
+        }
+        else {
+            // Lines differ but exist in both - treat as remove + add
+            if (oldIdx < oldLines.length) {
+                diffLines.push({
+                    type: 'remove',
+                    oldLineNum: oldIdx + 1,
+                    content: oldLine || '',
+                });
+                oldIdx++;
+            }
+            if (newIdx < newLines.length) {
+                diffLines.push({
+                    type: 'add',
+                    newLineNum: newIdx + 1,
+                    content: newLine || '',
+                });
+                newIdx++;
+            }
+        }
+    }
+    return diffLines;
+}
+/**
+ * Compress diff by grouping context lines
+ */
+function compressDiff(diffLines, contextLines = 2) {
+    const compressed = [];
+    let i = 0;
+    while (i < diffLines.length) {
+        const line = diffLines[i];
+        if (line && line.type !== 'context') {
+            // Add changed line
+            compressed.push(line);
+            i++;
+        }
+        else {
+            // Look for runs of context lines
+            const contextStart = i;
+            let contextEnd = i;
+            while (contextEnd < diffLines.length &&
+                diffLines[contextEnd]?.type === 'context') {
+                contextEnd++;
+            }
+            const contextLength = contextEnd - contextStart;
+            if (contextLength <= contextLines * 2) {
+                // Keep all context if small
+                for (let j = contextStart; j < contextEnd; j++) {
+                    if (diffLines[j])
+                        compressed.push(diffLines[j]);
+                }
+            }
+            else {
+                // Keep only beginning and end context
+                for (let j = contextStart; j < contextStart + contextLines; j++) {
+                    if (diffLines[j])
+                        compressed.push(diffLines[j]);
+                }
+                // Add placeholder for skipped lines
+                const skipped = contextLength - contextLines * 2;
+                compressed.push({
+                    type: 'context',
+                    content: `... ${skipped} unchanged lines ...`,
+                });
+                for (let j = contextEnd - contextLines; j < contextEnd; j++) {
+                    if (diffLines[j])
+                        compressed.push(diffLines[j]);
+                }
+            }
+            i = contextEnd;
+        }
+    }
+    return compressed;
+}
+/**
+ * Format todo list output from plan_task
+ */
+export function formatTodos(content) {
+    try {
+        // Try to parse as JSON first (if plan_task returns structured data)
+        const data = JSON.parse(content);
+        if (data.tasks && Array.isArray(data.tasks)) {
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { bold: true, color: "cyan" }, "\uD83D\uDCCB Todos"),
+                data.tasks.map((task, idx) => (React.createElement(Box, { key: idx, marginLeft: 2 },
+                    React.createElement(Text, { color: task.completed ? 'green' : 'gray' },
+                        task.completed ? '☒' : '☐',
+                        ' ',
+                        task.content || task.title || task.description))))));
+        }
+    }
+    catch {
+        // Not JSON, parse as plain text todo list
+        const lines = content.split('\n');
+        const todoLines = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Match patterns like: "☒ Task name" or "- [x] Task name" or "✓ Task name"
+            if (trimmed.match(/^[☒✓✅-]\s*\[x\]\s*/i)) {
+                todoLines.push({
+                    completed: true,
+                    text: trimmed.replace(/^[☒✓✅-]\s*\[x\]\s*/i, ''),
+                });
+            }
+            else if (trimmed.match(/^[☐-]\s*\[\s*\]\s*/)) {
+                todoLines.push({
+                    completed: false,
+                    text: trimmed.replace(/^[☐-]\s*\[\s*\]\s*/, ''),
+                });
+            }
+            else if (trimmed.match(/^[-*•]\s+/)) {
+                todoLines.push({
+                    completed: false,
+                    text: trimmed.replace(/^[-*•]\s+/, ''),
+                });
+            }
+        }
+        if (todoLines.length > 0) {
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { bold: true, color: "cyan" }, "\uD83D\uDCCB Todos"),
+                todoLines.map((todo, idx) => (React.createElement(Box, { key: idx, marginLeft: 2 },
+                    React.createElement(Text, { color: todo.completed ? 'green' : 'gray' },
+                        todo.completed ? '☒' : '☐',
+                        " ",
+                        todo.text))))));
+        }
+    }
+    // Fallback to plain text
+    return React.createElement(Text, null, content);
+}
+/**
+ * Format git-style diff output for file operations
+ */
+export function formatDiff(content, filePath) {
+    const lines = content.split('\n');
+    const diffLines = [];
+    let lineNumber = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] || '';
+        // File header
+        if (line.startsWith('---') || line.startsWith('+++')) {
+            diffLines.push(React.createElement(Box, { key: i },
+                React.createElement(Text, { bold: true, color: "cyan" }, line)));
+            continue;
+        }
+        // Hunk header (e.g., @@ -1,4 +1,6 @@)
+        if (line.startsWith('@@')) {
+            diffLines.push(React.createElement(Box, { key: i },
+                React.createElement(Text, { bold: true, color: "magenta" }, line)));
+            continue;
+        }
+        // Deleted line
+        if (line.startsWith('-')) {
+            diffLines.push(React.createElement(Box, { key: i },
+                React.createElement(Text, { dimColor: true }, String(lineNumber).padStart(4, ' ')),
+                React.createElement(Text, { color: "red" }, ` ${line}`)));
+            lineNumber++;
+            continue;
+        }
+        // Added line
+        if (line.startsWith('+')) {
+            diffLines.push(React.createElement(Box, { key: i },
+                React.createElement(Text, { dimColor: true }, String(lineNumber).padStart(4, ' ')),
+                React.createElement(Text, { color: "green" }, ` ${line}`)));
+            lineNumber++;
+            continue;
+        }
+        // Context line (unchanged)
+        diffLines.push(React.createElement(Box, { key: i },
+            React.createElement(Text, { dimColor: true }, String(lineNumber).padStart(4, ' ')),
+            React.createElement(Text, null, ` ${line}`)));
+        lineNumber++;
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        filePath && React.createElement(Text, { bold: true, color: "yellow" }, `📝 ${filePath}`),
+        diffLines));
+}
+/**
+ * Format code blocks
+ */
+export function formatCode(content) {
+    const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+    const parts = [];
+    let lastIndex = 0;
+    let match;
+    let idx = 0;
+    while ((match = codeBlockRegex.exec(content)) !== null) {
+        // Text before code block
+        if (match.index > lastIndex) {
+            parts.push(React.createElement(Text, { key: `text-${idx}` }, content.slice(lastIndex, match.index)));
+        }
+        // Code block
+        const language = match[1] || 'text';
+        const code = match[2];
+        parts.push(React.createElement(Box, { key: `code-${idx}`, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1 },
+            React.createElement(Text, { dimColor: true }, language),
+            React.createElement(Text, { color: "cyan" }, code)));
+        lastIndex = match.index + match[0].length;
+        idx++;
+    }
+    // Remaining text
+    if (lastIndex < content.length) {
+        parts.push(React.createElement(Text, { key: `text-${idx}` }, content.slice(lastIndex)));
+    }
+    return React.createElement(Box, { flexDirection: "column" }, parts);
+}
+/**
+ * Format file tree output
+ * Pattern: 📁 LIST DIRECTORY (path)
+ *          ↳ Listed X items.
+ */
+const formatFileTree = (content, toolInfo) => {
+    let itemCount = 0;
+    let directory = 'current directory';
+    // Get directory from toolInfo args
+    if (toolInfo?.args?.path) {
+        directory = toolInfo?.args.path;
+    }
+    // Count items from tree output
+    if (content) {
+        const lines = content.split('\n').filter(line => {
+            const trimmed = line.trim();
+            return trimmed && !trimmed.startsWith('Failed');
+        });
+        itemCount = lines.length;
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true, color: "cyan" },
+            "\uD83D\uDCC1 LIST DIRECTORY ",
+            React.createElement(Text, { color: "gray" },
+                "(",
+                directory,
+                ")")),
+        React.createElement(Box, { marginLeft: 1 },
+            React.createElement(Text, { color: "green" },
+                "\u21B3 Listed ",
+                itemCount,
+                " items."))));
+};
+/**
+ * Format file read output
+ * Pattern: 📄 READ (filename)
+ *          ↳ Read X lines.
+ */
+const formatFileRead = (content, toolInfo) => {
+    let lineCount = 0;
+    let fileName = 'file';
+    // Get file name from toolInfo args
+    if (toolInfo?.args?.path) {
+        const parts = toolInfo.args.path.split('/');
+        fileName = parts[parts.length - 1] || toolInfo.args.path;
+    }
+    // Count lines from content
+    if (content) {
+        lineCount = content.split('\n').length;
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true, color: "cyan" },
+            "\uD83D\uDCC4 READ ",
+            React.createElement(Text, { color: "gray" },
+                "(",
+                fileName,
+                ")")),
+        React.createElement(Box, { marginLeft: 1 },
+            React.createElement(Text, { color: "green" },
+                "\u21B3 Read ",
+                lineCount,
+                " lines."))));
+};
+/**
+ * Format file write output with diff view
+ * Handles both new file creation and file updates
+ */
+const formatFileWrite = (content, toolInfo) => {
+    let fileName = 'file';
+    let writeResult = null;
+    // Try to parse FileWriteResult from content
+    try {
+        writeResult = JSON.parse(content);
+    }
+    catch {
+        // Fallback: treat as new file with content from args
+        if (toolInfo?.args?.content) {
+            writeResult = {
+                isNewFile: true,
+                newContent: toolInfo.args.content,
+                linesAdded: toolInfo.args.content.split('\n').length,
+                linesRemoved: 0,
+                path: toolInfo.args.path,
+            };
+        }
+    }
+    if (!writeResult) {
+        return React.createElement(Text, { wrap: "wrap" }, content);
+    }
+    // Get file name
+    if (writeResult.path) {
+        const parts = writeResult.path.split('/');
+        fileName = parts[parts.length - 1] || writeResult.path;
+    }
+    const { isNewFile, oldContent, newContent, linesAdded, linesRemoved } = writeResult;
+    // Header and status
+    const statusText = isNewFile
+        ? `Succeeded. File created. (+${linesAdded} added)`
+        : `Succeeded. File edited. (+${linesAdded} added, -${linesRemoved} removed)`;
+    // Calculate max content width (terminal width - border - padding - line numbers)
+    const terminalWidth = getTerminalWidth();
+    const maxContentWidth = terminalWidth - 15; // Reserve space for borders, padding, line numbers
+    if (isNewFile) {
+        // New file: show only first 10 lines
+        const diffLines = [];
+        const contentLines = newContent.split('\n');
+        const MAX_DISPLAY_LINES = 10;
+        // Chỉ hiển thị 10 dòng đầu nếu file có nhiều hơn 10 dòng
+        const linesToShow = contentLines.length > MAX_DISPLAY_LINES
+            ? contentLines.slice(0, MAX_DISPLAY_LINES)
+            : contentLines;
+        linesToShow.forEach((line, idx) => {
+            const truncated = truncateLine(line, maxContentWidth);
+            diffLines.push(React.createElement(Box, { key: idx },
+                React.createElement(Text, { dimColor: true }, String(idx + 1).padStart(4, ' ')),
+                React.createElement(Text, { color: "green" }, ` + ${truncated}`)));
+        });
+        // Thêm dòng "..." nếu có nhiều hơn 10 dòng
+        if (contentLines.length > MAX_DISPLAY_LINES) {
+            diffLines.push(React.createElement(Box, { key: "truncated" },
+                React.createElement(Text, { dimColor: true },
+                    "... (",
+                    contentLines.length - MAX_DISPLAY_LINES,
+                    " more lines)")));
+        }
+        return (React.createElement(Box, { flexDirection: "column", width: terminalWidth - 2 },
+            React.createElement(Text, { bold: true, color: "cyan" },
+                "\uD83D\uDCDD APPLY PATCH ",
+                React.createElement(Text, { color: "gray" },
+                    "(",
+                    fileName,
+                    ")")),
+            React.createElement(Box, { marginLeft: 1, marginBottom: 1 },
+                React.createElement(Text, { color: "green" },
+                    "\u21B3 ",
+                    statusText)),
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, paddingY: 0, width: terminalWidth - 4 }, diffLines)));
+    }
+    else {
+        // File edited: show full diff
+        const diffLines = generateDiff(oldContent || '', newContent);
+        const compressedDiff = compressDiff(diffLines, 2);
+        const diffElements = [];
+        compressedDiff.forEach((line, idx) => {
+            if (line.content.startsWith('...') &&
+                line.content.includes('unchanged')) {
+                // Placeholder for skipped lines
+                diffElements.push(React.createElement(Box, { key: idx },
+                    React.createElement(Text, { dimColor: true }, line.content)));
+            }
+            else if (line.type === 'add') {
+                const truncated = truncateLine(line.content, maxContentWidth);
+                diffElements.push(React.createElement(Box, { key: idx },
+                    React.createElement(Text, { dimColor: true }, ' '.padStart(4, ' ')),
+                    React.createElement(Text, { dimColor: true }, "|"),
+                    React.createElement(Text, { dimColor: true }, String(line.newLineNum).padStart(4, ' ')),
+                    React.createElement(Text, { color: "green" }, ` + ${truncated}`)));
+            }
+            else if (line.type === 'remove') {
+                const truncated = truncateLine(line.content, maxContentWidth);
+                diffElements.push(React.createElement(Box, { key: idx },
+                    React.createElement(Text, { dimColor: true }, String(line.oldLineNum).padStart(4, ' ')),
+                    React.createElement(Text, { dimColor: true }, "|"),
+                    React.createElement(Text, { dimColor: true }, ' '.padStart(4, ' ')),
+                    React.createElement(Text, { color: "red" }, ` - ${truncated}`)));
+            }
+            else {
+                // Context line
+                const truncated = truncateLine(line.content, maxContentWidth);
+                diffElements.push(React.createElement(Box, { key: idx },
+                    React.createElement(Text, { dimColor: true }, String(line.oldLineNum).padStart(4, ' ')),
+                    React.createElement(Text, { dimColor: true }, "|"),
+                    React.createElement(Text, { dimColor: true }, String(line.newLineNum).padStart(4, ' ')),
+                    React.createElement(Text, null, `   ${truncated}`)));
+            }
+        });
+        // Add truncation notice if diff is too long
+        if (diffElements.length > 30) {
+            diffElements.splice(30);
+            diffElements.push(React.createElement(Box, { key: "truncated" },
+                React.createElement(Text, { dimColor: true }, "... (diff truncated for display)")));
+        }
+        return (React.createElement(Box, { flexDirection: "column", width: terminalWidth - 2 },
+            React.createElement(Text, { bold: true, color: "cyan" },
+                "\uD83D\uDCDD APPLY PATCH ",
+                React.createElement(Text, { color: "gray" },
+                    "(",
+                    fileName,
+                    ")")),
+            React.createElement(Box, { marginLeft: 1, marginBottom: 1 },
+                React.createElement(Text, { color: "green" },
+                    "\u21B3 ",
+                    statusText)),
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, paddingY: 0, width: terminalWidth - 4 }, diffElements)));
+    }
+};
+/**
+ * Format command execution output
+ * Pattern: ⚡ EXECUTE (command)
+ *          ↳ ✓ Success. Output: X lines. (hoặc ✗ Failed)
+ */
+const formatCommandRun = (content, toolInfo) => {
+    let isSuccess = true;
+    let outputLines = 0;
+    let command = 'command';
+    // Get command from toolInfo args
+    if (toolInfo?.args?.command) {
+        command = toolInfo.args.command;
+    }
+    // Parse content to determine success/failure
+    if (content) {
+        // Format: stdout:\n...\n\nstderr:\n...
+        const stdoutMatch = content.match(/stdout:\n([\s\S]*?)\n\nstderr:/);
+        const stderrMatch = content.match(/stderr:\n([\s\S]*)/);
+        if (stdoutMatch && stdoutMatch[1]) {
+            const lines = stdoutMatch[1].split('\n').filter(line => line.trim());
+            outputLines = lines.length;
+        }
+        // Check if there's meaningful error content in stderr
+        if (stderrMatch && stderrMatch[1]) {
+            const stderrContent = stderrMatch[1].trim();
+            // Some commands output warnings to stderr but still succeed
+            // Only mark as failed if there's actual error content
+            if (stderrContent && stderrContent.toLowerCase().includes('error')) {
+                isSuccess = false;
+            }
+        }
+        // Check for common error indicators
+        if (content.toLowerCase().includes('command not found') ||
+            content.toLowerCase().includes('no such file') ||
+            content.toLowerCase().includes('permission denied')) {
+            isSuccess = false;
+        }
+    }
+    const statusIcon = isSuccess ? '✓' : '✗';
+    const statusText = isSuccess ? 'Success' : 'Failed';
+    const statusColor = isSuccess ? 'green' : 'red';
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true, color: "cyan" },
+            "\u26A1 EXECUTE ",
+            React.createElement(Text, { color: "gray" },
+                "(",
+                command,
+                ")")),
+        React.createElement(Box, { marginLeft: 1 },
+            React.createElement(Text, { color: statusColor },
+                "\u21B3 ",
+                statusIcon,
+                " ",
+                statusText,
+                ". Output: ",
+                outputLines,
+                " lines."))));
+};
+/**
+ * Normalize tool name by removing "galaxy:" prefix if present
+ */
+const normalizeToolName = (toolName) => {
+    if (!toolName)
+        return '';
+    return toolName.replace(/^galaxy:/, '');
+};
+/**
+ * Main formatter dispatcher
+ */
+export function formatMessage(content, toolName, toolInfo) {
+    // Normalize tool name
+    const normalizedToolName = normalizeToolName(toolName);
+    // Convert to string if needed
+    const contentStr = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+    // Match tool-specific formatters
+    switch (normalizedToolName) {
+        case 'file_tree':
+            return formatFileTree(contentStr, toolInfo);
+        case 'file_read':
+            return formatFileRead(contentStr, toolInfo);
+        case 'file_write':
+            return formatFileWrite(contentStr, toolInfo);
+        case 'command_run':
+            return formatCommandRun(contentStr, toolInfo);
+        case 'plan_task':
+            // Plan is already displayed in planning list, don't show tool result
+            return null;
+        case 'progress_reporter':
+            // Progress updates are shown in planning list status, don't show tool result
+            return null;
+        case 'todos':
+            return formatTodos(contentStr);
+        case 'diff':
+            return formatDiff(contentStr, toolName);
+        case 'code':
+            return formatCode(contentStr);
+        default:
+            // Full content display with word wrap
+            return React.createElement(Text, { wrap: "wrap" }, contentStr);
+    }
+}

package/dist/utils/progress-tracker.d.ts

@@ -0,0 +1,59 @@
+export interface ProgressStep {
+    step: number;
+    action: string;
+    status: 'pending' | 'in-progress' | 'completed' | 'failed';
+    startTime?: Date;
+    endTime?: Date;
+    error?: string;
+    filesCreated?: string[];
+}
+export interface ProjectProgress {
+    projectName: string;
+    startTime: Date;
+    lastUpdated: Date;
+    currentStep: number;
+    totalSteps: number;
+    steps: ProgressStep[];
+}
+export declare class ProgressTracker {
+    private progressFilePath;
+    private progress;
+    constructor(workingDir?: string);
+    /**
+     * Initialize new progress tracking
+     */
+    initializeProgress(projectName: string, steps: ProgressStep[]): void;
+    /**
+     * Load existing progress
+     */
+    loadProgress(): ProjectProgress | null;
+    /**
+     * Update step status
+     */
+    updateStepStatus(stepNum: number, status: ProgressStep['status'], error?: string, filesCreated?: string[]): void;
+    /**
+     * Generate markdown content
+     */
+    private generateMarkdown;
+    /**
+     * Save progress to markdown file
+     */
+    saveProgress(): void;
+    /**
+     * Get current progress
+     */
+    getProgress(): ProjectProgress | null;
+    /**
+     * Check if progress file exists
+     */
+    hasProgress(): boolean;
+    /**
+     * Clear progress (delete file)
+     */
+    clearProgress(): void;
+    /**
+     * Get progress file path
+     */
+    getProgressFilePath(): string;
+}
+export declare const progressTracker: ProgressTracker;