@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/cli/src/commands/memory/index.js

@@ -1,11 +0,0 @@
-/**
- * @fileoverview Memory Commands Index - Simplified
- *
- * 导出所有 memory 子命令
- *
- * Simplified 设计：只保留 record 和 recall 两个核心命令
- */
-export { MemoryCommand } from "./memory.js";
-export { RecordCommand } from "./record.js";
-export { RecallCommand } from "./recall.js";
-//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/memory/memory.d.ts

@@ -1,10 +0,0 @@
-/**
- * @fileoverview Memory Command - Simplified
- *
- * 命令：roy memory
- *
- * Simplified 设计：只保留 record 和 recall 命令
- */
-import { CommandModule } from "yargs";
-export declare const MemoryCommand: CommandModule;
-//# sourceMappingURL=memory.d.ts.map

package/dist/cli/src/commands/memory/memory.js

@@ -1,21 +0,0 @@
-/**
- * @fileoverview Memory Command - Simplified
- *
- * 命令：roy memory
- *
- * Simplified 设计：只保留 record 和 recall 命令
- */
-import { RecordCommand } from "./record.js";
-import { RecallCommand } from "./recall.js";
-export const MemoryCommand = {
-    command: "memory",
-    describe: "管理记忆文件 (record, recall)",
-    builder: (yargs) => yargs
-        .command(RecordCommand)
-        .command(RecallCommand)
-        .demandCommand(1, "请指定子命令。可用子命令: record, recall"),
-    handler: () => {
-        // 默认显示帮助
-    },
-};
-//# sourceMappingURL=memory.js.map

package/dist/cli/src/commands/memory/organize.d.ts

@@ -1,48 +0,0 @@
-/**
- * @fileoverview Memory Organize Command
- *
- * Manual trigger for memory organization
- *
- * Usage:
- *   roy memory organize
- *   roy memory organize --scope project
- *   roy memory organize --scope global
- *   roy memory organize --scope all
- *   roy memory organize --since 2026-04-01
- *   roy memory organize --session <session-id>
- *   roy memory organize --list-sessions
- */
-import { CommandModule } from "yargs";
-import { EnvironmentService } from "../../services/environment.service";
-import { OutputService } from "../../services/output.service";
-import type { SessionComponent, AgentComponent, MemoryPlugin as IMemoryPlugin } from "@ai-setting/roy-agent-core";
-/**
- * OrganizeContext - 用于依赖注入的上下文
- */
-export interface OrganizeContext {
-    envService: EnvironmentService;
-    sessionComponent: SessionComponent | null;
-    agentComponent: AgentComponent | null;
-    memoryPlugin?: IMemoryPlugin;
-}
-/**
- * 创建 OrganizeContext
- */
-export declare function createOrganizeContext(envService: EnvironmentService): OrganizeContext;
-/**
- * 准备 MemoryPlugin
- *
- * @param workDir 工作目录
- * @param agentComponent AgentComponent（可选，用于 AI 记忆整理）
- */
-export declare function prepareMemoryPlugin(workDir: string, agentComponent?: AgentComponent): Promise<IMemoryPlugin>;
-/**
- * 清理资源
- */
-export declare function cleanupOrganizeResources(ctx: OrganizeContext, memoryPlugin?: IMemoryPlugin): void;
-export declare const OrganizeCommand: CommandModule;
-/**
- * 列出所有会话
- */
-export declare function listSessions(sessionComponent: SessionComponent | null, output: OutputService): Promise<void>;
-//# sourceMappingURL=organize.d.ts.map

package/dist/cli/src/commands/memory/organize.js

