@ai-setting/roy-agent-cli 1.0.0

package/src/commands/shared/session-manager.test.ts

@@ -0,0 +1,212 @@
+/**
+ * @fileoverview SessionManager Test
+ * 
+ * TDD: 测试 SessionManager 的核心功能
+ */
+
+import { describe, test, expect, vi, beforeEach, afterEach } from "bun:test";
+import { SessionManager } from "./session-manager";
+import { OutputService } from "../../services/output.service";
+
+// Mock types
+interface MockSession {
+  id: string;
+  title: string;
+}
+
+interface MockSessionComponent {
+  getActiveSession: ReturnType<typeof vi.fn>;
+  get: ReturnType<typeof vi.fn>;
+  setActiveSession: ReturnType<typeof vi.fn>;
+  create: ReturnType<typeof vi.fn>;
+}
+
+describe("SessionManager", () => {
+  let sessionManager: SessionManager;
+  let mockSessionComponent: MockSessionComponent;
+  let mockOutput: OutputService;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // 创建 mock SessionComponent
+    mockSessionComponent = {
+      getActiveSession: vi.fn(),
+      get: vi.fn(),
+      setActiveSession: vi.fn(),
+      create: vi.fn(),
+    };
+
+    mockOutput = new OutputService();
+    mockOutput.configure({ quiet: true });
+
+    // Spy on console methods
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    sessionManager = new SessionManager({
+      sessionComponent: mockSessionComponent as any,
+      output: mockOutput,
+      quiet: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("init()", () => {
+    test("should create new session when no sessionId provided", async () => {
+      // Given: no active session and no sessionId
+      // First call to getActiveSession returns null (no active session)
+      // First call to get() returns the newly created session
+      mockSessionComponent.getActiveSession.mockResolvedValue(null);
+      mockSessionComponent.create.mockResolvedValue({
+        id: "sess_new123",
+        title: "New Session",
+      });
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+      mockSessionComponent.get.mockResolvedValueOnce({
+        id: "sess_new123",
+        title: "New Session",
+      });
+
+      // When
+      const result = await sessionManager.init();
+
+      // Then
+      expect(result.isNewSession).toBe(true);
+      expect(result.sessionId).toBe("sess_new123");
+      expect(mockSessionComponent.create).toHaveBeenCalledWith({
+        title: expect.stringContaining("Session -"),
+      });
+    });
+
+    test("should return existing session when sessionId exists", async () => {
+      // Given: existing session
+      const existingSession: MockSession = {
+        id: "sess_existing",
+        title: "Existing Session",
+      };
+      mockSessionComponent.get.mockResolvedValue(existingSession);
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+
+      // When
+      const result = await sessionManager.init("sess_existing");
+
+      // Then
+      expect(result.isNewSession).toBe(false);
+      expect(result.sessionId).toBe("sess_existing");
+      expect(result.sessionTitle).toBe("Existing Session");
+      expect(mockSessionComponent.create).not.toHaveBeenCalled();
+    });
+
+    test("should create new session when specified sessionId does not exist", async () => {
+      // Given: sessionId provided but doesn't exist
+      // First call to get() returns null (session not found)
+      // Second call to get() returns the newly created session
+      mockSessionComponent.get
+        .mockResolvedValueOnce(null) // first call - session not found
+        .mockResolvedValueOnce({ id: "sess_new456", title: "New Session" }); // second call - new session
+      mockSessionComponent.create.mockResolvedValue({
+        id: "sess_new456",
+        title: "New Session",
+      });
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+
+      // When
+      const result = await sessionManager.init("sess_nonexistent");
+
+      // Then
+      expect(result.isNewSession).toBe(true);
+      expect(result.sessionId).toBe("sess_new456");
+      expect(mockSessionComponent.create).toHaveBeenCalled();
+    });
+
+    test("should continue last session when isContinue is true", async () => {
+      // Given: active session exists
+      // First call to getActiveSession returns the active session
+      // First call to get() returns the active session
+      const activeSession: MockSession = {
+        id: "sess_active",
+        title: "Active Session",
+      };
+      mockSessionComponent.getActiveSession.mockResolvedValue(activeSession);
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+      mockSessionComponent.get.mockResolvedValueOnce(activeSession);
+
+      // When
+      const result = await sessionManager.init(undefined, true);
+
+      // Then
+      expect(result.sessionId).toBe("sess_active");
+      expect(mockSessionComponent.getActiveSession).toHaveBeenCalled();
+      expect(mockSessionComponent.create).not.toHaveBeenCalled();
+    });
+
+    test("should prefer explicit sessionId over continue flag", async () => {
+      // Given: both sessionId and isContinue provided
+      const existingSession: MockSession = {
+        id: "sess_explicit",
+        title: "Explicit Session",
+      };
+      mockSessionComponent.get.mockResolvedValue(existingSession);
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+
+      // When: sessionId takes precedence
+      const result = await sessionManager.init("sess_explicit", true);
+
+      // Then
+      expect(result.sessionId).toBe("sess_explicit");
+      expect(mockSessionComponent.getActiveSession).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("switchSession()", () => {
+    test("should switch to specified session", async () => {
+      // Given
+      const targetSession: MockSession = {
+        id: "sess_target",
+        title: "Target Session",
+      };
+      mockSessionComponent.get.mockResolvedValue(targetSession);
+      mockSessionComponent.setActiveSession.mockResolvedValue(undefined);
+
+      // When
+      const result = await sessionManager.switchSession("sess_target");
+
+      // Then
+      expect(result.sessionId).toBe("sess_target");
+      expect(result.sessionTitle).toBe("Target Session");
+      expect(mockSessionComponent.setActiveSession).toHaveBeenCalledWith("sess_target");
+    });
+  });
+
+  describe("getCurrentSession()", () => {
+    test("should return current active session", async () => {
+      // Given
+      const activeSession: MockSession = {
+        id: "sess_current",
+        title: "Current Session",
+      };
+      mockSessionComponent.getActiveSession.mockResolvedValue(activeSession);
+
+      // When
+      const result = await sessionManager.getCurrentSession();
+
+      // Then
+      expect(result).toEqual(activeSession);
+    });
+
+    test("should return null when no active session", async () => {
+      // Given
+      mockSessionComponent.getActiveSession.mockResolvedValue(null);
+
+      // When
+      const result = await sessionManager.getCurrentSession();
+
+      // Then
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/commands/shared/session-manager.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Session Manager - Session 管理共享逻辑
+ * 
+ * 从 act.ts 抽取，供 interactive 复用
+ * 
+ * 功能：
+ * - 获取/创建 Session
+ * - 设置活跃会话
+ * - 切换会话
+ */
+
+import { OutputService } from "../../services/output.service";
+import type { Session, SessionComponent } from "@ai-setting/roy-agent-core";
+
+export interface SessionInitResult {
+  sessionId: string;
+  isNewSession: boolean;
+  sessionTitle: string;
+}
+
+export interface SessionManagerOptions {
+  sessionComponent: SessionComponent;
+  output: OutputService;
+  quiet: boolean;
+}
+
+/**
+ * SessionManager - 会话管理
+ */
+export class SessionManager {
+  private sessionComponent: SessionComponent;
+  private output: OutputService;
+  private quiet: boolean;
+
+  constructor(options: SessionManagerOptions) {
+    this.sessionComponent = options.sessionComponent;
+    this.output = options.output;
+    this.quiet = options.quiet;
+  }
+
+  /**
+   * 初始化会话
+   * 
+   * 优先级：
+   * 1. 指定 sessionId -> 验证并使用
+   * 2. --continue -> 获取上次会话
+   * 3. 无 -> 创建新会话
+   */
+  async init(sessionId?: string, isContinue?: boolean): Promise<SessionInitResult> {
+    let targetSessionId = sessionId;
+    let isNewSession = false;
+
+    // --continue 模式
+    if (isContinue && !targetSessionId) {
+      const activeSession = await this.sessionComponent.getActiveSession();
+      if (activeSession) {
+        targetSessionId = activeSession.id;
+        if (!this.quiet) {
+          this.output.info(`继续会话: ${activeSession.title} (${targetSessionId})`);
+        }
+      } else {
+        this.output.warn("没有找到上次会话，将创建新会话");
+      }
+    }
+
+    // 指定 session 验证
+    if (targetSessionId) {
+      await this.sessionComponent.setActiveSession(targetSessionId);
+      const session = await this.sessionComponent.get(targetSessionId);
+      if (session) {
+        if (!this.quiet) {
+          this.output.info(`会话: ${session.title} (${targetSessionId})`);
+        }
+      } else {
+        this.output.warn(`会话不存在: ${targetSessionId}，将创建新会话`);
+        targetSessionId = undefined;
+      }
+    }
+
+    // 创建新会话
+    if (!targetSessionId) {
+      const newSession = await this.sessionComponent.create({
+        title: `Session - ${new Date().toLocaleString("zh-CN")}`,
+      });
+      targetSessionId = newSession.id;
+      isNewSession = true;
+      await this.sessionComponent.setActiveSession(targetSessionId);
+      if (!this.quiet) {
+        this.output.info(`创建新会话: ${newSession.title} (${targetSessionId})`);
+      }
+    }
+
+    const session = await this.sessionComponent.get(targetSessionId!);
+    return {
+      sessionId: targetSessionId!,
+      isNewSession,
+      sessionTitle: session?.title || "Unknown",
+    };
+  }
+
+  /**
+   * 切换会话
+   */
+  async switchSession(sessionId: string): Promise<SessionInitResult> {
+    return this.init(sessionId, false);
+  }
+
+  /**
+   * 获取当前会话信息
+   */
+  async getCurrentSession(): Promise<Session | undefined> {
+    return this.sessionComponent.getActiveSession();
+  }
+}

package/src/commands/skills/get.ts

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview Skills Get Command
+ * 
+ * 命令：roy skills get <name>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { SkillComponent, SkillEntry } from "@ai-setting/roy-agent-core";
+
+interface GetOptions {
+  name: string;
+  json?: boolean;
+  config?: string;
+}
+
+export const GetCommand: CommandModule<object, GetOptions> = {
+  command: "get <name>",
+  describe: "获取指定技能内容",
+  
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "技能名称",
+      })
+      .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+      }),
+  
+  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 skillComponent = env.getComponent("skill") as SkillComponent | undefined;
+
+      if (!skillComponent) {
+        output.error("SkillComponent not available");
+        process.exit(1);
+      }
+
+      const skill = skillComponent.getSkill(args.name);
+
+      if (!skill) {
+        output.error(`Skill not found: ${args.name}`);
+        output.log("Use 'roy skills list' to see available skills.");
+        process.exit(1);
+      }
+
+      if (args.json) {
+        output.json({
+          name: skill.name,
+          description: skill.description,
+          source: skill.source,
+          filePath: skill.filePath,
+          content: skill.content,
+        });
+      } else {
+        // 输出技能信息头
+        output.log(chalk.bold.cyan(`# ${skill.name}`));
+        output.log("");
+        output.log(`${chalk.gray("Description:")} ${skill.description}`);
+        output.log(`${chalk.gray("Source:")} ${skill.source}`);
+        output.log(`${chalk.gray("File:")} ${skill.filePath}`);
+        output.log("");
+        output.log(chalk.bold("--- Content ---"));
+        output.log("");
+        output.log(skill.content);
+      }
+    } catch (error) {
+      output.error(`Failed to get skill: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/skills/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Skills Command Entry
+ * 
+ * 命令入口：roy skills [action]
+ */
+
+import { CommandModule } from "yargs";
+import { ListCommand } from "./list";
+import { GetCommand } from "./get";
+import { SearchCommand } from "./search";
+import { ReloadCommand } from "./reload";
+import { ShowConfigCommand } from "./show-config";
+
+/**
+ * Skills Command
+ * 
+ * 技能管理命令，提供以下子命令：
+ * - list: 列出所有技能
+ * - get: 获取指定技能内容
+ * - search: 搜索技能
+ * - reload: 重新加载技能
+ * - show-config: 显示配置信息
+ */
+export const SkillsCommand: CommandModule = {
+  command: "skills",
+  describe: "技能管理 - 列出、获取、搜索、重新加载技能",
+  builder: (yargs) =>
+    yargs
+      .command(ListCommand)
+      .command(GetCommand)
+      .command(SearchCommand)
+      .command(ReloadCommand)
+      .command(ShowConfigCommand)
+      .demandCommand()
+      .help(),
+  handler: () => {
+    console.log("Use 'roy skills --help' for usage information");
+  },
+};

package/src/commands/skills/list.ts

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Skills List Command
+ * 
+ * 命令：roy skills list
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { SkillComponent, SkillListItem } from "@ai-setting/roy-agent-core";
+
+interface ListOptions {
+  source?: "built-in" | "user" | "project" | "all";
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+export const ListCommand: CommandModule<object, object> = {
+  command: "list",
+  aliases: ["ls"],
+  describe: "列出所有可用技能",
+  
+  builder: (yargs) =>
+    yargs
+      .option("source", {
+        alias: "s",
+        type: "string",
+        choices: ["built-in", "user", "project", "all"],
+        default: "all",
+        description: "按来源筛选",
+      })
+      .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+      })
+      .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        default: false,
+        description: "简洁输出",
+      }),
+  
+  async handler(args) {
+    const a = args as any;
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: a.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const skillComponent = env.getComponent("skill") as SkillComponent | undefined;
+
+      if (!skillComponent) {
+        output.error("SkillComponent not available");
+        process.exit(1);
+      }
+
+      const skills = skillComponent.getSkillList() as SkillListItem[];
+
+      // 按来源筛选
+      const filtered = a.source && a.source !== "all"
+        ? skills.filter((s: SkillListItem) => s.source === a.source)
+        : skills;
+
+      if (a.json) {
+        output.json({
+          skills: filtered.map((s: SkillListItem) => ({
+            name: s.name,
+            description: s.description,
+            source: s.source,
+          })),
+          count: filtered.length,
+        });
+      } else if (a.quiet) {
+        filtered.forEach((s: SkillListItem) => output.log(s.name));
+      } else {
+        // 表格输出
+        const header = [
+          chalk.bold("Name"),
+          chalk.bold("Description"),
+          chalk.bold("Source"),
+        ].join(" | ");
+
+        const sourceColor = (source: string) => {
+          switch (source) {
+            case "project": return chalk.green;
+            case "user": return chalk.blue;
+            case "built-in": return chalk.gray;
+            default: return chalk.white;
+          }
+        };
+
+        const rows = filtered.map((s: SkillListItem) => {
+          const desc = s.description.length > 50 
+            ? s.description.slice(0, 47) + "..." 
+            : s.description;
+          return [
+            chalk.cyan(s.name),
+            desc,
+            sourceColor(s.source)(`[${s.source}]`),
+          ].join(" | ");
+        });
+
+        output.log([
+          `┌─ Skills ${"─".repeat(55)}┐`,
+          `│${header}│`,
+          "├" + "─".repeat(header.length + 2) + "┤",
+          ...rows.map(r => `│${r}│`),
+          "└" + "─".repeat(header.length + 2) + "┘",
+          "",
+          chalk.gray(`Total: ${filtered.length} skills`),
+        ].join("\n"));
+      }
+    } catch (error) {
+      output.error(`Failed to list skills: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/skills/reload.ts

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Skills Reload Command
+ * 
+ * 命令：roy skills reload
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { SkillComponent } from "@ai-setting/roy-agent-core";
+
+interface ReloadOptions {
+  config?: string;
+}
+
+export const ReloadCommand: CommandModule<object, ReloadOptions> = {
+  command: "reload",
+  describe: "重新扫描并更新 SkillTool",
+  
+  builder: (yargs) =>
+    yargs
+      .option("config", {
+        type: "string",
+        description: "配置文件路径",
+      }),
+  
+  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 skillComponent = env.getComponent("skill") as SkillComponent | undefined;
+
+      if (!skillComponent) {
+        output.error("SkillComponent not available");
+        process.exit(1);
+      }
+
+      output.log(chalk.blue("Reloading skills..."));
+
+      await skillComponent.reload();
+
+      const skills = skillComponent.getSkillList();
+      output.log(chalk.green(`Successfully reloaded ${skills.length} skills`));
+    } catch (error) {
+      output.error(`Failed to reload skills: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};