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

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

@@ -1,406 +0,0 @@
-/**
- * @fileoverview MemoryComponent - Simplified
- *
- * 记忆管理核心组件
- *
- * 简化设计：
- * - 移除 DraftManager、MemoryOrganizer、AccessLog 依赖
- * - 只保留核心的 memory 文件操作
- * - 提供 recallMemory(scope) 方法支持 project/global scope
- */
-import { BaseComponent } from "../component.js";
-import { createLogger } from "../log-trace/logger.js";
-import { DEFAULT_MEMORY_CONFIG } from "./memory-config.js";
-import { createMemoryTools } from "./built-in/index.js";
-import { MEMORY_CONFIG_REGISTRATION, MEMORY_DEFAULTS } from "./memory-config-registration.js";
-import { envKeyToConfigKey } from "../../config/env-key.js";
-import path from "path";
-import fs from "fs/promises";
-const logger = createLogger("memory");
-/**
- * MemoryComponent - Simplified
- *
- * 简化的记忆管理组件，只负责：
- * - 管理本地文件系统记忆存储
- * - 注册记忆操作工具
- * - 提供目录扫描和缓存
- *
- * 复杂功能已移除：
- * - DraftManager（草稿管理）
- * - MemoryOrganizer（记忆整理）
- * - AccessLog（访问日志）
- */
-export class MemoryComponent extends BaseComponent {
-    name = "memory";
-    version = "2.0.0";
-    config;
-    toolComponent;
-    configComponent;
-    // 缓存
-    cache = new Map();
-    /** 配置变更 watcher 清理函数 */
-    configWatcher;
-    // ====================
-    // Lifecycle
-    // ====================
-    async init(config) {
-        await super.init(config);
-        // 从 options 获取 ConfigComponent
-        const options = config?.options;
-        if (!options?.configComponent) {
-            throw new Error("ConfigComponent is required for MemoryComponent initialization");
-        }
-        this.configComponent = options.configComponent;
-        await this.registerConfig(options);
-        logger.info("[MemoryComponent] Initialized (simplified)");
-    }
-    /**
-     * 注册配置到 ConfigComponent
-     */
-    async registerConfig(options) {
-        const configComponent = this.configComponent;
-        if (!configComponent)
-            return;
-        const { configPath, envPrefix, config } = options;
-        const prefix = envPrefix ?? "MEMORY";
-        // 1. 使用 registerComponent 注册配置结构
-        configComponent.registerComponent(MEMORY_CONFIG_REGISTRATION);
-        // 2. 注册 FileSource
-        if (configPath) {
-            configComponent.registerSource({
-                type: "file",
-                relativePath: configPath,
-                optional: true,
-                watch: false
-            });
-        }
-        // 3. 注册 EnvSource
-        configComponent.registerSource({
-            type: "env",
-            envPrefix: prefix,
-            priority: 20,
-            watch: false
-        });
-        // 4. 从 sources 加载配置
-        await configComponent.load("memory");
-        // 5. 后备方案：直接读取环境变量
-        for (const envKey of Object.keys(process.env)) {
-            const configKey = envKeyToConfigKey(envKey, prefix, "memory");
-            if (!configKey)
-                continue;
-            const value = process.env[envKey];
-            if (value !== undefined) {
-                await configComponent.set(configKey, value);
-            }
-        }
-        // 6. 设置默认值
-        for (const [key, value] of Object.entries(MEMORY_DEFAULTS)) {
-            if (configComponent.get(key) === undefined) {
-                await configComponent.set(key, value);
-            }
-        }
-        // 7. 直接配置对象（最高优先级）
-        if (config) {
-            const flatConfig = this.flattenConfig(config);
-            for (const [key, value] of Object.entries(flatConfig)) {
-                await configComponent.set(key, value);
-            }
-        }
-        // 8. 注册配置热更新监听
-        this.registerConfigWatcher(configComponent);
-        // 9. 解析最终配置
-        this.buildConfig(configComponent);
-    }
-    /**
-     * 构建最终配置对象
-     */
-    buildConfig(configComponent) {
-        const recursive = configComponent.get("memory.recursive") ?? true;
-        const cacheEnabled = configComponent.get("memory.cacheEnabled") ?? true;
-        const cacheTTL = configComponent.get("memory.cacheTTL") ?? 300000;
-        const memoryFile = configComponent.get("memory.memoryFile") ?? "memory.md";
-        // 从配置获取 memoryPaths
-        const memoryPathsConfig = configComponent.get("memory.memoryPaths");
-        let memoryPaths = [];
-        if (Array.isArray(memoryPathsConfig)) {
-            memoryPaths = memoryPathsConfig;
-        }
-        else if (typeof memoryPathsConfig === "string") {
-            try {
-                memoryPaths = JSON.parse(memoryPathsConfig);
-            }
-            catch {
-                memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
-            }
-        }
-        if (memoryPaths.length === 0) {
-            memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
-        }
-        this.config = {
-            memoryPaths,
-            recursive,
-            cacheEnabled,
-            cacheTTL,
-            memoryFile,
-        };
-    }
-    /**
-     * 将配置对象展平为点号路径
-     */
-    flattenConfig(obj, prefix = "memory") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            const fullKey = `${prefix}.${key}`;
-            if (value && typeof value === "object" && !Array.isArray(value)) {
-                Object.assign(result, this.flattenConfig(value, fullKey));
-            }
-            else {
-                result[fullKey] = value;
-            }
-        }
-        return result;
-    }
-    /**
-     * 注册配置热更新监听
-     */
-    registerConfigWatcher(configComponent) {
-        if (typeof configComponent.watch !== "function") {
-            return;
-        }
-        this.configWatcher = configComponent.watch("memory.*", (event) => {
-            this.onConfigChange(event);
-        });
-    }
-    /**
-     * 处理配置变更
-     */
-    onConfigChange(event) {
-        logger.info(`[MemoryComponent] Config changed: ${event.key}`, {
-            oldValue: event.oldValue,
-            newValue: event.newValue
-        });
-        if (this.configComponent) {
-            this.buildConfig(this.configComponent);
-        }
-        this.cache.clear();
-    }
-    async start() {
-        await super.start();
-        // 获取 ToolComponent
-        this.toolComponent = this.env?.getComponent("tool");
-        if (!this.toolComponent) {
-            logger.warn("[MemoryComponent] ToolComponent not found, skipping tool registration");
-            return;
-        }
-        // 注册工具
-        await this.registerTools();
-        this.setStatus("running");
-        logger.info(`[MemoryComponent] Started with ${this.toolComponent.getToolCount()} tools`);
-    }
-    async stop() {
-        // 清理配置 watcher
-        if (this.configWatcher) {
-            this.configWatcher();
-            this.configWatcher = undefined;
-        }
-        // 取消注册工具
-        if (this.toolComponent) {
-            this.toolComponent.unregister("record_memory");
-            this.toolComponent.unregister("recall_memory");
-        }
-        // 清理缓存
-        this.cache.clear();
-        await super.stop();
-        logger.info("[MemoryComponent] Stopped");
-    }
-    // ====================
-    // Tool Registration
-    // ====================
-    async registerTools() {
-        if (!this.toolComponent)
-            return;
-        // 创建工具
-        const tools = createMemoryTools((args) => this.recordMemory(args), (scope) => this.recallMemory(scope), {
-            getMemoryPaths: () => this.getMemoryPaths(),
-            getMemoryFile: () => this.getMemoryFile(),
-        });
-        // 注册到 ToolComponent
-        for (const tool of tools) {
-            this.toolComponent.register(tool);
-        }
-        logger.info("[MemoryComponent] Registered memory tools");
-    }
-    // ====================
-    // Memory Operations
-    // ====================
-    /**
-     * 获取所有配置的 memory 路径
-     */
-    getMemoryPaths() {
-        return this.config.memoryPaths;
-    }
-    /**
-     * 更新 memory paths
-     */
-    updateMemoryPaths(paths) {
-        this.config.memoryPaths = paths;
-        this.clearCache();
-    }
-    /**
-     * 获取记忆文件名
-     */
-    getMemoryFile() {
-        return this.config.memoryFile ?? "memory.md";
-    }
-    /**
-     * 记录记忆
-     *
-     * @param args.mode 操作模式
-     * @param args.content 记忆内容
-     * @param args.title 标题
-     * @param args.filename 文件名
-     * @param args.scope 作用域 (project/global)，用于选择正确的 memory path
-     */
-    async recordMemory(args) {
-        const { mode, content, title, filename, scope } = args;
-        const memoryFile = filename ?? this.getMemoryFile();
-        const paths = this.config.memoryPaths;
-        if (paths.length === 0) {
-            return null;
-        }
-        // 根据 scope 选择正确的路径
-        let basePath;
-        if (scope) {
-            const targetPath = paths.find(p => p.type === scope);
-            if (!targetPath) {
-                logger.warn(`[recordMemory] No ${scope} path configured, using first available path`);
-                basePath = paths[0].path;
-            }
-            else {
-                basePath = targetPath.path;
-            }
-        }
-        else {
-            // 默认使用第一个路径
-            basePath = paths[0].path;
-        }
-        const filePath = path.join(basePath, memoryFile);
-        try {
-            let existingContent = "";
-            let fileExists = false;
-            try {
-                existingContent = await fs.readFile(filePath, "utf-8");
-                fileExists = true;
-            }
-            catch {
-                // 文件不存在
-            }
-            let newContent;
-            let action;
-            switch (mode) {
-                case "delete":
-                    if (fileExists) {
-                        await fs.unlink(filePath);
-                        this.clearCache();
-                        return { path: filePath, action: "delete" };
-                    }
-                    return null;
-                case "overwrite":
-                    if (title && content) {
-                        newContent = `## ${title}\n\n${content}\n`;
-                    }
-                    else {
-                        newContent = content ?? "";
-                    }
-                    action = fileExists ? "overwrite" : "created";
-                    break;
-                case "append":
-                    if (!content) {
-                        throw new Error("content is required for append mode");
-                    }
-                    if (title) {
-                        newContent = existingContent + `\n## ${title}\n\n${content}\n`;
-                    }
-                    else {
-                        newContent = existingContent + `\n${content}\n`;
-                    }
-                    action = fileExists ? "append" : "created";
-                    break;
-                case "prepend":
-                    if (!content) {
-                        throw new Error("content is required for prepend mode");
-                    }
-                    if (title) {
-                        newContent = `## ${title}\n\n${content}\n\n---\n\n${existingContent}`;
-                    }
-                    else {
-                        newContent = `${content}\n\n---\n\n${existingContent}`;
-                    }
-                    action = fileExists ? "prepend" : "created";
-                    break;
-                default:
-                    throw new Error(`Unknown mode: ${mode}`);
-            }
-            await fs.mkdir(basePath, { recursive: true });
-            await fs.writeFile(filePath, newContent, "utf-8");
-            this.clearCache();
-            return { path: filePath, action };
-        }
-        catch (error) {
-            logger.error(`[recordMemory] Failed: ${error}`);
-            throw error;
-        }
-    }
-    /**
-     * 回忆记忆 - 读取所有记忆文件内容
-     *
-     * @param scope 可选：project 或 global，默认读取所有
-     */
-    async recallMemory(scope) {
-        const memoryFile = this.getMemoryFile();
-        const paths = this.config.memoryPaths;
-        const results = [];
-        for (const memoryPath of paths) {
-            // 如果指定了 scope，只读取匹配的记忆
-            if (scope && memoryPath.type !== scope) {
-                continue;
-            }
-            const filePath = path.join(memoryPath.path, memoryFile);
-            try {
-                const content = await fs.readFile(filePath, "utf-8");
-                if (content.trim()) {
-                    results.push(`## [${memoryPath.type}] ${memoryFile}\n${content}`);
-                }
-            }
-            catch {
-                // 文件不存在，跳过
-            }
-        }
-        return results.join("\n\n");
-    }
-    // ====================
-    // Cache
-    // ====================
-    clearCache() {
-        this.cache.clear();
-    }
-    getCache(key) {
-        if (!this.config.cacheEnabled)
-            return undefined;
-        const entry = this.cache.get(key);
-        if (!entry)
-            return undefined;
-        const age = Date.now() - entry.timestamp;
-        if (age > (this.config.cacheTTL ?? 300000)) {
-            this.cache.delete(key);
-            return undefined;
-        }
-        return entry.data;
-    }
-    setCache(key, data) {
-        if (!this.config.cacheEnabled)
-            return;
-        this.cache.set(key, { data, timestamp: Date.now() });
-    }
-}
-//# sourceMappingURL=memory-component.js.map

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

