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

package/dist/cli/src/commands/memory/index.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Memory Commands Index - Simplified
+ *
+ * 导出所有 memory 子命令
+ *
+ * Simplified 设计：只保留 record 和 recall 两个核心命令
+ */
+export { MemoryCommand } from "./memory.js";
+export { RecordCommand } from "./record.js";
+export { RecallCommand } from "./recall.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/memory/memory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Memory Command - Simplified
+ *
+ * 命令：roy memory
+ *
+ * Simplified 设计：只保留 record 和 recall 命令
+ */
+import { CommandModule } from "yargs";
+export declare const MemoryCommand: CommandModule;
+//# sourceMappingURL=memory.d.ts.map

package/dist/cli/src/commands/memory/memory.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Memory Command - Simplified
+ *
+ * 命令：roy memory
+ *
+ * Simplified 设计：只保留 record 和 recall 命令
+ */
+import { RecordCommand } from "./record.js";
+import { RecallCommand } from "./recall.js";
+export const MemoryCommand = {
+    command: "memory",
+    describe: "管理记忆文件 (record, recall)",
+    builder: (yargs) => yargs
+        .command(RecordCommand)
+        .command(RecallCommand)
+        .demandCommand(1, "请指定子命令。可用子命令: record, recall"),
+    handler: () => {
+        // 默认显示帮助
+    },
+};
+//# sourceMappingURL=memory.js.map

package/dist/cli/src/commands/memory/organize.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Memory Organize Command
+ *
+ * Manual trigger for memory organization
+ *
+ * Usage:
+ *   roy memory organize
+ *   roy memory organize --scope project
+ *   roy memory organize --scope global
+ *   roy memory organize --scope all
+ *   roy memory organize --since 2026-04-01
+ *   roy memory organize --session <session-id>
+ *   roy memory organize --list-sessions
+ */
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import type { SessionComponent, AgentComponent, MemoryPlugin as IMemoryPlugin } from "@ai-setting/roy-agent-core";
+/**
+ * OrganizeContext - 用于依赖注入的上下文
+ */
+export interface OrganizeContext {
+    envService: EnvironmentService;
+    sessionComponent: SessionComponent | null;
+    agentComponent: AgentComponent | null;
+    memoryPlugin?: IMemoryPlugin;
+}
+/**
+ * 创建 OrganizeContext
+ */
+export declare function createOrganizeContext(envService: EnvironmentService): OrganizeContext;
+/**
+ * 准备 MemoryPlugin
+ *
+ * @param workDir 工作目录
+ * @param agentComponent AgentComponent（可选，用于 AI 记忆整理）
+ */
+export declare function prepareMemoryPlugin(workDir: string, agentComponent?: AgentComponent): Promise<IMemoryPlugin>;
+/**
+ * 清理资源
+ */
+export declare function cleanupOrganizeResources(ctx: OrganizeContext, memoryPlugin?: IMemoryPlugin): void;
+export declare const OrganizeCommand: CommandModule;
+/**
+ * 列出所有会话
+ */
+export declare function listSessions(sessionComponent: SessionComponent | null, output: OutputService): Promise<void>;
+//# sourceMappingURL=organize.d.ts.map

package/dist/cli/src/commands/memory/organize.js

