aegiscode 3.1.8 → 3.1.10

package/src/services/VersionChecker.ts

@@ -0,0 +1,445 @@
+/**
+ * VersionChecker - 版本检查服务
+ * 
+ * 
+ * - 启动时并行检查是否有新版本
+ * - 缓存机制（1小时 TTL）
+ * - 跳过版本功能（Skip until next version）
+ */
+
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+// ========== 从 package.json 读取配
+
+interface PackageJson {
+  name: string;
+  version: string;
+  repository?: {
+    type?: string;
+    url?: string;
+  } | string;
+  homepage?: string;
+}
+
+/**
+ * 
+ * 
+ * 
+ * 
+ * 
+ */
+function readPackageJsonSync(): PackageJson {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  
+  // 可能的 package.json 路径（基
+  const possiblePaths = [
+    path.resolve(__dirname, '../package.json'),     // 打包
+    path.resolve(__dirname, '../../package.json'),  // 开发环
+  ];
+
+  for (const pkgPath of possiblePaths) {
+    try {
+      const content = fs.readFileSync(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content) as PackageJson;
+      // 验证是否是正确的 package（名字匹
+      if (pkg.name === 'aegis' || pkg.name === 'aegis-cli' || pkg.name === 'aegiscode') {
+        return pkg;
+      }
+    } catch {
+      // 继续尝试下一个路
+    }
+  }
+
+  // 如果都失败，使用默认
+  return { name: 'aegis', version: '0.1.0' };
+}
+
+const packageJson = readPackageJsonSync();
+
+/**
+ * 
+ * 
+ */
+function getReleaseNotesUrl(): string {
+  // 从 repository.url 提
+  const repoUrl = typeof packageJson.repository === 'string'
+    ? packageJson.repository
+    : packageJson.repository?.url;
+  
+  if (repoUrl) {
+    // 转
+    const match = repoUrl.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+    if (match) {
+      return `https://github.com/${match[1]}/releases`;
+    }
+  }
+  
+  // 从 homepage 提
+  if (packageJson.homepage) {
+    const homepageMatch = packageJson.homepage.match(/github\.com\/([^/#]+\/[^/#]+)/);
+    if (homepageMatch) {
+      return `https://github.com/${homepageMatch[1]}/releases`;
+    }
+  }
+  
+  // 默认
+  return `https://www.npmjs.com/package/${PACKAGE_NAME}`;
+}
+
+// ========== 配置常
+
+const PACKAGE_NAME = packageJson.name;
+const CURRENT_VERSION = packageJson.version;
+const DEFAULT_NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const CACHE_TTL = 60 * 60 * 1000; // 1 小
+const CACHE_DIR = path.join(os.homedir(), `.${PACKAGE_NAME}`);
+const CACHE_FILE = path.join(CACHE_DIR, 'version-cache.json');
+
+// ========== 读取用户 npm 配
+
+/**
+ * 
+ * 
+ */
+async function getNpmRegistry(): Promise<string> {
+  const npmrcLocations = [
+    path.join(process.cwd(), '.npmrc'),           // 项目
+    path.join(os.homedir(), '.npmrc'),            // 用户
+  ];
+
+  for (const npmrcPath of npmrcLocations) {
+    try {
+      const content = await fsPromises.readFile(npmrcPath, 'utf-8');
+      // 匹
+      const match = content.match(/^\s*registry\s*=\s*(.+?)\s*$/m);
+      if (match && match[1]) {
+        let registry = match[1].trim();
+        // 移除尾部斜
+        if (registry.endsWith('/')) {
+          registry = registry.slice(0, -1);
+        }
+        return registry;
+      }
+    } catch {
+      // 文件不存在或读取失败，继续尝试下一
+    }
+  }
+
+  return DEFAULT_NPM_REGISTRY_URL;
+}
+
+// ========== 类型定
+
+/**
+ * 
+ */
+export interface VersionCheckResult {
+  currentVersion: string;
+  latestVersion: string | null;
+  hasUpdate: boolean;
+  shouldPrompt: boolean; // 是否应该显示提示（考虑 skip 设
+  releaseNotesUrl: string;
+  error?: string;
+}
+
+/**
+ * 
+ */
+interface VersionCache {
+  latestVersion: string;
+  checkedAt: number;
+  skipUntilVersion?: string; // 跳过直到此版
+}
+
+// ========== 缓存操
+
+/**
+ * 
+ */
+async function readCache(): Promise<VersionCache | null> {
+  try {
+    const content = await fsPromises.readFile(CACHE_FILE, 'utf-8');
+    const cache: VersionCache = JSON.parse(content);
+    return cache;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 
+ */
+async function writeCache(cache: VersionCache): Promise<void> {
+  try {
+    await fsPromises.mkdir(CACHE_DIR, { recursive: true });
+    await fsPromises.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    // 缓存写入失败不影响主流
+    console.error('[VersionChecker] Failed to write cache:', error);
+  }
+}
+
+/**
+ * 
+ */
+function isCacheValid(cache: VersionCache): boolean {
+  return Date.now() - cache.checkedAt < CACHE_TTL;
+}
+
+// ========== 版本比
+
+/**
+ * 
+ * 
+ */
+function compareVersions(a: string, b: string): number {
+  const partsA = a.replace(/^v/, '').split('.').map(Number);
+  const partsB = b.replace(/^v/, '').split('.').map(Number);
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB) return 1;
+    if (numA < numB) return -1;
+  }
+  return 0;
+}
+
+// ========== 核心功
+
+/**
+ * 
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000); // 5秒超
+
+    // 从用户配置读
+    const registryUrl = await getNpmRegistry();
+    
+    const response = await fetch(`${registryUrl}/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal,
+      headers: {
+        'Accept': 'application/json',
+      },
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = await response.json() as { version?: string };
+    return data.version || null;
+  } catch {
+    // 网络错误、超时等，静默失
+    return null;
+  }
+}
+
+/**
+ * 
+ * 
+ * @param forceCheck - 是否强制检查（忽略缓存）
+ */
+export async function checkVersion(forceCheck = false): Promise<VersionCheckResult> {
+  const result: VersionCheckResult = {
+    currentVersion: CURRENT_VERSION,
+    latestVersion: null,
+    hasUpdate: false,
+    shouldPrompt: false,
+    releaseNotesUrl: getReleaseNotesUrl(),
+  };
+
+  try {
+    // 1. 尝试读取缓
+    const cache = await readCache();
+
+    // 2. 如果缓存有效且不强制检查，使用缓
+    if (cache && isCacheValid(cache) && !forceCheck) {
+      result.latestVersion = cache.latestVersion;
+    } else {
+      // 3. 从 npm 获取最新版
+      const latestVersion = await fetchLatestVersion();
+      
+      if (latestVersion) {
+        result.latestVersion = latestVersion;
+        
+        // 4. 更新缓存（保
+        await writeCache({
+          latestVersion,
+          checkedAt: Date.now(),
+          skipUntilVersion: cache?.skipUntilVersion,
+        });
+      } else if (cache) {
+        // 获取失败但有旧缓存，使用旧数
+        result.latestVersion = cache.latestVersion;
+      }
+    }
+
+    // 5. 判断是否有更
+    if (result.latestVersion) {
+      result.hasUpdate = compareVersions(result.latestVersion, CURRENT_VERSION) > 0;
+    }
+
+    // 6. 判断是否应该提示（考虑 skip 设
+    if (result.hasUpdate && result.latestVersion) {
+      const skipVersion = cache?.skipUntilVersion;
+      if (skipVersion) {
+        // 如果最新版本大于跳过版本，则应该提
+        result.shouldPrompt = compareVersions(result.latestVersion, skipVersion) > 0;
+      } else {
+        result.shouldPrompt = true;
+      }
+    }
+
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : 'Unknown error';
+  }
+
+  return result;
+}
+
+/**
+ * 
+ * 
+ * 
+ */
+export async function checkVersionOnStartup(): Promise<VersionCheckResult | null> {
+  const result = await checkVersion();
+  
+  // 只有需要提示时才返回结
+  if (result.shouldPrompt) {
+    return result;
+  }
+  
+  return null;
+}
+
+/**
+ * 
+ */
+export async function setSkipUntilVersion(version: string): Promise<void> {
+  const cache = await readCache();
+  await writeCache({
+    latestVersion: cache?.latestVersion || version,
+    checkedAt: cache?.checkedAt || Date.now(),
+    skipUntilVersion: version,
+  });
+}
+
+/**
+ * 
+ */
+export async function clearSkipVersion(): Promise<void> {
+  const cache = await readCache();
+  if (cache) {
+    await writeCache({
+      latestVersion: cache.latestVersion,
+      checkedAt: cache.checkedAt,
+      // 不设
+    });
+  }
+}
+
+/**
+ * 
+ * 
+ */
+const NPM_GLOBAL_PREFIX = path.join(os.homedir(), '.npm-global');
+const NPM_GLOBAL_BIN = path.join(NPM_GLOBAL_PREFIX, 'bin');
+
+function isPrefixBinInPath(): boolean {
+  const pathEntries = (process.env.PATH || '').split(path.delimiter);
+  return pathEntries.some((p) => p && path.resolve(p) === NPM_GLOBAL_BIN);
+}
+
+export function getUpgradeCommand(): string {
+  // Install into a per-user prefix so the upgrade never needs root and
+  // always lands under the home directory instead of a system npm dir.
+  return `npm install -g ${PACKAGE_NAME}@latest --prefer-online --prefix "${NPM_GLOBAL_PREFIX}"`;
+}
+
+/**
+ *
+ */
+export async function performUpgrade(): Promise<{ success: boolean; message: string }> {
+  const { spawn } = await import('child_process');
+
+  await fsPromises.mkdir(NPM_GLOBAL_PREFIX, { recursive: true }).catch(() => {});
+
+  return new Promise((resolve) => {
+    const command = getUpgradeCommand();
+
+    const child = spawn(command, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        const pathWarning = isPrefixBinInPath()
+          ? ''
+          : `\n⚠️  Add ${NPM_GLOBAL_BIN} to your PATH to use the updated '${PACKAGE_NAME}' command, e.g.:\n   export PATH="${NPM_GLOBAL_BIN}:$PATH"`;
+        resolve({
+          success: true,
+          message: `✅ Upgrade successful! Restarting...${pathWarning}`,
+        });
+      } else {
+        resolve({
+          success: false,
+          message: `❌ Upgrade failed (exit code: ${code})`,
+        });
+      }
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        success: false,
+        message: `❌ Upgrade failed: ${error.message}`,
+      });
+    });
+  });
+}
+
+/**
+ * 
+ * 
+ */
+export function restartApp(): void {
+  // 启动新的 aegis 进
+  // 使用 detached: true 让子进程独立运
+  // 使用 stdio: 'inherit' 让新进程继承终
+  const childEnv = { ...process.env };
+  if (!isPrefixBinInPath()) {
+    childEnv.PATH = `${NPM_GLOBAL_BIN}${path.delimiter}${childEnv.PATH || ''}`;
+  }
+
+  const child = spawn(PACKAGE_NAME, process.argv.slice(2), {
+    stdio: 'inherit',
+    shell: true,
+    detached: true,
+    env: childEnv,
+  });
+
+  // 让子进程脱离父进
+  child.unref();
+
+  // 退出当前进
+  process.exit(0);
+}
+
+/**
+ * 
+ */
+export function getCurrentVersion(): string {
+  return CURRENT_VERSION;
+}

