aegiscode 3.1.8 → 3.1.10

package/src/ui/components/markdown/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Markdown 组件导出
+ */
+
+export * from './types.js';
+export { parseMarkdown, stripMarkdown } from './parser.js';
+export { MessageRenderer } from './MessageRenderer.js';
+export { CodeHighlighter } from './CodeHighlighter.js';

package/src/ui/components/markdown/parser.ts

@@ -0,0 +1,336 @@
+/**
+ * Markdown 解析器
+ * 
+ * 
+ */
+
+import type { ParsedBlock, TableData } from './types.js';
+
+/** 已知的编程语言标识列表（用于区分 language 和 file path） */
+const KNOWN_LANGUAGES = new Set([
+  'javascript', 'js', 'typescript', 'ts', 'tsx', 'jsx',
+  'python', 'py', 'ruby', 'rb', 'go', 'rust', 'rs',
+  'java', 'kotlin', 'kt', 'scala', 'swift', 'c', 'cpp', 'h',
+  'csharp', 'cs', 'php', 'lua', 'perl', 'r', 'sql',
+  'html', 'css', 'scss', 'sass', 'less',
+  'json', 'yaml', 'yml', 'toml', 'xml', 'ini', 'env',
+  'bash', 'sh', 'zsh', 'fish', 'powershell', 'ps1',
+  'markdown', 'md', 'text', 'txt', 'plain',
+  'diff', 'patch', 'dockerfile', 'makefile', 'cmake',
+  'graphql', 'gql', 'proto', 'protobuf',
+  'vim', 'elixir', 'ex', 'erlang', 'haskell', 'hs',
+  'ocaml', 'ml', 'fsharp', 'clojure', 'lisp', 'scheme',
+  'dart', 'zig', 'nim', 'v', 'wasm', 'solidity', 'sol',
+]);
+
+/**
+ * 
+ * 
+ * 
+ *   ```typescript                → { language: 'typescript' }
+ *   ```typescript:src/main.tsx   → { language: 'typescript', filePath: 'src/main.tsx' }
+ *   ```src/main.tsx              → { language: 'typescript', filePath: 'src/main.tsx' }
+ *   ```12:30:src/main.tsx        → { language: undefined, filePath: 'src/main.tsx', startLine: 12 }
+ */
+function parseCodeBlockSpec(spec: string | null): { language?: string; filePath?: string; startLine?: number } {
+  if (!spec) return {};
+
+  // Format: startLine:endLine:filepath (e.g., 12:30:src/main.tsx)
+  const lineRefMatch = spec.match(/^(\d+):(\d+):(.+)$/);
+  if (lineRefMatch) {
+    const filePath = lineRefMatch[3];
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    return {
+      language: ext && KNOWN_LANGUAGES.has(ext) ? ext : undefined,
+      filePath,
+      startLine: parseInt(lineRefMatch[1], 10),
+    };
+  }
+
+  // Format: language:filepath (e.g., typescript:src/main.tsx)
+  const colonIdx = spec.indexOf(':');
+  if (colonIdx > 0) {
+    const before = spec.slice(0, colonIdx).toLowerCase();
+    const after = spec.slice(colonIdx + 1);
+    if (KNOWN_LANGUAGES.has(before) && after.length > 0) {
+      return { language: before, filePath: after };
+    }
+  }
+
+  // Plain language (e.g., typescript)
+  if (KNOWN_LANGUAGES.has(spec.toLowerCase())) {
+    return { language: spec.toLowerCase() };
+  }
+
+  // Might be a file path (contains / or .)
+  if (spec.includes('/') || spec.includes('.')) {
+    const ext = spec.split('.').pop()?.toLowerCase();
+    return {
+      language: ext && KNOWN_LANGUAGES.has(ext) ? ext : undefined,
+      filePath: spec,
+    };
+  }
+
+  // Fallback: treat as language
+  return { language: spec };
+}
+
+/**
+ * Markdown 模式匹配
+ */
+const MARKDOWN_PATTERNS = {
+  codeBlock: /^(\s*)```([^\s]*?)?\s*$/,
+  heading: /^(#{1,6})\s+(.+)/,
+  ulItem: /^(\s*)([-*+])\s+(.+)/,
+  olItem: /^(\s*)(\d+)\.\s+(.+)/,
+  hr: /^[-*_]{3,}\s*$/,
+  table: /^\|(.+)\|$/,
+  tableSeparator: /^\|[\s]*:?-+:?[\s]*(\|[\s]*:?-+:?[\s]*)+\|?$/,
+  blockquote: /^>\s*(.*)$/,
+  empty: /^\s*$/,
+} as const;
+
+/**
+ * 
+ */
+const INLINE_PATTERNS = {
+  bold: /\*\*(.+?)\*\*/g,
+  italic: /\*(.+?)\*/g,
+  code: /`([^`]+)`/g,
+  strikethrough: /~~(.+?)~~/g,
+  link: /\[([^\]]+)\]\(([^)]+)\)/g,
+} as const;
+
+/**
+ * 
+ */
+export function parseMarkdown(content: string): ParsedBlock[] {
+  const blocks: ParsedBlock[] = [];
+  const lines = content.split(/\r?\n/);
+
+  let inCodeBlock = false;
+  let codeBlockContent: string[] = [];
+  let codeBlockSpec: ReturnType<typeof parseCodeBlockSpec> = {};
+  let codeBlockIndent = 0; // 代码块开始行的缩进
+
+  let inTable = false;
+  let tableHeaders: string[] = [];
+  let tableRows: string[][] = [];
+  let tableAlignments: ('left' | 'center' | 'right')[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // ===== 代码块处
+    if (inCodeBlock) {
+      const match = line.match(MARKDOWN_PATTERNS.codeBlock);
+      if (match && match[2] === undefined) {
+        // 代码块结
+        blocks.push({
+          type: 'code',
+          content: codeBlockContent.join('\n'),
+          language: codeBlockSpec.language,
+          filePath: codeBlockSpec.filePath,
+        });
+        inCodeBlock = false;
+        codeBlockContent = [];
+        codeBlockSpec = {};
+        codeBlockIndent = 0;
+      } else {
+        // 去除代码块开始行的缩进量（处理缩进代码
+        const stripped = codeBlockIndent > 0 && line.startsWith(' '.repeat(codeBlockIndent))
+          ? line.slice(codeBlockIndent)
+          : line;
+        codeBlockContent.push(stripped);
+      }
+      continue;
+    }
+
+    // 检查代码块开
+    const codeMatch = line.match(MARKDOWN_PATTERNS.codeBlock);
+    if (codeMatch) {
+      // 先完成表
+      if (inTable) {
+        blocks.push(createTableBlock(tableHeaders, tableRows, tableAlignments));
+        inTable = false;
+        tableHeaders = [];
+        tableRows = [];
+        tableAlignments = [];
+      }
+      
+      inCodeBlock = true;
+      codeBlockIndent = codeMatch[1]?.length || 0; // 记录缩进
+      codeBlockSpec = parseCodeBlockSpec(codeMatch[2] || null);
+      continue;
+    }
+
+    // ===== 表格处
+    if (MARKDOWN_PATTERNS.table.test(line)) {
+      const cells = parseTableRow(line);
+      
+      if (!inTable) {
+        // 可能是表
+        tableHeaders = cells;
+        inTable = true;
+        continue;
+      }
+      
+      // 检查是否是分隔
+      if (MARKDOWN_PATTERNS.tableSeparator.test(line)) {
+        tableAlignments = parseTableAlignments(line);
+        continue;
+      }
+      
+      // 数据
+      tableRows.push(cells);
+      continue;
+    } else if (inTable) {
+      // 表格结
+      blocks.push(createTableBlock(tableHeaders, tableRows, tableAlignments));
+      inTable = false;
+      tableHeaders = [];
+      tableRows = [];
+      tableAlignments = [];
+    }
+
+    // ===== 空
+    if (MARKDOWN_PATTERNS.empty.test(line)) {
+      blocks.push({ type: 'empty', content: '' });
+      continue;
+    }
+
+    // ===== 水平
+    if (MARKDOWN_PATTERNS.hr.test(line)) {
+      blocks.push({ type: 'hr', content: '' });
+      continue;
+    }
+
+    // ===== 标
+    const headingMatch = line.match(MARKDOWN_PATTERNS.heading);
+    if (headingMatch) {
+      blocks.push({
+        type: 'heading',
+        content: headingMatch[2],
+        level: headingMatch[1].length,
+      });
+      continue;
+    }
+
+    // ===== 无序列
+    const ulMatch = line.match(MARKDOWN_PATTERNS.ulItem);
+    if (ulMatch) {
+      blocks.push({
+        type: 'list',
+        content: ulMatch[3],
+        listType: 'ul',
+        marker: ulMatch[2],
+        indent: ulMatch[1].length,
+      });
+      continue;
+    }
+
+    // ===== 有序列
+    const olMatch = line.match(MARKDOWN_PATTERNS.olItem);
+    if (olMatch) {
+      blocks.push({
+        type: 'list',
+        content: olMatch[3],
+        listType: 'ol',
+        marker: olMatch[2] + '.',
+        indent: olMatch[1].length,
+      });
+      continue;
+    }
+
+    // ===== 引
+    const blockquoteMatch = line.match(MARKDOWN_PATTERNS.blockquote);
+    if (blockquoteMatch) {
+      blocks.push({
+        type: 'blockquote',
+        content: blockquoteMatch[1],
+      });
+      continue;
+    }
+
+    // ===== 普通文
+    blocks.push({ type: 'text', content: line });
+  }
+
+  // Suppress empty code blocks during streaming — content arrives fast enough
+  // that the flash of an empty box is worse UX than a 1-frame delay.
+  if (inCodeBlock && codeBlockContent.length > 0) {
+    blocks.push({
+      type: 'code',
+      content: codeBlockContent.join('\n'),
+      language: codeBlockSpec.language,
+      filePath: codeBlockSpec.filePath,
+    });
+  }
+
+  // 处理未结束的表
+  if (inTable && tableHeaders.length > 0) {
+    blocks.push(createTableBlock(tableHeaders, tableRows, tableAlignments));
+  }
+
+  return blocks;
+}
+
+/**
+ * 
+ */
+function parseTableRow(line: string): string[] {
+  return line
+    .slice(1, -1) // 去掉首尾
+    .split('|')
+    .map(cell => cell.trim());
+}
+
+/**
+ * 
+ */
+function parseTableAlignments(line: string): ('left' | 'center' | 'right')[] {
+  return line
+    .slice(1, -1)
+    .split('|')
+    .map(cell => {
+      const trimmed = cell.trim();
+      if (trimmed.startsWith(':') && trimmed.endsWith(':')) {
+        return 'center';
+      }
+      if (trimmed.endsWith(':')) {
+        return 'right';
+      }
+      return 'left';
+    });
+}
+
+/**
+ * 
+ */
+function createTableBlock(
+  headers: string[],
+  rows: string[][],
+  alignments: ('left' | 'center' | 'right')[]
+): ParsedBlock {
+  return {
+    type: 'table',
+    content: '',
+    tableData: {
+      headers,
+      rows,
+      alignments: alignments.length > 0 ? alignments : headers.map(() => 'left'),
+    },
+  };
+}
+
+/**
+ * 
+ */
+export function stripMarkdown(text: string): string {
+  return text
+    .replace(/\*\*(.+?)\*\*/g, '$1')  // 粗
+    .replace(/\*(.+?)\*/g, '$1')      // 斜
+    .replace(/~~(.+?)~~/g, '$1')      // 删除
+    .replace(/`([^`]+)`/g, '$1')      // 代
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1'); // 链
+}

package/src/ui/components/markdown/types.ts

@@ -0,0 +1,66 @@
+/**
+ * Markdown 解析器类型定义
+ */
+
+/**
+ * 
+ */
+export type BlockType = 
+  | 'text'
+  | 'code'
+  | 'heading'
+  | 'table'
+  | 'list'
+  | 'hr'
+  | 'empty'
+  | 'blockquote';
+
+/**
+ * 
+ */
+export type ListType = 'ul' | 'ol';
+
+/**
+ * 
+ */
+export interface TableData {
+  headers: string[];
+  rows: string[][];
+  alignments: ('left' | 'center' | 'right')[];
+}
+
+/**
+ * 
+ */
+export interface ParsedBlock {
+  type: BlockType;
+  content: string;
+  language?: string;
+  /** 代码块关联的文件路径 */
+  filePath?: string;
+  level?: number;
+  listType?: ListType;
+  marker?: string;
+  tableData?: TableData;
+  indent?: number;
+}
+
+/**
+ * 
+ */
+export type InlineFormatType = 
+  | 'bold'
+  | 'italic'
+  | 'code'
+  | 'link'
+  | 'strikethrough'
+  | 'text';
+
+/**
+ * 
+ */
+export interface InlineSegment {
+  type: InlineFormatType;
+  content: string;
+  url?: string;
+}

package/src/ui/focus/FocusManager.ts

@@ -0,0 +1,137 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import { FocusId, type FocusState, type FocusActions } from './types.js';
+
+type FocusListener = (state: FocusState) => void;
+
+/**
+ * 
+ */
+class FocusManagerImpl {
+  private state: FocusState = {
+    currentFocus: FocusId.MAIN_INPUT,
+    previousFocus: null,
+    focusStack: [FocusId.MAIN_INPUT],
+  };
+  
+  private listeners: Set<FocusListener> = new Set();
+
+  /**
+   * 
+   */
+  getState(): FocusState {
+    return { ...this.state };
+  }
+
+  /**
+   * 
+   */
+  getCurrentFocus(): FocusId {
+    return this.state.currentFocus;
+  }
+
+  /**
+   * 
+   */
+  setFocus(id: FocusId): void {
+    if (this.state.currentFocus === id) {
+      return;
+    }
+
+    this.state = {
+      currentFocus: id,
+      previousFocus: this.state.currentFocus,
+      focusStack: [...this.state.focusStack, id],
+    };
+    
+    this.notify();
+  }
+
+  /**
+   * 
+   */
+  pushFocus(id: FocusId): void {
+    this.state = {
+      currentFocus: id,
+      previousFocus: this.state.currentFocus,
+      focusStack: [...this.state.focusStack, id],
+    };
+    
+    this.notify();
+  }
+
+  /**
+   * 
+   */
+  popFocus(): void {
+    if (this.state.focusStack.length <= 1) {
+      return;
+    }
+
+    const newStack = this.state.focusStack.slice(0, -1);
+    const previousFocus = newStack[newStack.length - 1] || FocusId.MAIN_INPUT;
+    
+    this.state = {
+      currentFocus: previousFocus,
+      previousFocus: this.state.currentFocus,
+      focusStack: newStack,
+    };
+    
+    this.notify();
+  }
+
+  /**
+   * 
+   */
+  resetFocus(): void {
+    this.state = {
+      currentFocus: FocusId.MAIN_INPUT,
+      previousFocus: this.state.currentFocus,
+      focusStack: [FocusId.MAIN_INPUT],
+    };
+    
+    this.notify();
+  }
+
+  /**
+   * 
+   */
+  subscribe(listener: FocusListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /**
+   * 
+   */
+  private notify(): void {
+    const state = this.getState();
+    for (const listener of this.listeners) {
+      listener(state);
+    }
+  }
+
+  /**
+   * 
+   */
+  getActions(): FocusActions {
+    return {
+      setFocus: (id: FocusId) => this.setFocus(id),
+      popFocus: () => this.popFocus(),
+      resetFocus: () => this.resetFocus(),
+      pushFocus: (id: FocusId) => this.pushFocus(id),
+    };
+  }
+}
+
+// 导出单
+export const focusManager = new FocusManagerImpl();
+
+// 导出操作快捷方
+export const focusActions = focusManager.getActions();

package/src/ui/focus/index.ts

@@ -0,0 +1,13 @@
+/**
+ * 
+ */
+
+export { FocusId, type FocusState, type FocusActions } from './types.js';
+export { focusManager, focusActions } from './FocusManager.js';
+export {
+  useCurrentFocus,
+  useFocusState,
+  useFocusActions,
+  useIsFocused,
+  useFocus,
+} from './useFocus.js';

package/src/ui/focus/types.ts

@@ -0,0 +1,54 @@
+/**
+ * 
+ */
+
+/**
+ * 
+ * 
+ */
+export enum FocusId {
+  /** 主输入框 */
+  MAIN_INPUT = 'main-input',
+  /** 确认对话框 */
+  CONFIRMATION_PROMPT = 'confirmation-prompt',
+  /** 主题选择器 */
+  THEME_SELECTOR = 'theme-selector',
+  /** 模型选择器 */
+  MODEL_SELECTOR = 'model-selector',
+  /** 会话选择器 */
+  SESSION_SELECTOR = 'session-selector',
+  /** 文件选择器 */
+  FILE_SELECTOR = 'file-selector',
+  /** 帮助面板 */
+  HELP_PANEL = 'help-panel',
+  /** 通用选择器 */
+  SELECTOR = 'selector',
+  /** 无焦点 */
+  NONE = 'none',
+}
+
+/**
+ * 
+ */
+export interface FocusState {
+  /** 当前焦点 ID */
+  currentFocus: FocusId;
+  /** 上一个焦点 ID（用于返回） */
+  previousFocus: FocusId | null;
+  /** 焦点历史栈 */
+  focusStack: FocusId[];
+}
+
+/**
+ * 
+ */
+export interface FocusActions {
+  /** 设置焦点 */
+  setFocus: (id: FocusId) => void;
+  /** 返回上一个焦点 */
+  popFocus: () => void;
+  /** 重置焦点到默认 */
+  resetFocus: () => void;
+  /** 推入焦点栈 */
+  pushFocus: (id: FocusId) => void;
+}

package/src/ui/focus/useFocus.ts

@@ -0,0 +1,75 @@
+/**
+ * 
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import { focusManager, focusActions } from './FocusManager.js';
+import { FocusId, type FocusState, type FocusActions } from './types.js';
+
+/**
+ * 
+ */
+export const useCurrentFocus = (): FocusId => {
+  const [currentFocus, setCurrentFocus] = useState<FocusId>(
+    focusManager.getCurrentFocus()
+  );
+
+  useEffect(() => {
+    const unsubscribe = focusManager.subscribe((state) => {
+      setCurrentFocus(state.currentFocus);
+    });
+    return unsubscribe;
+  }, []);
+
+  return currentFocus;
+};
+
+/**
+ * 
+ */
+export const useFocusState = (): FocusState => {
+  const [state, setState] = useState<FocusState>(focusManager.getState());
+
+  useEffect(() => {
+    const unsubscribe = focusManager.subscribe((newState) => {
+      setState(newState);
+    });
+    return unsubscribe;
+  }, []);
+
+  return state;
+};
+
+/**
+ * 
+ */
+export const useFocusActions = (): FocusActions => {
+  return focusActions;
+};
+
+/**
+ * 
+ */
+export const useIsFocused = (focusId: FocusId): boolean => {
+  const currentFocus = useCurrentFocus();
+  return currentFocus === focusId;
+};
+
+/**
+ * 
+ */
+export const useFocus = () => {
+  const state = useFocusState();
+  const actions = useFocusActions();
+  
+  const isFocused = useCallback(
+    (id: FocusId) => state.currentFocus === id,
+    [state.currentFocus]
+  );
+
+  return {
+    ...state,
+    ...actions,
+    isFocused,
+  };
+};

package/src/ui/hooks/index.ts

@@ -0,0 +1,11 @@
+/**
+ * UI Hooks 导出
+ */
+
+export { useTerminalWidth, useTerminalHeight, useTerminalSize } from './useTerminalWidth.js';
+export { useCommandHistory } from './useCommandHistory.js';
+export { useInputBuffer } from './useInputBuffer.js';
+export { useCtrlCHandler } from './useCtrlCHandler.js';
+export { useConfirmation } from './useConfirmation.js';
+export { useAgent } from './useAgent.js';
+export { useCommandProcessor } from './useCommandProcessor.js';