deeper-cli 1.0.0

package/src/core/eventbus.ts

@@ -0,0 +1,202 @@
+import { EventEmitter } from 'node:events';
+
+export interface ContextUpdatedPayload {
+  modelName: string;
+  tokenCount: number;
+  memoryUsage: number;
+  uptime: number;
+}
+
+export interface MessagePayload {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  thinking?: string;
+  timestamp: number;
+}
+
+export interface ToolCallPayload {
+  id: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: string;
+}
+
+export interface DiffPayload {
+  filePath: string;
+  oldContent: string;
+  newContent: string;
+}
+
+export interface AgentPayload {
+  id: string;
+  name: string;
+  status: 'idle' | 'running' | 'completed' | 'failed';
+  parentId?: string;
+  task: string;
+  children?: AgentPayload[];
+}
+
+export const Events = {
+  CONTEXT_UPDATED: 'context:updated',
+  MESSAGE_SEND: 'message:send',
+  MESSAGE_RECEIVED: 'message:received',
+  MESSAGE_STREAMING: 'message:streaming',
+  TOOL_CALL_START: 'tool:call:start',
+  TOOL_CALL_END: 'tool:call:end',
+  FILE_DIFF: 'file:diff',
+  AGENT_TREE_UPDATED: 'agent:tree:updated',
+  APP_QUIT: 'app:quit',
+  APP_CLEAR: 'app:clear',
+  STATUS_UPDATE: 'status:update',
+  CONFIG_CHANGED: 'config:changed',
+  AGENT_STATUS_CHANGE: 'agent:status:change',
+  AGENT_CREATED: 'agent:created',
+  AGENT_THINKING: 'agent:thinking',
+  AGENT_EXECUTING: 'agent:executing',
+  AGENT_WAITING: 'agent:waiting',
+  AGENT_COMPLETED: 'agent:completed',
+  AGENT_FAILED: 'agent:failed',
+  AGENT_CANCELLED: 'agent:cancelled',
+  AGENT_LOOP_ITERATION: 'agent:loop:iteration',
+  AGENT_LOOP_DETECTED: 'agent:loop:detected',
+  AGENT_LOOP_LIMIT: 'agent:loop:limit',
+  TOOL_CALL_ERROR: 'tool:call:error',
+  ORCHESTRATOR_DECOMPOSE: 'orchestrator:decompose',
+  ORCHESTRATOR_DISPATCH: 'orchestrator:dispatch',
+  ORCHESTRATOR_AGGREGATE: 'orchestrator:aggregate',
+  SUBAGENT_START: 'subagent:start',
+  SUBAGENT_TIMEOUT: 'subagent:timeout',
+  SUBAGENT_COMPLETE: 'subagent:complete',
+  SUBAGENT_ERROR: 'subagent:error',
+  POOL_ACQUIRE: 'pool:acquire',
+  POOL_RELEASE: 'pool:release',
+  POOL_QUEUE: 'pool:queue',
+  CONTEXT_SUMMARIZED: 'context:summarized',
+  CONTEXT_TOKEN_WARNING: 'context:token:warning',
+  MCP_CONNECTED: 'mcp:connected',
+  MCP_ERROR: 'mcp:error',
+  MCP_DISCONNECTED: 'mcp:disconnected',
+  MCP_TOOLS_DISCOVERED: 'mcp:tools:discovered',
+  SKILL_LOADED: 'skill:loaded',
+  SKILL_EXECUTED: 'skill:executed',
+  SKILL_CREATED: 'skill:created',
+  SKILL_TRIGGERED: 'skill:triggered',
+} as const;
+
+export const EventBusEvents = Events;
+
+export class EventBus extends EventEmitter {
+  private static instance: EventBus;
+
+  static getInstance(): EventBus {
+    if (!EventBus.instance) {
+      EventBus.instance = new EventBus();
+    }
+    return EventBus.instance;
+  }
+
+  onContextUpdated(handler: (payload: ContextUpdatedPayload) => void): void {
+    this.on(EventBusEvents.CONTEXT_UPDATED, handler);
+  }
+
+  emitContextUpdated(payload: ContextUpdatedPayload): void {
+    this.emit(EventBusEvents.CONTEXT_UPDATED, payload);
+  }
+
+  onMessageSend(handler: (payload: { content: string }) => void): void {
+    this.on(EventBusEvents.MESSAGE_SEND, handler);
+  }
+
+  emitMessageSend(payload: { content: string }): void {
+    this.emit(EventBusEvents.MESSAGE_SEND, payload);
+  }
+
+  onMessageReceived(handler: (payload: MessagePayload) => void): void {
+    this.on(EventBusEvents.MESSAGE_RECEIVED, handler);
+  }
+
+  emitMessageReceived(payload: MessagePayload): void {
+    this.emit(EventBusEvents.MESSAGE_RECEIVED, payload);
+  }
+
+  onMessageStreaming(handler: (payload: { id: string; content: string; thinking?: string }) => void): void {
+    this.on(EventBusEvents.MESSAGE_STREAMING, handler);
+  }
+
+  emitMessageStreaming(payload: { id: string; content: string; thinking?: string }): void {
+    this.emit(EventBusEvents.MESSAGE_STREAMING, payload);
+  }
+
+  onToolCallStart(handler: (payload: ToolCallPayload) => void): void {
+    this.on(EventBusEvents.TOOL_CALL_START, handler);
+  }
+
+  emitToolCallStart(payload: ToolCallPayload): void {
+    this.emit(EventBusEvents.TOOL_CALL_START, payload);
+  }
+
+  onToolCallEnd(handler: (payload: ToolCallPayload) => void): void {
+    this.on(EventBusEvents.TOOL_CALL_END, handler);
+  }
+
+  emitToolCallEnd(payload: ToolCallPayload): void {
+    this.emit(EventBusEvents.TOOL_CALL_END, payload);
+  }
+
+  onFileDiff(handler: (payload: DiffPayload) => void): void {
+    this.on(EventBusEvents.FILE_DIFF, handler);
+  }
+
+  emitFileDiff(payload: DiffPayload): void {
+    this.emit(EventBusEvents.FILE_DIFF, payload);
+  }
+
+  onAgentTreeUpdated(handler: (payload: { agents: AgentPayload[] }) => void): void {
+    this.on(EventBusEvents.AGENT_TREE_UPDATED, handler);
+  }
+
+  emitAgentTreeUpdated(payload: { agents: AgentPayload[] }): void {
+    this.emit(EventBusEvents.AGENT_TREE_UPDATED, payload);
+  }
+
+  onAppQuit(handler: () => void): void {
+    this.on(EventBusEvents.APP_QUIT, handler);
+  }
+
+  emitAppQuit(): void {
+    this.emit(EventBusEvents.APP_QUIT);
+  }
+
+  onAppClear(handler: () => void): void {
+    this.on(EventBusEvents.APP_CLEAR, handler);
+  }
+
+  emitAppClear(): void {
+    this.emit(EventBusEvents.APP_CLEAR);
+  }
+
+  onStatusUpdate(handler: (payload: Partial<ContextUpdatedPayload>) => void): void {
+    this.on(EventBusEvents.STATUS_UPDATE, handler);
+  }
+
+  emitStatusUpdate(payload: Partial<ContextUpdatedPayload>): void {
+    this.emit(EventBusEvents.STATUS_UPDATE, payload);
+  }
+
+  onConfigChanged(handler: (payload: Record<string, unknown>) => void): void {
+    this.on(EventBusEvents.CONFIG_CHANGED, handler);
+  }
+
+  emitConfigChanged(payload: Record<string, unknown>): void {
+    this.emit(EventBusEvents.CONFIG_CHANGED, payload);
+  }
+
+  reset(): void {
+    this.removeAllListeners();
+  }
+}
+
+export const eventbus = EventBus.getInstance();
+export const globalEventBus = eventbus;

