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

package/dist/core/src/env/mcp/types.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect } from "vitest";
+import { McpServerLocalConfigSchema, McpServerRemoteConfigSchema, McpServerConfigSchema, } from "./types.js";
+/**
+ * TDD: 验证 MCP 类型定义
+ */
+describe("McpServerLocalConfigSchema", () => {
+    it("should validate valid local server config", () => {
+        const localConfig = {
+            type: "local",
+            command: ["bun", "run", "server.ts"],
+        };
+        const result = McpServerLocalConfigSchema.safeParse(localConfig);
+        expect(result.success).toBe(true);
+    });
+    it("should accept optional fields", () => {
+        const localConfig = {
+            type: "local",
+            command: ["bun", "run", "server.ts"],
+            environment: { NODE_ENV: "production" },
+            enabled: true,
+            timeout: 60000,
+        };
+        const result = McpServerLocalConfigSchema.safeParse(localConfig);
+        expect(result.success).toBe(true);
+    });
+    it("should reject empty command", () => {
+        const localConfig = {
+            type: "local",
+            command: [],
+        };
+        const result = McpServerLocalConfigSchema.safeParse(localConfig);
+        expect(result.success).toBe(false);
+    });
+    it("should reject wrong type", () => {
+        const localConfig = {
+            type: "remote",
+            command: ["bun", "run", "server.ts"],
+        };
+        const result = McpServerLocalConfigSchema.safeParse(localConfig);
+        expect(result.success).toBe(false);
+    });
+});
+describe("McpServerRemoteConfigSchema", () => {
+    it("should validate valid remote server config", () => {
+        const remoteConfig = {
+            type: "remote",
+            url: "https://mcp.example.com",
+        };
+        const result = McpServerRemoteConfigSchema.safeParse(remoteConfig);
+        expect(result.success).toBe(true);
+    });
+    it("should accept optional headers", () => {
+        const remoteConfig = {
+            type: "remote",
+            url: "https://mcp.example.com",
+            headers: { Authorization: "Bearer token" },
+        };
+        const result = McpServerRemoteConfigSchema.safeParse(remoteConfig);
+        expect(result.success).toBe(true);
+    });
+    it("should reject invalid url", () => {
+        const remoteConfig = {
+            type: "remote",
+            url: "not-a-url",
+        };
+        const result = McpServerRemoteConfigSchema.safeParse(remoteConfig);
+        expect(result.success).toBe(false);
+    });
+});
+describe("McpServerConfigSchema", () => {
+    it("should validate local config", () => {
+        const config = {
+            type: "local",
+            command: ["bun", "run", "server.ts"],
+        };
+        const result = McpServerConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+    });
+    it("should validate remote config", () => {
+        const config = {
+            type: "remote",
+            url: "https://mcp.example.com",
+        };
+        const result = McpServerConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+    });
+    it("should reject invalid discriminated union", () => {
+        const config = {
+            type: "invalid",
+        };
+        const result = McpServerConfigSchema.safeParse(config);
+        expect(result.success).toBe(false);
+    });
+});
+describe("DiscoveredMcpServer", () => {
+    it("should have required name field", () => {
+        const server = {
+            name: "test-mcp",
+        };
+        expect(server.name).toBe("test-mcp");
+        expect(server.entryPath).toBeUndefined();
+    });
+    it("should allow optional fields", () => {
+        const server = {
+            name: "test-mcp",
+            entryPath: "/path/to/server.ts",
+            configPath: "/path/to/config.jsonc",
+            packagePath: "/path/to/package.json",
+            directoryConfig: { enabled: true },
+        };
+        expect(server.entryPath).toBe("/path/to/server.ts");
+        expect(server.directoryConfig?.enabled).toBe(true);
+    });
+});
+describe("McpServerStatus", () => {
+    it("should have required fields", () => {
+        const status = {
+            name: "test-server",
+            status: "connected",
+        };
+        expect(status.name).toBe("test-server");
+        expect(status.status).toBe("connected");
+    });
+    it("should allow optional fields", () => {
+        const status = {
+            name: "test-server",
+            status: "error",
+            error: "Connection failed",
+            toolsCount: 5,
+        };
+        expect(status.status).toBe("error");
+        expect(status.error).toBe("Connection failed");
+        expect(status.toolsCount).toBe(5);
+    });
+});
+//# sourceMappingURL=types.test.js.map

