@ai-setting/roy-agent-cli 1.0.0

package/src/commands/sessions/index.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Sessions Command Entry
+ * 
+ * 命令入口：roy sessions [action]
+ * 
+ * 注意：--quiet / -q 选项现在由 cli.ts 的全局 middleware 统一处理
+ */
+
+import { CommandModule } from "yargs";
+import { ListCommand } from "./list";
+import { GetCommand } from "./get";
+import { NewCommand } from "./new";
+import { RenameCommand } from "./rename";
+import { DeleteCommand } from "./delete";
+import { MessagesCommand } from "./messages";
+import { CompactCommand } from "./compact";
+import { CheckpointsCommand } from "./checkpoints";
+import { ActiveCommand } from "./active";
+import { AddMessageCommand } from "./add-message";
+import { MockCommand } from "./mock";
+import { GrepCommand } from "./grep";
+
+/**
+ * Sessions Command
+ * 
+ * 会话管理命令，提供以下子命令：
+ * - list: 列出所有会话
+ * - get: 获取会话详情
+ * - new: 创建新会话
+ * - rename: 更新会话标题
+ * - delete: 删除会话（支持批量删除、全量删除、按时间删除）
+ * - messages: 查看消息
+ * - grep: 全文搜索消息
+ * - compact: 压缩会话 (new)
+ * - checkpoints: 查看检查点 (new)
+ * - active: 活跃会话管理
+ * - add-message: 添加单条消息
+ * - mock: 插入模拟消息（用于测试）
+ * 
+ * 删除命令使用示例：
+ *   roy sessions delete <id>                    # 删除单个会话
+ *   roy sessions delete <id1> <id2> <id3>       # 批量删除
+ *   roy sessions delete --all                    # 删除所有会话
+ *   roy sessions delete --all --keep-active     # 删除所有非活跃会话
+ *   roy sessions delete --older-than 30          # 删除30天前的会话
+ *   roy sessions delete --dry-run               # 预览模式
+ * 
+ * 搜索命令使用示例：
+ *   roy sessions grep K8s deployment error       # 多关键字搜索
+ *   roy sessions grep "exact phrase"            # 精确短语
+ *   roy sessions grep --session <id> query      # 搜索指定会话
+ *   roy sessions grep --limit 10 query         # 限制结果数
+ *   roy sessions grep --json query              # JSON 输出
+ */
+export const SessionsCommand: CommandModule = {
+  command: "sessions",
+  describe: `会话管理 - 列出、创建、删除和管理会话
+  
+删除命令使用示例：
+  roy sessions delete <id>                    # 删除单个会话
+  roy sessions delete <id1> <id2> <id3>       # 批量删除
+  roy sessions delete --all                   # 删除所有会话
+  roy sessions delete --all --keep-active     # 删除所有非活跃会话
+  roy sessions delete --older-than 30         # 删除30天前的会话
+  roy sessions delete --dry-run               # 预览模式
+
+搜索命令使用示例：
+  roy sessions grep K8s deployment error       # 多关键字搜索
+  roy sessions grep "exact phrase"            # 精确短语
+  roy sessions grep --session <id> query      # 搜索指定会话
+  roy sessions grep --limit 10 query          # 限制结果数
+  roy sessions grep --json query              # JSON 输出`,
+  builder: (yargs) => {
+    // 注意：--quiet / -q 选项现在由 cli.ts 的全局 middleware 统一处理
+    return yargs
+      .command(ListCommand)
+      .command(GetCommand)
+      .command(NewCommand)
+      .command(RenameCommand)
+      .command(DeleteCommand)
+      .command(MessagesCommand)
+      .command(GrepCommand)
+      .command(CompactCommand)
+      .command(CheckpointsCommand)
+      .command(ActiveCommand)
+      .command(AddMessageCommand)
+      .command(MockCommand)
+      .demandCommand()
+      .help();
+  },
+  handler: () => {
+    // Default handler - shouldn't be reached if demandCommand is true
+    console.log("Use 'roy sessions --help' for usage information");
+  },
+};

