@ai-setting/roy-agent-cli 1.0.0

package/src/commands/eventsource/status.ts

@@ -0,0 +1,185 @@
+/**
+ * @fileoverview EventSource Status Command
+ * 
+ * 查看事件源状态
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { EventSourceComponentInterface, EventSourceStatus } from "@ai-setting/roy-agent-core";
+
+export interface EventSourceStatusOptions {
+  id?: string;
+  config?: string;
+  json?: boolean;
+}
+
+const STATUS_COLORS: Record<EventSourceStatus, (text: string) => string> = {
+  created: chalk.gray,
+  starting: chalk.yellow,
+  running: chalk.green,
+  stopping: chalk.yellow,
+  stopped: chalk.gray,
+  error: chalk.red,
+};
+
+const STATUS_ICONS: Record<EventSourceStatus, string> = {
+  created: "○",
+  starting: "◐",
+  running: "●",
+  stopping: "◑",
+  stopped: "○",
+  error: "✗",
+};
+
+const STATUS_LABELS: Record<EventSourceStatus, string> = {
+  created: "已创建",
+  starting: "启动中",
+  running: "运行中",
+  stopping: "停止中",
+  stopped: "已停止",
+  error: "错误",
+};
+
+export const EventSourceStatusCommand: CommandModule<object, EventSourceStatusOptions> = {
+  command: "status [id]",
+  aliases: ["stat"],
+  describe: "查看事件源状态",
+
+  builder: (yargs) =>
+    yargs
+      .positional("id", {
+        describe: "事件源 ID（可选，查看所有或单个）",
+        type: "string",
+      })
+      .option("json", {
+        alias: "j",
+        describe: "JSON 格式输出",
+        type: "boolean",
+        default: false,
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      // 如果指定了 ID，查看单个
+      if (args.id) {
+        const sources = esComponent.list();
+        const matchedSource = sources.find(
+          (s) => s.id === args.id || s.id.startsWith(args.id!)
+        );
+
+        if (!matchedSource) {
+          output.error(`事件源不存在: ${args.id}`);
+          process.exit(1);
+        }
+
+        const status = esComponent.getStatus(matchedSource.id) || "unknown";
+        const statusColor = STATUS_COLORS[status as EventSourceStatus] || chalk.gray;
+
+        if (args.json) {
+          output.json({
+            id: matchedSource.id,
+            name: matchedSource.name,
+            type: matchedSource.type,
+            status,
+            enabled: matchedSource.enabled,
+            eventTypes: matchedSource.eventTypes,
+            config: {
+              command: matchedSource.command,
+              interval: matchedSource.interval,
+              url: matchedSource.url,
+            },
+          });
+          return;
+        }
+
+        output.log(chalk.bold("事件源详情"));
+        output.log("─".repeat(50));
+        output.log(`  ID:       ${chalk.gray(matchedSource.id)}`);
+        output.log(`  Name:     ${chalk.cyan(matchedSource.name)}`);
+        output.log(`  Type:     ${chalk.cyan(matchedSource.type)}`);
+        output.log(`  Status:   ${statusColor(`${STATUS_ICONS[status as EventSourceStatus]} ${STATUS_LABELS[status as EventSourceStatus]}`)}`);
+        output.log(`  Enabled:  ${matchedSource.enabled ? chalk.green("是") : chalk.gray("否")}`);
+        
+        if (matchedSource.eventTypes?.length) {
+          output.log(`  Events:   ${chalk.gray(matchedSource.eventTypes.join(", "))}`);
+        }
+        if (matchedSource.command) {
+          output.log(`  Command:  ${chalk.gray(matchedSource.command)}`);
+        }
+        if (matchedSource.interval) {
+          output.log(`  Interval: ${chalk.gray(`${matchedSource.interval}ms`)}`);
+        }
+        if (matchedSource.url) {
+          output.log(`  URL:      ${chalk.gray(matchedSource.url)}`);
+        }
+        output.log("");
+        return;
+      }
+
+      // 查看所有状态
+      const sources = esComponent.list();
+
+      if (sources.length === 0) {
+        output.log(chalk.yellow("没有配置的事件源"));
+        return;
+      }
+
+      if (args.json) {
+        const sourcesWithStatus = sources.map((s) => ({
+          id: s.id,
+          name: s.name,
+          type: s.type,
+          status: esComponent.getStatus(s.id) || "unknown",
+          enabled: s.enabled,
+        }));
+        output.json({ sources: sourcesWithStatus, count: sources.length });
+        return;
+      }
+
+      output.log(chalk.bold("事件源状态概览"));
+      output.log("─".repeat(60));
+
+      for (const source of sources) {
+        const status = esComponent.getStatus(source.id) || "unknown";
+        const statusColor = STATUS_COLORS[status as EventSourceStatus] || chalk.gray;
+        const icon = STATUS_ICONS[status as EventSourceStatus] || "?";
+        const label = STATUS_LABELS[status as EventSourceStatus] || status;
+
+        output.log("");
+        output.log(`  ${chalk.cyan(source.name)} ${chalk.gray(`(${source.type})`)}`);
+        output.log(`  └─ Status: ${statusColor(`${icon} ${label}`)}`);
+        output.log(`     ID: ${chalk.gray(source.id.substring(0, 8))}...`);
+      }
+
+      output.log("");
+      const runningCount = sources.filter(
+        (s) => esComponent.getStatus(s.id) === "running"
+      ).length;
+      output.log(
+        chalk.green(`✅ ${runningCount}/${sources.length} 运行中`)
+      );
+
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/eventsource/stop.ts

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview EventSource Stop Command
+ * 
+ * 停止事件源
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { EventSourceComponentInterface } from "@ai-setting/roy-agent-core";
+
+export interface EventSourceStopOptions {
+  id: string;
+  config?: string;
+  force?: boolean;
+}
+
+export const EventSourceStopCommand: CommandModule<object, EventSourceStopOptions> = {
+  command: "stop <id>",
+  aliases: ["kill"],
+  describe: "停止指定的事件源",
+
+  builder: (yargs) =>
+    yargs
+      .positional("id", {
+        describe: "事件源 ID（支持前缀匹配）",
+        type: "string",
+        demandOption: true,
+      })
+      .option("force", {
+        alias: "f",
+        describe: "强制停止",
+        type: "boolean",
+        default: false,
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const esComponent = env.getComponent("event-source") as unknown as EventSourceComponentInterface | undefined;
+
+      if (!esComponent) {
+        output.error("EventSourceComponent not available");
+        process.exit(1);
+      }
+
+      // 查找事件源（支持前缀匹配）
+      const sources = esComponent.list();
+      const matchedSource = sources.find(
+        (s) => s.id === args.id || s.id.startsWith(args.id)
+      );
+
+      if (!matchedSource) {
+        output.error(`事件源不存在: ${args.id}`);
+        process.exit(1);
+      }
+
+      // 检查状态
+      const status = esComponent.getStatus(matchedSource.id);
+      if (status !== "running") {
+        output.log(chalk.yellow(`事件源未运行: ${matchedSource.name} (${status || "unknown"})`));
+        return;
+      }
+
+      // 停止
+      output.info(`正在停止事件源 '${matchedSource.name}'...`);
+
+      try {
+        await esComponent.stopSource(matchedSource.id);
+        output.success(chalk.green(`事件源已停止: ${matchedSource.name}`));
+      } catch (error) {
+        output.error(`停止失败: ${error}`);
+        process.exit(1);
+      }
+
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/index.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview CLI Commands Index
+ *
+ * 导出所有内置命令，供插件复用
+ */
+
+export { ActCommand } from "./act";
+export type { ActOptions } from "./act";
+
+export { InteractiveCommand } from "./interactive";
+
+export { SessionsCommand } from "./sessions";
+
+export { TasksCommand } from "./tasks";
+
+export { CommandsCommand } from "./commands";
+
+export { ToolsCommand } from "./tools";
+
+export { EventSourceCommand } from "./eventsource";
+
+export { WorkflowCommand } from "./workflow";