package/src/services/index.ts

@@ -0,0 +1,57 @@
+/**
+ * Services 模块导出
+ */
+
+// VersionChecker
+export {
+  checkVersion,
+  checkVersionOnStartup,
+  setSkipUntilVersion,
+  clearSkipVersion,
+  getUpgradeCommand,
+  performUpgrade,
+  getCurrentVersion,
+} from './VersionChecker.js';
+
+export type { VersionCheckResult } from './VersionChecker.js';
+
+// ChatService
+export {
+  OpenAIChatService,
+  createChatService,
+} from './ChatService.js';
+
+export type { ChatServiceConfig } from './ChatService.js';
+
+// Streaming
+export {
+  parseStreamEvent,
+  TranscriptBuffer,
+  ThrottledRenderer,
+  TERMINAL_FORMATTING,
+  PLAIN_TEXT_FORMATTING,
+  buildRenderContext,
+  TERMINAL_PROFILE,
+  PLAIN_TEXT_PROFILE,
+  COMPACT_TERMINAL_PROFILE,
+  buildRenderingProfile,
+  getStatusForEvent,
+  STATUS_MESSAGE_PREFIXES,
+} from './streaming/index.js';
+export type {
+  AnthropicStreamEvent,
+  ContentBlockStartEvent,
+  ContentBlockDeltaEvent,
+  ContentBlockStopEvent,
+  MessageStartEvent,
+  MessageDeltaEvent,
+  MessageStopEvent,
+  ParsedEvent,
+  ParsedEventType,
+  StreamSegment,
+  SegmentKind,
+  RenderContext,
+  RenderFormatting,
+  RenderingProfile,
+} from './streaming/types.js';
+export { TRANSCRIPT_EVENT_TYPES } from './streaming/types.js';