@@ -1,5 +0,0 @@
-/**
- * @fileoverview MemoryComponent Tests - Simplified
- */
-export {};
-//# sourceMappingURL=memory-component.test.d.ts.map

package/dist/core/src/env/memory/memory-component.test.js

@@ -1,183 +0,0 @@
-/**
- * @fileoverview MemoryComponent Tests - Simplified
- */
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import path from "path";
-import fs from "fs/promises";
-import os from "os";
-import { MemoryComponent } from "./memory-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-describe("MemoryComponent", () => {
-    let memoryComponent;
-    let configComponent;
-    let testDir;
-    beforeEach(async () => {
-        // 创建临时测试目录
-        testDir = path.join(os.tmpdir(), `memory-test-${Date.now()}`);
-        await fs.mkdir(path.join(testDir, "operations"), { recursive: true });
-        await fs.mkdir(path.join(testDir, "solutions"), { recursive: true });
-        // 写入测试文件
-        await fs.writeFile(path.join(testDir, "operations", "task_123_design.md"), "# 操作记录\n\n## 问题\nBun 编译崩溃", "utf-8");
-        await fs.writeFile(path.join(testDir, "solutions", "fix_bun_crash.md"), "# 解决方案\n\n使用 gpt-4o 模型", "utf-8");
-        // 创建组件
-        configComponent = new ConfigComponent();
-        memoryComponent = new MemoryComponent();
-        await memoryComponent.init({
-            options: {
-                configComponent,
-                config: {
-                    memoryPaths: [{ type: "project", path: testDir }],
-                    recursive: true,
-                    cacheEnabled: false,
-                },
-            },
-        });
-    });
-    afterEach(async () => {
-        // 清理
-        try {
-            await memoryComponent.stop();
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-    });
-    describe("init", () => {
-        it("should initialize with config", async () => {
-            expect(memoryComponent.name).toBe("memory");
-            expect(memoryComponent.version).toBe("2.0.0");
-        });
-        it("should get memory paths", () => {
-            const paths = memoryComponent.getMemoryPaths();
-            expect(paths).toHaveLength(1);
-            expect(paths[0].path).toBe(testDir);
-        });
-    });
-    describe("recordMemory", () => {
-        it("should create new memory file", async () => {
-            const result = await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 新记忆\n\n测试内容",
-                title: "测试记忆",
-            });
-            expect(result).not.toBeNull();
-            expect(result.action).toBe("created");
-            // 验证文件存在
-            const memoryPath = path.join(testDir, "memory.md");
-            const content = await fs.readFile(memoryPath, "utf-8");
-            expect(content).toContain("测试记忆");
-        });
-        it("should overwrite existing memory file", async () => {
-            // 先创建
-            await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 旧内容\n\n旧",
-            });
-            // 再覆盖
-            const result = await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 新内容\n\n新",
-                title: "更新标题",
-            });
-            expect(result.action).toBe("overwrite");
-            const memoryPath = path.join(testDir, "memory.md");
-            const content = await fs.readFile(memoryPath, "utf-8");
-            expect(content).toContain("新内容");
-            expect(content).not.toContain("旧内容");
-        });
-        it("should append to memory file", async () => {
-            // 先创建
-            await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 初始内容",
-            });
-            // 追加
-            const result = await memoryComponent.recordMemory({
-                mode: "append",
-                content: "追加的内容",
-                title: "追加段落",
-            });
-            expect(result.action).toBe("append");
-            const memoryPath = path.join(testDir, "memory.md");
-            const content = await fs.readFile(memoryPath, "utf-8");
-            expect(content).toContain("初始内容");
-            expect(content).toContain("追加的内容");
-        });
-        it("should prepend to memory file", async () => {
-            // 先创建
-            await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 原有内容",
-            });
-            // 插入
-            const result = await memoryComponent.recordMemory({
-                mode: "prepend",
-                content: "前置内容",
-                title: "新段落",
-            });
-            expect(result.action).toBe("prepend");
-            const memoryPath = path.join(testDir, "memory.md");
-            const content = await fs.readFile(memoryPath, "utf-8");
-            expect(content.indexOf("前置内容")).toBeLessThan(content.indexOf("原有内容"));
-        });
-        it("should delete memory file", async () => {
-            // 先创建
-            await memoryComponent.recordMemory({
-                mode: "overwrite",
-                content: "# 要删除的内容",
-            });
-            // 删除
-            const result = await memoryComponent.recordMemory({
-                mode: "delete",
-            });
-            expect(result.action).toBe("delete");
-            const memoryPath = path.join(testDir, "memory.md");
-            const exists = await fs.access(memoryPath).then(() => true).catch(() => false);
-            expect(exists).toBe(false);
-        });
-    });
-    describe("recallMemory", () => {
-        it("should read memory.md content", async () => {
-            // 创建 memory.md 文件
-            await fs.writeFile(path.join(testDir, "memory.md"), "# 用户记忆\n\n我喜欢吃苹果 🍎", "utf-8");
-            const result = await memoryComponent.recallMemory();
-            expect(result).toContain("[project]");
-            expect(result).toContain("memory.md");
-            expect(result).toContain("我喜欢吃苹果");
-        });
-        it("should read from multiple memory paths", async () => {
-            // 创建第二个路径
-            const secondDir = path.join(os.tmpdir(), `memory-test-second-${Date.now()}`);
-            await fs.mkdir(secondDir, { recursive: true });
-            await fs.writeFile(path.join(secondDir, "memory.md"), "# 全局记忆\n\n全局配置信息", "utf-8");
-            // 更新配置添加第二个路径
-            memoryComponent.updateMemoryPaths([
-                { type: "project", path: testDir },
-                { type: "user", path: secondDir },
-            ]);
-            // 创建 testDir 的 memory.md
-            await fs.writeFile(path.join(testDir, "memory.md"), "# 用户记忆\n\n用户偏好", "utf-8");
-            const result = await memoryComponent.recallMemory();
-            // 验证两个 scope 都出现
-            expect(result).toContain("[project]");
-            expect(result).toContain("[user]");
-            expect(result).toContain("用户偏好");
-            expect(result).toContain("全局配置信息");
-            // 清理
-            await fs.rm(secondDir, { recursive: true, force: true });
-        });
-    });
-    describe("lifecycle", () => {
-        it("should transition to running state after start", async () => {
-            await memoryComponent.start();
-            expect(memoryComponent.getStatus()).toBe("running");
-        });
-        it("should transition to stopped state after stop", async () => {
-            await memoryComponent.start();
-            await memoryComponent.stop();
-            expect(memoryComponent.getStatus()).toBe("stopped");
-        });
-    });
-});
-//# sourceMappingURL=memory-component.test.js.map