@@ -1,233 +0,0 @@
-/**
- * @fileoverview Memory Organize Command
- *
- * Manual trigger for memory organization
- *
- * Usage:
- *   roy memory organize
- *   roy memory organize --scope project
- *   roy memory organize --scope global
- *   roy memory organize --scope all
- *   roy memory organize --since 2026-04-01
- *   roy memory organize --session <session-id>
- *   roy memory organize --list-sessions
- */
-import { EnvironmentService } from "../../services/environment.service.js";
-import { OutputService } from "../../services/output.service.js";
-import chalk from "chalk";
-/**
- * 创建 OrganizeContext
- */
-export function createOrganizeContext(envService) {
-    return {
-        envService,
-        sessionComponent: envService.getSession(),
-        agentComponent: envService.getAgent(),
-    };
-}
-/**
- * 准备 MemoryPlugin
- *
- * @param workDir 工作目录
- * @param agentComponent AgentComponent（可选，用于 AI 记忆整理）
- */
-export async function prepareMemoryPlugin(workDir, agentComponent) {
-    // 动态导入 MemoryPlugin
-    const { MemoryPlugin } = await import("@ai-setting/roy-agent-core");
-    // 设置全局注册表（供 MemoryPlugin 初始化时获取组件）
-    const globalRegistry = globalThis.__royAgentRegistry || {};
-    // 保留现有的 sessionComponent（如果有）
-    if (!globalRegistry.sessionComponent) {
-        // 从 EnvironmentService 获取（如果可用）
-        // 注意：在 CLI 模式下，sessionComponent 由调用方通过 ctx 传递
-    }
-    globalRegistry.agentComponent = agentComponent;
-    globalThis.__royAgentRegistry = globalRegistry;
-    // 创建 MemoryPlugin
-    const memoryPlugin = new MemoryPlugin(workDir, {
-        enabled: true,
-    });
-    await memoryPlugin.initialize();
-    // 额外注册 AgentComponent（双保险，确保 MemoryPlugin 能使用 AI）
-    if (agentComponent) {
-        memoryPlugin.registerAgentComponent(agentComponent);
-    }
-    return memoryPlugin;
-}
-/**
- * 清理资源
- */
-export function cleanupOrganizeResources(ctx, memoryPlugin) {
-    // 清理全局注册表
-    delete globalThis.__royAgentRegistry;
-    // MemoryPlugin 清理由调用方负责
-    ctx.memoryPlugin = memoryPlugin;
-}
-export const OrganizeCommand = {
-    command: "organize [options]",
-    describe: "手动触发记忆整理",
-    builder: (yargs) => yargs
-        .option("scope", {
-        alias: "s",
-        description: "整理范围: project, global, all (默认: all)",
-        type: "string",
-        choices: ["project", "global", "all"],
-        default: "all",
-    })
-        .option("since", {
-        alias: "t",
-        description: "整理指定时间以来的记忆 (ISO 日期或 Unix 时间戳)",
-        type: "string",
-    })
-        .option("session", {
-        alias: "S",
-        description: "整理指定会话的记忆",
-        type: "string",
-    })
-        .option("list-sessions", {
-        alias: "l",
-        description: "列出可用的会话",
-        type: "boolean",
-        default: false,
-    })
-        .example("roy memory organize", "整理所有记忆")
-        .example("roy memory organize --scope project", "只整理项目记忆")
-        .example("roy memory organize --scope global", "只整理全局记忆")
-        .example("roy memory organize --since 2026-04-01", "整理指定时间以来的记忆")
-        .example("roy memory organize --list-sessions", "列出所有会话")
-        .example("roy memory organize --session abc123", "整理指定会话的记忆"),
-    async handler(argv) {
-        const output = new OutputService();
-        const envService = new EnvironmentService(output);
-        let memoryPlugin;
-        try {
-            await envService.create();
-            const ctx = createOrganizeContext(envService);
-            const sessionComponent = ctx.sessionComponent;
-            // 处理 --list-sessions 选项
-            if (argv.listSessions) {
-                await listSessions(sessionComponent, output);
-                return;
-            }
-            const options = argv;
-            output.log(chalk.bold("\n📋 记忆整理\n"));
-            // 如果指定了 session，获取该 session 的消息并显示预览
-            if (options.session) {
-                output.log(chalk.gray(`📂 会话: ${options.session}`));
-                const messages = await getSessionMessages(sessionComponent, options.session);
-                if (messages.length === 0) {
-                    output.error(`会话不存在或没有消息: ${options.session}`);
-                    process.exit(1);
-                }
-                output.log(chalk.gray(`📝 共 ${messages.length} 条消息\n`));
-                // 显示消息预览
-                output.log(chalk.gray("📄 消息摘要预览:"));
-                for (let i = 0; i < Math.min(3, messages.length); i++) {
-                    const msg = messages[i];
-                    const content = typeof msg.content === "string"
-                        ? msg.content.substring(0, 100) + "..."
-                        : JSON.stringify(msg.content).substring(0, 100) + "...";
-                    output.log(chalk.gray(`  [${msg.role}] ${content}`));
-                }
-                output.log("");
-            }
-            else {
-                output.log(chalk.gray("💡 提示: 使用 --session 指定会话来整理对话记忆\n"));
-            }
-            output.log(chalk.gray(`🎯 整理范围: ${options.scope || "all"}\n`));
-            // 获取 AgentComponent
-            if (!ctx.agentComponent) {
-                output.error("AgentComponent not available, cannot organize memory with AI");
-                process.exit(1);
-            }
-            // 准备 MemoryPlugin（包含注册 AgentComponent）
-            memoryPlugin = await prepareMemoryPlugin(process.cwd(), ctx.agentComponent);
-            // 解析 since 时间戳
-            let sinceTimestamp;
-            if (options.since) {
-                const date = new Date(options.since);
-                if (!isNaN(date.getTime())) {
-                    sinceTimestamp = date.getTime();
-                }
-            }
-            // 调用 organize
-            output.log(chalk.gray("⏳ 正在整理记忆...\n"));
-            await memoryPlugin.organize({
-                scope: options.scope || "all",
-                sessionId: options.session,
-                since: sinceTimestamp,
-            });
-            output.success("\n✅ 记忆整理完成");
-            output.log(chalk.gray("\n提示: 使用 `roy memory recall` 查看整理后的记忆"));
-        }
-        catch (error) {
-            output.error(`整理记忆失败: ${error}`);
-            process.exit(1);
-        }
-        finally {
-            // 清理 MemoryPlugin
-            if (memoryPlugin) {
-                await memoryPlugin.dispose();
-            }
-            // 清理全局注册表
-            cleanupOrganizeResources(createOrganizeContext(envService), memoryPlugin);
-            // 清理 EnvironmentService
-            await envService.dispose();
-        }
-    },
-};
-/**
- * 获取指定 session 的消息
- */
-async function getSessionMessages(sessionComponent, sessionId) {
-    if (!sessionComponent) {
-        return [];
-    }
-    try {
-        const session = await sessionComponent.get(sessionId);
-        if (!session) {
-            return [];
-        }
-        // 获取消息，默认获取最近 100 条
-        const messages = await sessionComponent.getMessages(sessionId, { limit: 100 });
-        // 过滤掉 tool 相关消息，只保留 user 和 assistant
-        return messages
-            .filter((msg) => msg.role === "user" || msg.role === "assistant")
-            .map((msg) => ({
-            role: msg.role,
-            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
-        }));
-    }
-    catch (error) {
-        return [];
-    }
-}
-/**
- * 列出所有会话
- */
-export async function listSessions(sessionComponent, output) {
-    if (!sessionComponent) {
-        output.error("SessionComponent not available");
-        return;
-    }
-    try {
-        const sessions = await sessionComponent.list({ limit: 20 });
-        if (sessions.length === 0) {
-            output.log(chalk.gray("暂无会话"));
-            return;
-        }
-        output.log(chalk.bold(`\n📂 会话列表 (最近 20 个)\n\n`));
-        for (const session of sessions) {
-            const date = new Date(session.createdAt).toLocaleDateString("zh-CN");
-            const time = new Date(session.createdAt).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
-            output.log(chalk.cyan(`ID: ${session.id}`));
-            output.log(`  标题: ${session.title || "无标题"}`);
-            output.log(`  创建: ${date} ${time}`);
-            output.log("");
-        }
-    }
-    catch (error) {
-        output.error(`列出会话失败: ${error}`);
-    }
-}
-//# sourceMappingURL=organize.js.map

