@ai-setting/roy-agent-cli 1.0.0

package/src/services/output.service.test.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview OutputService Tests
+ */
+
+import { describe, it, expect } from "bun:test";
+import { OutputService } from "./output.service";
+
+describe("OutputService", () => {
+  describe("configure", () => {
+    it("should have default values", () => {
+      const output = new OutputService();
+      expect(output.isQuiet()).toBe(false);
+      expect(output.isJsonOutput()).toBe(false);
+    });
+
+    it("should enable quiet mode", () => {
+      const output = new OutputService();
+      output.configure({ quiet: true });
+      expect(output.isQuiet()).toBe(true);
+    });
+
+    it("should enable json output mode", () => {
+      const output = new OutputService();
+      output.configure({ jsonOutput: true });
+      expect(output.isJsonOutput()).toBe(true);
+    });
+  });
+
+  describe("info", () => {
+    it("should output info message", () => {
+      const output = new OutputService();
+      output.info("test message");
+    });
+
+    it("should not output in quiet mode", () => {
+      const output = new OutputService();
+      output.configure({ quiet: true });
+      output.info("test message");
+    });
+  });
+
+  describe("success", () => {
+    it("should output success message", () => {
+      const output = new OutputService();
+      output.success("operation succeeded");
+    });
+
+    it("should not output in quiet mode", () => {
+      const output = new OutputService();
+      output.configure({ quiet: true });
+      output.success("test");
+    });
+  });
+
+  describe("warn", () => {
+    it("should output warning message", () => {
+      const output = new OutputService();
+      output.warn("warning message");
+    });
+
+    it("should not output in quiet mode", () => {
+      const output = new OutputService();
+      output.configure({ quiet: true });
+      output.warn("warning");
+    });
+  });
+
+  describe("error", () => {
+    it("should output error message", () => {
+      const output = new OutputService();
+      output.error("error message");
+    });
+
+    it("should output even in quiet mode", () => {
+      const output = new OutputService();
+      output.configure({ quiet: true });
+      output.error("error in quiet mode");
+    });
+  });
+
+  describe("printJson", () => {
+    it("should output formatted json", () => {
+      const output = new OutputService();
+      output.printJson({ key: "value" });
+    });
+
+    it("should output compact json when pretty is false", () => {
+      const output = new OutputService();
+      output.printJson({ key: "value" }, false);
+    });
+  });
+});

package/src/services/output.service.ts

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Output Service
+ * 
+ * 统一的输出格式化服务（非交互式）
+ */
+
+import chalk from "chalk";
+
+export interface OutputOptions {
+  quiet?: boolean;
+  jsonOutput?: boolean;
+  noColor?: boolean;
+}
+
+/**
+ * OutputService - CLI 输出服务
+ * 
+ * 提供统一的格式化输出：
+ * - 普通消息
+ * - 成功/警告/错误消息
+ * - JSON 输出
+ */
+export class OutputService {
+  private quiet: boolean = false;
+  private jsonOutput: boolean = false;
+  private noColor: boolean = false;
+
+  /**
+   * 配置输出选项
+   */
+  configure(options: OutputOptions): void {
+    this.quiet = options.quiet ?? this.quiet;
+    this.jsonOutput = options.jsonOutput ?? this.jsonOutput;
+    this.noColor = options.noColor ?? this.noColor;
+  }
+
+  /**
+   * 获取配置状态
+   */
+  isQuiet(): boolean {
+    return this.quiet;
+  }
+
+  isJsonOutput(): boolean {
+    return this.jsonOutput;
+  }
+
+  isNoColor(): boolean {
+    return this.noColor;
+  }
+
+  /**
+   * 输出普通消息
+   */
+  info(message: string): void {
+    if (!this.quiet) {
+      console.log(message);
+    }
+  }
+
+  /**
+   * 输出日志消息（不添加前缀）
+   */
+  log(message?: string): void {
+    console.log(message ?? "");
+  }
+
+  /**
+   * 输出成功消息
+   */
+  success(message: string): void {
+    if (!this.quiet) {
+      console.log(chalk.green("✓ ") + message);
+    }
+  }
+
+  /**
+   * 输出警告消息
+   */
+  warn(message: string): void {
+    if (!this.quiet) {
+      console.warn(chalk.yellow("⚠ ") + message);
+    }
+  }
+
+  /**
+   * 输出错误消息
+   * 
+   * 注意：错误消息即使在安静模式下也会输出
+   */
+  error(message: string): void {
+    console.error(chalk.red("✗ ") + message);
+  }
+
+  /**
+   * 输出错误消息（详细版）
+   */
+  errorDetailed(message: string, details?: unknown): void {
+    console.error(chalk.red("✗ ") + message);
+    if (details && !this.quiet) {
+      console.error(JSON.stringify(details, null, 2));
+    }
+  }
+
+  /**
+   * 格式化并输出 JSON
+   */
+  printJson(data: unknown, pretty: boolean = true): void {
+    if (pretty) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(JSON.stringify(data));
+    }
+  }
+
+  /**
+   * 输出 JSON（别名方法）
+   */
+  json(data: unknown): void {
+    this.printJson(data);
+  }
+}