package/src/commands/sessions/list.ts

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Sessions List Command
+ * 
+ * 命令：roy sessions list
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import { CliQuietModeService } from "../../services/quiet-mode.service";
+import chalk from "chalk";
+import type {
+  SessionComponent,
+  Session,
+  ListSessionsOptions,
+} from "@ai-setting/roy-agent-core";
+
+// Inline type for WorkflowSessionMetadata to avoid import issue
+interface WorkflowSessionMetadata {
+  type: 'workflow';
+  workflowId?: string;
+  workflowName: string;
+  status: 'running' | 'paused' | 'completed' | 'failed';
+}
+
+interface ListOptions {
+  limit?: number;
+  offset?: number;
+  sort?: string;
+  order?: string;
+  json?: boolean;
+  quiet?: boolean;
+  id?: boolean;
+  config?: string;
+  type?: string;
+  status?: string;
+}
+
+export const ListCommand: CommandModule<object, ListOptions> = {
+  command: "list [options]",
+  aliases: ["ls"],
+  describe: "列出所有会话",
+
+  builder: (yargs) =>
+    yargs
+      .option("limit", { alias: "n", type: "number", default: 20 })
+      .option("offset", { type: "number", default: 0 })
+      .option("sort", { type: "string", default: "updatedAt" })
+      .option("order", { type: "string", default: "desc" })
+      .option("json", { alias: "j", type: "boolean", default: false })
+      .option("quiet", { alias: "q", type: "boolean", default: false })
+      .option("id", { alias: "i", type: "boolean", default: false, description: "显示 Session ID" })
+      .option("type", { alias: "t", type: "string", description: "按 session 类型过滤 (如 workflow)" })
+      .option("status", { alias: "s", type: "string", description: "按状态过滤 (如 running, paused)" }),
+
+  async handler(args) {
+    const isQuiet = args.quiet === true;
+    if (isQuiet) {
+      CliQuietModeService.getInstance().setQuiet(true);
+    }
+
+    const output = new OutputService();
+    output.configure({ quiet: isQuiet });
+    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 sessionComponent = env.getComponent("session") as SessionComponent;
+
+      if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        process.exit(1);
+      }
+
+      const listOptions: ListSessionsOptions = {
+        sort: { field: args.sort as any, order: args.order as any },
+        offset: args.offset,
+        limit: args.limit,
+      };
+      
+      // Add metadata filter if type or status is specified
+      if (args.type || args.status) {
+        const metadataFilter: Record<string, unknown> = {};
+        if (args.type) {
+          metadataFilter.type = args.type;
+        }
+        if (args.status) {
+          metadataFilter.status = args.status;
+        }
+        listOptions.filter = {
+          metadata: metadataFilter,
+        };
+      }
+      
+      const sessions = await sessionComponent.list(listOptions);
+      const totalCount = await sessionComponent.getCount();
+      const activeSessionId = sessionComponent.getActiveSessionId();
+
+      if (args.json) {
+        output.json({
+          sessions: sessions.map((s: Session) => {
+            const workflowMeta = s.metadata?.type === 'workflow' 
+              ? s.metadata as unknown as WorkflowSessionMetadata 
+              : null;
+            return {
+              id: s.id,
+              title: s.title,
+              directory: s.directory,
+              messageCount: s.messageCount,
+              type: workflowMeta?.type || 'chat',
+              status: workflowMeta?.status,
+              workflowName: workflowMeta?.workflowName,
+              hasCheckpoint: !!s.metadata?.checkpoints?.checkpoints?.length,
+              lastCheckpointAt: s.metadata?.checkpoints?.latestCheckpointId,
+              createdAt: new Date(s.createdAt).toISOString(),
+              updatedAt: new Date(s.updatedAt).toISOString(),
+              isActive: s.id === activeSessionId,
+            };
+          }),
+          total: sessions.length,
+          totalCount: totalCount,
+        });
+      } else if (args.quiet || args.id) {
+        // 简洁输出：只显示 ID
+        sessions.forEach((s: Session) => output.log(s.id));
+      } else {
+        // 表格输出
+        const hasTypeFilter = !!args.type;
+        const hasStatusFilter = !!args.status;
+        
+        const header = [
+          chalk.bold("#"),
+          chalk.bold("Title"),
+          chalk.bold("ID"),
+          hasTypeFilter || hasStatusFilter ? chalk.bold("Status") : null,
+          chalk.bold("Msgs"),
+          chalk.bold("CP"),
+        ].filter(Boolean).join(" │ ");
+
+        const rows = sessions.map((s: Session, i: number) => {
+          const marker = s.id === activeSessionId ? chalk.green("▶") : " ";
+          const hasCp = (s.metadata?.checkpoints?.checkpoints?.length ?? 0) > 0;
+          const title = s.title.length > 20 ? s.title.slice(0, 17) + "..." : s.title;
+          // 显示完整的 Session ID
+          const idStr = s.id;
+          
+          // Get workflow metadata if present
+          const workflowMeta = s.metadata?.type === 'workflow' 
+            ? s.metadata as unknown as WorkflowSessionMetadata 
+            : null;
+          const typeStr = workflowMeta?.type || '';
+          const statusStr = workflowMeta?.status || '';
+          
+          // Format status for display
+          let statusDisplay = '';
+          if (hasTypeFilter || hasStatusFilter) {
+            if (workflowMeta) {
+              statusDisplay = workflowMeta.status === 'running' ? chalk.green('running') 
+                : workflowMeta.status === 'paused' ? chalk.yellow('paused')
+                : workflowMeta.status === 'completed' ? chalk.gray('completed')
+                : workflowMeta.status === 'failed' ? chalk.red('failed')
+                : statusStr;
+            }
+          }
+
+          const cells = [
+            marker + " " + (args.offset! + i + 1),
+            title,
+            chalk.gray(idStr),
+          ];
+          
+          if (hasTypeFilter || hasStatusFilter) {
+            cells.push(statusDisplay || chalk.gray('-'));
+          }
+          
+          cells.push(
+            s.messageCount.toString(),
+            hasCp ? chalk.green("✓") : chalk.gray("-"),
+          );
+
+          return cells.join(" │ ");
+        });
+
+        const showingInfo = totalCount > sessions.length
+          ? `Showing ${sessions.length} of ${totalCount} sessions`
+          : `${totalCount} sessions`;
+
+        output.log([
+          `┌─ Sessions ${"─".repeat(50)}┐`,
+          `│${header}│`,
+          "├" + "─".repeat(header.length + 2) + "┤",
+          ...rows.map((r: string) => `│${r}│`),
+          "└" + "─".repeat(header.length + 2) + "┘",
+          "",
+          chalk.gray(showingInfo),
+        ].join("\n"));
+      }
+    } catch (error) {
+      output.error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/sessions/messages.test.ts

@@ -0,0 +1,333 @@
+/**
+ * @fileoverview Messages Command Tests
+ * 
+ * TDD: 测试 sessions messages 命令的分页和总数功能
+ */
+
+import { describe, test, expect, vi, beforeEach } from "bun:test";
+import type { SessionMessage } from "@ai-setting/roy-agent-core";
+
+describe("MessagesCommand MessagesOptions", () => {
+  test("should have required offset parameter", () => {
+    // Given: 期望 offset 是必填参数
+    const options = {
+      sessionId: "test-session",
+      offset: 10,
+      limit: 20,
+    };
+    
+    // Then: offset 和 limit 应该是必填的
+    expect(options.offset).toBeDefined();
+    expect(options.limit).toBeDefined();
+  });
+
+  test("should have required limit parameter", () => {
+    const options = {
+      sessionId: "test-session",
+      offset: 0,
+      limit: 50,
+    };
+    
+    expect(options.offset).toBeDefined();
+    expect(options.limit).toBeDefined();
+  });
+});
+
+describe("MessagesCommand Pagination Logic", () => {
+  // Mock SessionComponent
+  let mockSessionComponent: {
+    get: ReturnType<typeof vi.fn>;
+    getMessages: ReturnType<typeof vi.fn>;
+    getMessageCount: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockSessionComponent = {
+      get: vi.fn(),
+      getMessages: vi.fn(),
+      getMessageCount: vi.fn(),
+    };
+    
+    // Setup default mocks
+    mockSessionComponent.get.mockResolvedValue({
+      id: "test-session",
+      title: "Test Session",
+    });
+    
+    mockSessionComponent.getMessageCount.mockResolvedValue(100);
+    mockSessionComponent.getMessages.mockResolvedValue([
+      {
+        id: "msg-1",
+        sessionID: "test-session",
+        role: "user",
+        content: "Hello",
+        timestamp: Date.now(),
+      },
+    ]);
+  });
+
+  test("should call getMessages with offset and limit", async () => {
+    // Given: offset=10, limit=20
+    const offset = 10;
+    const limit = 20;
+    
+    // When: 调用 getMessages
+    const messages = await mockSessionComponent.getMessages("test-session", {
+      offset,
+      limit,
+    });
+    
+    // Then: 应该传入正确的 offset 和 limit
+    expect(mockSessionComponent.getMessages).toHaveBeenCalledWith(
+      "test-session",
+      { offset: 10, limit: 20 }
+    );
+    expect(messages).toHaveLength(1);
+  });
+
+  test("should call getMessageCount to get total", async () => {
+    // Given
+    const sessionId = "test-session";
+    
+    // When: 获取消息总数
+    const totalCount = await mockSessionComponent.getMessageCount(sessionId);
+    
+    // Then: 应该返回正确的总数
+    expect(mockSessionComponent.getMessageCount).toHaveBeenCalledWith(sessionId);
+    expect(totalCount).toBe(100);
+  });
+
+  test("should return messages with pagination info", async () => {
+    // Given
+    const sessionId = "test-session";
+    const offset = 0;
+    const limit = 10;
+    
+    // 模拟分页数据
+    const mockMessages: SessionMessage[] = Array.from({ length: 10 }, (_, i) => ({
+      id: `msg-${i}`,
+      sessionID: sessionId,
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: `Message ${i}`,
+      timestamp: Date.now() + i,
+    }));
+    
+    mockSessionComponent.getMessages.mockResolvedValue(mockMessages);
+    mockSessionComponent.getMessageCount.mockResolvedValue(100);
+    
+    // When
+    const [messages, totalCount] = await Promise.all([
+      mockSessionComponent.getMessages(sessionId, { offset, limit }),
+      mockSessionComponent.getMessageCount(sessionId),
+    ]);
+    
+    // Then
+    expect(messages).toHaveLength(10);
+    expect(totalCount).toBe(100);
+  });
+
+  test("should handle edge case: offset equals total count", async () => {
+    // Given: offset 等于总数（最后一页之后）
+    const sessionId = "test-session";
+    mockSessionComponent.getMessages.mockResolvedValue([]);
+    mockSessionComponent.getMessageCount.mockResolvedValue(50);
+    
+    // When
+    const [messages, totalCount] = await Promise.all([
+      mockSessionComponent.getMessages(sessionId, { offset: 50, limit: 10 }),
+      mockSessionComponent.getMessageCount(sessionId),
+    ]);
+    
+    // Then
+    expect(messages).toHaveLength(0);
+    expect(totalCount).toBe(50);
+  });
+});
+
+describe("MessagesCommand JSON Output", () => {
+  test("should include total count in JSON output", () => {
+    // Given: JSON 响应应该包含总数
+    const jsonResponse = {
+      sessionId: "test-session",
+      messages: [
+        {
+          id: "msg-1",
+          role: "user",
+          content: "Hello",
+          timestamp: new Date().toISOString(),
+        },
+      ],
+      total: 100, // 消息总数
+      pagination: {
+        offset: 0,
+        limit: 10,
+      },
+    };
+    
+    // Then: 应该包含 total 字段
+    expect(jsonResponse).toHaveProperty("total");
+    expect(jsonResponse.total).toBe(100);
+  });
+
+  test("should include pagination info in JSON output", () => {
+    // Given
+    const jsonResponse = {
+      sessionId: "test-session",
+      messages: [],
+      total: 100,
+      pagination: {
+        offset: 10,
+        limit: 20,
+        hasMore: true, // 是否有更多消息
+      },
+    };
+    
+    // Then
+    expect(jsonResponse.pagination).toBeDefined();
+    expect(jsonResponse.pagination.offset).toBe(10);
+    expect(jsonResponse.pagination.limit).toBe(20);
+  });
+});
+
+describe("MessagesCommand CLI Options", () => {
+  test("offset should be required in CLI builder", () => {
+    // Given: CLI 参数定义
+    const expectedOptions = {
+      offset: { alias: "o", type: "number", demandOption: true },
+      limit: { alias: "n", type: "number", demandOption: true },
+    };
+    
+    // Then: offset 和 limit 应该是必填的 (demandOption: true)
+    expect(expectedOptions.offset.demandOption).toBe(true);
+    expect(expectedOptions.limit.demandOption).toBe(true);
+  });
+
+  test("should have default values for optional parameters", () => {
+    // Note: 虽然 offset 和 limit 是必填的，但 reverse 和 json 有默认值
+    const cliOptions = {
+      offset: { alias: "o", type: "number", demandOption: true },
+      limit: { alias: "n", type: "number", demandOption: true },
+      reverse: { alias: "r", type: "boolean", default: false },
+      json: { alias: "j", type: "boolean", default: false },
+    };
+    
+    expect(cliOptions.reverse.default).toBe(false);
+    expect(cliOptions.json.default).toBe(false);
+  });
+});
+
+describe("MessagesCommand Format Message Content", () => {
+  test("should handle tool-call with undefined arguments without error", () => {
+    // Given: tool-call part 的 arguments 是 undefined
+    const mockMessage = {
+      id: "msg-1",
+      role: "assistant",
+      content: "",
+      timestamp: Date.now(),
+      parts: [
+        { type: "tool-call", toolCallId: "call_1", toolName: "bash", arguments: undefined, state: "pending" },
+      ],
+    };
+    
+    // Then: 应该能安全处理 undefined arguments
+    const formatMessageContent = (m: any): string[] => {
+      const lines: string[] = [];
+      if (m.parts && m.parts.length > 0) {
+        for (const part of m.parts) {
+          if (part.type === "tool-call") {
+            lines.push(`[Tool Call] ${part.toolName}`);
+            // 修复后的代码逻辑
+            const argsStr = typeof part.arguments === 'string'
+              ? part.arguments
+              : JSON.stringify(part.arguments ?? null, null, 2);
+            if (argsStr && argsStr.length > 200) {
+              lines.push(...argsStr.slice(0, 197).split("\n").map(() => "line"));
+              lines.push("...");
+            } else if (argsStr) {
+              lines.push(...argsStr.split("\n").map(() => "line"));
+            }
+          }
+        }
+      }
+      return lines;
+    };
+    
+    // Should not throw
+    expect(() => formatMessageContent(mockMessage)).not.toThrow();
+    const result = formatMessageContent(mockMessage);
+    expect(result).toContain("[Tool Call] bash");
+  });
+});
+
+describe("MessagesCommand getMessageCount Integration", () => {
+  let mockSessionComponent: {
+    getMessageCount: ReturnType<typeof vi.fn>;
+    getMessages: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockSessionComponent = {
+      getMessageCount: vi.fn(),
+      getMessages: vi.fn(),
+    };
+  });
+
+  test("should use getMessageCount to get total messages", async () => {
+    // Given
+    mockSessionComponent.getMessageCount.mockResolvedValue(150);
+    
+    // When
+    const total = await mockSessionComponent.getMessageCount("session-123");
+    
+    // Then
+    expect(total).toBe(150);
+    expect(mockSessionComponent.getMessageCount).toHaveBeenCalledWith("session-123");
+  });
+
+  test("should calculate hasMore based on offset, limit and total", async () => {
+    // Given
+    const offset = 90;
+    const limit = 20;
+    const total = 100;
+    
+    // When: 计算是否还有更多消息
+    // offset + limit < total 表示还有下一页
+    const hasMore = offset + limit < total;
+    
+    // Then: offset=90, limit=20, total=100
+    // offset + limit = 110, 110 < 100 = false
+    expect(hasMore).toBe(false);
+  });
+
+  test("should correctly determine hasMore when at last page", async () => {
+    // Given
+    const offset = 90;
+    const limit = 10;
+    const total = 100;
+    
+    // When
+    const hasMore = offset + limit < total;
+    
+    // Then: offset=90, limit=10, total=100
+    // offset + limit = 100, 100 < 100 = false
+    expect(hasMore).toBe(false);
+  });
+
+  test("should correctly determine hasMore when more pages exist", async () => {
+    // Given
+    const offset = 0;
+    const limit = 10;
+    const total = 100;
+    
+    // When
+    const hasMore = offset + limit < total;
+    
+    // Then: offset=0, limit=10, total=100
+    // 0 + 10 = 10, 10 < 100 = true
+    expect(hasMore).toBe(true);
+  });
+});