package/dist/core/src/env/memory/memory-config-registration.d.ts

@@ -1,19 +0,0 @@
-/**
- * @fileoverview Memory Component 配置注册
- *
- * 使用 ConfigComponent.registerComponent() 机制统一管理配置
- */
-import type { ComponentRegistration } from "../../config/config-component";
-/**
- * Memory Component 默认配置值
- *
- * 注意：键使用完整格式（带 "memory." 前缀），在 registerConfig 中手动设置
- */
-export declare const MEMORY_DEFAULTS: Record<string, unknown>;
-/**
- * Memory Component 配置注册常量
- *
- * 定义了所有 Memory 相关的配置项和来源
- */
-export declare const MEMORY_CONFIG_REGISTRATION: ComponentRegistration;
-//# sourceMappingURL=memory-config-registration.d.ts.map

package/dist/core/src/env/memory/memory-config-registration.js

@@ -1,43 +0,0 @@
-/**
- * @fileoverview Memory Component 配置注册
- *
- * 使用 ConfigComponent.registerComponent() 机制统一管理配置
- */
-import path from "path";
-import os from "os";
-/**
- * Memory Component 默认配置值
- *
- * 注意：键使用完整格式（带 "memory." 前缀），在 registerConfig 中手动设置
- */
-export const MEMORY_DEFAULTS = {
-    "memory.recursive": true,
-    "memory.cacheEnabled": true,
-    "memory.cacheTTL": 300000, // 5 分钟
-    "memory.memoryFile": "memory.md", // 默认记忆文件名
-    // memoryPaths 的默认值（统一在 ConfigComponent 中管理）
-    "memory.memoryPaths": [
-        { type: "global", path: path.join(os.homedir(), ".config", "roy-agent", "memory") },
-        { type: "project", path: ".roy/memory" },
-    ],
-};
-/**
- * Memory Component 配置注册常量
- *
- * 定义了所有 Memory 相关的配置项和来源
- */
-export const MEMORY_CONFIG_REGISTRATION = {
-    name: "memory",
-    sources: [
-        { type: "env", envPrefix: "MEMORY", priority: 20, watch: false },
-    ],
-    keys: [
-        { key: "memory.recursive", sources: ["env", "file"] },
-        { key: "memory.cacheEnabled", sources: ["env", "file"] },
-        { key: "memory.cacheTTL", sources: ["env", "file"] },
-        { key: "memory.memoryPaths", sources: ["env", "file"] },
-        { key: "memory.memoryFile", sources: ["env", "file"] },
-    ],
-    // 注意：不使用 defaults 字段，默认值在 registerConfig 中手动 set
-};
-//# sourceMappingURL=memory-config-registration.js.map

package/dist/core/src/env/memory/memory-config-registration.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview Memory Component 配置注册测试
- */
-export {};
-//# sourceMappingURL=memory-config-registration.test.d.ts.map