package/src/core/logger.ts

@@ -0,0 +1,109 @@
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { DEEPER_LOGS_DIR } from './constants.js';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+const LOG_LEVEL_RANK: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+export class Logger {
+  private level: LogLevel;
+  private logDir: string;
+  private currentLogFile: string;
+
+  constructor(level: LogLevel = 'info', logDir?: string) {
+    this.level = level;
+    this.logDir = logDir ?? DEEPER_LOGS_DIR;
+    this.currentLogFile = this.generateLogFileName();
+    this.ensureLogDir();
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  debug(message: string, data?: unknown): void {
+    this.log('debug', message, data);
+  }
+
+  info(message: string, data?: unknown): void {
+    this.log('info', message, data);
+  }
+
+  warn(message: string, data?: unknown): void {
+    this.log('warn', message, data);
+  }
+
+  error(message: string, data?: unknown): void {
+    this.log('error', message, data);
+  }
+
+  private log(level: LogLevel, message: string, data?: unknown): void {
+    if (LOG_LEVEL_RANK[level] < LOG_LEVEL_RANK[this.level]) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    const formatted = this.formatMessage(level, timestamp, message, data);
+
+    switch (level) {
+      case 'error':
+        console.error(formatted);
+        break;
+      case 'warn':
+        console.warn(formatted);
+        break;
+      default:
+        console.log(formatted);
+        break;
+    }
+
+    try {
+      appendFileSync(this.currentLogFile, this.stripAnsi(formatted) + '\n', 'utf-8');
+    } catch {
+    }
+  }
+
+  private formatMessage(level: LogLevel, timestamp: string, message: string, data?: unknown): string {
+    const levelUpper = level.toUpperCase();
+    const base = `[${timestamp}] [${levelUpper}] ${message}`;
+    if (data !== undefined) {
+      if (typeof data === 'string') {
+        return `${base} ${data}`;
+      }
+      if (data instanceof Error) {
+        return `${base} ${data.message}\n${data.stack ?? ''}`;
+      }
+      try {
+        return `${base} ${JSON.stringify(data)}`;
+      } catch {
+        return `${base} [Unserializable data]`;
+      }
+    }
+    return base;
+  }
+
+  private stripAnsi(text: string): string {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+  }
+
+  private generateLogFileName(): string {
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10).replace(/-/g, '');
+    return join(this.logDir, `deeper-${dateStr}.log`);
+  }
+
+  private ensureLogDir(): void {
+    const dir = dirname(this.currentLogFile);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+export const logger = new Logger();

package/src/core/storage.ts

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { DEEPER_HOME } from './constants.js';
+
+export class Storage {
+  private baseDir: string;
+
+  constructor(baseDir?: string) {
+    this.baseDir = baseDir ?? join(DEEPER_HOME, 'storage');
+    this.ensureDir(this.baseDir);
+  }
+
+  get<T = unknown>(key: string): T | null {
+    const filePath = this.getFilePath(key);
+    try {
+      if (!existsSync(filePath)) {
+        return null;
+      }
+      const content = readFileSync(filePath, 'utf-8');
+      return JSON.parse(content) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  set<T = unknown>(key: string, value: T): void {
+    const filePath = this.getFilePath(key);
+    this.ensureDir(dirname(filePath));
+    writeFileSync(filePath, JSON.stringify(value, null, 2), 'utf-8');
+  }
+
+  delete(key: string): boolean {
+    const filePath = this.getFilePath(key);
+    try {
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+
+  has(key: string): boolean {
+    return existsSync(this.getFilePath(key));
+  }
+
+  keys(): string[] {
+    const result: string[] = [];
+    try {
+      if (existsSync(this.baseDir)) {
+        const files = readdirSync(this.baseDir, { recursive: true });
+        for (const file of files) {
+          const fileName = typeof file === 'string' ? file : file.toString('utf-8');
+          if (fileName.endsWith('.json')) {
+            result.push(fileName.replace(/\.json$/, '').replace(/\\/g, '/'));
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+
+  clear(): void {
+    try {
+      const files = readdirSync(this.baseDir, { recursive: true });
+      for (const file of files) {
+        const fullPath = join(this.baseDir, typeof file === 'string' ? file : file.toString('utf-8'));
+        try {
+          unlinkSync(fullPath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+
+  setBaseDir(dir: string): void {
+    this.baseDir = dir;
+    this.ensureDir(dir);
+  }
+
+  private getFilePath(key: string): string {
+    const safeKey = key.replace(/[<>:"/\\|?*]/g, '_');
+    return join(this.baseDir, `${safeKey}.json`);
+  }
+
+  private ensureDir(dir: string): void {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+export const storage = new Storage();

package/src/index.ts

@@ -0,0 +1,26 @@
+export { defaultTheme, type Theme } from './ui/themes/default.ts';
+export { darkTheme } from './ui/themes/dark.ts';
+export { lightTheme } from './ui/themes/light.ts';
+
+export { Spinner } from './ui/Spinner.tsx';
+export { MessageBubble } from './ui/MessageBubble.tsx';
+export { ToolCallCard } from './ui/ToolCallCard.tsx';
+export { DiffView } from './ui/DiffView.tsx';
+export { FilePreview } from './ui/FilePreview.tsx';
+export { AgentTree } from './ui/AgentTree.tsx';
+export { ConfirmDialog } from './ui/ConfirmDialog.tsx';
+export { StatusBar } from './ui/StatusBar.tsx';
+export { InputBox } from './ui/InputBox.tsx';
+export { ChatView } from './ui/ChatView.tsx';
+export { App } from './ui/App.tsx';
+
+export { eventbus, EventBusEvents, type ContextUpdatedPayload, type MessagePayload, type ToolCallPayload, type DiffPayload, type AgentPayload } from './core/eventbus.ts';
+export { loadConfig, saveConfig, getConfig, updateConfig, resetConfig, getConfigValue, setConfigValue, getApiKey, getModel, getBaseUrl, type DeeperConfig, type MCPConfigEntry, type SkillConfigEntry } from './core/config.ts';
+export { DEEPER_VERSION, DEEPER_NAME, DEEPER_HOME, DEEPER_CONFIG_FILE, DEEPSEEK_DEFAULT_MODEL, DEEPSEEK_BASE_URL, TOOL_CATEGORIES, AGENT_MAX_SUB_AGENTS, CONTEXT_MAX_TOKENS, MCP_CONNECTION_TIMEOUT_MS } from './core/constants.ts';
+export type { ToolCategory } from './core/constants.ts';
+export { type JSONSchema, type ToolParameter, type ToolDefinition, type ToolResult, type ToolExecutor, type Tool, type ToolCall, type ToolCallResult, type ToolSafetyLevel, TOOL_SAFETY_MAP } from './tools/tool-types.ts';
+export { type DeepSeekMessage, type DeepSeekToolCall, type DeepSeekToolDefinition, type DeepSeekRequest, type DeepSeekResponse, type DeepSeekStreamChunk, type ChatMessage, type ToolCallRecord, type AgentInfo, type SlashCommand, SLASH_COMMANDS } from './model/types.ts';
+
+export { bootstrap, checkNodeVersion, getVersionInfo, type BootstrapResult } from './cli/bootstrap.ts';
+export { chat } from './cli/commands/chat.tsx';
+export { run } from './cli/commands/run.ts';

package/src/mcp/ConfigLoader.ts

@@ -0,0 +1,74 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { DEEPER_MCP_FILE } from '../core/constants.js';
+import type { MCPServerConfig } from './types.js';
+
+export class ConfigLoader {
+  private configPath: string;
+
+  constructor(configPath?: string) {
+    this.configPath = configPath || DEEPER_MCP_FILE;
+  }
+
+  async load(): Promise<MCPServerConfig[]> {
+    if (!existsSync(this.configPath)) {
+      return [];
+    }
+
+    try {
+      const content = await readFile(this.configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+
+      if (Array.isArray(parsed)) {
+        return this.validateConfigs(parsed);
+      }
+
+      if (parsed && parsed.mcpServers) {
+        return this.validateConfigs(parsed.mcpServers);
+      }
+
+      return [];
+    } catch {
+      return [];
+    }
+  }
+
+  async loadSingle(name: string): Promise<MCPServerConfig | null> {
+    const configs = await this.load();
+    return configs.find((c) => c.name === name) || null;
+  }
+
+  private validateConfigs(raw: unknown[]): MCPServerConfig[] {
+    const valid: MCPServerConfig[] = [];
+
+    for (const item of raw) {
+      if (!item || typeof item !== 'object') continue;
+
+      const obj = item as Record<string, unknown>;
+
+      if (!obj.name || typeof obj.name !== 'string') continue;
+      if (!obj.type || (obj.type !== 'stdio' && obj.type !== 'sse')) continue;
+
+      const config: MCPServerConfig = {
+        name: obj.name,
+        type: obj.type as 'stdio' | 'sse',
+        command: typeof obj.command === 'string' ? obj.command : undefined,
+        args: Array.isArray(obj.args) ? obj.args.map(String) : undefined,
+        url: typeof obj.url === 'string' ? obj.url : undefined,
+        headers: typeof obj.headers === 'object' && obj.headers
+          ? obj.headers as Record<string, string>
+          : undefined,
+        env: typeof obj.env === 'object' && obj.env
+          ? obj.env as Record<string, string>
+          : undefined,
+      };
+
+      if (config.type === 'stdio' && !config.command) continue;
+      if (config.type === 'sse' && !config.url) continue;
+
+      valid.push(config);
+    }
+
+    return valid;
+  }
+}