package/dist/core/src/env/memory/built-in/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Memory Built-in Tools Index
+ *
+ * 简化的记忆工具导出
+ *
+ * 只暴露两个工具：
+ * - record_memory: 统一的记忆写入工具
+ * - recall_memory: 统一的记忆读取工具
+ */
+import type { Tool } from "../../tool/types";
+import type { MemoryPath, RecordMemoryResult } from "../types";
+/**
+ * record_memory 工具操作接口
+ */
+export interface RecordMemoryOperations {
+    (args: {
+        scope: "project" | "global";
+        mode: "append" | "prepend" | "overwrite" | "delete";
+        content?: string;
+        title?: string;
+    }): Promise<RecordMemoryResult | null>;
+}
+/**
+ * recall_memory 工具操作接口
+ */
+export interface RecallMemoryOperations {
+    (scope?: "project" | "global"): Promise<string>;
+}
+/**
+ * MemoryToolConfig
+ */
+export interface MemoryToolConfig {
+    getMemoryPaths: () => MemoryPath[];
+    getMemoryFile: () => string;
+}
+/**
+ * 创建所有记忆工具
+ */
+export declare function createMemoryTools(recordMemory: RecordMemoryOperations, recallMemory: RecallMemoryOperations, config: MemoryToolConfig): Tool[];
+export { RecordMemorySchema, type RecordMemoryParams } from "./record-memory";
+export { RecallMemorySchema, type RecallMemoryParams } from "./recall-memory";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/memory/built-in/index.js

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Memory Built-in Tools Index
+ *
+ * 简化的记忆工具导出
+ *
+ * 只暴露两个工具：
+ * - record_memory: 统一的记忆写入工具
+ * - recall_memory: 统一的记忆读取工具
+ */
+import { createRecordMemoryTool } from "./record-memory.js";
+import { createRecallMemoryTool } from "./recall-memory.js";
+/**
+ * 创建所有记忆工具
+ */
+export function createMemoryTools(recordMemory, recallMemory, config) {
+    return [
+        createRecordMemoryTool(recordMemory, config.getMemoryPaths, config.getMemoryFile),
+        createRecallMemoryTool(recallMemory, config.getMemoryPaths, config.getMemoryFile),
+    ];
+}
+// Re-export schemas for external use
+export { RecordMemorySchema } from "./record-memory.js";
+export { RecallMemorySchema } from "./recall-memory.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview recall_memory Tool
+ *
+ * 统一的记忆读取工具
+ */
+import type { Tool } from "../../tool/types";
+import { z } from "zod";
+import type { MemoryPath } from "../types";
+/**
+ * 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>;
+export interface RecallMemoryOptions {
+    scope?: "project" | "global";
+}
+/**
+ * 创建 recall_memory 工具
+ */
+export declare function createRecallMemoryTool(recallMemory: (scope?: "project" | "global") => Promise<string>, getMemoryPaths: () => MemoryPath[], getMemoryFile: () => string): Tool;
+export { RecallMemorySchema as UnifiedRecallMemorySchema };
+export type { RecallMemoryParams as UnifiedRecallMemoryParams };
+//# sourceMappingURL=recall-memory.d.ts.map

package/dist/core/src/env/memory/built-in/recall-memory.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview recall_memory Tool
+ *
+ * 统一的记忆读取工具
+ */
+import { z } from "zod";
+/**
+ * recall_memory 工具参数
+ */
+export const RecallMemorySchema = z.object({
+    /** 作用域 (可选，不传则读取所有 scope) */
+    scope: z.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）"),
+});
+/**
+ * 创建 recall_memory 工具
+ */
+export function createRecallMemoryTool(recallMemory, getMemoryPaths, getMemoryFile) {
+    return {
+        name: "recall_memory",
+        description: buildDescription(getMemoryPaths, getMemoryFile),
+        parameters: RecallMemorySchema,
+        execute: async (args, _ctx) => {
+            const params = RecallMemorySchema.parse(args);
+            const startTime = Date.now();
+            try {
+                const content = await recallMemory(params.scope);
+                if (!content) {
+                    return {
+                        success: true,
+                        output: "(No memory files found)",
+                        metadata: { execution_time_ms: Date.now() - startTime },
+                    };
+                }
+                return {
+                    success: true,
+                    output: content,
+                    metadata: { execution_time_ms: Date.now() - startTime },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: Date.now() - startTime },
+                };
+            }
+        },
+    };
+}
+function buildDescription(getMemoryPaths, getMemoryFile) {
+    const paths = getMemoryPaths();
+    const memoryFile = getMemoryFile();
+    const lines = [
+        `# Recall Memory Tool`,
+        "",
+        `Recall memory from memory files. Reads from the memory.md file in the specified scope.`,
+        "",
+        `## Parameters`,
+        "",
+        "- **scope** (optional): 作用域 - project 或 global（不传则读取所有）",
+        "",
+        `## Memory Files`,
+        "",
+    ];
+    if (paths.length === 0) {
+        lines.push("No memory paths configured.");
+    }
+    else {
+        lines.push("Files will be read from:");
+        for (const p of paths) {
+            lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+        }
+    }
+    return lines.join("\n");
+}
+// Re-export for external use
+export { RecallMemorySchema as UnifiedRecallMemorySchema };
+//# sourceMappingURL=recall-memory.js.map

