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

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

@@ -1,166 +0,0 @@
-/**
- * @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

@@ -1,7 +0,0 @@
-/**
- * @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

@@ -1,114 +0,0 @@
-/**
- * @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

@@ -1,104 +0,0 @@
-/**
- * @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

@@ -1,155 +0,0 @@
-/**
- * @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

@@ -1,13 +0,0 @@
-/**
- * @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

@@ -1,44 +0,0 @@
-/**
- * @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

@@ -1,17 +0,0 @@
-/**
- * @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

@@ -1,44 +0,0 @@
-/**
- * @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

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