package/src/services/quiet-mode.service.test.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview QuietMode Service Tests
+ * 
+ * TDD: 测试统一的 QuietMode 服务
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { CliQuietModeService } from "./quiet-mode.service";
+
+describe("CliQuietModeService", () => {
+  let service: CliQuietModeService;
+
+  beforeEach(() => {
+    service = new CliQuietModeService();
+  });
+
+  afterEach(() => {
+    // 重置 quiet 模式状态
+    service.reset();
+  });
+
+  describe("singleton", () => {
+    test("should return singleton instance", () => {
+      const instance1 = CliQuietModeService.getInstance();
+      const instance2 = CliQuietModeService.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe("setQuiet", () => {
+    test("should enable quiet mode", () => {
+      service.setQuiet(true);
+      expect(service.isQuiet()).toBe(true);
+    });
+
+    test("should disable quiet mode", () => {
+      service.setQuiet(true);
+      service.setQuiet(false);
+      expect(service.isQuiet()).toBe(false);
+    });
+  });
+
+  describe("setQuietFromArgv", () => {
+    test("should set quiet mode from argv when quiet is true", () => {
+      const argv = { quiet: true };
+      service.setQuietFromArgv(argv);
+      expect(service.isQuiet()).toBe(true);
+    });
+
+    test("should not change quiet mode when quiet is false or undefined", () => {
+      service.setQuiet(true);
+      const argv = { quiet: false };
+      service.setQuietFromArgv(argv);
+      expect(service.isQuiet()).toBe(true);
+
+      service.reset();
+      const argv2 = {};
+      service.setQuietFromArgv(argv2);
+      expect(service.isQuiet()).toBe(false);
+    });
+  });
+
+  describe("reset", () => {
+    test("should reset quiet mode to false", () => {
+      service.setQuiet(true);
+      service.reset();
+      expect(service.isQuiet()).toBe(false);
+    });
+  });
+});
+
+describe("CliQuietModeService integration", () => {
+  let service: CliQuietModeService;
+
+  beforeEach(() => {
+    service = CliQuietModeService.getInstance();
+    service.reset();
+  });
+
+  afterEach(() => {
+    service.reset();
+  });
+
+  test("should enable quiet mode when -q flag is provided", () => {
+    // sessions grep -q
+    const argv = { quiet: true };
+    service.setQuietFromArgv(argv);
+    expect(service.isQuiet()).toBe(true);
+  });
+
+  test("should not enable quiet mode when -q flag is not provided", () => {
+    // tasks list (no -q)
+    const argv = {};
+    service.setQuietFromArgv(argv);
+    expect(service.isQuiet()).toBe(false);
+  });
+
+  test("should preserve quiet mode across command sequence when always enabled", () => {
+    // 如果命令行参数一直带有 -q，quiet 模式应该保持
+    service.setQuietFromArgv({ quiet: true });
+    expect(service.isQuiet()).toBe(true);
+
+    service.setQuietFromArgv({ quiet: true });
+    expect(service.isQuiet()).toBe(true);
+  });
+
+  test("should reset quiet mode manually when needed", () => {
+    service.setQuietFromArgv({ quiet: true });
+    expect(service.isQuiet()).toBe(true);
+
+    service.reset();
+    expect(service.isQuiet()).toBe(false);
+  });
+});

package/src/services/quiet-mode.service.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview CLI Quiet Mode Service
+ * 
+ * 统一管理 CLI 的 quiet 模式状态
+ * 
+ * 设计目标：
+ * 1. 单例模式 - 全局共享状态
+ * 2. 与 LogTraceComponent 集成 - 通过 ConfigComponent 配置
+ * 3. 支持命令行参数和配置文件双重控制
+ * 
+ * 使用方式：
+ * ```typescript
+ * // 1. 从命令行参数设置
+ * const service = CliQuietModeService.getInstance();
+ * service.setQuietFromArgv(argv);
+ * 
+ * // 2. 在命令中使用
+ * if (service.isQuiet()) {
+ *   setQuietMode(true);
+ * }
+ * 
+ * // 3. 重置状态（新命令开始时）
+ * service.reset();
+ * ```
+ */
+
+import { setQuietMode as setCoreQuietMode, isQuietMode as isCoreQuietMode } from "@ai-setting/roy-agent-core";
+
+export class CliQuietModeService {
+  private static instance: CliQuietModeService;
+
+  private constructor() {}
+
+  /**
+   * 获取单例实例
+   */
+  static getInstance(): CliQuietModeService {
+    if (!CliQuietModeService.instance) {
+      CliQuietModeService.instance = new CliQuietModeService();
+    }
+    return CliQuietModeService.instance;
+  }
+
+  /**
+   * 设置 quiet 模式
+   * 
+   * 内部调用 core 的 setQuietMode，同步到 LogTraceComponent
+   */
+  setQuiet(value: boolean): void {
+    setCoreQuietMode(value);
+  }
+
+  /**
+   * 从命令行参数设置 quiet 模式
+   * 
+   * @param argv - yargs 解析后的参数对象
+   * 
+   * 注意：只在 quiet 为 true 时设置，避免覆盖配置文件中的设置
+   */
+  setQuietFromArgv(argv: Record<string, unknown>): void {
+    if (argv.quiet === true) {
+      this.setQuiet(true);
+    }
+  }
+
+  /**
+   * 获取当前 quiet 模式状态
+   */
+  isQuiet(): boolean {
+    return isCoreQuietMode();
+  }
+
+  /**
+   * 重置 quiet 模式为 false
+   * 
+   * 用于新命令开始时清理状态
+   */
+  reset(): void {
+    setCoreQuietMode(false);
+  }
+}

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

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview StreamOutputService Tests
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import { StreamOutputService, resetStreamAbort } from "./stream-output.service";
+import type { EnvEvent } from "@ai-setting/roy-agent-core";
+
+describe("StreamOutputService", () => {
+  let service: StreamOutputService;
+  
+  beforeEach(() => {
+    // 重置全局 abort 状态，避免被其他测试污染
+    resetStreamAbort();
+    service = new StreamOutputService();
+  });
+
+  describe("handleEvent", () => {
+    test("should collect text deltas", () => {
+      const textEvent: EnvEvent = {
+        id: "1",
+        type: "llm.text",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { delta: "Hello" }
+      };
+      
+      service.handleEvent(textEvent);
+      expect(service.getFullText()).toBe("Hello");
+    });
+
+    test("should accumulate text deltas", () => {
+      const event1: EnvEvent = {
+        id: "1",
+        type: "llm.text",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { delta: "Hello " }
+      };
+      
+      const event2: EnvEvent = {
+        id: "2",
+        type: "llm.text",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { delta: "world" }
+      };
+      
+      service.handleEvent(event1);
+      service.handleEvent(event2);
+      expect(service.getFullText()).toBe("Hello world");
+    });
+
+    test("should handle reasoning events when showReasoning is enabled", () => {
+      const reasoningService = new StreamOutputService({ showReasoning: true });
+      
+      const reasoningEvent: EnvEvent = {
+        id: "1",
+        type: "llm.reasoning",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { content: "Let me think..." }
+      };
+      
+      // Should not throw
+      expect(() => reasoningService.handleEvent(reasoningEvent)).not.toThrow();
+    });
+
+    test("should ignore reasoning events when showReasoning is disabled", () => {
+      const reasoningService = new StreamOutputService({ showReasoning: false });
+      
+      const reasoningEvent: EnvEvent = {
+        id: "1",
+        type: "llm.reasoning",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { content: "Let me think..." }
+      };
+      
+      // Should not throw
+      expect(() => reasoningService.handleEvent(reasoningEvent)).not.toThrow();
+    });
+
+    test("should handle tool_call events when showToolCalls is enabled", () => {
+      const toolService = new StreamOutputService({ showToolCalls: true });
+      
+      const toolEvent: EnvEvent = {
+        id: "1",
+        type: "llm.tool_call",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { 
+          toolCall: {
+            id: "call_123",
+            name: "bash",
+            arguments: '{"command":"ls"}'
+          }
+        }
+      };
+      
+      // Should not throw
+      expect(() => toolService.handleEvent(toolEvent)).not.toThrow();
+    });
+
+    test("should handle completed event and extract usage info", () => {
+      const completedEvent: EnvEvent = {
+        id: "1",
+        type: "llm.completed",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: {
+          content: "Final response",
+          metadata: {
+            model: "minimax/MiniMax-M2.5-highspeed",
+            usage: {
+              promptTokens: 1000,
+              completionTokens: 500,
+              totalTokens: 1500,
+            },
+          },
+        },
+      };
+
+      // Should not throw
+      expect(() => service.handleEvent(completedEvent)).not.toThrow();
+
+      // Verify usage info is extracted
+      const usageInfo = service.getUsageInfo();
+      expect(usageInfo).toEqual({
+        model: "MiniMax-M2.5-highspeed",
+        providerId: "minimax",
+        promptTokens: 1000,
+        completionTokens: 500,
+        totalTokens: 1500,
+      });
+    });
+
+    test("should handle completed event without usage info", () => {
+      const completedEvent: EnvEvent = {
+        id: "1",
+        type: "llm.completed",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: {
+          content: "Final response",
+        },
+      };
+
+      // Should not throw
+      expect(() => service.handleEvent(completedEvent)).not.toThrow();
+
+      // Usage info should be undefined
+      const usageInfo = service.getUsageInfo();
+      expect(usageInfo).toBeUndefined();
+    });
+
+    test("should reset usage info on reset", () => {
+      const completedEvent: EnvEvent = {
+        id: "1",
+        type: "llm.completed",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: {
+          content: "Final response",
+          metadata: {
+            model: "minimax/MiniMax-M2.5-highspeed",
+            usage: {
+              promptTokens: 1000,
+              completionTokens: 500,
+              totalTokens: 1500,
+            },
+          },
+        },
+      };
+
+      service.handleEvent(completedEvent);
+      expect(service.getUsageInfo()).toBeDefined();
+
+      service.reset();
+      expect(service.getUsageInfo()).toBeUndefined();
+    });
+
+    test("should handle start event", () => {
+      const startEvent: EnvEvent = {
+        id: "1",
+        type: "llm.start",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { metadata: { model: "test-model" } }
+      };
+      
+      // Should not throw
+      expect(() => service.handleEvent(startEvent)).not.toThrow();
+    });
+  });
+
+  describe("reset", () => {
+    test("should reset fullText", () => {
+      const textEvent: EnvEvent = {
+        id: "1",
+        type: "llm.text",
+        timestamp: Date.now(),
+        metadata: {},
+        payload: { delta: "Hello" }
+      };
+      
+      service.handleEvent(textEvent);
+      expect(service.getFullText()).toBe("Hello");
+      
+      service.reset();
+      expect(service.getFullText()).toBe("");
+    });
+  });
+});