@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/memory/plugin/memory-manager.js

@@ -0,0 +1,166 @@
+/**
+ * @fileoverview MemoryManager V3 - Simplified
+ *
+ * 后台异步任务队列处理
+ *
+ * 简化设计：
+ * - 移除 DraftManager（草稿管理已废弃）
+ * - 移除 MemoryOrganizer（整理机制已废弃）
+ * - 移除 AccessLog（访问日志已废弃）
+ * - 只保留核心的任务队列处理
+ */
+import { createLogger } from "../../log-trace/logger.js";
+const logger = createLogger("MemoryManagerV3");
+/**
+ * 生成唯一任务 ID
+ */
+function generateTaskId() {
+    return `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * MemoryManager V3 - Simplified
+ *
+ * 简化的后台异步内存处理，只负责任务队列
+ */
+export class MemoryManager {
+    /** 队列最大容量，防止内存溢出 */
+    static MAX_QUEUE_SIZE = 100;
+    queue = [];
+    processing = false;
+    shuttingDown = false;
+    config;
+    processingPromise = null;
+    resolveProcessing = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    /**
+     * 更新配置
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * 入队（非阻塞）
+     */
+    enqueue(task) {
+        if (this.shuttingDown) {
+            logger.debug("MemoryManager is shutting down, ignoring new task");
+            return;
+        }
+        const fullTask = {
+            ...task,
+            id: generateTaskId(),
+        };
+        // 队列大小限制，防止内存溢出
+        if (this.queue.length >= MemoryManager.MAX_QUEUE_SIZE) {
+            const dropped = this.queue.shift();
+            logger.warn(`Queue full (${MemoryManager.MAX_QUEUE_SIZE}), dropping oldest task: ${dropped?.id}`);
+        }
+        this.queue.push(fullTask);
+        logger.debug(`Task enqueued: ${task.type}, queue size: ${this.queue.length}`);
+        // 如果没有正在处理，启动处理循环
+        if (!this.processing) {
+            this.startProcessingLoop();
+        }
+    }
+    /**
+     * 启动处理循环
+     */
+    startProcessingLoop() {
+        const runLoop = async () => {
+            while (this.queue.length > 0 && !this.shuttingDown) {
+                const task = this.queue.shift();
+                try {
+                    await this.processTask(task);
+                }
+                catch (error) {
+                    logger.error(`Task ${task.id} failed:`, error);
+                }
+            }
+            // 处理完成
+            this.processing = false;
+            if (this.resolveProcessing) {
+                this.resolveProcessing();
+                this.resolveProcessing = null;
+                this.processingPromise = null;
+            }
+        };
+        this.processing = true;
+        this.processingPromise = new Promise((resolve) => {
+            this.resolveProcessing = resolve;
+        });
+        setImmediate(() => {
+            runLoop().catch((error) => {
+                logger.error("Processing loop error:", error);
+                this.processing = false;
+            });
+        });
+    }
+    /**
+     * 检查是否有待处理任务
+     */
+    hasPendingTasks() {
+        return this.queue.length > 0 || this.processing;
+    }
+    /**
+     * 等待处理完成
+     */
+    async waitForCompletion() {
+        // 如果队列为空且没有正在处理，快速路径
+        if (this.queue.length === 0 && !this.processing) {
+            return;
+        }
+        // 如果有待处理的 Promise，等待它
+        if (this.processingPromise) {
+            await this.processingPromise;
+        }
+    }
+    /**
+     * 准备关闭
+     */
+    prepareShutdown() {
+        this.shuttingDown = true;
+        logger.info("MemoryManager preparing for shutdown");
+    }
+    /**
+     * 释放资源
+     */
+    async dispose() {
+        // 等待当前任务完成
+        await this.waitForCompletion();
+        // 清空队列
+        this.queue = [];
+        logger.info("MemoryManager disposed");
+    }
+    /**
+     * 处理单个任务
+     */
+    async processTask(task) {
+        logger.debug(`Processing task: ${task.type}`);
+        switch (task.type) {
+            case "extract_memory":
+                await this.handleExtractMemory(task.payload);
+                break;
+            default:
+                logger.warn(`Unknown task type: ${task.type}`);
+        }
+    }
+    /**
+     * 处理记忆提取
+     */
+    async handleExtractMemory(payload) {
+        const messageCount = payload.messages?.length || 0;
+        logger.info(`Extracting memory from ${messageCount} messages`);
+        // 调用回调
+        if (this.config.onExtractMemory) {
+            try {
+                await this.config.onExtractMemory(payload);
+            }
+            catch (error) {
+                logger.error("Memory extraction failed", { error });
+            }
+        }
+    }
+}
+//# sourceMappingURL=memory-manager.js.map

package/dist/core/src/env/memory/plugin/memory-plugin-agent.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Memory Plugin Agent 集成测试 (Simplified)
+ *
+ * 简化后的 Memory Agent 集成测试
+ */
+export {};
+//# sourceMappingURL=memory-plugin-agent.test.d.ts.map

package/dist/core/src/env/memory/plugin/memory-plugin-agent.test.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Memory Plugin Agent 集成测试 (Simplified)
+ *
+ * 简化后的 Memory Agent 集成测试
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import path from "path";
+import fs from "fs/promises";
+import os from "os";
+import { buildProjectInput, buildGlobalInput, applyMemoryResult, generateProjectSummary, } from "./memory-agent.js";
+describe("buildProjectInput", () => {
+    let testDir;
+    let projectDir;
+    beforeEach(async () => {
+        testDir = path.join(os.tmpdir(), `memory-agent-test-${Date.now()}`);
+        projectDir = path.join(testDir, "project-a");
+        await fs.mkdir(projectDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true }).catch(() => { });
+    });
+    it("should build input for project scope", async () => {
+        const input = await buildProjectInput({
+            projectPath: projectDir,
+            currentMemoryMd: "# Project Memory\n\nTest content",
+            messages: [
+                { role: "user", content: "Hello" },
+            ],
+        });
+        expect(input.scope).toBe("project");
+        expect(input.baseDir).toContain(".roy/memory");
+        expect(input.currentMemoryMd).toContain("Project Memory");
+        expect(input.messages.length).toBe(1);
+    });
+});
+describe("buildGlobalInput", () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = path.join(os.tmpdir(), `memory-agent-test-${Date.now()}`);
+        await fs.mkdir(path.join(testDir, "memory"), { recursive: true });
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true }).catch(() => { });
+    });
+    it("should build input for global scope with project summaries", async () => {
+        const projectSummaries = [
+            {
+                projectPath: "/path/to/project-a",
+                projectName: "project-a",
+                lastUpdated: Date.now(),
+                summary: "Project A summary",
+                shortSummary: "A",
+                memoryMdPath: "/path/to/project-a/.roy/memory/memory.md",
+            },
+        ];
+        const input = buildGlobalInput({
+            baseDir: testDir,
+            currentMemoryMd: "# Global Memory",
+            messages: [],
+            projectSummaries,
+        });
+        expect(input.scope).toBe("global");
+        expect(input.baseDir).toBe(testDir);
+        expect(input.projectSummaries).toHaveLength(1);
+        expect(input.projectSummaries[0].projectName).toBe("project-a");
+    });
+});
+describe("applyMemoryResult", () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = path.join(os.tmpdir(), `memory-agent-test-${Date.now()}`);
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true }).catch(() => { });
+    });
+    it("should write memory.md content", async () => {
+        const result = {
+            scope: "project",
+            memoryMdContent: "# Updated Memory\n\nNew content",
+            hasUpdates: true,
+        };
+        await applyMemoryResult(result, testDir);
+        const memoryPath = path.join(testDir, "memory.md");
+        const content = await fs.readFile(memoryPath, "utf-8");
+        expect(content).toContain("Updated Memory");
+    });
+});
+describe("generateProjectSummary", () => {
+    it("should generate summary with required fields", () => {
+        const summary = generateProjectSummary({
+            projectPath: "/path/to/project",
+            projectName: "test-project",
+            memoryMdContent: "# Test Project\n\nSome important content here.",
+            memoryMdPath: "/path/to/project/.roy/memory/memory.md",
+        });
+        expect(summary.projectPath).toBe("/path/to/project");
+        expect(summary.projectName).toBe("test-project");
+        expect(summary.lastUpdated).toBeGreaterThan(0);
+        expect(summary.summary).toBeTruthy();
+        expect(summary.shortSummary).toBeTruthy();
+        expect(summary.memoryMdPath).toBe("/path/to/project/.roy/memory/memory.md");
+    });
+    it("should generate short summary from memory content", () => {
+        const summary = generateProjectSummary({
+            projectPath: "/path/to/project",
+            projectName: "test",
+            memoryMdContent: "# Test Project\n\nThis is a long description of what the project does with many more details.",
+            memoryMdPath: "/path/memory.md",
+        });
+        // Short summary should be shorter or equal to full summary
+        expect(summary.shortSummary.length).toBeLessThanOrEqual(summary.summary.length);
+    });
+});
+//# sourceMappingURL=memory-plugin-agent.test.js.map

package/dist/core/src/env/memory/plugin/memory-plugin.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview MemoryPlugin - Simplified
+ *
+ * Hook handler for agent:after.react
+ *
+ * 简化设计（移除旧的复杂机制）：
+ * - 移除了 DraftManager（草稿管理已废弃）
+ * - 移除了 MemoryOrganizer（整理机制已废弃）
+ * - 移除了 AccessLog（访问日志已废弃）
+ *
+ * 新的记忆管理方式：
+ * - 使用 `roy memory recall --extract` 命令手动触发
+ * - 使用 Memory Agent 自动分析会话历史
+ * - 直接更新 memory.md 文件
+ */
+import type { HookContext } from "../../agent/types";
+import type { MemoryPluginConfig } from "./types";
+/**
+ * MemoryPlugin - Simplified
+ *
+ * 简化的记忆插件，不再自动处理。
+ *
+ * 用户应该使用 `roy memory recall --extract` 命令来手动触发记忆提取。
+ *
+ * 保留此插件是为了：
+ * 1. 保持 API 兼容性
+ * 2. 未来可以扩展为可选的自动触发
+ */
+export declare class MemoryPlugin {
+    private config;
+    private disposed;
+    private initialized;
+    /** 项目 memory 基础目录 */
+    private projectBaseDir;
+    /** 全局 memory 基础目录 */
+    private globalBaseDir;
+    /** 当前工作目录（用于推断项目路径） */
+    private workDir;
+    /** AgentComponent 引用（延迟获取） */
+    private agentComponent;
+    constructor(baseDir: string, config?: MemoryPluginConfig);
+    /**
+     * Plugin 名称
+     */
+    get name(): string;
+    /**
+     * 订阅的 Hook 点
+     */
+    get hookPoint(): "agent:after.react";
+    /**
+     * 优先级
+     */
+    get priority(): number;
+    /**
+     * 描述
+     */
+    get description(): string;
+    /**
+     * 获取 Hook 定义
+     */
+    get hooks(): {
+        point: "agent:after.react";
+        priority: number;
+    }[];
+    /**
+     * 初始化
+     */
+    initialize(): Promise<void>;
+    /**
+     * 执行 Hook
+     *
+     * 简化为空操作。用户应该使用 `roy memory recall --extract` 命令。
+     */
+    execute(ctx: HookContext): Promise<void>;
+    /**
+     * 准备关闭
+     */
+    prepareShutdown(): void;
+    /**
+     * 检查是否有待处理任务
+     */
+    hasPendingTasks(): boolean;
+    /**
+     * 等待处理完成
+     */
+    waitForCompletion(): Promise<void>;
+    /**
+     * 释放资源
+     */
+    dispose(): Promise<void>;
+    /**
+     * 获取项目 base dir
+     */
+    getProjectBaseDir(): string;
+    /**
+     * 获取全局 base dir
+     */
+    getGlobalBaseDir(): string;
+}
+/**
+ * 创建 MemoryPlugin 实例
+ */
+export declare function createMemoryPlugin(baseDir: string, config?: MemoryPluginConfig): MemoryPlugin;
+//# sourceMappingURL=memory-plugin.d.ts.map

package/dist/core/src/env/memory/plugin/memory-plugin.js

@@ -0,0 +1,155 @@
+/**
+ * @fileoverview MemoryPlugin - Simplified
+ *
+ * Hook handler for agent:after.react
+ *
+ * 简化设计（移除旧的复杂机制）：
+ * - 移除了 DraftManager（草稿管理已废弃）
+ * - 移除了 MemoryOrganizer（整理机制已废弃）
+ * - 移除了 AccessLog（访问日志已废弃）
+ *
+ * 新的记忆管理方式：
+ * - 使用 `roy memory recall --extract` 命令手动触发
+ * - 使用 Memory Agent 自动分析会话历史
+ * - 直接更新 memory.md 文件
+ */
+import { DEFAULT_MEMORY_PLUGIN_CONFIG } from "./types.js";
+import { createLogger } from "../../log-trace/logger.js";
+import path from "path";
+import os from "os";
+const logger = createLogger("MemoryPlugin");
+/**
+ * MemoryPlugin - Simplified
+ *
+ * 简化的记忆插件，不再自动处理。
+ *
+ * 用户应该使用 `roy memory recall --extract` 命令来手动触发记忆提取。
+ *
+ * 保留此插件是为了：
+ * 1. 保持 API 兼容性
+ * 2. 未来可以扩展为可选的自动触发
+ */
+export class MemoryPlugin {
+    config;
+    disposed = false;
+    initialized = false;
+    /** 项目 memory 基础目录 */
+    projectBaseDir = "";
+    /** 全局 memory 基础目录 */
+    globalBaseDir = "";
+    /** 当前工作目录（用于推断项目路径） */
+    workDir = "";
+    /** AgentComponent 引用（延迟获取） */
+    agentComponent = null;
+    constructor(baseDir, config = {}) {
+        this.config = { ...DEFAULT_MEMORY_PLUGIN_CONFIG, ...config };
+        this.workDir = baseDir;
+        this.projectBaseDir = path.join(baseDir, ".roy", "memory");
+        this.globalBaseDir = path.join(os.homedir(), ".config", "roy-agent", "memory");
+        logger.info("MemoryPlugin (simplified) created", { baseDir, config: this.config });
+    }
+    /**
+     * Plugin 名称
+     */
+    get name() {
+        return "MemoryPlugin";
+    }
+    /**
+     * 订阅的 Hook 点
+     */
+    get hookPoint() {
+        return "agent:after.react";
+    }
+    /**
+     * 优先级
+     */
+    get priority() {
+        return 50;
+    }
+    /**
+     * 描述
+     */
+    get description() {
+        return "Memory management plugin. Use 'roy memory recall --extract' to extract memories.";
+    }
+    /**
+     * 获取 Hook 定义
+     */
+    get hooks() {
+        return [
+            {
+                point: this.hookPoint,
+                priority: this.priority,
+            },
+        ];
+    }
+    /**
+     * 初始化
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        logger.info("MemoryPlugin (simplified) initialized");
+    }
+    /**
+     * 执行 Hook
+     *
+     * 简化为空操作。用户应该使用 `roy memory recall --extract` 命令。
+     */
+    async execute(ctx) {
+        if (this.disposed || !this.config.enabled || !this.initialized) {
+            return;
+        }
+        // 不再自动处理。用户应该使用 `roy memory recall --extract`
+        logger.debug("MemoryPlugin hook executed. Use 'roy memory recall --extract' for memory extraction.");
+    }
+    /**
+     * 准备关闭
+     */
+    prepareShutdown() {
+        // 无需处理
+    }
+    /**
+     * 检查是否有待处理任务
+     */
+    hasPendingTasks() {
+        return false;
+    }
+    /**
+     * 等待处理完成
+     */
+    async waitForCompletion() {
+        // 无需等待
+    }
+    /**
+     * 释放资源
+     */
+    async dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        logger.info("MemoryPlugin (simplified) disposed");
+    }
+    /**
+     * 获取项目 base dir
+     */
+    getProjectBaseDir() {
+        return this.projectBaseDir;
+    }
+    /**
+     * 获取全局 base dir
+     */
+    getGlobalBaseDir() {
+        return this.globalBaseDir;
+    }
+}
+/**
+ * 创建 MemoryPlugin 实例
+ */
+export function createMemoryPlugin(baseDir, config) {
+    return new MemoryPlugin(baseDir, config);
+}
+//# sourceMappingURL=memory-plugin.js.map

package/dist/core/src/env/memory/plugin/plugin-simplified.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Memory Plugin Simplified Tests (TDD)
+ *
+ * 测试目标：验证简化后的 Memory Plugin 设计
+ *
+ * 设计原则：
+ * - 移除 DraftManager（草稿管理已废弃）
+ * - 移除 MemoryOrganizer（整理机制已废弃）
+ * - 移除 AccessLog（访问日志已废弃）
+ * - 保留 MemoryManager（核心组件）
+ */
+export {};
+//# sourceMappingURL=plugin-simplified.test.d.ts.map

package/dist/core/src/env/memory/plugin/plugin-simplified.test.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Memory Plugin Simplified Tests (TDD)
+ *
+ * 测试目标：验证简化后的 Memory Plugin 设计
+ *
+ * 设计原则：
+ * - 移除 DraftManager（草稿管理已废弃）
+ * - 移除 MemoryOrganizer（整理机制已废弃）
+ * - 移除 AccessLog（访问日志已废弃）
+ * - 保留 MemoryManager（核心组件）
+ */
+import { describe, expect, test } from "bun:test";
+import * as pluginModule from "./index.js";
+describe("Memory Plugin - Simplified Design", () => {
+    describe("should NOT export deprecated components", () => {
+        test("DraftManager should be removed/not exported", () => {
+            // DraftManager 已被移除，不应该导出
+            expect(pluginModule).not.toHaveProperty("DraftManager");
+        });
+        test("MemoryOrganizer should be removed/not exported", () => {
+            expect(pluginModule).not.toHaveProperty("MemoryOrganizer");
+        });
+        test("AccessLog should be removed/not exported", () => {
+            expect(pluginModule).not.toHaveProperty("AccessLog");
+        });
+    });
+    describe("should keep core functionality", () => {
+        test("MemoryManager should still exist as core component", () => {
+            // MemoryManager 保留，作为核心组件
+            expect(pluginModule.MemoryManager).toBeDefined();
+        });
+        test("MemoryPlugin should still exist for backwards compatibility", () => {
+            // MemoryPlugin 保留，但简化内部实现
+            expect(pluginModule.MemoryPlugin).toBeDefined();
+        });
+        test("createMemoryPlugin should still exist", () => {
+            expect(pluginModule.createMemoryPlugin).toBeDefined();
+        });
+        test("recallMemory should still exist", () => {
+            expect(pluginModule.recallMemory).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=plugin-simplified.test.js.map

package/dist/core/src/env/memory/plugin/recall-memory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Recall Memory - Simplified
+ *
+ * 简化设计：
+ * - 移除 AccessLog（访问日志已废弃）
+ * - 只读取 memory.md 文件
+ */
+import type { MemoryPath } from "../types";
+/**
+ * 读取记忆文件
+ *
+ * @param memoryPaths - 记忆路径列表
+ * @returns 记忆内容
+ */
+export declare function recallMemory(memoryPaths: MemoryPath[]): Promise<string>;
+export type { MemoryPath } from "../types";
+//# sourceMappingURL=recall-memory.d.ts.map

package/dist/core/src/env/memory/plugin/recall-memory.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Recall Memory - Simplified
+ *
+ * 简化设计：
+ * - 移除 AccessLog（访问日志已废弃）
+ * - 只读取 memory.md 文件
+ */
+import fs from "fs/promises";
+import path from "path";
+/**
+ * 读取记忆文件
+ *
+ * @param memoryPaths - 记忆路径列表
+ * @returns 记忆内容
+ */
+export async function recallMemory(memoryPaths) {
+    const results = [];
+    for (const memoryPath of memoryPaths) {
+        const scope = memoryPath.type; // "global" | "project"
+        const baseDir = memoryPath.path;
+        try {
+            // 读取 memory.md
+            const memoryFile = path.join(baseDir, "memory.md");
+            try {
+                const content = await fs.readFile(memoryFile, "utf-8");
+                if (content.trim()) {
+                    results.push(`## [${scope}] memory.md\n${content}`);
+                }
+            }
+            catch {
+                // 文件不存在，跳过
+            }
+        }
+        catch (error) {
+            // 整个 scope 处理失败，跳过
+            console.error(`Error processing memory path ${baseDir}:`, error);
+        }
+    }
+    if (results.length === 0) {
+        return "(No memory files found)";
+    }
+    return results.join("\n\n");
+}
+//# sourceMappingURL=recall-memory.js.map

package/dist/core/src/env/memory/plugin/recall-memory.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Recall Memory Tests - Simplified
+ *
+ * 测试简化后的 recall_memory 工具
+ */
+export {};
+//# sourceMappingURL=recall-memory.test.d.ts.map