@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

package/dist/shared/@ai-setting/roy-agent-core-4txzpsbt.js

@@ -1,393 +0,0 @@
-import {
-  createMemoryTools
-} from "./roy-agent-core-g1s2h0e5.js";
-import {
-  envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-
-// src/env/memory/types.ts
-import { z } from "zod";
-var RecordMemorySchema = z.object({
-  scope: z.enum(["project", "global"]).describe("作用域: project/global"),
-  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
-  content: z.string().optional().describe("记忆内容"),
-  title: z.string().optional().describe("章节标题")
-});
-var RecallMemorySchema = z.object({
-  scope: z.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）")
-});
-// src/env/memory/memory-config.ts
-import path from "path";
-import os from "os";
-var DEFAULT_MEMORY_CONFIG = {
-  memoryPaths: [
-    {
-      type: "global",
-      path: path.join(os.homedir(), ".config", "roy-agent", "memory")
-    },
-    {
-      type: "project",
-      path: ".roy/memory"
-    }
-  ],
-  recursive: true,
-  cacheEnabled: true,
-  cacheTTL: 5 * 60 * 1000
-};
-var SOURCE_PRIORITY = {
-  global: 0,
-  project: 1
-};
-function getSourcePriority(source) {
-  return SOURCE_PRIORITY[source] ?? 0;
-}
-// src/env/memory/memory-component.ts
-init_logger();
-
-// src/env/memory/memory-config-registration.ts
-import path2 from "path";
-import os2 from "os";
-var MEMORY_DEFAULTS = {
-  "memory.recursive": true,
-  "memory.cacheEnabled": true,
-  "memory.cacheTTL": 300000,
-  "memory.memoryFile": "memory.md",
-  "memory.memoryPaths": [
-    { type: "global", path: path2.join(os2.homedir(), ".config", "roy-agent", "memory") },
-    { type: "project", path: ".roy/memory" }
-  ]
-};
-var 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"] }
-  ]
-};
-
-// src/env/memory/memory-component.ts
-import path3 from "path";
-import fs from "fs/promises";
-var logger = createLogger("memory");
-
-class MemoryComponent extends BaseComponent {
-  name = "memory";
-  version = "2.0.0";
-  config;
-  toolComponent;
-  configComponent;
-  cache = new Map;
-  configWatcher;
-  async init(config) {
-    await super.init(config);
-    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)");
-  }
-  async registerConfig(options) {
-    const configComponent = this.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix ?? "MEMORY";
-    configComponent.registerComponent(MEMORY_CONFIG_REGISTRATION);
-    if (configPath) {
-      configComponent.registerSource({
-        type: "file",
-        relativePath: configPath,
-        optional: true,
-        watch: false
-      });
-    }
-    configComponent.registerSource({
-      type: "env",
-      envPrefix: prefix,
-      priority: 20,
-      watch: false
-    });
-    await configComponent.load("memory");
-    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);
-      }
-    }
-    for (const [key, value] of Object.entries(MEMORY_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-    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";
-    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();
-    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() {
-    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");
-  }
-  async registerTools() {
-    if (!this.toolComponent)
-      return;
-    const tools = createMemoryTools((args) => this.recordMemory(args), (scope) => this.recallMemory(scope), {
-      getMemoryPaths: () => this.getMemoryPaths(),
-      getMemoryFile: () => this.getMemoryFile()
-    });
-    for (const tool of tools) {
-      this.toolComponent.register(tool);
-    }
-    logger.info("[MemoryComponent] Registered memory tools");
-  }
-  getMemoryPaths() {
-    return this.config.memoryPaths;
-  }
-  updateMemoryPaths(paths) {
-    this.config.memoryPaths = paths;
-    this.clearCache();
-  }
-  getMemoryFile() {
-    return this.config.memoryFile ?? "memory.md";
-  }
-  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;
-    }
-    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 = path3.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}
-
-${content}
-`;
-          } 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 + `
-## ${title}
-
-${content}
-`;
-          } else {
-            newContent = existingContent + `
-${content}
-`;
-          }
-          action = fileExists ? "append" : "created";
-          break;
-        case "prepend":
-          if (!content) {
-            throw new Error("content is required for prepend mode");
-          }
-          if (title) {
-            newContent = `## ${title}
-
-${content}
-
----
-
-${existingContent}`;
-          } else {
-            newContent = `${content}
-
----
-
-${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;
-    }
-  }
-  async recallMemory(scope) {
-    const memoryFile = this.getMemoryFile();
-    const paths = this.config.memoryPaths;
-    const results = [];
-    for (const memoryPath of paths) {
-      if (scope && memoryPath.type !== scope) {
-        continue;
-      }
-      const filePath = path3.join(memoryPath.path, memoryFile);
-      try {
-        const content = await fs.readFile(filePath, "utf-8");
-        if (content.trim()) {
-          results.push(`## [${memoryPath.type}] ${memoryFile}
-${content}`);
-        }
-      } catch {}
-    }
-    return results.join(`
-
-`);
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-  getCache(key) {
-    if (!this.config.cacheEnabled)
-      return;
-    const entry = this.cache.get(key);
-    if (!entry)
-      return;
-    const age = Date.now() - entry.timestamp;
-    if (age > (this.config.cacheTTL ?? 300000)) {
-      this.cache.delete(key);
-      return;
-    }
-    return entry.data;
-  }
-  setCache(key, data) {
-    if (!this.config.cacheEnabled)
-      return;
-    this.cache.set(key, { data, timestamp: Date.now() });
-  }
-}
-export { DEFAULT_MEMORY_CONFIG, SOURCE_PRIORITY, getSourcePriority, MemoryComponent };