package/dist/cli/src/commands/memory/recall.d.ts

@@ -1,10 +0,0 @@
-/**
- * @fileoverview Memory Recall Command
- *
- * 命令：roy memory recall
- *
- * 读取所有 memory file 的内容
- */
-import { CommandModule } from "yargs";
-export declare const RecallCommand: CommandModule<object, object>;
-//# sourceMappingURL=recall.d.ts.map

package/dist/cli/src/commands/memory/recall.js

@@ -1,69 +0,0 @@
-/**
- * @fileoverview Memory Recall Command
- *
- * 命令：roy memory recall
- *
- * 读取所有 memory file 的内容
- */
-import { EnvironmentService } from "../../services/environment.service.js";
-import { OutputService } from "../../services/output.service.js";
-import chalk from "chalk";
-export const RecallCommand = {
-    command: "recall",
-    aliases: ["load"],
-    describe: "读取所有 memory file 的内容",
-    builder: (yargs) => yargs
-        .option("config", {
-        type: "string",
-        describe: "Config file path",
-    })
-        .option("json", {
-        alias: "j",
-        type: "boolean",
-        default: false,
-        description: "JSON 格式输出",
-    })
-        .option("scope", {
-        type: "string",
-        choices: ["project", "global"],
-        describe: "记忆作用域 (可选，不传则读取所有)",
-    }),
-    async handler(args) {
-        const a = args;
-        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 memoryComponent = env.getComponent("memory");
-            if (!memoryComponent) {
-                output.error("MemoryComponent not available");
-                process.exit(1);
-            }
-            // 读取记忆
-            const content = await memoryComponent.recallMemory(a.scope);
-            if (!content) {
-                output.log(chalk.gray("(No memory files found)"));
-                return;
-            }
-            if (a.json) {
-                output.json({ content });
-                return;
-            }
-            // 直接输出 markdown 内容（处理转义字符）
-            output.log(content.replace(/\\n/g, "\n"));
-        }
-        catch (error) {
-            output.error(`Failed to recall memory: ${error}`);
-            process.exit(1);
-        }
-        finally {
-            await envService.dispose();
-        }
-    },
-};
-//# sourceMappingURL=recall.js.map