package/src/commands/input-handler.test.ts

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview InputHandler - TDD Tests
+ * 
+ * 核心设计：
+ * - 纯粹 buffer 管理
+ * - 只负责 pushLine, getBuffer, reset, getPrompt
+ */
+
+import { describe, test, expect } from "bun:test";
+import { InputHandler } from "./input-handler";
+
+describe("InputHandler", () => {
+
+  describe("pushLine - 添加输入", () => {
+
+    test("添加单行内容", () => {
+      const handler = new InputHandler();
+      handler.pushLine("hello");
+      expect(handler.getBuffer()).toBe("hello");
+    });
+
+    test("添加多行内容", () => {
+      const handler = new InputHandler();
+      handler.pushLine("line1");
+      handler.pushLine("line2");
+      expect(handler.getBuffer()).toBe("line1\nline2");
+    });
+
+    test("添加空行", () => {
+      const handler = new InputHandler();
+      handler.pushLine("hello");
+      handler.pushLine("");
+      expect(handler.getBuffer()).toBe("hello\n");
+    });
+
+    test("支持空白行", () => {
+      const handler = new InputHandler();
+      handler.pushLine("line1");
+      handler.pushLine("");
+      handler.pushLine("");
+      handler.pushLine("line2");
+      expect(handler.getBuffer()).toBe("line1\n\n\nline2");
+    });
+  });
+
+  describe("reset - 重置", () => {
+
+    test("重置后 buffer 为空", () => {
+      const handler = new InputHandler();
+      handler.pushLine("hello");
+      handler.reset();
+      expect(handler.getBuffer()).toBe("");
+    });
+  });
+
+  describe("getPrompt - 获取提示符", () => {
+
+    test("初始状态返回用户提示符", () => {
+      const handler = new InputHandler();
+      expect(handler.getPrompt()).toBe("❯ ");
+    });
+
+    test("有多行输入时返回继续提示符", () => {
+      const handler = new InputHandler();
+      handler.pushLine("hello");
+      expect(handler.getPrompt()).toBe("... ");
+    });
+
+    test("reset 后恢复用户提示符", () => {
+      const handler = new InputHandler();
+      handler.pushLine("hello");
+      handler.reset();
+      expect(handler.getPrompt()).toBe("❯ ");
+    });
+  });
+});