package/dist/core/src/env/memory/built-in/record-memory.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview record_memory Tool
+ *
+ * 统一的记忆记录工具
+ */
+import type { Tool } from "../../tool/types";
+import { z } from "zod";
+import type { MemoryPath, RecordMemoryResult } from "../types";
+/**
+ * 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>;
+export interface RecordMemoryOptions {
+    scope: "project" | "global";
+    mode: "append" | "prepend" | "overwrite" | "delete";
+    content?: string;
+    title?: string;
+}
+/**
+ * 创建 record_memory 工具
+ */
+export declare function createRecordMemoryTool(recordMemory: (args: RecordMemoryOptions) => Promise<RecordMemoryResult | null>, getMemoryPaths: () => MemoryPath[], getMemoryFile: () => string): Tool;
+export { RecordMemorySchema as UnifiedRecordMemorySchema };
+export type { RecordMemoryParams as UnifiedRecordMemoryParams };
+//# sourceMappingURL=record-memory.d.ts.map

package/dist/core/src/env/memory/built-in/record-memory.js

@@ -0,0 +1,111 @@
+// packages/core/src/env/memory/built-in/record-memory.ts
+import { z } from "zod";
+/**
+ * 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("章节标题"),
+});
+/**
+ * 创建 record_memory 工具
+ */
+export function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
+    return {
+        name: "record_memory",
+        description: buildDescription(getMemoryPaths, getMemoryFile),
+        parameters: RecordMemorySchema,
+        execute: async (args, _ctx) => {
+            const params = RecordMemorySchema.parse(args);
+            const startTime = Date.now();
+            try {
+                const result = await recordMemory({
+                    scope: params.scope,
+                    mode: params.mode,
+                    content: params.content,
+                    title: params.title,
+                });
+                if (!result) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: "未配置 memory 路径，无法记录记忆",
+                        metadata: { execution_time_ms: Date.now() - startTime },
+                    };
+                }
+                const actionMessages = {
+                    created: "已创建记忆文件",
+                    overwrite: "已覆盖记忆文件",
+                    append: "已追加内容到记忆文件",
+                    prepend: "已插入内容到记忆文件开头",
+                    delete: "已删除记忆文件",
+                };
+                return {
+                    success: true,
+                    output: `${actionMessages[result.action]}: ${result.path}`,
+                    metadata: {
+                        execution_time_ms: Date.now() - startTime,
+                        path: result.path,
+                        action: result.action,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: Date.now() - startTime },
+                };
+            }
+        },
+    };
+}
+function buildDescription(getMemoryPaths, getMemoryFile) {
+    const paths = getMemoryPaths();
+    const memoryFile = getMemoryFile();
+    const lines = [
+        `# Record Memory Tool`,
+        "",
+        `Record memory to file. Writes to the memory.md file in the specified scope.`,
+        "",
+        `## Modes`,
+        "",
+        "| Mode | Description |",
+        "|------|-------------|",
+        "| **append** | 追加内容到 ${memoryFile} 尾部 |",
+        "| **prepend** | 插入内容到 ${memoryFile} 开头 |",
+        "| **overwrite** | 覆盖 ${memoryFile} |",
+        "| **delete** | 删除 ${memoryFile} |",
+        "",
+        `## Parameters`,
+        "",
+        "- **scope** (required): 作用域 - project 或 global",
+        "- **mode** (required): 操作模式",
+        "- **content** (optional): 记忆内容",
+        "- **title** (optional): 章节标题",
+        "",
+        `## Memory Paths`,
+        "",
+    ];
+    if (paths.length === 0) {
+        lines.push("No memory paths configured.");
+    }
+    else {
+        lines.push("Files will be written to:");
+        for (const p of paths) {
+            lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+        }
+    }
+    return lines.join("\n");
+}
+// Re-export for external use
+export { RecordMemorySchema as UnifiedRecordMemorySchema };
+//# sourceMappingURL=record-memory.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Memory Component Index
+ *
+ * 导出 Memory 组件及相关类型
+ */
+export * from "./types";
+export { DEFAULT_MEMORY_CONFIG, SOURCE_PRIORITY, getSourcePriority } from "./memory-config";
+export { MemoryComponent, type MemoryComponentOptions } from "./memory-component";
+export { RecordMemorySchema, RecallMemorySchema } from "./built-in";
+export * from "./plugin";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Memory Component Index
+ *
+ * 导出 Memory 组件及相关类型
+ */
+// Types - only export from one place to avoid duplicates
+export * from "./types.js";
+// Config
+export { DEFAULT_MEMORY_CONFIG, SOURCE_PRIORITY, getSourcePriority } from "./memory-config.js";
+// Component
+export { MemoryComponent } from "./memory-component.js";
+// Built-in Tools - export only schemas to avoid type conflicts
+export { RecordMemorySchema, RecallMemorySchema } from "./built-in/index.js";
+// Memory Plugin (for --plugin memory)
+export * from "./plugin/index.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview MemoryComponent - Simplified
+ *
+ * 记忆管理核心组件
+ *
+ * 简化设计：
+ * - 移除 DraftManager、MemoryOrganizer、AccessLog 依赖
+ * - 只保留核心的 memory 文件操作
+ * - 提供 recallMemory(scope) 方法支持 project/global scope
+ */
+import { BaseComponent, type ComponentConfig } from "../component";
+import type { MemoryConfig, MemoryPath, RecordMemoryMode, RecordMemoryResult } from "./types";
+import type { ConfigComponent } from "../../config/config-component";
+/**
+ * MemoryComponent 配置选项（通过 options 传递）
+ */
+export interface MemoryComponentOptions {
+    /** ConfigComponent 实例（必填） */
+    configComponent: ConfigComponent;
+    /** 配置文件相对路径（可选，基于 XDG_DATA_HOME） */
+    configPath?: string;
+    /** 环境变量前缀（可选，默认 "MEMORY"） */
+    envPrefix?: string;
+    /** 直接传入的配置对象（可选，优先级最高） */
+    config?: Partial<MemoryConfig>;
+}
+/**
+ * MemoryComponent - Simplified
+ *
+ * 简化的记忆管理组件，只负责：
+ * - 管理本地文件系统记忆存储
+ * - 注册记忆操作工具
+ * - 提供目录扫描和缓存
+ *
+ * 复杂功能已移除：
+ * - DraftManager（草稿管理）
+ * - MemoryOrganizer（记忆整理）
+ * - AccessLog（访问日志）
+ */
+export declare class MemoryComponent extends BaseComponent {
+    name: string;
+    version: string;
+    private config;
+    private toolComponent?;
+    private configComponent?;
+    private cache;
+    /** 配置变更 watcher 清理函数 */
+    private configWatcher?;
+    init(config?: ComponentConfig): Promise<void>;
+    /**
+     * 注册配置到 ConfigComponent
+     */
+    private registerConfig;
+    /**
+     * 构建最终配置对象
+     */
+    private buildConfig;
+    /**
+     * 将配置对象展平为点号路径
+     */
+    private flattenConfig;
+    /**
+     * 注册配置热更新监听
+     */
+    private registerConfigWatcher;
+    /**
+     * 处理配置变更
+     */
+    protected onConfigChange(event: {
+        key: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+    }): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private registerTools;
+    /**
+     * 获取所有配置的 memory 路径
+     */
+    getMemoryPaths(): MemoryPath[];
+    /**
+     * 更新 memory paths
+     */
+    updateMemoryPaths(paths: MemoryPath[]): void;
+    /**
+     * 获取记忆文件名
+     */
+    getMemoryFile(): string;
+    /**
+     * 记录记忆
+     *
+     * @param args.mode 操作模式
+     * @param args.content 记忆内容
+     * @param args.title 标题
+     * @param args.filename 文件名
+     * @param args.scope 作用域 (project/global)，用于选择正确的 memory path
+     */
+    recordMemory(args: {
+        mode: RecordMemoryMode;
+        content?: string;
+        title?: string;
+        filename?: string;
+        scope?: "project" | "global";
+    }): Promise<RecordMemoryResult | null>;
+    /**
+     * 回忆记忆 - 读取所有记忆文件内容
+     *
+     * @param scope 可选：project 或 global，默认读取所有
+     */
+    recallMemory(scope?: "project" | "global"): Promise<string>;
+    private clearCache;
+    private getCache;
+    private setCache;
+}
+//# sourceMappingURL=memory-component.d.ts.map