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

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

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

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

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

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

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

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

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

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

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