package/src/services/streaming/OpenAIEventAdapter.ts

@@ -0,0 +1,126 @@
+/**
+ * OpenAIEventAdapter — converts OpenAI streaming delta chunks to AnthropicStreamEvent[].
+ *
+ * OpenAI streaming delivers flat delta objects (delta.content, delta.tool_calls[]).
+ * The rest of the streaming pipeline speaks Anthropic's content_block model
+ * (content_block_start / content_block_delta / content_block_stop).
+ *
+ * This stateful adapter bridges the two formats so StreamEventParser +
+ * TranscriptBuffer can work regardless of which backend is in use.
+ */
+
+import type { AnthropicStreamEvent } from './types.js';
+
+export class OpenAIEventAdapter {
+  private _textBlockOpen = false;
+  private _thinkingBlockOpen = false;
+  private _textIdx = 0;
+  private _thinkingIdx = 1;
+  private _nextToolIdx = 2;
+  /** OpenAI tool call index → { id, name, blockIdx } */
+  private _toolBlocks = new Map<number, { id: string; name: string; blockIdx: number }>();
+
+  /**
+   * Convert one OpenAI streaming chunk delta into zero or more AnthropicStreamEvents.
+   * Call once per chunk, in arrival order.
+   */
+  adapt(delta: {
+    content?: string | null;
+    reasoning_content?: string | null;
+    thinking?: string | null;
+    reasoning?: string | null;
+    tool_calls?: Array<{
+      index: number;
+      id?: string;
+      function?: { name?: string; arguments?: string };
+    }> | null;
+  }): AnthropicStreamEvent[] {
+    const events: AnthropicStreamEvent[] = [];
+
+    // Text content
+    if (delta.content) {
+      if (!this._textBlockOpen) {
+        events.push({
+          type: 'content_block_start',
+          index: this._textIdx,
+          content_block: { type: 'text', text: '' },
+        });
+        this._textBlockOpen = true;
+      }
+      events.push({
+        type: 'content_block_delta',
+        index: this._textIdx,
+        delta: { type: 'text_delta', text: delta.content },
+      });
+    }
+
+    // Thinking / reasoning content (multiple field names across providers)
+    const thinking = delta.reasoning_content ?? delta.thinking ?? delta.reasoning;
+    if (thinking) {
+      if (!this._thinkingBlockOpen) {
+        events.push({
+          type: 'content_block_start',
+          index: this._thinkingIdx,
+          content_block: { type: 'thinking', thinking: '' },
+        });
+        this._thinkingBlockOpen = true;
+      }
+      events.push({
+        type: 'content_block_delta',
+        index: this._thinkingIdx,
+        delta: { type: 'thinking_delta', thinking },
+      });
+    }
+
+    // Tool calls
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const oi = tc.index;
+        if (!this._toolBlocks.has(oi) && tc.id && tc.function?.name) {
+          const blockIdx = this._nextToolIdx++;
+          this._toolBlocks.set(oi, { id: tc.id, name: tc.function.name, blockIdx });
+          events.push({
+            type: 'content_block_start',
+            index: blockIdx,
+            content_block: { type: 'tool_use', id: tc.id, name: tc.function.name, input: {} },
+          });
+        }
+        const tool = this._toolBlocks.get(oi);
+        if (tool && tc.function?.arguments) {
+          events.push({
+            type: 'content_block_delta',
+            index: tool.blockIdx,
+            delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+          });
+        }
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Emit stop events for all open blocks, then message_stop.
+   * Call once after the stream ends.
+   */
+  finalize(stopReason?: string): AnthropicStreamEvent[] {
+    const events: AnthropicStreamEvent[] = [];
+    if (this._textBlockOpen) {
+      events.push({ type: 'content_block_stop', index: this._textIdx });
+    }
+    if (this._thinkingBlockOpen) {
+      events.push({ type: 'content_block_stop', index: this._thinkingIdx });
+    }
+    for (const { blockIdx } of this._toolBlocks.values()) {
+      events.push({ type: 'content_block_stop', index: blockIdx });
+    }
+    if (stopReason) {
+      events.push({
+        type: 'message_delta',
+        delta: { stop_reason: stopReason, stop_sequence: null },
+      });
+    }
+    events.push({ type: 'message_stop' });
+    return events;
+  }
+}

package/src/services/streaming/RenderingProfile.ts

@@ -0,0 +1,90 @@
+/**
+ * RenderingProfile — platform-specific rendering configuration.
+ *
+ * Replicates free-claude-code's messaging/rendering/profiles.py.
+ * Bundles format_status function, parse_mode, render context, and
+ * character limits into a single profile for a given target format.
+ */
+
+import type { RenderingProfile } from './types.js';
+import {
+  TERMINAL_FORMATTING,
+  PLAIN_TEXT_FORMATTING,
+  buildRenderContext,
+} from './renderFormatting.js';
+
+/**
+ * Format a status line: emoji + bold(label) [+ suffix].
+ * Replicates the format_status function from discord/telegram markdown modules.
+ */
+function formatStatus(
+  emoji: string,
+  label: string,
+  suffix?: string,
+  formatting: typeof TERMINAL_FORMATTING = TERMINAL_FORMATTING,
+): string {
+  const base = `${emoji} ${formatting.bold(label)}`;
+  if (suffix) {
+    return `${base} ${formatting.escapeText(suffix)}`;
+  }
+  return base;
+}
+
+/** Status formatter using terminal formatting */
+function termFormatStatus(emoji: string, label: string, suffix?: string): string {
+  return formatStatus(emoji, label, suffix, TERMINAL_FORMATTING);
+}
+
+/** Status formatter using plain text (no ANSI) */
+function plainFormatStatus(emoji: string, label: string, suffix?: string): string {
+  return formatStatus(emoji, label, suffix, PLAIN_TEXT_FORMATTING);
+}
+
+// ==================== Pre-built Profiles ====================
+
+/** Terminal rendering profile (ANSI bold, backtick code, unlimited chars) */
+export const TERMINAL_PROFILE: RenderingProfile = {
+  formatStatus: termFormatStatus,
+  parseMode: null,
+  renderCtx: buildRenderContext({ formatting: TERMINAL_FORMATTING, limitChars: 100000 }),
+  limitChars: 100000,
+};
+
+/** Plain text rendering profile (no ANSI, backtick code, suitable for logging) */
+export const PLAIN_TEXT_PROFILE: RenderingProfile = {
+  formatStatus: plainFormatStatus,
+  parseMode: null,
+  renderCtx: buildRenderContext({ formatting: PLAIN_TEXT_FORMATTING, limitChars: 100000 }),
+  limitChars: 100000,
+};
+
+/** Compact terminal profile — tighter limits for constrained displays */
+export const COMPACT_TERMINAL_PROFILE: RenderingProfile = {
+  formatStatus: termFormatStatus,
+  parseMode: null,
+  renderCtx: buildRenderContext({
+    formatting: TERMINAL_FORMATTING,
+    limitChars: 4000,
+    thinkingTailMax: 500,
+    textTailMax: 1000,
+    toolOutputTailMax: 800,
+  }),
+  limitChars: 4000,
+};
+
+/**
+ * Build a rendering profile by platform name.
+ * Replicates build_rendering_profile() from profiles.py.
+ */
+export function buildRenderingProfile(platformName: string): RenderingProfile {
+  switch (platformName) {
+    case 'terminal':
+      return TERMINAL_PROFILE;
+    case 'compact':
+      return COMPACT_TERMINAL_PROFILE;
+    case 'plain':
+      return PLAIN_TEXT_PROFILE;
+    default:
+      return TERMINAL_PROFILE;
+  }
+}