@ai-setting/roy-agent-cli 1.0.0

package/src/services/stream-output.service.ts

@@ -0,0 +1,323 @@
+/**
+ * @fileoverview Stream Output Service
+ * 
+ * 处理 LLM 流式事件并输出到控制台
+ */
+
+import chalk from "chalk";
+import type { EnvEvent } from "@ai-setting/roy-agent-core";
+import { createLogger } from "@ai-setting/roy-agent-core";
+
+// 创建 logger
+const logger = createLogger("stream-output");
+
+// ============ ANSI 颜色定义 ============
+export const COLORS = {
+  // 用户输入颜色 (cyan)
+  userInput: chalk.cyan,
+  userInputPrefix: chalk.cyan("❯"),
+  
+  // Assistant 输出颜色 (green)
+  assistant: chalk.green,
+  
+  // 系统消息颜色 (yellow)
+  system: chalk.yellow,
+  
+  // 思考过程颜色 (dim gray)
+  reasoning: chalk.dim.gray,
+  
+  // 工具调用颜色 (magenta)
+  toolCall: chalk.magenta,
+  
+  // 工具结果颜色 (blue)
+  toolResult: chalk.blue,
+  
+  // 错误颜色 (red)
+  error: chalk.red,
+  
+  // 进度/思考中颜色 (dim)
+  progress: chalk.dim,
+} as const;
+
+// Abort 信号类型
+export type AbortSignal = {
+  aborted: boolean;
+};
+
+/**
+ * 全局 abort 信号（用于流式输出中断）
+ */
+export const streamAbortSignal: AbortSignal = {
+  aborted: false,
+};
+
+/**
+ * 重置 abort 信号
+ */
+export function resetStreamAbort(): void {
+  streamAbortSignal.aborted = false;
+}
+
+/**
+ * 请求 abort 流式输出
+ */
+export function abortStream(): void {
+  streamAbortSignal.aborted = true;
+}
+
+/**
+ * Usage 信息接口
+ */
+export interface UsageInfo {
+  /** 模型名称 */
+  model: string;
+  /** Provider ID */
+  providerId?: string;
+  /** Prompt tokens */
+  promptTokens?: number;
+  /** Completion tokens */
+  completionTokens?: number;
+  /** Total tokens */
+  totalTokens?: number;
+}
+
+export interface StreamOutputOptions {
+  /** 显示推理/思考过程 */
+  showReasoning?: boolean;
+  /** 显示工具调用 */
+  showToolCalls?: boolean;
+  /** 显示工具结果 */
+  showToolResults?: boolean;
+}
+
+/**
+ * 流式输出服务
+ * 
+ * 订阅 Environment 的 LLM 事件，流式输出文本到 stdout
+ */
+export class StreamOutputService {
+  private fullText: string = "";
+  private options: StreamOutputOptions;
+  private usageInfo?: UsageInfo;
+  private contextWindow?: number;
+  private contextThreshold?: number;
+  private isFirstText = true;  // 用于控制换行
+  private reasoningStarted = false;  // 思考过程是否已开始
+  private thinkingPrinted = false;  // "[thinking...]" 是否已打印
+
+  constructor(options: StreamOutputOptions = {}) {
+    this.options = options;
+  }
+
+  /**
+   * 设置上下文窗口信息
+   */
+  setContextInfo(window: number, threshold: number): void {
+    this.contextWindow = window;
+    this.contextThreshold = threshold;
+  }
+
+  /**
+   * 检查是否已 abort
+   */
+  private checkAbort(): boolean {
+    if (streamAbortSignal.aborted) {
+      // 输出 abort 提示
+      console.log(`\n${COLORS.system("[已中断]")}\n`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 处理环境事件
+   */
+  handleEvent(event: EnvEvent): void {
+    // 检查 abort 信号
+    if (this.checkAbort()) {
+      return;
+    }
+
+    const { type, payload } = event;
+
+    switch (type) {
+      case "llm.start":
+        this.handleStart(payload as { metadata?: { model?: string } });
+        break;
+        
+      case "llm.text":
+        this.handleText(payload as { delta?: string; content?: string });
+        break;
+        
+      case "llm.reasoning":
+        this.handleReasoning(payload as { content?: string });
+        break;
+        
+      case "llm.tool_call":
+        this.handleToolCall(payload as { toolCall?: { id?: string; name?: string; arguments?: string } });
+        break;
+        
+      case "llm.completed":
+        this.handleCompleted(payload as { content?: string; metadata?: unknown });
+        break;
+    }
+  }
+
+  /**
+   * 处理开始事件
+   */
+  private handleStart(payload: { metadata?: { model?: string } }): void {
+    if (payload.metadata?.model) {
+      // 可选：显示模型信息
+      // process.stderr.write(`\n[Using model: ${payload.metadata.model}]\n`);
+    }
+  }
+
+  /**
+   * 处理文本事件
+   */
+  private handleText(payload: { delta?: string; content?: string }): void {
+    // 清除 "[thinking...]" 如果已打印
+    if (!this.thinkingPrinted) {
+      this.thinkingPrinted = true;
+      // 移动光标到行首，清除 "[thinking...]" 并换行
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+    }
+
+    const text = payload.delta ?? payload.content ?? "";
+    
+    if (!text) return;
+    
+    // 如果是第一个文本块，先换行
+    if (this.isFirstText) {
+      process.stdout.write("\n");
+      this.isFirstText = false;
+    }
+    
+    // 使用 assistant 颜色输出
+    process.stdout.write(COLORS.assistant(text));
+    this.fullText += text;
+  }
+
+  /**
+   * 处理思考过程事件
+   */
+  private handleReasoning(payload: { content?: string }): void {
+    if (!this.options.showReasoning) return;
+    
+    const content = payload.content ?? "";
+    if (!content) return;
+
+    // 如果是开始思考，先换行并显示标题
+    if (!this.reasoningStarted) {
+      this.reasoningStarted = true;
+      process.stdout.write("\n\n" + COLORS.reasoning("┌─ 思考过程 ─") + "\n");
+    }
+    
+    process.stdout.write(COLORS.reasoning(content));
+  }
+
+  /**
+   * 处理工具调用事件
+   */
+  private handleToolCall(payload: { toolCall?: { id?: string; name?: string; arguments?: string } }): void {
+    if (!this.options.showToolCalls) return;
+    
+    const toolCall = payload.toolCall;
+    if (toolCall?.name) {
+      process.stdout.write("\n" + COLORS.toolCall(`🔧 [Tool] ${toolCall.name}`) + "\n");
+    }
+  }
+
+  /**
+   * 处理完成事件
+   */
+  private handleCompleted(payload: { content?: string; metadata?: unknown }): void {
+    // 完成时输出换行
+    process.stdout.write("\n");
+
+    // 如果有思考过程，关闭思考框
+    if (this.reasoningStarted) {
+      process.stdout.write(COLORS.reasoning("└" + "─".repeat(20) + "\n"));
+      this.reasoningStarted = false;
+    }
+
+    // 提取 usage 信息
+    const metadata = payload.metadata as {
+      model?: string;
+      usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+      };
+    } | undefined;
+
+    if (metadata?.model || metadata?.usage) {
+      let modelName = metadata.model || "";
+      let providerId: string | undefined;
+
+      // 解析 model 名称（格式：provider/model 或 model）
+      if (modelName.includes("/")) {
+        const parts = modelName.split("/");
+        providerId = parts[0];
+        modelName = parts[parts.length - 1];
+      }
+
+      this.usageInfo = {
+        model: modelName,
+        providerId,
+        promptTokens: metadata.usage?.promptTokens,
+        completionTokens: metadata.usage?.completionTokens,
+        totalTokens: metadata.usage?.totalTokens,
+      };
+
+      // 打印 usage 日志
+      const logData: Record<string, unknown> = {
+        promptTokens: this.usageInfo.promptTokens,
+        completionTokens: this.usageInfo.completionTokens,
+        totalTokens: this.usageInfo.totalTokens,
+      };
+
+      // 添加 context 信息（如果已设置）
+      if (this.contextWindow !== undefined) {
+        logData.contextWindow = this.contextWindow;
+        if (this.contextThreshold !== undefined) {
+          logData.contextThreshold = this.contextThreshold;
+          // 计算使用率
+          if (this.usageInfo.totalTokens && this.contextWindow) {
+            const usageRate = (this.usageInfo.totalTokens / this.contextWindow * 100).toFixed(1);
+            logData.usageRate = `${usageRate}%`;
+          }
+        }
+      }
+
+      logger.info(`[LLM] ${modelName}`, logData);
+    }
+  }
+
+  /**
+   * 获取完整文本
+   */
+  getFullText(): string {
+    return this.fullText;
+  }
+
+  /**
+   * 获取 usage 信息
+   */
+  getUsageInfo(): UsageInfo | undefined {
+    return this.usageInfo;
+  }
+
+  /**
+   * 重置状态
+   */
+  reset(): void {
+    this.fullText = "";
+    this.usageInfo = undefined;
+    this.isFirstText = true;
+    this.reasoningStarted = false;
+    this.thinkingPrinted = false;
+    // 保留 contextInfo，因为它是配置信息，不需要每次重置
+  }
+}

package/src/util/which.test.ts

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview which 命令测试
+ * 
+ * TDD: 测试跨平台 which 命令功能
+ */
+
+import { describe, test, expect } from "bun:test";
+import { which } from "./which";
+
+describe("which 命令 - 跨平台兼容性测试", () => {
+  describe("绝对路径处理", () => {
+    test("应识别绝对路径", () => {
+      // 使用系统中肯定存在的文件
+      const result = which("/bin/ls");
+      expect(result).toBe("/bin/ls");
+    });
+
+    test("不存在的绝对路径应返回 null", () => {
+      const result = which("/non/existent/path/command");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("PATH 环境变量", () => {
+    test("Unix 平台应使用冒号分隔 PATH", () => {
+      // 测试逻辑：在 Unix 系统上应该能找到 ls
+      const result = which("ls");
+      expect(result).not.toBeNull();
+      expect(result).toContain("ls");
+    });
+
+    test("Windows 平台应使用分号分隔 PATH", () => {
+      const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+      Object.defineProperty(process, "platform", {
+        value: "win32",
+        writable: true,
+        configurable: true,
+      });
+
+      try {
+        const pathSeparator = process.platform === "win32" ? ";" : ":";
+        expect(pathSeparator).toBe(";");
+      } finally {
+        if (originalPlatform) {
+          Object.defineProperty(process, "platform", originalPlatform);
+        }
+      }
+    });
+  });
+
+  describe("PATHEXT 扩展名 (Windows)", () => {
+    test("Windows 平台应检查常见扩展名", () => {
+      const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+      Object.defineProperty(process, "platform", {
+        value: "win32",
+        writable: true,
+        configurable: true,
+      });
+
+      try {
+        const extensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";");
+        expect(extensions).toContain(".EXE");
+        expect(extensions).toContain(".BAT");
+        expect(extensions).toContain(".CMD");
+      } finally {
+        if (originalPlatform) {
+          Object.defineProperty(process, "platform", originalPlatform);
+        }
+      }
+    });
+  });
+
+  describe("系统 which 命令 fallback", () => {
+    test("Unix 平台可以使用系统 which 命令", () => {
+      // 在 Linux 上测试 which 命令是否存在
+      const result = which("ls");
+      expect(result).not.toBeNull();
+    });
+
+    test("Windows 平台不应尝试执行系统 which 命令", () => {
+      // 这个测试验证 Windows 平台上逻辑正确
+      // 当 platform 是 win32 时，不应该执行 execSync which
+      const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+      Object.defineProperty(process, "platform", {
+        value: "win32",
+        writable: true,
+        configurable: true,
+      });
+
+      try {
+        // 验证 pathSeparator 在 Windows 上是分号
+        const pathSeparator = process.platform === "win32" ? ";" : ":";
+        expect(pathSeparator).toBe(";");
+      } finally {
+        if (originalPlatform) {
+          Object.defineProperty(process, "platform", originalPlatform);
+        }
+      }
+    });
+  });
+});

package/src/util/which.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview which 命令实现
+ * 
+ * 在 PATH 中查找可执行文件
+ */
+
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+
+/**
+ * 在 PATH 中查找可执行文件
+ * 
+ * @param command 命令名称
+ * @returns 命令的完整路径，如果找不到返回 null
+ */
+export function which(command: string): string | null {
+  // 如果是绝对路径，直接检查是否存在
+  if (path.isAbsolute(command)) {
+    return fs.existsSync(command) ? command : null;
+  }
+
+  // 获取 PATH 环境变量
+  const PATH = process.env.PATH ?? "";
+  const pathSeparator = process.platform === "win32" ? ";" : ":";
+  const paths = PATH.split(pathSeparator);
+
+  // Windows 下还要检查 PATHEXT
+  const extensions = process.platform === "win32"
+    ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")
+    : [""];
+
+  for (const dir of paths) {
+    for (const ext of extensions) {
+      const fullPath = path.join(dir, command + ext);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+
+  // 尝试使用系统 which 命令（仅在非 Windows 平台）
+  // Windows 没有原生的 which 命令，需要使用 PowerShell 的 Get-Command 或手动遍历
+  if (process.platform !== "win32") {
+    try {
+      const result = execSync(`which ${command}`, { encoding: "utf-8" });
+      const trimmed = result.trim();
+      return trimmed || null;
+    } catch {
+      // fall through to return null
+    }
+  }
+  
+  return null;
+}