package/dist/cli/src/commands/memory/record.d.ts

@@ -1,11 +0,0 @@
-/**
- * @fileoverview Memory Record Command
- *
- * 命令：roy memory record
- *
- * 将记忆内容记录到 memory file
- * 支持 --extract 模式：从会话历史中提取记忆并保存
- */
-import { CommandModule } from "yargs";
-export declare const RecordCommand: CommandModule<object, object>;
-//# sourceMappingURL=record.d.ts.map

package/dist/cli/src/commands/memory/record.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview Memory Record Command
- *
- * 命令：roy memory record
- *
- * 将记忆内容记录到 memory file
- * 支持 --extract 模式：从会话历史中提取记忆并保存
- */
-import { EnvironmentService } from "../../services/environment.service.js";
-import { OutputService } from "../../services/output.service.js";
-import chalk from "chalk";
-import { createMemoryAgentTools, getBuiltInPrompt } from "@ai-setting/roy-agent-core";
-import { bashTool, globTool, readFileTool } from "@ai-setting/roy-agent-core";
-/**
- * Memory Agent 提取模式 - 从会话历史生成记忆
- */
-async function runExtractMode(output, memoryComponent, agentComponent, sessionComponent, env, options) {
-    const { scope, sessionId, require: userRequirement } = options;
-    output.log(chalk.blue(`\n🔍 Memory Extract Mode (${scope})`));
-    output.log(chalk.gray("正在分析会话历史，生成记忆...\n"));
-    try {
-        // 1. 获取当前 memory
-        const currentMemory = await memoryComponent.recallMemory(scope) || "(无现有记忆)";
-        // 2. 获取 prompt（通过 PromptComponent 或 fallback 到 getBuiltInPrompt）
-        const promptName = scope === "project" ? "project-memory" : "global-memory";
-        let promptTemplate;
-        try {
-            const promptComponent = env?.getComponent?.("prompt");
-            if (promptComponent) {
-                promptTemplate = await promptComponent.getPrompt(promptName);
-            }
-        }
-        catch (err) {
-            // PromptComponent 不可用或获取失败，fallback 到 getBuiltInPrompt
-        }
-        // Fallback：如果 PromptComponent 不可用或未找到，使用 getBuiltInPrompt
-        if (!promptTemplate) {
-            promptTemplate = getBuiltInPrompt(promptName);
-        }
-        if (!promptTemplate) {
-            output.error(`Prompt not found for scope: ${scope}`);
-            process.exit(1);
-        }
-        // 3. 替换变量
-        const systemPrompt = promptTemplate
-            .replace("{USER_REQUIREMENT}", userRequirement || "请从会话历史中提炼关键知识。")
-            .replace("{SCOPE}", scope)
-            .replace("{CURRENT_MEMORY}", currentMemory);
-        // 4. 创建 Memory Agent tools
-        const memoryTools = createMemoryAgentTools({
-            sessionComponent,
-            memoryComponent: memoryComponent,
-        });
-        // 5. 准备 Agent 工具列表
-        const agentTools = [
-            memoryTools.searchSessions,
-            memoryTools.getSession,
-            memoryTools.writeMemory,
-        ];
-        // 6. Project scope 额外添加文件工具（读取项目文档和代码）
-        if (scope === "project") {
-            agentTools.push(bashTool, globTool, readFileTool);
-        }
-        // 7. 获取允许的工具名称列表
-        const allowedToolNames = agentTools.map((t) => t.name);
-        // 8. 注册 Agent
-        const agentName = `memory-extract-${scope}`;
-        agentComponent.registerAgent(agentName, {
-            type: "sub",
-            systemPrompt,
-            allowedTools: allowedToolNames,
-            deniedTools: [],
-        });
-        agentComponent.setDefaultTools(agentTools);
-        // 9. 将 Agent tools 注册到 ToolComponent（用于 executeTool 时查找）
-        const toolComponent = env.getComponent?.("tool");
-        if (toolComponent) {
-            for (const tool of agentTools) {
-                try {
-                    toolComponent.register(tool);
-                    output.log(chalk.gray(`Tool registered: ${tool.name}`));
-                }
-                catch (err) {
-                    output.log(chalk.gray(`Tool already registered: ${tool.name}`));
-                }
-            }
-        }
-        output.log(chalk.gray(`Agent "${agentName}" registered with ${agentTools.length} tools`));
-        // 6. 执行 Agent（使用 handle_query，参考 delegate_task 模式）
-        // 这确保与 delegate_task 使用相同的执行路径，包括 memory 注入等
-        const query = `请分析会话历史，提炼${scope === "project" ? "项目" : "全局"}记忆并写入记忆文件。`;
-        let result;
-        try {
-            // 使用 env.handle_query() 而不是 agentComponent.run()
-            // 这与 delegate_task 的实现模式一致
-            result = await env.handle_query(query, {
-                sessionId,
-                agentType: agentName,
-            });
-        }
-        catch (error) {
-            result = `执行失败: ${error instanceof Error ? error.message : String(error)}`;
-        }
-        // 10. 输出结果
-        // handle_query 返回 string，如果有错误会抛出异常
-        if (result && result.startsWith("执行失败")) {
-            output.error(`提取失败: ${result}`);
-        }
-        else if (result) {
-            output.log(chalk.green("\n✅ 记忆提取完成"));
-            output.log(chalk.gray("记忆已保存到 memory 文件。\n"));
-            // 可选：输出 agent 返回的结果摘要
-            if (result.length > 0 && result !== "✅ 记忆提取完成") {
-                output.log(chalk.gray(`执行摘要: ${result.substring(0, 200)}${result.length > 200 ? "..." : ""}`));
-            }
-        }
-        // 11. 清理 - 注销 Agent 和 Tools
-        agentComponent.unregisterAgent(agentName);
-        if (toolComponent) {
-            // 清理 memory tools
-            for (const tool of [memoryTools.searchSessions, memoryTools.getSession, memoryTools.writeMemory]) {
-                toolComponent.unregister(tool.name);
-            }
-            // 如果是 project scope，额外清理文件工具
-            if (scope === "project") {
-                for (const toolName of ["bash", "glob", "read_file"]) {
-                    toolComponent.unregister(toolName);
-                }
-            }
-        }
-    }
-    catch (error) {
-        output.error(`提取失败: ${error}`);
-        throw error;
-    }
-}
-export const RecordCommand = {
-    command: "record",
-    aliases: ["save"],
-    describe: "记录记忆内容到 memory file",
-    builder: (yargs) => yargs
-        .option("mode", {
-        alias: "m",
-        type: "string",
-        choices: ["append", "prepend", "overwrite", "delete"],
-        default: "append",
-        description: "操作模式: append(尾部追加), prepend(头部插入), overwrite(覆盖), delete(删除)",
-    })
-        .option("content", {
-        alias: "c",
-        type: "string",
-        description: "记忆内容 (markdown 格式)",
-    })
-        .option("title", {
-        alias: "t",
-        type: "string",
-        description: "记忆标题 (用于生成章节标题)",
-    })
-        .option("filename", {
-        alias: "f",
-        type: "string",
-        description: "文件名 (默认使用 memory.memoryFile 配置)",
-    })
-        .option("config", {
-        type: "string",
-        describe: "Config file path",
-    })
-        // Extract 模式选项
-        .option("extract", {
-        alias: "e",
-        type: "boolean",
-        default: false,
-        description: "触发提取模式：从会话历史中提取记忆",
-    })
-        .option("scope", {
-        type: "string",
-        choices: ["project", "global"],
-        describe: "记忆作用域",
-        demandOption: true, // 必填
-    })
-        .option("session-id", {
-        type: "string",
-        describe: "指定 session ID（可选）",
-    })
-        .option("require", {
-        alias: "r",
-        type: "string",
-        describe: "自然语言提取指导",
-    })
-        .demandOption(["mode"], "请指定操作模式 (--mode)")
-        .check((argv) => {
-        const mode = argv.mode;
-        // extract 模式不需要 content
-        if (argv.extract) {
-            return true;
-        }
-        if (mode !== "delete" && !argv.content) {
-            throw new Error("--content is required for all modes except 'delete' and 'extract'");
-        }
-        return true;
-    }),
-    async handler(args) {
-        const a = args;
-        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 memoryComponent = env.getComponent("memory");
-            if (!memoryComponent) {
-                output.error("MemoryComponent not available");
-                process.exit(1);
-            }
-            // Extract 模式：从会话历史提取记忆
-            if (a.extract) {
-                const agentComponent = env.getComponent("agent");
-                const sessionComponent = env.getComponent("session");
-                if (!agentComponent) {
-                    output.error("AgentComponent not available");
-                    process.exit(1);
-                }
-                await runExtractMode(output, memoryComponent, agentComponent, sessionComponent, env, {
-                    scope: a.scope || "project",
-                    sessionId: args["session-id"],
-                    require: a.require,
-                });
-                return;
-            }
-            // 普通 record 模式
-            const result = await memoryComponent.recordMemory({
-                scope: a.scope,
-                mode: a.mode,
-                content: a.content,
-                title: a.title,
-            });
-            if (!result) {
-                output.error("Failed to record memory: no memory paths configured");
-                process.exit(1);
-            }
-            const actionMessages = {
-                created: "已创建记忆文件",
-                overwrite: "已覆盖记忆文件",
-                append: "已追加内容到记忆文件",
-                prepend: "已插入内容到记忆文件开头",
-                delete: "已删除记忆文件",
-            };
-            output.log(chalk.green(`✓ ${actionMessages[result.action]}`));
-            output.log(chalk.gray(`路径: ${result.path}`));
-            // 如果是 overwrite/append/prepend，显示写入的内容预览
-            if (result.action !== "delete" && a.content) {
-                const preview = a.content.substring(0, 100);
-                output.log(chalk.gray(`内容预览: ${preview}${a.content.length > 100 ? "..." : ""}`));
-            }
-        }
-        catch (error) {
-            output.error(`Failed to record memory: ${error}`);
-            process.exit(1);
-        }
-        finally {
-            await envService.dispose();
-        }
-    },
-};
-//# sourceMappingURL=record.js.map