@ai-setting/roy-agent-cli 1.0.0

package/src/commands/sessions/delete.ts

@@ -0,0 +1,236 @@
+/**
+ * @fileoverview Sessions Delete Command
+ * 
+ * 命令：roy sessions delete <session-id...>
+ * 
+ * 支持：
+ * - 单个删除：roy sessions delete <session-id>
+ * - 批量删除：roy sessions delete <session-id-1> <session-id-2> ...
+ * - 全量删除：roy sessions delete --all
+ * - 按时间删除：roy sessions delete --older-than <days>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { SessionComponent, Session } from "@ai-setting/roy-agent-core";
+
+interface DeleteOptions {
+  sessionIds: string[];
+  all?: boolean;
+  olderThan?: number;
+  keepActive?: boolean;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: string;
+}
+
+export const DeleteCommand: CommandModule<object, object> = {
+  command: "delete [session-ids...]",
+  aliases: ["rm"],
+  describe: "删除会话（支持批量删除和全量删除）",
+
+  builder: (yargs) =>
+    yargs
+      .positional("session-ids", {
+        describe: "会话 ID（可指定多个）",
+        type: "string",
+        demandOption: false,
+      })
+      .option("all", {
+        alias: "a",
+        type: "boolean",
+        default: false,
+        description: "删除所有会话",
+      })
+      .option("older-than", {
+        alias: "o",
+        type: "number",
+        description: "删除指定天数之前的会话",
+      })
+      .option("keep-active", {
+        alias: "k",
+        type: "boolean",
+        default: false,
+        description: "全量删除时保留当前活动会话",
+      })
+      .option("force", {
+        alias: "f",
+        type: "boolean",
+        default: false,
+        description: "跳过确认直接删除",
+      })
+      .option("dry-run", {
+        alias: "d",
+        type: "boolean",
+        default: false,
+        description: "预览模式，只显示将要删除的会话",
+      })
+      .check((argv) => {
+        // 确保至少指定了一种删除方式
+        const sessionIds = argv.sessionIds as string[] | undefined;
+        const hasIds = sessionIds && sessionIds.length > 0;
+        const hasAll = argv.all === true;
+        const hasOlderThan = argv.olderThan !== undefined;
+        
+        if (!hasIds && !hasAll && !hasOlderThan) {
+          throw new Error("请指定要删除的会话 ID，或使用 --all 或 --older-than 选项");
+        }
+        return true;
+      }),
+
+  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 sessionComponent = env.getComponent("session") as SessionComponent | undefined;
+
+      if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        process.exit(1);
+      }
+
+      const activeSessionId = sessionComponent.getActiveSessionId();
+      let sessionsToDelete: Session[] = [];
+
+      // 确定要删除的会话
+      if (a.sessionIds && a.sessionIds.length > 0) {
+        // 批量删除指定的会话
+        for (const id of a.sessionIds) {
+          const session = await sessionComponent.get(id);
+          if (session) {
+            sessionsToDelete.push(session);
+          } else {
+            output.warn(`Session not found: ${id}`);
+          }
+        }
+      } else if (a.all) {
+        // 全量删除
+        const allSessions = await sessionComponent.list({ limit: 100000 });
+        sessionsToDelete = allSessions.filter((s: Session) => {
+          if (a.keepActive && s.id === activeSessionId) {
+            return false;
+          }
+          return true;
+        });
+        if (a.keepActive && sessionsToDelete.length > 0) {
+          output.log(chalk.yellow(`Keeping active session: ${activeSessionId}`));
+        }
+      } else if (a.olderThan !== undefined) {
+        // 按时间删除
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - a.olderThan);
+        const cutoffTimestamp = cutoffDate.getTime();
+
+        const allSessions = await sessionComponent.list({ limit: 100000 });
+        sessionsToDelete = allSessions.filter((s: Session) => {
+          const updatedAt = new Date(s.updatedAt).getTime();
+          if (updatedAt < cutoffTimestamp) {
+            if (a.keepActive && s.id === activeSessionId) {
+              return false;
+            }
+            return true;
+          }
+          return false;
+        });
+        output.log(chalk.gray(`Deleting sessions not updated since ${cutoffDate.toISOString().split("T")[0]} (${a.olderThan} days ago)`));
+      } else {
+        // 这个分支理论上不会到达，因为 yargs check 已经验证了
+        output.log("No sessions to delete");
+        return;
+      }
+
+      if (sessionsToDelete.length === 0) {
+        output.log("No sessions to delete");
+        return;
+      }
+
+      // 预览模式
+      if (a.dryRun) {
+        output.log(chalk.yellow(`[DRY RUN] Would delete ${sessionsToDelete.length} session(s):\n`));
+        sessionsToDelete.forEach((s: Session, i: number) => {
+          const marker = s.id === activeSessionId ? chalk.green("▶") : " ";
+          output.log(`  ${marker} ${s.id}`);
+          output.log(`     Title: ${s.title}`);
+          output.log(`     Updated: ${new Date(s.updatedAt).toLocaleString()}`);
+          if (i < sessionsToDelete.length - 1) output.log("");
+        });
+        return;
+      }
+
+      // 确认删除
+      if (!a.force) {
+        output.log(chalk.red(`\n⚠️  About to delete ${sessionsToDelete.length} session(s):\n`));
+        sessionsToDelete.forEach((s: Session, i: number) => {
+          const marker = s.id === activeSessionId ? chalk.green("▶") : " ";
+          output.log(`  ${marker} ${s.id} - ${s.title}`);
+        });
+        output.log("");
+        
+        const answer = await new Promise<string>((resolve) => {
+          const readline = require("readline");
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+          });
+          rl.question(chalk.red("Type 'yes' to confirm deletion: "), (res: string) => {
+            rl.close();
+            resolve(res);
+          });
+        });
+
+        if (answer.toLowerCase() !== "yes") {
+          output.log("Deletion cancelled");
+          return;
+        }
+      }
+
+      // 执行删除
+      let successCount = 0;
+      let failCount = 0;
+      const errors: string[] = [];
+
+      for (const session of sessionsToDelete) {
+        try {
+          const success = await sessionComponent.delete(session.id);
+          if (success) {
+            successCount++;
+          } else {
+            failCount++;
+            errors.push(`Failed to delete: ${session.id}`);
+          }
+        } catch (error) {
+          failCount++;
+          errors.push(`${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+
+      // 输出结果
+      if (successCount > 0) {
+        output.success(chalk.green(`✓`) + ` Deleted ${successCount} session(s)`);
+      }
+      if (failCount > 0) {
+        output.error(`✗ Failed to delete ${failCount} session(s)`);
+        errors.forEach((e) => output.error(`  - ${e}`));
+      }
+
+      if (successCount === 0 && failCount === 0) {
+        output.log("No sessions were deleted");
+      }
+    } catch (error) {
+      output.error(`Failed to delete session: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/sessions/get.ts

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Sessions Get Command
+ * 
+ * 命令：roy sessions get <session-id>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { SessionComponent, Session, SessionCheckpoint } from "@ai-setting/roy-agent-core";
+
+// Inline type for WorkflowSessionMetadata
+interface WorkflowSessionMetadata {
+  type: 'workflow';
+  workflowId?: string;
+  workflowName: string;
+  status: 'running' | 'paused' | 'completed' | 'failed';
+  agentSessions?: AgentSessionRef[];
+}
+
+interface AgentSessionRef {
+  nodeId: string;
+  sessionId: string;
+  status: 'active' | 'paused' | 'completed';
+}
+
+interface GetOptions {
+  sessionId: string;
+  messages?: boolean;
+  checkpoints?: boolean;
+  json?: boolean;
+  config?: string;
+}
+
+export const GetCommand: CommandModule<object, object> = {
+  command: "get <session-id>",
+  aliases: ["show"],
+  describe: "获取会话详情",
+
+  builder: (yargs) =>
+    yargs
+      .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+      })
+      .option("messages", { type: "boolean", default: false })
+      .option("checkpoints", { alias: "c", type: "boolean", default: false })
+      .option("json", { alias: "j", type: "boolean", default: false }),
+
+  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 sessionComponent = env.getComponent("session") as SessionComponent | undefined;
+
+      if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        process.exit(1);
+      }
+
+      const session = await sessionComponent.get(a.sessionId);
+      if (!session) {
+        output.error(`Session not found: ${a.sessionId}`);
+        process.exit(1);
+      }
+
+      const activeSessionId = sessionComponent.getActiveSessionId();
+      const checkpoints: SessionCheckpoint[] = a.checkpoints 
+        ? await sessionComponent.getCheckpoints(a.sessionId)
+        : [];
+
+      if (a.json) {
+        output.json({
+          id: session.id,
+          title: session.title,
+          directory: session.directory,
+          parentID: session.parentID,
+          messageCount: session.messageCount,
+          isActive: session.id === activeSessionId,
+          checkpoints: checkpoints.map((cp: SessionCheckpoint) => ({
+            id: cp.id,
+            title: cp.title,
+            messageIndex: cp.messageIndex,
+            type: cp.type,
+            createdAt: new Date(cp.createdAt).toISOString(),
+            processKeyPoints: cp.processKeyPoints,
+            currentState: cp.currentState,
+          })),
+          metadata: session.metadata,
+          createdAt: new Date(session.createdAt).toISOString(),
+          updatedAt: new Date(session.updatedAt).toISOString(),
+        });
+      } else {
+        // 详细信息输出
+        const lines = [
+          chalk.bold("┌─ Session Details ─────────────────────────────────┐"),
+          `│ ID:          ${session.id}`,
+          `│ Title:       ${session.title}`,
+          `│ Directory:   ${session.directory}`,
+          `│ Messages:    ${session.messageCount}`,
+          `│ Active:      ${session.id === activeSessionId ? chalk.green("✓") : chalk.gray("-")}`,
+          `│ Created:     ${new Date(session.createdAt).toLocaleString("zh-CN")}`,
+          `│ Updated:     ${new Date(session.updatedAt).toLocaleString("zh-CN")}`,
+        ];
+
+        // Check if this is a workflow session
+        const workflowMeta = session.metadata?.type === 'workflow' 
+          ? session.metadata as unknown as WorkflowSessionMetadata 
+          : null;
+        
+        if (workflowMeta) {
+          lines.push("├─ Workflow Info ─────────────────────────────────────┤");
+          lines.push(`│ Type:        ${chalk.cyan("workflow")}`);
+          lines.push(`│ Workflow:    ${workflowMeta.workflowName}`);
+          if (workflowMeta.workflowId) {
+            lines.push(`│ Workflow ID: ${workflowMeta.workflowId}`);
+          }
+          const statusColor = workflowMeta.status === 'running' ? chalk.green 
+            : workflowMeta.status === 'paused' ? chalk.yellow 
+            : workflowMeta.status === 'completed' ? chalk.gray 
+            : chalk.red;
+          lines.push(`│ Status:      ${statusColor(workflowMeta.status)}`);
+          
+          // Display agent sub-sessions if any
+          if (workflowMeta.agentSessions && workflowMeta.agentSessions.length > 0) {
+            lines.push("├─ Agent Sub-sessions ─────────────────────────────────┤");
+            workflowMeta.agentSessions.forEach((agent: AgentSessionRef) => {
+              const agentStatusColor = agent.status === 'active' ? chalk.green 
+                : agent.status === 'paused' ? chalk.yellow 
+                : chalk.gray;
+              lines.push(`│ ${agent.nodeId}: ${agent.sessionId} (${agentStatusColor(agent.status)})`);
+            });
+          }
+        }
+
+        if (checkpoints.length > 0) {
+          lines.push("├─ Checkpoints ──────────────────────────────────────┤");
+          checkpoints.slice(-5).reverse().forEach((cp: SessionCheckpoint, i: number) => {
+            const marker = i === 0 ? "✓ Latest" : "  #" + (checkpoints.length - i);
+            lines.push(`│ ${marker}  ${cp.title}`);
+            lines.push(`│           ${new Date(cp.createdAt).toLocaleString("zh-CN")}`);
+          });
+        }
+
+        lines.push("└───────────────────────────────────────────────────┘");
+        output.log(lines.join("\n"));
+      }
+    } catch (error) {
+      output.error(`Failed to get session: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/sessions/grep.ts

@@ -0,0 +1,233 @@
+/**
+ * @fileoverview Sessions Grep Command
+ * 
+ * 命令：roy sessions grep <query>
+ * 
+ * 在所有会话消息中进行全文搜索，支持：
+ * - 多关键字搜索 (AND/OR/NOT)
+ * - 按会话过滤
+ * - 按时间范围过滤
+ * - 结果以 session 为单位聚合展示
+ * - --quiet 安静模式
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import { type SessionComponent, type SearchMessagesOptions } from "@ai-setting/roy-agent-core";
+import { CliQuietModeService } from "../../services/quiet-mode.service";
+
+export const GrepCommand: CommandModule<object, object> = {
+  command: "grep <query...>",
+  aliases: ["search"],
+  describe: "搜索会话消息（全文搜索）",
+
+  builder: (yargs) =>
+    yargs
+      .positional("query", {
+        describe: "搜索关键词（支持 AND/OR/NOT）",
+        type: "string",
+        demandOption: true,
+      })
+      .option("session", {
+        alias: "s",
+        type: "string",
+        description: "限制搜索特定会话 ID",
+      })
+      .option("limit", {
+        alias: "n",
+        type: "number",
+        default: 50,
+        description: "最大返回结果数",
+      })
+      .option("before", {
+        alias: "b",
+        type: "number",
+        description: "搜索此时间之前的消息（Unix timestamp 或天数）",
+      })
+      .option("after", {
+        alias: "a",
+        type: "number",
+        description: "搜索此时间之后的消息（Unix timestamp 或天数）",
+      })
+      .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 格式输出",
+      })
+      .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        default: false,
+        description: "简洁输出",
+      }),
+
+  async handler(args) {
+    // 强制类型转换以处理 yargs 的类型推断问题
+    const a = args as any;
+    
+    // 在任何日志输出之前设置 quiet 模式
+    const isQuiet = a.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: a.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 now = Date.now();
+      let beforeTime: number | undefined;
+      let afterTime: number | undefined;
+
+      if (a.before !== undefined) {
+        // 如果是小于 1e12，视为天数
+        beforeTime = a.before < 1e12 
+          ? now - a.before * 24 * 60 * 60 * 1000 
+          : a.before;
+      }
+
+      if (a.after !== undefined) {
+        afterTime = a.after < 1e12 
+          ? now - a.after * 24 * 60 * 60 * 1000 
+          : a.after;
+      }
+
+      // query 是 string[]，合并为字符串
+      const query = Array.isArray(a.query) ? a.query.join(" ") : a.query ?? "";
+
+      const searchOptions: SearchMessagesOptions = {
+        query,
+        sessionId: a.session,
+        limit: a.limit,
+        beforeTime,
+        afterTime,
+      };
+
+      // 执行搜索
+      const results = await sessionComponent.searchMessages(searchOptions);
+
+      if (results.length === 0) {
+        if (!a.quiet) {
+          output.log(chalk.yellow(`No results found for: ${query}`));
+        }
+        return;
+      }
+
+      if (a.json) {
+        // JSON 格式输出
+        output.json({
+          query,
+          totalMatches: results.reduce((sum, r) => sum + r.matches.length, 0),
+          sessionCount: results.length,
+          results: results.map((r) => ({
+            sessionId: r.sessionId,
+            sessionTitle: r.sessionTitle,
+            messageCount: r.messageCount,
+            matches: r.matches.map((m) => ({
+              messageId: m.messageId,
+              role: m.role,
+              content: m.content,
+              timestamp: new Date(m.timestamp).toISOString(),
+              contextBefore: m.contextBefore,
+              contextAfter: m.contextAfter,
+            })),
+          })),
+        });
+      } else if (a.quiet) {
+        // 简洁输出：只显示匹配的消息
+        for (const result of results) {
+          for (const match of result.matches) {
+            const time = new Date(match.timestamp).toLocaleString("zh-CN");
+            output.log(`${chalk.gray(result.sessionId)} ${chalk.blue(result.sessionTitle)} ${chalk.gray(time)}`);
+            output.log(`  ${match.content}`);
+            output.log("");
+          }
+        }
+      } else {
+        // 格式化输出：以 session 为单位聚合
+        let totalMatches = 0;
+        
+        for (let ri = 0; ri < results.length; ri++) {
+          const result = results[ri];
+          totalMatches += result.matches.length;
+          
+          // Session 头部
+          const time = new Date(result.updatedAt).toLocaleString("zh-CN");
+          const titleStr = `─ ${result.sessionTitle} (${result.sessionId})`;
+          output.log(chalk.bold(`\n┌${titleStr}${"─".repeat(Math.max(0, 50 - titleStr.length))}┐`));
+          output.log(`│ ${chalk.gray(`Updated: ${time} | ${result.messageCount} messages | ${result.matches.length} matches`)}${" ".repeat(Math.max(0, 50 - 60))}│`);
+
+          // 每条匹配的消息
+          for (let i = 0; i < result.matches.length; i++) {
+            const match = result.matches[i];
+            const roleColor = match.role === "user" ? chalk.blue 
+              : match.role === "assistant" ? chalk.green 
+              : chalk.gray;
+            const msgTime = new Date(match.timestamp).toLocaleTimeString("zh-CN", {
+              hour: "2-digit",
+              minute: "2-digit",
+            });
+
+            output.log(`├─ #${i + 1} ${roleColor(match.role.padEnd(10))} ${chalk.gray(msgTime)}`);
+            output.log("│");
+
+            // 消息内容（限制行数，过滤空行）
+            const lines = match.content
+              .split("\n")
+              .map(line => line.trim())  // 去除每行首尾空白
+              .filter(line => line.length > 0);  // 过滤空行
+            
+            const maxLines = 5;
+            const displayLines = lines.slice(0, maxLines);
+            
+            if (displayLines.length === 0) {
+              output.log("│   " + chalk.gray("(empty content)"));
+            } else {
+              for (const line of displayLines) {
+                const truncated = line.length > 76 ? line.slice(0, 73) + "..." : line;
+                output.log(`│   ${chalk.gray(truncated)}`);
+              }
+            }
+            
+            if (lines.length > maxLines) {
+              output.log("│   " + chalk.gray(`... (${lines.length - maxLines} more lines)`));
+            }
+            output.log("│");
+          }
+          
+          // Session 底部
+          output.log(`└${"─".repeat(52)}┘`);
+        }
+
+        // 统计信息
+        output.log(`\n${chalk.green("✓")} Found ${chalk.bold(totalMatches.toString())} matches in ${chalk.bold(results.length.toString())} sessions`);
+        output.log(chalk.gray(`Query: "${query}"`));
+      }
+    } catch (error) {
+      output.error(`Search failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};