package/src/commands/input-handler.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview InputHandler - 纯粹 buffer 管理
+ * 
+ * 只负责累积输入，不处理结束检测
+ */
+
+export class InputHandler {
+  private buffer: string[] = [];
+
+  // 提示符
+  private static readonly USER_PROMPT = "❯ ";
+  private static readonly CONTINUATION_PROMPT = "... ";
+
+  /**
+   * 添加一行输入
+   */
+  pushLine(line: string): void {
+    this.buffer.push(line);
+  }
+
+  /**
+   * 获取当前 buffer 内容
+   */
+  getBuffer(): string {
+    return this.buffer.join("\n");
+  }
+
+  /**
+   * 重置 buffer
+   */
+  reset(): void {
+    this.buffer = [];
+  }
+
+  /**
+   * 获取提示符
+   */
+  getPrompt(): string {
+    return this.buffer.length > 0
+      ? InputHandler.CONTINUATION_PROMPT
+      : InputHandler.USER_PROMPT;
+  }
+}

package/src/commands/interactive-esc.test.ts

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Interactive Esc Key Handler Tests
+ * 
+ * TDD: 测试 Interactive 模式的 Esc 按键中断功能
+ * 
+ * 场景 1: 正在执行时按 Esc - 中断 LLM 调用 + 停止流式输出 + 恢复 prompt
+ * 场景 2: 空闲时按 Esc - 不做任何操作
+ */
+
+import { describe, test, expect, vi, beforeEach } from "bun:test";
+import { REPL } from "./interactive";
+import { COLORS, abortStream, resetStreamAbort, streamAbortSignal } from "../services/stream-output.service";
+
+// ============================================================================
+// Test Suite
+// ============================================================================
+
+describe("REPL.handleEscKey - Esc 按键中断流式输出", () => {
+  let mockExecute: ReturnType<typeof vi.fn>;
+  let mockStatus: ReturnType<typeof vi.fn>;
+  let mockShutdown: ReturnType<typeof vi.fn>;
+  let mockAbort: ReturnType<typeof vi.fn>;
+  let mockEnv: any;
+
+  beforeEach(() => {
+    // 重置 abort 信号
+    resetStreamAbort();
+
+    // 创建 mock 函数
+    mockExecute = vi.fn().mockResolvedValue("done");
+    mockStatus = vi.fn().mockReturnValue({
+      sessionId: "test",
+      sessionTitle: "Test",
+      messageCount: 0,
+      tokenCount: 0,
+    });
+    mockShutdown = vi.fn().mockResolvedValue(undefined);
+    mockAbort = vi.fn();
+
+    // Mock environment with agent component
+    mockEnv = {
+      getComponent: vi.fn().mockImplementation((name: string) => {
+        if (name === "agent") {
+          return { abort: mockAbort };
+        }
+        return undefined;
+      }),
+    };
+  });
+
+  test("handleEscKey() 方法应该存在", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // Assert - handleEscKey 应该是 REPL 的一个方法
+    expect(typeof repl.handleEscKey).toBe("function");
+  });
+
+  test("正在执行时按 Esc - 应该调用 AgentComponent.abort", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // 模拟正在执行状态
+    // 通过私有属性访问（测试用途）
+    (repl as any).isExecuting = true;
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - AgentComponent.abort 应该被调用
+    expect(mockAbort).toHaveBeenCalledWith("default");
+    expect(mockAbort).toHaveBeenCalledTimes(1);
+  });
+
+  test("正在执行时按 Esc - 应该调用 abortStream", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // 模拟正在执行状态
+    (repl as any).isExecuting = true;
+
+    // 重置确认
+    resetStreamAbort();
+    expect(streamAbortSignal.aborted).toBe(false);
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - abortStream 应该被调用，streamAbortSignal.aborted 应该为 true
+    expect(streamAbortSignal.aborted).toBe(true);
+  });
+
+  test("正在执行时按 Esc - 应该重置 isExecuting 状态为 false", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // 模拟正在执行状态
+    (repl as any).isExecuting = true;
+    expect((repl as any).isExecuting).toBe(true);
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - isExecuting 应该被重置为 false
+    expect((repl as any).isExecuting).toBe(false);
+  });
+
+  test("空闲时按 Esc - 不应该调用 AgentComponent.abort", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // 确保处于空闲状态
+    (repl as any).isExecuting = false;
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - AgentComponent.abort 不应该被调用
+    expect(mockAbort).not.toHaveBeenCalled();
+  });
+
+  test("空闲时按 Esc - 不应该调用 abortStream", () => {
+    // Arrange
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      mockEnv
+    );
+
+    // 确保处于空闲状态
+    (repl as any).isExecuting = false;
+
+    // 重置确认
+    resetStreamAbort();
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - abortStream 不应该被调用
+    expect(streamAbortSignal.aborted).toBe(false);
+  });
+
+  test("没有 env 时按 Esc - 应该仍然调用 abortStream", () => {
+    // Arrange - 不传入 env
+    const repl = new REPL(
+      {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: mockExecute,
+        onStatus: mockStatus,
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: mockShutdown,
+      },
+      undefined // 不传入 env
+    );
+
+    // 模拟正在执行状态
+    (repl as any).isExecuting = true;
+    resetStreamAbort();
+
+    // Act
+    repl.handleEscKey();
+
+    // Assert - 即使没有 env，abortStream 也应该被调用
+    expect(streamAbortSignal.aborted).toBe(true);
+  });
+});
+
+describe("Esc 与 Ctrl+C 的区别", () => {
+  test("Esc 和 Ctrl+C 都会中断流式输出，但行为不同", () => {
+    // 这个测试文档化两种中断方式的区别
+    
+    // Ctrl+C 第一次：中断执行 + 显示 "按 Ctrl+C 再次中断或退出程序"
+    // Ctrl+C 第二次（在空闲时）：退出程序
+    
+    // Esc：仅在执行时中断 + 显示 "[已中断，可以继续输入]"
+    // Esc 在空闲时：不做任何操作
+    
+    // 两种方式都调用：
+    // 1. AgentComponent.abort("default") - 中断底层 LLM 调用
+    // 2. abortStream() - 停止流式输出显示
+    // 3. isExecuting = false - 重置状态
+    // 4. rl.prompt(true) - 恢复 prompt
+    
+    // 不同点：
+    // - Esc 在空闲时不做任何操作
+    // - Ctrl+C 在空闲时会退出程序
+    
+    expect(true).toBe(true); // 文档化测试
+  });
+});