aiexecode 1.0.75 → 1.0.81

package/src/frontend/utils/markdownParser.js

@@ -6,226 +6,372 @@
 import React from 'react';
 import { Text, Box } from 'ink';
 import { theme } from '../design/themeColors.js';
+import { colorizeCode } from './syntaxHighlighter.js';
+import { GridRenderer } from './GridRenderer.js';
+import { ProcessInlineText } from './InlineFormatter.js';
+
+// 렌더링 상수
+const SPACING = {
+    EMPTY_LINE: 1,
+    CODE_PADDING: 1,
+    LIST_PREFIX_PAD: 1,
+    LIST_TEXT_GROW: 1
+};
 
 /**
  * 마크다운 텍스트를 파싱하여 Ink 컴포넌트로 변환
+ * @param {string} text - 마크다운 텍스트
+ * @param {Object} options - 렌더링 옵션
+ * @param {boolean} options.isPending - 스트리밍 중 여부
+ * @param {number} options.availableHeight - 사용 가능한 터미널 높이
+ * @param {number} options.terminalWidth - 터미널 너비 (기본값: 80)
+ * @returns {React.ReactNode}
  */
-export function renderMarkdown(text) {
+export function renderMarkdown(text, options = {}) {
     if (!text) return null;
 
-    const lines = text.split('\n');
-    const elements = [];
-    let inCodeBlock = false;
-    let codeLines = [];
-    let codeLanguage = '';
-
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-
-        // Code block 처리
-        if (line.trim().startsWith('```')) {
-            if (inCodeBlock) {
-                // Code block 끝
-                if (codeLines.length > 0) {
-                    elements.push(
-                        React.createElement(Box, {
-                            key: `code-${i}`,
-                            flexDirection: 'column',
-                            borderStyle: 'round',
-                            borderColor: theme.text.secondary,
-                            paddingX: 1,
-                            marginY: 0
-                        },
-                            React.createElement(Text, { color: theme.text.secondary }, codeLines.join('\n'))
-                        )
-                    );
-                }
-                codeLines = [];
-                codeLanguage = '';
-                inCodeBlock = false;
+    const {
+        isPending = false,
+        availableHeight,
+        terminalWidth = 80
+    } = options;
+
+    const lineArray = text.split(/\r?\n/);
+
+    // 정규식 패턴
+    const patterns = {
+        header: /^ *(#{1,4}) +(.*)/,
+        codeFence: /^ *(`{3,}|~{3,}) *(\w*?) *$/,
+        unorderedList: /^([ \t]*)([-*+]) +(.*)/,
+        orderedList: /^([ \t]*)(\d+)\. +(.*)/,
+        horizontalRule: /^ *([-*_] *){3,} *$/,
+        tableRow: /^\s*\|(.+)\|\s*$/,
+        tableSeparator: /^\s*\|?\s*(:?-+:?)\s*(\|\s*(:?-+:?)\s*)+\|?\s*$/
+    };
+
+    const blocks = [];
+    let previousLineWasEmpty = true;
+
+    // 상태 변수
+    let codeBlockActive = false;
+    let codeBlockLines = [];
+    let codeBlockLanguage = null;
+    let codeBlockFence = '';
+
+    let tableActive = false;
+    let tableHeaderCells = [];
+    let tableDataRows = [];
+
+    function appendBlock(block) {
+        if (block) {
+            blocks.push(block);
+            previousLineWasEmpty = false;
+        }
+    }
+
+    lineArray.forEach((currentLine, lineIndex) => {
+        const lineKey = `ln-${lineIndex}`;
+
+        // 코드 블록 내부 처리
+        if (codeBlockActive) {
+            const fenceMatch = currentLine.match(patterns.codeFence);
+            if (fenceMatch &&
+                fenceMatch[1].startsWith(codeBlockFence[0]) &&
+                fenceMatch[1].length >= codeBlockFence.length) {
+                appendBlock(
+                    React.createElement(BuildCodeBlock, {
+                        key: lineKey,
+                        lines: codeBlockLines,
+                        language: codeBlockLanguage,
+                        isPending,
+                        availableHeight,
+                        terminalWidth
+                    })
+                );
+                codeBlockActive = false;
+                codeBlockLines = [];
+                codeBlockLanguage = null;
+                codeBlockFence = '';
             } else {
-                // Code block 시작
-                codeLanguage = line.trim().slice(3).trim();
-                inCodeBlock = true;
+                codeBlockLines.push(currentLine);
             }
-            continue;
+            return;
         }
 
-        if (inCodeBlock) {
-            codeLines.push(line);
-            continue;
-        }
+        // 패턴 매칭
+        const fenceMatch = currentLine.match(patterns.codeFence);
+        const headerMatch = currentLine.match(patterns.header);
+        const ulMatch = currentLine.match(patterns.unorderedList);
+        const olMatch = currentLine.match(patterns.orderedList);
+        const hrMatch = currentLine.match(patterns.horizontalRule);
+        const tableRowMatch = currentLine.match(patterns.tableRow);
+        const tableSepMatch = currentLine.match(patterns.tableSeparator);
 
-        // 빈 줄
-        if (line.trim() === '') {
-            elements.push(React.createElement(Text, { key: `empty-${i}` }, ''));
-            continue;
+        // 코드 블록 시작
+        if (fenceMatch) {
+            codeBlockActive = true;
+            codeBlockFence = fenceMatch[1];
+            codeBlockLanguage = fenceMatch[2] || null;
+        }
+        // 테이블 시작 감지
+        else if (tableRowMatch && !tableActive) {
+            if (lineIndex + 1 < lineArray.length &&
+                lineArray[lineIndex + 1].match(patterns.tableSeparator)) {
+                tableActive = true;
+                tableHeaderCells = tableRowMatch[1].split('|').map(cell => cell.trim());
+                tableDataRows = [];
+            } else {
+                appendBlock(
+                    React.createElement(Box, { key: lineKey },
+                        React.createElement(Text, { wrap: 'wrap' },
+                            React.createElement(ProcessInlineText, { content: currentLine })
+                        )
+                    )
+                );
+            }
+        }
+        // 테이블 구분선 스킵
+        else if (tableActive && tableSepMatch) {
+            // 구분선은 무시
+        }
+        // 테이블 데이터 행
+        else if (tableActive && tableRowMatch) {
+            const cells = tableRowMatch[1].split('|').map(cell => cell.trim());
+            while (cells.length < tableHeaderCells.length) cells.push('');
+            if (cells.length > tableHeaderCells.length) cells.length = tableHeaderCells.length;
+            tableDataRows.push(cells);
         }
+        // 테이블 종료
+        else if (tableActive && !tableRowMatch) {
+            if (tableHeaderCells.length > 0 && tableDataRows.length > 0) {
+                appendBlock(
+                    React.createElement(BuildTable, {
+                        key: `table-${blocks.length}`,
+                        columnHeaders: tableHeaderCells,
+                        dataRows: tableDataRows,
+                        maxWidth: terminalWidth
+                    })
+                );
+            }
+            tableActive = false;
+            tableDataRows = [];
+            tableHeaderCells = [];
 
-        // Heading 처리 (### 먼저 검사 - 긴 것부터)
-        if (line.startsWith('### ')) {
-            elements.push(
-                React.createElement(Box, {
-                    key: `h3-${i}`,
-                    flexDirection: 'row'
-                },
-                    React.createElement(Text, {
-                        color: theme.text.accent,
-                        bold: true
-                    }, renderInlineMarkdown(line.slice(4)))
-                )
-            );
-            continue;
+            // 현재 줄 처리
+            if (currentLine.trim().length > 0) {
+                appendBlock(
+                    React.createElement(Box, { key: lineKey },
+                        React.createElement(Text, { wrap: 'wrap' },
+                            React.createElement(ProcessInlineText, { content: currentLine })
+                        )
+                    )
+                );
+            }
         }
-        if (line.startsWith('## ')) {
-            elements.push(
-                React.createElement(Box, {
-                    key: `h2-${i}`,
-                    flexDirection: 'row'
-                },
-                    React.createElement(Text, {
-                        color: theme.text.accent,
-                        bold: true
-                    }, renderInlineMarkdown(line.slice(3)))
+        // 수평선
+        else if (hrMatch) {
+            appendBlock(
+                React.createElement(Box, { key: lineKey },
+                    React.createElement(Text, { dimColor: true }, '---')
                 )
             );
-            continue;
         }
-        if (line.startsWith('# ')) {
-            elements.push(
-                React.createElement(Box, {
-                    key: `h1-${i}`,
-                    flexDirection: 'row'
-                },
-                    React.createElement(Text, {
-                        color: theme.text.accent,
-                        bold: true
-                    }, renderInlineMarkdown(line.slice(2)))
-                )
+        // 헤더
+        else if (headerMatch) {
+            const level = headerMatch[1].length;
+            const headerText = headerMatch[2];
+            let headerElement = null;
+
+            switch (level) {
+                case 1:
+                    headerElement = React.createElement(Text, { bold: true, color: theme.text.link },
+                        React.createElement(ProcessInlineText, { content: headerText })
+                    );
+                    break;
+                case 2:
+                    headerElement = React.createElement(Text, { bold: true, color: theme.text.link },
+                        React.createElement(ProcessInlineText, { content: headerText })
+                    );
+                    break;
+                case 3:
+                    headerElement = React.createElement(Text, { bold: true, color: theme.text.primary },
+                        React.createElement(ProcessInlineText, { content: headerText })
+                    );
+                    break;
+                case 4:
+                    headerElement = React.createElement(Text, { italic: true, color: theme.text.secondary },
+                        React.createElement(ProcessInlineText, { content: headerText })
+                    );
+                    break;
+                default:
+                    headerElement = React.createElement(Text, { color: theme.text.primary },
+                        React.createElement(ProcessInlineText, { content: headerText })
+                    );
+            }
+            if (headerElement) {
+                appendBlock(React.createElement(Box, { key: lineKey }, headerElement));
+            }
+        }
+        // 순서 없는 리스트
+        else if (ulMatch) {
+            const [, indent, marker, content] = ulMatch;
+            appendBlock(
+                React.createElement(BuildListItem, {
+                    key: lineKey,
+                    itemText: content,
+                    listType: 'ul',
+                    marker: marker,
+                    indentation: indent
+                })
             );
-            continue;
         }
-
-        // 리스트 항목 처리
-        const listMatch = line.match(/^(\s*)([-*•])\s+(.+)$/);
-        if (listMatch) {
-            const [, indent, bullet, content] = listMatch;
-            elements.push(
-                React.createElement(Box, {
-                    key: `list-${i}`,
-                    flexDirection: 'row',
-                    marginLeft: indent.length
-                },
-                    React.createElement(Text, { color: theme.text.accent }, bullet + ' '),
-                    React.createElement(Text, null, renderInlineMarkdown(content))
-                )
+        // 순서 있는 리스트
+        else if (olMatch) {
+            const [, indent, marker, content] = olMatch;
+            appendBlock(
+                React.createElement(BuildListItem, {
+                    key: lineKey,
+                    itemText: content,
+                    listType: 'ol',
+                    marker: marker,
+                    indentation: indent
+                })
             );
-            continue;
         }
+        // 빈 줄 또는 일반 텍스트
+        else {
+            if (currentLine.trim().length === 0 && !codeBlockActive) {
+                if (!previousLineWasEmpty) {
+                    blocks.push(
+                        React.createElement(Box, {
+                            key: `space-${lineIndex}`,
+                            height: SPACING.EMPTY_LINE
+                        })
+                    );
+                    previousLineWasEmpty = true;
+                }
+            } else {
+                appendBlock(
+                    React.createElement(Box, { key: lineKey },
+                        React.createElement(Text, { wrap: 'wrap', color: theme.text.primary },
+                            React.createElement(ProcessInlineText, { content: currentLine })
+                        )
+                    )
+                );
+            }
+        }
+    });
 
-        // 일반 텍스트 (인라인 마크다운 처리)
-        elements.push(
-            React.createElement(Box, {
-                key: `line-${i}`,
-                flexDirection: 'row'
-            },
-                React.createElement(Text, null, renderInlineMarkdown(line))
-            )
+    // 닫히지 않은 코드 블록 처리
+    if (codeBlockActive) {
+        appendBlock(
+            React.createElement(BuildCodeBlock, {
+                key: 'eof-code',
+                lines: codeBlockLines,
+                language: codeBlockLanguage,
+                isPending,
+                availableHeight,
+                terminalWidth
+            })
         );
     }
 
-    return React.createElement(Box, { flexDirection: 'column' }, elements);
+    // 닫히지 않은 테이블 처리
+    if (tableActive && tableHeaderCells.length > 0 && tableDataRows.length > 0) {
+        appendBlock(
+            React.createElement(BuildTable, {
+                key: `table-${blocks.length}`,
+                columnHeaders: tableHeaderCells,
+                dataRows: tableDataRows,
+                maxWidth: terminalWidth
+            })
+        );
+    }
+
+    return React.createElement(React.Fragment, null, blocks);
 }
 
 /**
- * 인라인 마크다운 처리 (**, `, 등)
+ * 코드 블록 렌더링 컴포넌트
  */
-function renderInlineMarkdown(text) {
-    const parts = [];
-    let currentIndex = 0;
-    let partKey = 0;
-
-    // 모든 마크다운 패턴 찾기 (정규식 재생성하여 lastIndex 문제 방지)
-    const patterns = [];
-
-    // **bold** 패턴 찾기
-    let boldRegex = /\*\*([^*]+)\*\*/g;
-    let match;
-    while ((match = boldRegex.exec(text)) !== null) {
-        patterns.push({
-            type: 'bold',
-            start: match.index,
-            end: match.index + match[0].length,
-            content: match[1]
-        });
-    }
-
-    // `code` 패턴 찾기
-    let codeRegex = /`([^`]+)`/g;
-    while ((match = codeRegex.exec(text)) !== null) {
-        patterns.push({
-            type: 'code',
-            start: match.index,
-            end: match.index + match[0].length,
-            content: match[1]
-        });
-    }
+const BuildCodeBlockInternal = ({ lines, language, isPending, availableHeight, terminalWidth }) => {
+    const MIN_LINES_BEFORE_MSG = 1;
+    const RESERVED_LINES = 2;
 
-    // 시작 위치로 정렬
-    patterns.sort((a, b) => a.start - b.start);
+    if (isPending && availableHeight !== undefined) {
+        const maxLines = Math.max(0, availableHeight - RESERVED_LINES);
 
-    // 겹치는 패턴 제거 (먼저 나온 패턴 우선)
-    const filteredPatterns = [];
-    let lastEnd = 0;
-    for (const pattern of patterns) {
-        if (pattern.start >= lastEnd) {
-            filteredPatterns.push(pattern);
-            lastEnd = pattern.end;
-        }
-    }
-
-    // 패턴 적용
-    for (const pattern of filteredPatterns) {
-        // 이전 텍스트 추가
-        if (currentIndex < pattern.start) {
-            const plainText = text.slice(currentIndex, pattern.start);
-            if (plainText) {
-                parts.push(
-                    React.createElement(Text, { key: `text-${partKey++}` }, plainText)
+        if (lines.length > maxLines) {
+            if (maxLines < MIN_LINES_BEFORE_MSG) {
+                return React.createElement(Box, { paddingLeft: SPACING.CODE_PADDING },
+                    React.createElement(Text, { color: theme.text.secondary },
+                        '... code is being written ...'
+                    )
                 );
             }
-        }
 
-        // 패턴 적용된 텍스트 추가
-        if (pattern.type === 'bold') {
-            parts.push(
-                React.createElement(Text, {
-                    key: `bold-${partKey++}`,
-                    bold: true,
-                    color: theme.text.primary
-                }, pattern.content)
-            );
-        } else if (pattern.type === 'code') {
-            parts.push(
-                React.createElement(Text, {
-                    key: `code-${partKey++}`,
-                    color: theme.status.warning
-                }, pattern.content)
-            );
-        }
-
-        currentIndex = pattern.end;
-    }
+            const truncatedLines = lines.slice(0, maxLines);
+            const truncatedCode = colorizeCode(truncatedLines.join('\n'), language, true);
 
-    // 남은 텍스트 추가
-    if (currentIndex < text.length) {
-        const remainingText = text.slice(currentIndex);
-        if (remainingText) {
-            parts.push(
-                React.createElement(Text, { key: `text-${partKey++}` }, remainingText)
+            return React.createElement(Box, {
+                paddingLeft: SPACING.CODE_PADDING,
+                flexDirection: 'column'
+            },
+                truncatedCode,
+                React.createElement(Text, { color: theme.text.secondary },
+                    '... generating more ...'
+                )
             );
         }
     }
 
-    return parts.length > 0 ? parts : text;
-}
+    const fullCode = lines.join('\n');
+    const highlightedCode = colorizeCode(fullCode, language, true);
+
+    return React.createElement(Box, {
+        paddingLeft: SPACING.CODE_PADDING,
+        flexDirection: 'column',
+        width: terminalWidth,
+        flexShrink: 0
+    }, highlightedCode);
+};
+
+const BuildCodeBlock = React.memo(BuildCodeBlockInternal);
+
+/**
+ * 리스트 항목 렌더링 컴포넌트
+ */
+const BuildListItemInternal = ({ itemText, listType, marker, indentation = '' }) => {
+    const displayPrefix = listType === 'ol' ? `${marker}. ` : `${marker} `;
+    const prefixLength = displayPrefix.length;
+    const indentAmount = indentation.length;
+
+    return React.createElement(Box, {
+        paddingLeft: indentAmount + SPACING.LIST_PREFIX_PAD,
+        flexDirection: 'row'
+    },
+        React.createElement(Box, { width: prefixLength },
+            React.createElement(Text, { color: theme.text.primary }, displayPrefix)
+        ),
+        React.createElement(Box, { flexGrow: SPACING.LIST_TEXT_GROW },
+            React.createElement(Text, { wrap: 'wrap', color: theme.text.primary },
+                React.createElement(ProcessInlineText, { content: itemText })
+            )
+        )
+    );
+};
+
+const BuildListItem = React.memo(BuildListItemInternal);
+
+/**
+ * 테이블 렌더링 컴포넌트
+ */
+const BuildTableInternal = ({ columnHeaders, dataRows, maxWidth }) => {
+    return React.createElement(GridRenderer, {
+        columnHeaders,
+        dataRows,
+        maxWidth
+    });
+};
+
+const BuildTable = React.memo(BuildTableInternal);

package/src/util/version_check.js

@@ -0,0 +1,116 @@
+/**
+ * Version check utility
+ * Compares local version with remote version from GitHub
+ */
+
+import { createDebugLogger } from './debug_log.js';
+import https from 'https';
+
+const debugLog = createDebugLogger('version_check.log', 'version_check');
+
+const REMOTE_PACKAGE_JSON_URL = 'https://raw.githubusercontent.com/kstost/aiexecode/refs/heads/main/package.json';
+const TIMEOUT_MS = 5000; // 5 seconds timeout
+
+/**
+ * Fetch remote package.json from GitHub
+ * @returns {Promise<Object|null>} Remote package.json object or null on error
+ */
+async function fetchRemotePackageJson() {
+    return new Promise((resolve) => {
+        const req = https.get(REMOTE_PACKAGE_JSON_URL, { timeout: TIMEOUT_MS }, (res) => {
+            let data = '';
+
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                if (res.statusCode === 200) {
+                    try {
+                        const packageJson = JSON.parse(data);
+                        resolve(packageJson);
+                    } catch (err) {
+                        debugLog(`Failed to parse remote package.json: ${err.message}`);
+                        resolve(null);
+                    }
+                } else {
+                    debugLog(`HTTP ${res.statusCode} when fetching remote package.json`);
+                    resolve(null);
+                }
+            });
+        });
+
+        req.on('error', (err) => {
+            debugLog(`Network error when fetching remote package.json: ${err.message}`);
+            resolve(null);
+        });
+
+        req.on('timeout', () => {
+            debugLog('Timeout when fetching remote package.json');
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} version1 - First version (e.g., "1.0.76")
+ * @param {string} version2 - Second version (e.g., "1.0.77")
+ * @returns {number} -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+ */
+function compareVersions(version1, version2) {
+    const v1parts = version1.split('.').map(Number);
+    const v2parts = version2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
+        const v1 = v1parts[i] || 0;
+        const v2 = v2parts[i] || 0;
+
+        if (v1 < v2) return -1;
+        if (v1 > v2) return 1;
+    }
+
+    return 0;
+}
+
+/**
+ * Check for available updates
+ * @param {string} currentVersion - Current local version
+ * @returns {Promise<Object>} Object with { hasUpdate: boolean, remoteVersion: string|null, updateAvailable: boolean }
+ */
+export async function checkForUpdates(currentVersion) {
+    debugLog(`Checking for updates... Current version: ${currentVersion}`);
+
+    const remotePackageJson = await fetchRemotePackageJson();
+
+    if (!remotePackageJson || !remotePackageJson.version) {
+        debugLog('Could not fetch remote version');
+        return {
+            hasUpdate: false,
+            remoteVersion: null,
+            updateAvailable: false
+        };
+    }
+
+    const remoteVersion = remotePackageJson.version;
+    debugLog(`Remote version: ${remoteVersion}`);
+
+    const comparison = compareVersions(currentVersion, remoteVersion);
+
+    if (comparison < 0) {
+        debugLog(`Update available: ${currentVersion} → ${remoteVersion}`);
+        return {
+            hasUpdate: true,
+            remoteVersion,
+            updateAvailable: true
+        };
+    } else {
+        debugLog('No update available (local version is up to date or newer)');
+        return {
+            hasUpdate: false,
+            remoteVersion,
+            updateAvailable: false
+        };
+    }
+}