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

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

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Recall Memory Tests - Simplified
+ *
+ * 测试简化后的 recall_memory 工具
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { recallMemory } from "./recall-memory.js";
+describe("RecallMemory - Simplified", () => {
+    let tmpDir;
+    let globalDir;
+    let projectDir;
+    const globalMemoryPath = {
+        type: "global",
+        path: "",
+    };
+    const projectMemoryPath = {
+        type: "project",
+        path: "",
+    };
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "recall-memory-test-"));
+        // Create global memory directory
+        globalDir = path.join(tmpDir, "global-memory");
+        await fs.mkdir(globalDir, { recursive: true });
+        globalMemoryPath.path = globalDir;
+        // Create project memory directory
+        projectDir = path.join(tmpDir, "project-memory");
+        await fs.mkdir(projectDir, { recursive: true });
+        projectMemoryPath.path = projectDir;
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    describe("basic recall", () => {
+        it("should return empty when no memory files exist", async () => {
+            const result = await recallMemory([globalMemoryPath]);
+            expect(result).toBe("(No memory files found)");
+        });
+        it("should return memory.md content", async () => {
+            await fs.writeFile(path.join(globalDir, "memory.md"), "# Global Memory\n\nTest content.", "utf-8");
+            const result = await recallMemory([globalMemoryPath]);
+            expect(result).toContain("# Global Memory");
+            expect(result).toContain("Test content.");
+        });
+        it("should include scope prefix in output", async () => {
+            await fs.writeFile(path.join(globalDir, "memory.md"), "# Global Memory", "utf-8");
+            const result = await recallMemory([globalMemoryPath]);
+            expect(result).toContain("[global]");
+        });
+    });
+    describe("multiple memory paths", () => {
+        it("should recall from multiple scopes", async () => {
+            await fs.writeFile(path.join(globalDir, "memory.md"), "# Global", "utf-8");
+            await fs.writeFile(path.join(projectDir, "memory.md"), "# Project", "utf-8");
+            const result = await recallMemory([globalMemoryPath, projectMemoryPath]);
+            expect(result).toContain("[global]");
+            expect(result).toContain("# Global");
+            expect(result).toContain("[project]");
+            expect(result).toContain("# Project");
+        });
+    });
+    describe("error handling", () => {
+        it("should continue when one scope fails", async () => {
+            // Valid global scope
+            await fs.writeFile(path.join(globalDir, "memory.md"), "# Global", "utf-8");
+            // Invalid project path
+            const invalidPath = { type: "project", path: "/nonexistent/path" };
+            // Should not throw, should still return global content
+            const result = await recallMemory([globalMemoryPath, invalidPath]);
+            expect(result).toContain("# Global");
+        });
+    });
+    describe("output format", () => {
+        it("should separate scopes with double newlines", async () => {
+            await fs.writeFile(path.join(globalDir, "memory.md"), "Global content", "utf-8");
+            await fs.writeFile(path.join(projectDir, "memory.md"), "Project content", "utf-8");
+            const result = await recallMemory([globalMemoryPath, projectMemoryPath]);
+            // Should have sections separated
+            expect(result.split("\n\n").length).toBeGreaterThanOrEqual(2);
+        });
+    });
+});
+//# sourceMappingURL=recall-memory.test.js.map

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

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Memory Plugin Types (Simplified)
+ *
+ * MemoryPlugin 相关类型定义
+ *
+ * 简化设计：
+ * - 移除 Draft 相关的类型
+ * - 移除 AccessLog 相关的类型
+ */
+import type { HookContext } from "../../hook/types";
+import type { ModelMessage } from "ai";
+/**
+ * MemoryPlugin configuration
+ */
+export interface MemoryPluginConfig {
+    /** Enable memory plugin */
+    enabled?: boolean;
+}
+/**
+ * Default MemoryPlugin configuration
+ */
+export declare const DEFAULT_MEMORY_PLUGIN_CONFIG: MemoryPluginConfig;
+/**
+ * Memory task types
+ */
+export type MemoryTaskType = "extract_memory";
+/**
+ * Memory task
+ */
+export interface MemoryTask {
+    id: string;
+    type: MemoryTaskType;
+    payload: unknown;
+    timestamp: number;
+    priority: number;
+}
+/**
+ * Extract memory payload
+ */
+export interface ExtractMemoryPayload {
+    messages: ModelMessage[];
+    sessionId?: string;
+    /** Hook context for Memory Agent */
+    ctx?: MemoryHookContext;
+}
+/**
+ * SessionMessage 接口
+ */
+export interface SessionMessage {
+    /** 消息角色 */
+    role: "user" | "assistant" | "system" | "tool";
+    /** 消息内容 */
+    content: string | Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    /** 工具调用 ID（仅 tool 角色） */
+    toolCallId?: string;
+    /** 工具名称（仅 tool 角色） */
+    toolName?: string;
+    /** 时间戳 */
+    timestamp?: number;
+}
+/**
+ * Hook context data for agent:after.react
+ */
+export interface MemoryHookContext {
+    /** Current messages for memory extraction */
+    messages: ModelMessage[];
+    /** Current session ID */
+    sessionId?: string;
+    /** Project summaries (populated by project agent) */
+    projectSummaries?: unknown[];
+}
+export type { HookContext };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Memory Plugin Types (Simplified)
+ *
+ * MemoryPlugin 相关类型定义
+ *
+ * 简化设计：
+ * - 移除 Draft 相关的类型
+ * - 移除 AccessLog 相关的类型
+ */
+/**
+ * Default MemoryPlugin configuration
+ */
+export const DEFAULT_MEMORY_PLUGIN_CONFIG = {
+    enabled: true,
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview Memory Agent Tools
+ *
+ * Memory Agent 使用的工具：
+ * - search_sessions: 搜索会话历史
+ * - get_session: 获取指定会话
+ * - write_memory: 写入记忆文件
+ * - bash: 执行 Shell 命令（用于探索项目结构）
+ * - read_file: 读取文件内容（用于阅读文档）
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+/**
+ * search_sessions 输入参数
+ */
+export declare const SearchSessionsSchema: z.ZodObject<{
+    query: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+    session_id?: string;
+    limit?: number;
+}, {
+    query?: string;
+    session_id?: string;
+    limit?: number;
+}>;
+export type SearchSessionsParams = z.infer<typeof SearchSessionsSchema>;
+/**
+ * get_session 输入参数
+ */
+export declare const GetSessionSchema: z.ZodObject<{
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    session_id?: string;
+}, {
+    session_id?: string;
+}>;
+export type GetSessionParams = z.infer<typeof GetSessionSchema>;
+/**
+ * write_memory 输入参数
+ */
+export declare const WriteMemorySchema: z.ZodObject<{
+    scope: z.ZodEnum<["project", "global"]>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content?: string;
+    scope?: "project" | "global";
+}, {
+    content?: string;
+    scope?: "project" | "global";
+}>;
+export type WriteMemoryParams = z.infer<typeof WriteMemorySchema>;
+/**
+ * Session Component 接口（需要 searchSessions, getSession 方法）
+ */
+export interface MemoryAgentSessionComponent {
+    /**
+     * 列出所有会话（用于 search_sessions）
+     */
+    list(options?: any): Promise<any[]>;
+    /**
+     * 获取会话上下文（包含消息）
+     */
+    getContext(sessionId: string, options?: any): Promise<any>;
+    /**
+     * 搜索会话（通过 grep 命令）
+     */
+    searchSessions(query: string, options?: {
+        session_id?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    /**
+     * 获取单个会话
+     */
+    getSession(sessionId: string): Promise<any | null>;
+}
+/**
+ * Memory Component 接口（需要 recallMemory, recordMemory 方法）
+ */
+export interface MemoryAgentMemoryComponent {
+    recallMemory(scope?: "project" | "global"): Promise<string | null>;
+    recordMemory(params: {
+        mode: string;
+        content: string;
+        scope?: string;
+    }): Promise<void>;
+}
+/**
+ * Config Component 接口
+ */
+export interface MemoryAgentConfigComponent {
+    get(key: string): unknown;
+}
+/**
+ * Memory Agent 工具工厂
+ */
+export declare function createMemoryAgentTools(deps: {
+    sessionComponent: MemoryAgentSessionComponent;
+    memoryComponent: MemoryAgentMemoryComponent;
+    configComponent?: MemoryAgentConfigComponent;
+}): {
+    searchSessions: Tool;
+    getSession: Tool;
+    writeMemory: Tool;
+    bash: Tool;
+    read_file: Tool;
+};
+//# sourceMappingURL=memory-agent-tools.d.ts.map

package/dist/core/src/env/memory/tools/memory-agent-tools.js

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview Memory Agent Tools
+ *
+ * Memory Agent 使用的工具：
+ * - search_sessions: 搜索会话历史
+ * - get_session: 获取指定会话
+ * - write_memory: 写入记忆文件
+ * - bash: 执行 Shell 命令（用于探索项目结构）
+ * - read_file: 读取文件内容（用于阅读文档）
+ */
+import { z } from "zod";
+import { readFileTool, bashTool } from "../../tool/built-in/index.js";
+// ============================================================================
+// Tool Input Schemas
+// ============================================================================
+/**
+ * search_sessions 输入参数
+ */
+export const SearchSessionsSchema = z.object({
+    query: z.string().describe("搜索关键词"),
+    session_id: z.string().optional().describe("可选：限制特定 session"),
+    limit: z.number().optional().default(10).describe("返回数量限制"),
+});
+/**
+ * get_session 输入参数
+ */
+export const GetSessionSchema = z.object({
+    session_id: z.string().describe("Session ID"),
+});
+/**
+ * write_memory 输入参数
+ */
+export const WriteMemorySchema = z.object({
+    scope: z.enum(["project", "global"]).describe("作用域"),
+    content: z.string().describe("新的记忆内容（Markdown 格式）"),
+});
+// ============================================================================
+// Tool Factory
+// ============================================================================
+/**
+ * Memory Agent 工具工厂
+ */
+export function createMemoryAgentTools(deps) {
+    // ============================================================================
+    // search_sessions tool
+    // ============================================================================
+    const searchSessions = {
+        name: "search_sessions",
+        description: "搜索会话历史，返回匹配的会话摘要列表",
+        parameters: SearchSessionsSchema,
+        execute: async (args, ctx) => {
+            try {
+                const params = SearchSessionsSchema.parse(args);
+                const results = await deps.sessionComponent.searchSessions(params.query, {
+                    session_id: params.session_id,
+                    limit: params.limit,
+                });
+                return {
+                    success: true,
+                    output: JSON.stringify(results, null, 2),
+                    metadata: {
+                        execution_time_ms: 0,
+                        count: results.length,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+    // ============================================================================
+    // get_session tool
+    // ============================================================================
+    const getSession = {
+        name: "get_session",
+        description: "获取指定会话的完整内容",
+        parameters: GetSessionSchema,
+        execute: async (args, ctx) => {
+            try {
+                const params = GetSessionSchema.parse(args);
+                const session = await deps.sessionComponent.getSession(params.session_id);
+                if (!session) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Session not found: ${params.session_id}`,
+                        metadata: { execution_time_ms: 0 },
+                    };
+                }
+                return {
+                    success: true,
+                    output: JSON.stringify(session, null, 2),
+                    metadata: {
+                        execution_time_ms: 0,
+                        session_id: session.sessionId,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+    // ============================================================================
+    // write_memory tool
+    // ============================================================================
+    const writeMemory = {
+        name: "write_memory",
+        description: "写入记忆文件（覆盖模式）",
+        parameters: WriteMemorySchema,
+        execute: async (args, ctx) => {
+            try {
+                const params = WriteMemorySchema.parse(args);
+                await deps.memoryComponent.recordMemory({
+                    mode: "overwrite",
+                    content: params.content,
+                    scope: params.scope,
+                });
+                return {
+                    success: true,
+                    output: `Memory updated successfully (${params.scope})`,
+                    metadata: {
+                        execution_time_ms: 0,
+                        scope: params.scope,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+    return {
+        searchSessions,
+        getSession,
+        writeMemory,
+        bash: bashTool,
+        read_file: readFileTool,
+    };
+}
+//# sourceMappingURL=memory-agent-tools.js.map

package/dist/core/src/env/memory/types.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+/**
+ * Memory 来源类型
+ * - project: 项目级记忆
+ * - global: 全局记忆
+ */
+export type MemorySource = "project" | "global";
+/**
+ * Memory 路径配置
+ */
+export interface MemoryPath {
+    /** 来源类型 */
+    type: MemorySource;
+    /** 绝对路径 */
+    path: string;
+}
+/**
+ * MemoryComponent 配置
+ */
+export interface MemoryConfig {
+    /** 多路径配置 */
+    memoryPaths: MemoryPath[];
+    /** 是否递归扫描子目录 */
+    recursive: boolean;
+    /** 是否启用缓存 */
+    cacheEnabled: boolean;
+    /** 缓存有效期（毫秒） */
+    cacheTTL?: number;
+    /** 记忆文件名 */
+    memoryFile?: string;
+}
+/**
+ * record_memory 操作模式
+ */
+export type RecordMemoryMode = "append" | "prepend" | "overwrite" | "delete";
+/**
+ * record_memory 操作结果
+ */
+export interface RecordMemoryResult {
+    /** 文件路径 */
+    path: string;
+    /** 操作类型 */
+    action: "created" | "append" | "prepend" | "overwrite" | "delete";
+}
+/**
+ * record_memory 工具参数
+ */
+export declare const RecordMemorySchema: z.ZodObject<{
+    /** 作用域 (必填) */
+    scope: z.ZodEnum<["project", "global"]>;
+    /** 操作模式 */
+    mode: z.ZodEnum<["append", "prepend", "overwrite", "delete"]>;
+    /** 记忆内容 (delete 模式不需要) */
+    content: z.ZodOptional<z.ZodString>;
+    /** 章节标题 (可选，用于生成 ## title 章节) */
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content?: string;
+    title?: string;
+    mode?: "delete" | "append" | "prepend" | "overwrite";
+    scope?: "project" | "global";
+}, {
+    content?: string;
+    title?: string;
+    mode?: "delete" | "append" | "prepend" | "overwrite";
+    scope?: "project" | "global";
+}>;
+export type RecordMemoryParams = z.infer<typeof RecordMemorySchema>;
+/**
+ * recall_memory 工具参数
+ */
+export declare const RecallMemorySchema: z.ZodObject<{
+    /** 作用域 (可选，不传则读取所有 scope) */
+    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
+}, "strip", z.ZodTypeAny, {
+    scope?: "project" | "global";
+}, {
+    scope?: "project" | "global";
+}>;
+export type RecallMemoryParams = z.infer<typeof RecallMemorySchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/src/env/memory/types.js

@@ -0,0 +1,25 @@
+// packages/core/src/env/memory/types.ts
+import { z } from "zod";
+// ==================== Tool 参数 Schema ====================
+/**
+ * record_memory 工具参数
+ */
+export const RecordMemorySchema = z.object({
+    /** 作用域 (必填) */
+    scope: z.enum(["project", "global"]).describe("作用域: project/global"),
+    /** 操作模式 */
+    mode: z.enum(["append", "prepend", "overwrite", "delete"])
+        .describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
+    /** 记忆内容 (delete 模式不需要) */
+    content: z.string().optional().describe("记忆内容"),
+    /** 章节标题 (可选，用于生成 ## title 章节) */
+    title: z.string().optional().describe("章节标题"),
+});
+/**
+ * recall_memory 工具参数
+ */
+export const RecallMemorySchema = z.object({
+    /** 作用域 (可选，不传则读取所有 scope) */
+    scope: z.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）"),
+});
+//# sourceMappingURL=types.js.map

package/dist/core/src/env/paths.d.ts

@@ -0,0 +1,47 @@
+/**
+ * XDG 基础目录类型
+ */
+export type XDGDirType = "config" | "state" | "data" | "cache";
+/**
+ * XDG 路径接口
+ */
+export interface XDGPaths {
+    home: string;
+    config: string;
+    state: string;
+    data: string;
+    cache: string;
+}
+/**
+ * XDG 路径计算器（惰性计算）
+ */
+declare class XDGPathsCalculator {
+    private _paths?;
+    get paths(): XDGPaths;
+    /**
+     * 获取特定类型的路径
+     */
+    getPath(type: XDGDirType): string;
+    /**
+     * 计算 Component 的绝对路径
+     */
+    getComponentPath(base: XDGDirType, subPath: string): string;
+    /**
+     * 强制重新计算路径（用于测试或配置变更）
+     */
+    reset(): void;
+}
+/**
+ * 全局 XDG 路径实例
+ */
+export declare const XDG_PATHS: XDGPathsCalculator;
+/**
+ * 获取 XDG 路径
+ */
+export declare function getXDGPaths(): XDGPaths;
+/**
+ * 获取特定类型的 XDG 路径
+ */
+export declare function getXDGPath(type: XDGDirType): string;
+export {};
+//# sourceMappingURL=paths.d.ts.map

package/dist/core/src/env/paths.js

@@ -0,0 +1,91 @@
+import os from "os";
+import path from "path";
+/**
+ * APP 名称
+ */
+const APP_NAME = "roy-agent";
+/**
+ * 获取 XDG 基础路径
+ */
+function getXdgBase() {
+    const home = os.homedir();
+    // 尝试使用 xdg-basedir，失败则使用默认路径
+    try {
+        const xdg = require("xdg-basedir");
+        return {
+            config: xdg.xdgConfig || path.join(home, ".config"),
+            state: xdg.xdgState || path.join(home, ".local", "state"),
+            data: xdg.xdgData || path.join(home, ".local", "share"),
+            cache: xdg.xdgCache || path.join(home, ".cache"),
+        };
+    }
+    catch {
+        return {
+            config: path.join(home, ".config"),
+            state: path.join(home, ".local", "state"),
+            data: path.join(home, ".local", "share"),
+            cache: path.join(home, ".cache"),
+        };
+    }
+}
+/**
+ * 计算 XDG 路径
+ */
+function computeXDGPaths() {
+    const home = os.homedir();
+    const xdg = getXdgBase();
+    return {
+        home,
+        config: path.join(xdg.config, APP_NAME),
+        state: path.join(xdg.state, APP_NAME),
+        data: path.join(xdg.data, APP_NAME),
+        cache: path.join(xdg.cache, APP_NAME),
+    };
+}
+/**
+ * XDG 路径计算器（惰性计算）
+ */
+class XDGPathsCalculator {
+    _paths;
+    get paths() {
+        if (!this._paths) {
+            this._paths = computeXDGPaths();
+        }
+        return this._paths;
+    }
+    /**
+     * 获取特定类型的路径
+     */
+    getPath(type) {
+        return this.paths[type];
+    }
+    /**
+     * 计算 Component 的绝对路径
+     */
+    getComponentPath(base, subPath) {
+        return path.join(this.paths[base], subPath);
+    }
+    /**
+     * 强制重新计算路径（用于测试或配置变更）
+     */
+    reset() {
+        this._paths = undefined;
+    }
+}
+/**
+ * 全局 XDG 路径实例
+ */
+export const XDG_PATHS = new XDGPathsCalculator();
+/**
+ * 获取 XDG 路径
+ */
+export function getXDGPaths() {
+    return XDG_PATHS.paths;
+}
+/**
+ * 获取特定类型的 XDG 路径
+ */
+export function getXDGPath(type) {
+    return XDG_PATHS.getPath(type);
+}
+//# sourceMappingURL=paths.js.map