@@ -0,0 +1,233 @@
+/**
+ * @fileoverview Memory Organize Command
+ *
+ * Manual trigger for memory organization
+ *
+ * Usage:
+ *   roy memory organize
+ *   roy memory organize --scope project
+ *   roy memory organize --scope global
+ *   roy memory organize --scope all
+ *   roy memory organize --since 2026-04-01
+ *   roy memory organize --session <session-id>
+ *   roy memory organize --list-sessions
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+/**
+ * 创建 OrganizeContext
+ */
+export function createOrganizeContext(envService) {
+    return {
+        envService,
+        sessionComponent: envService.getSession(),
+        agentComponent: envService.getAgent(),
+    };
+}
+/**
+ * 准备 MemoryPlugin
+ *
+ * @param workDir 工作目录
+ * @param agentComponent AgentComponent（可选，用于 AI 记忆整理）
+ */
+export async function prepareMemoryPlugin(workDir, agentComponent) {
+    // 动态导入 MemoryPlugin
+    const { MemoryPlugin } = await import("@ai-setting/roy-agent-core");
+    // 设置全局注册表（供 MemoryPlugin 初始化时获取组件）
+    const globalRegistry = globalThis.__royAgentRegistry || {};
+    // 保留现有的 sessionComponent（如果有）
+    if (!globalRegistry.sessionComponent) {
+        // 从 EnvironmentService 获取（如果可用）
+        // 注意：在 CLI 模式下，sessionComponent 由调用方通过 ctx 传递
+    }
+    globalRegistry.agentComponent = agentComponent;
+    globalThis.__royAgentRegistry = globalRegistry;
+    // 创建 MemoryPlugin
+    const memoryPlugin = new MemoryPlugin(workDir, {
+        enabled: true,
+    });
+    await memoryPlugin.initialize();
+    // 额外注册 AgentComponent（双保险，确保 MemoryPlugin 能使用 AI）
+    if (agentComponent) {
+        memoryPlugin.registerAgentComponent(agentComponent);
+    }
+    return memoryPlugin;
+}
+/**
+ * 清理资源
+ */
+export function cleanupOrganizeResources(ctx, memoryPlugin) {
+    // 清理全局注册表
+    delete globalThis.__royAgentRegistry;
+    // MemoryPlugin 清理由调用方负责
+    ctx.memoryPlugin = memoryPlugin;
+}
+export const OrganizeCommand = {
+    command: "organize [options]",
+    describe: "手动触发记忆整理",
+    builder: (yargs) => yargs
+        .option("scope", {
+        alias: "s",
+        description: "整理范围: project, global, all (默认: all)",
+        type: "string",
+        choices: ["project", "global", "all"],
+        default: "all",
+    })
+        .option("since", {
+        alias: "t",
+        description: "整理指定时间以来的记忆 (ISO 日期或 Unix 时间戳)",
+        type: "string",
+    })
+        .option("session", {
+        alias: "S",
+        description: "整理指定会话的记忆",
+        type: "string",
+    })
+        .option("list-sessions", {
+        alias: "l",
+        description: "列出可用的会话",
+        type: "boolean",
+        default: false,
+    })
+        .example("roy memory organize", "整理所有记忆")
+        .example("roy memory organize --scope project", "只整理项目记忆")
+        .example("roy memory organize --scope global", "只整理全局记忆")
+        .example("roy memory organize --since 2026-04-01", "整理指定时间以来的记忆")
+        .example("roy memory organize --list-sessions", "列出所有会话")
+        .example("roy memory organize --session abc123", "整理指定会话的记忆"),
+    async handler(argv) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        let memoryPlugin;
+        try {
+            await envService.create();
+            const ctx = createOrganizeContext(envService);
+            const sessionComponent = ctx.sessionComponent;
+            // 处理 --list-sessions 选项
+            if (argv.listSessions) {
+                await listSessions(sessionComponent, output);
+                return;
+            }
+            const options = argv;
+            output.log(chalk.bold("\n📋 记忆整理\n"));
+            // 如果指定了 session，获取该 session 的消息并显示预览
+            if (options.session) {
+                output.log(chalk.gray(`📂 会话: ${options.session}`));
+                const messages = await getSessionMessages(sessionComponent, options.session);
+                if (messages.length === 0) {
+                    output.error(`会话不存在或没有消息: ${options.session}`);
+                    process.exit(1);
+                }
+                output.log(chalk.gray(`📝 共 ${messages.length} 条消息\n`));
+                // 显示消息预览
+                output.log(chalk.gray("📄 消息摘要预览:"));
+                for (let i = 0; i < Math.min(3, messages.length); i++) {
+                    const msg = messages[i];
+                    const content = typeof msg.content === "string"
+                        ? msg.content.substring(0, 100) + "..."
+                        : JSON.stringify(msg.content).substring(0, 100) + "...";
+                    output.log(chalk.gray(`  [${msg.role}] ${content}`));
+                }
+                output.log("");
+            }
+            else {
+                output.log(chalk.gray("💡 提示: 使用 --session 指定会话来整理对话记忆\n"));
+            }
+            output.log(chalk.gray(`🎯 整理范围: ${options.scope || "all"}\n`));
+            // 获取 AgentComponent
+            if (!ctx.agentComponent) {
+                output.error("AgentComponent not available, cannot organize memory with AI");
+                process.exit(1);
+            }
+            // 准备 MemoryPlugin（包含注册 AgentComponent）
+            memoryPlugin = await prepareMemoryPlugin(process.cwd(), ctx.agentComponent);
+            // 解析 since 时间戳
+            let sinceTimestamp;
+            if (options.since) {
+                const date = new Date(options.since);
+                if (!isNaN(date.getTime())) {
+                    sinceTimestamp = date.getTime();
+                }
+            }
+            // 调用 organize
+            output.log(chalk.gray("⏳ 正在整理记忆...\n"));
+            await memoryPlugin.organize({
+                scope: options.scope || "all",
+                sessionId: options.session,
+                since: sinceTimestamp,
+            });
+            output.success("\n✅ 记忆整理完成");
+            output.log(chalk.gray("\n提示: 使用 `roy memory recall` 查看整理后的记忆"));
+        }
+        catch (error) {
+            output.error(`整理记忆失败: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            // 清理 MemoryPlugin
+            if (memoryPlugin) {
+                await memoryPlugin.dispose();
+            }
+            // 清理全局注册表
+            cleanupOrganizeResources(createOrganizeContext(envService), memoryPlugin);
+            // 清理 EnvironmentService
+            await envService.dispose();
+        }
+    },
+};
+/**
+ * 获取指定 session 的消息
+ */
+async function getSessionMessages(sessionComponent, sessionId) {
+    if (!sessionComponent) {
+        return [];
+    }
+    try {
+        const session = await sessionComponent.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        // 获取消息，默认获取最近 100 条
+        const messages = await sessionComponent.getMessages(sessionId, { limit: 100 });
+        // 过滤掉 tool 相关消息，只保留 user 和 assistant
+        return messages
+            .filter((msg) => msg.role === "user" || msg.role === "assistant")
+            .map((msg) => ({
+            role: msg.role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        }));
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * 列出所有会话
+ */
+export async function listSessions(sessionComponent, output) {
+    if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        return;
+    }
+    try {
+        const sessions = await sessionComponent.list({ limit: 20 });
+        if (sessions.length === 0) {
+            output.log(chalk.gray("暂无会话"));
+            return;
+        }
+        output.log(chalk.bold(`\n📂 会话列表 (最近 20 个)\n\n`));
+        for (const session of sessions) {
+            const date = new Date(session.createdAt).toLocaleDateString("zh-CN");
+            const time = new Date(session.createdAt).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
+            output.log(chalk.cyan(`ID: ${session.id}`));
+            output.log(`  标题: ${session.title || "无标题"}`);
+            output.log(`  创建: ${date} ${time}`);
+            output.log("");
+        }
+    }
+    catch (error) {
+        output.error(`列出会话失败: ${error}`);
+    }
+}
+//# sourceMappingURL=organize.js.map

package/dist/cli/src/commands/memory/recall.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Memory Recall Command
+ *
+ * 命令：roy memory recall
+ *
+ * 读取所有 memory file 的内容
+ */
+import { CommandModule } from "yargs";
+export declare const RecallCommand: CommandModule<object, object>;
+//# sourceMappingURL=recall.d.ts.map

package/dist/cli/src/commands/memory/recall.js

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Memory Recall Command
+ *
+ * 命令：roy memory recall
+ *
+ * 读取所有 memory file 的内容
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const RecallCommand = {
+    command: "recall",
+    aliases: ["load"],
+    describe: "读取所有 memory file 的内容",
+    builder: (yargs) => yargs
+        .option("config", {
+        type: "string",
+        describe: "Config file path",
+    })
+        .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 格式输出",
+    })
+        .option("scope", {
+        type: "string",
+        choices: ["project", "global"],
+        describe: "记忆作用域 (可选，不传则读取所有)",
+    }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const memoryComponent = env.getComponent("memory");
+            if (!memoryComponent) {
+                output.error("MemoryComponent not available");
+                process.exit(1);
+            }
+            // 读取记忆
+            const content = await memoryComponent.recallMemory(a.scope);
+            if (!content) {
+                output.log(chalk.gray("(No memory files found)"));
+                return;
+            }
+            if (a.json) {
+                output.json({ content });
+                return;
+            }
+            // 直接输出 markdown 内容（处理转义字符）
+            output.log(content.replace(/\\n/g, "\n"));
+        }
+        catch (error) {
+            output.error(`Failed to recall memory: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=recall.js.map

package/dist/cli/src/commands/memory/record.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Memory Record Command
+ *
+ * 命令：roy memory record
+ *
+ * 将记忆内容记录到 memory file
+ * 支持 --extract 模式：从会话历史中提取记忆并保存
+ */
+import { CommandModule } from "yargs";
+export declare const RecordCommand: CommandModule<object, object>;
+//# sourceMappingURL=record.d.ts.map

package/dist/cli/src/commands/memory/record.js

@@ -0,0 +1,268 @@
+/**
+ * @fileoverview Memory Record Command
+ *
+ * 命令：roy memory record
+ *
+ * 将记忆内容记录到 memory file
+ * 支持 --extract 模式：从会话历史中提取记忆并保存
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+import { createMemoryAgentTools, getBuiltInPrompt } from "@ai-setting/roy-agent-core";
+import { bashTool, globTool, readFileTool } from "@ai-setting/roy-agent-core";
+/**
+ * Memory Agent 提取模式 - 从会话历史生成记忆
+ */
+async function runExtractMode(output, memoryComponent, agentComponent, sessionComponent, env, options) {
+    const { scope, sessionId, require: userRequirement } = options;
+    output.log(chalk.blue(`\n🔍 Memory Extract Mode (${scope})`));
+    output.log(chalk.gray("正在分析会话历史，生成记忆...\n"));
+    try {
+        // 1. 获取当前 memory
+        const currentMemory = await memoryComponent.recallMemory(scope) || "(无现有记忆)";
+        // 2. 获取 prompt（通过 PromptComponent 或 fallback 到 getBuiltInPrompt）
+        const promptName = scope === "project" ? "project-memory" : "global-memory";
+        let promptTemplate;
+        try {
+            const promptComponent = env?.getComponent?.("prompt");
+            if (promptComponent) {
+                promptTemplate = await promptComponent.getPrompt(promptName);
+            }
+        }
+        catch (err) {
+            // PromptComponent 不可用或获取失败，fallback 到 getBuiltInPrompt
+        }
+        // Fallback：如果 PromptComponent 不可用或未找到，使用 getBuiltInPrompt
+        if (!promptTemplate) {
+            promptTemplate = getBuiltInPrompt(promptName);
+        }
+        if (!promptTemplate) {
+            output.error(`Prompt not found for scope: ${scope}`);
+            process.exit(1);
+        }
+        // 3. 替换变量
+        const systemPrompt = promptTemplate
+            .replace("{USER_REQUIREMENT}", userRequirement || "请从会话历史中提炼关键知识。")
+            .replace("{SCOPE}", scope)
+            .replace("{CURRENT_MEMORY}", currentMemory);
+        // 4. 创建 Memory Agent tools
+        const memoryTools = createMemoryAgentTools({
+            sessionComponent,
+            memoryComponent: memoryComponent,
+        });
+        // 5. 准备 Agent 工具列表
+        const agentTools = [
+            memoryTools.searchSessions,
+            memoryTools.getSession,
+            memoryTools.writeMemory,
+        ];
+        // 6. Project scope 额外添加文件工具（读取项目文档和代码）
+        if (scope === "project") {
+            agentTools.push(bashTool, globTool, readFileTool);
+        }
+        // 7. 获取允许的工具名称列表
+        const allowedToolNames = agentTools.map((t) => t.name);
+        // 8. 注册 Agent
+        const agentName = `memory-extract-${scope}`;
+        agentComponent.registerAgent(agentName, {
+            type: "sub",
+            systemPrompt,
+            allowedTools: allowedToolNames,
+            deniedTools: [],
+        });
+        agentComponent.setDefaultTools(agentTools);
+        // 9. 将 Agent tools 注册到 ToolComponent（用于 executeTool 时查找）
+        const toolComponent = env.getComponent?.("tool");
+        if (toolComponent) {
+            for (const tool of agentTools) {
+                try {
+                    toolComponent.register(tool);
+                    output.log(chalk.gray(`Tool registered: ${tool.name}`));
+                }
+                catch (err) {
+                    output.log(chalk.gray(`Tool already registered: ${tool.name}`));
+                }
+            }
+        }
+        output.log(chalk.gray(`Agent "${agentName}" registered with ${agentTools.length} tools`));
+        // 6. 执行 Agent（使用 handle_query，参考 delegate_task 模式）
+        // 这确保与 delegate_task 使用相同的执行路径，包括 memory 注入等
+        const query = `请分析会话历史，提炼${scope === "project" ? "项目" : "全局"}记忆并写入记忆文件。`;
+        let result;
+        try {
+            // 使用 env.handle_query() 而不是 agentComponent.run()
+            // 这与 delegate_task 的实现模式一致
+            result = await env.handle_query(query, {
+                sessionId,
+                agentType: agentName,
+            });
+        }
+        catch (error) {
+            result = `执行失败: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        // 10. 输出结果
+        // handle_query 返回 string，如果有错误会抛出异常
+        if (result && result.startsWith("执行失败")) {
+            output.error(`提取失败: ${result}`);
+        }
+        else if (result) {
+            output.log(chalk.green("\n✅ 记忆提取完成"));
+            output.log(chalk.gray("记忆已保存到 memory 文件。\n"));
+            // 可选：输出 agent 返回的结果摘要
+            if (result.length > 0 && result !== "✅ 记忆提取完成") {
+                output.log(chalk.gray(`执行摘要: ${result.substring(0, 200)}${result.length > 200 ? "..." : ""}`));
+            }
+        }
+        // 11. 清理 - 注销 Agent 和 Tools
+        agentComponent.unregisterAgent(agentName);
+        if (toolComponent) {
+            // 清理 memory tools
+            for (const tool of [memoryTools.searchSessions, memoryTools.getSession, memoryTools.writeMemory]) {
+                toolComponent.unregister(tool.name);
+            }
+            // 如果是 project scope，额外清理文件工具
+            if (scope === "project") {
+                for (const toolName of ["bash", "glob", "read_file"]) {
+                    toolComponent.unregister(toolName);
+                }
+            }
+        }
+    }
+    catch (error) {
+        output.error(`提取失败: ${error}`);
+        throw error;
+    }
+}
+export const RecordCommand = {
+    command: "record",
+    aliases: ["save"],
+    describe: "记录记忆内容到 memory file",
+    builder: (yargs) => yargs
+        .option("mode", {
+        alias: "m",
+        type: "string",
+        choices: ["append", "prepend", "overwrite", "delete"],
+        default: "append",
+        description: "操作模式: append(尾部追加), prepend(头部插入), overwrite(覆盖), delete(删除)",
+    })
+        .option("content", {
+        alias: "c",
+        type: "string",
+        description: "记忆内容 (markdown 格式)",
+    })
+        .option("title", {
+        alias: "t",
+        type: "string",
+        description: "记忆标题 (用于生成章节标题)",
+    })
+        .option("filename", {
+        alias: "f",
+        type: "string",
+        description: "文件名 (默认使用 memory.memoryFile 配置)",
+    })
+        .option("config", {
+        type: "string",
+        describe: "Config file path",
+    })
+        // Extract 模式选项
+        .option("extract", {
+        alias: "e",
+        type: "boolean",
+        default: false,
+        description: "触发提取模式：从会话历史中提取记忆",
+    })
+        .option("scope", {
+        type: "string",
+        choices: ["project", "global"],
+        describe: "记忆作用域",
+        demandOption: true, // 必填
+    })
+        .option("session-id", {
+        type: "string",
+        describe: "指定 session ID（可选）",
+    })
+        .option("require", {
+        alias: "r",
+        type: "string",
+        describe: "自然语言提取指导",
+    })
+        .demandOption(["mode"], "请指定操作模式 (--mode)")
+        .check((argv) => {
+        const mode = argv.mode;
+        // extract 模式不需要 content
+        if (argv.extract) {
+            return true;
+        }
+        if (mode !== "delete" && !argv.content) {
+            throw new Error("--content is required for all modes except 'delete' and 'extract'");
+        }
+        return true;
+    }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const memoryComponent = env.getComponent("memory");
+            if (!memoryComponent) {
+                output.error("MemoryComponent not available");
+                process.exit(1);
+            }
+            // Extract 模式：从会话历史提取记忆
+            if (a.extract) {
+                const agentComponent = env.getComponent("agent");
+                const sessionComponent = env.getComponent("session");
+                if (!agentComponent) {
+                    output.error("AgentComponent not available");
+                    process.exit(1);
+                }
+                await runExtractMode(output, memoryComponent, agentComponent, sessionComponent, env, {
+                    scope: a.scope || "project",
+                    sessionId: args["session-id"],
+                    require: a.require,
+                });
+                return;
+            }
+            // 普通 record 模式
+            const result = await memoryComponent.recordMemory({
+                scope: a.scope,
+                mode: a.mode,
+                content: a.content,
+                title: a.title,
+            });
+            if (!result) {
+                output.error("Failed to record memory: no memory paths configured");
+                process.exit(1);
+            }
+            const actionMessages = {
+                created: "已创建记忆文件",
+                overwrite: "已覆盖记忆文件",
+                append: "已追加内容到记忆文件",
+                prepend: "已插入内容到记忆文件开头",
+                delete: "已删除记忆文件",
+            };
+            output.log(chalk.green(`✓ ${actionMessages[result.action]}`));
+            output.log(chalk.gray(`路径: ${result.path}`));
+            // 如果是 overwrite/append/prepend，显示写入的内容预览
+            if (result.action !== "delete" && a.content) {
+                const preview = a.content.substring(0, 100);
+                output.log(chalk.gray(`内容预览: ${preview}${a.content.length > 100 ? "..." : ""}`));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to record memory: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=record.js.map