@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/shared/@ai-setting/roy-agent-core-6kvtahqv.js

@@ -0,0 +1,408 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/memory/plugin/memory-manager.ts
+init_logger();
+var logger = createLogger("MemoryManagerV3");
+function generateTaskId() {
+  return `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+class MemoryManager {
+  static MAX_QUEUE_SIZE = 100;
+  queue = [];
+  processing = false;
+  shuttingDown = false;
+  config;
+  processingPromise = null;
+  resolveProcessing = null;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  enqueue(task) {
+    if (this.shuttingDown) {
+      logger.debug("MemoryManager is shutting down, ignoring new task");
+      return;
+    }
+    const fullTask = {
+      ...task,
+      id: generateTaskId()
+    };
+    if (this.queue.length >= MemoryManager.MAX_QUEUE_SIZE) {
+      const dropped = this.queue.shift();
+      logger.warn(`Queue full (${MemoryManager.MAX_QUEUE_SIZE}), dropping oldest task: ${dropped?.id}`);
+    }
+    this.queue.push(fullTask);
+    logger.debug(`Task enqueued: ${task.type}, queue size: ${this.queue.length}`);
+    if (!this.processing) {
+      this.startProcessingLoop();
+    }
+  }
+  startProcessingLoop() {
+    const runLoop = async () => {
+      while (this.queue.length > 0 && !this.shuttingDown) {
+        const task = this.queue.shift();
+        try {
+          await this.processTask(task);
+        } catch (error) {
+          logger.error(`Task ${task.id} failed:`, error);
+        }
+      }
+      this.processing = false;
+      if (this.resolveProcessing) {
+        this.resolveProcessing();
+        this.resolveProcessing = null;
+        this.processingPromise = null;
+      }
+    };
+    this.processing = true;
+    this.processingPromise = new Promise((resolve) => {
+      this.resolveProcessing = resolve;
+    });
+    setImmediate(() => {
+      runLoop().catch((error) => {
+        logger.error("Processing loop error:", error);
+        this.processing = false;
+      });
+    });
+  }
+  hasPendingTasks() {
+    return this.queue.length > 0 || this.processing;
+  }
+  async waitForCompletion() {
+    if (this.queue.length === 0 && !this.processing) {
+      return;
+    }
+    if (this.processingPromise) {
+      await this.processingPromise;
+    }
+  }
+  prepareShutdown() {
+    this.shuttingDown = true;
+    logger.info("MemoryManager preparing for shutdown");
+  }
+  async dispose() {
+    await this.waitForCompletion();
+    this.queue = [];
+    logger.info("MemoryManager disposed");
+  }
+  async processTask(task) {
+    logger.debug(`Processing task: ${task.type}`);
+    switch (task.type) {
+      case "extract_memory":
+        await this.handleExtractMemory(task.payload);
+        break;
+      default:
+        logger.warn(`Unknown task type: ${task.type}`);
+    }
+  }
+  async handleExtractMemory(payload) {
+    const messageCount = payload.messages?.length || 0;
+    logger.info(`Extracting memory from ${messageCount} messages`);
+    if (this.config.onExtractMemory) {
+      try {
+        await this.config.onExtractMemory(payload);
+      } catch (error) {
+        logger.error("Memory extraction failed", { error });
+      }
+    }
+  }
+}
+// src/env/memory/plugin/types.ts
+var DEFAULT_MEMORY_PLUGIN_CONFIG = {
+  enabled: true
+};
+
+// src/env/memory/plugin/memory-plugin.ts
+init_logger();
+import path from "path";
+import os from "os";
+var logger2 = createLogger("MemoryPlugin");
+
+class MemoryPlugin {
+  config;
+  disposed = false;
+  initialized = false;
+  projectBaseDir = "";
+  globalBaseDir = "";
+  workDir = "";
+  agentComponent = null;
+  constructor(baseDir, config = {}) {
+    this.config = { ...DEFAULT_MEMORY_PLUGIN_CONFIG, ...config };
+    this.workDir = baseDir;
+    this.projectBaseDir = path.join(baseDir, ".roy", "memory");
+    this.globalBaseDir = path.join(os.homedir(), ".config", "roy-agent", "memory");
+    logger2.info("MemoryPlugin (simplified) created", { baseDir, config: this.config });
+  }
+  get name() {
+    return "MemoryPlugin";
+  }
+  get hookPoint() {
+    return "agent:after.react";
+  }
+  get priority() {
+    return 50;
+  }
+  get description() {
+    return "Memory management plugin. Use 'roy memory recall --extract' to extract memories.";
+  }
+  get hooks() {
+    return [
+      {
+        point: this.hookPoint,
+        priority: this.priority
+      }
+    ];
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    logger2.info("MemoryPlugin (simplified) initialized");
+  }
+  async execute(ctx) {
+    if (this.disposed || !this.config.enabled || !this.initialized) {
+      return;
+    }
+    logger2.debug("MemoryPlugin hook executed. Use 'roy memory recall --extract' for memory extraction.");
+  }
+  prepareShutdown() {}
+  hasPendingTasks() {
+    return false;
+  }
+  async waitForCompletion() {}
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    logger2.info("MemoryPlugin (simplified) disposed");
+  }
+  getProjectBaseDir() {
+    return this.projectBaseDir;
+  }
+  getGlobalBaseDir() {
+    return this.globalBaseDir;
+  }
+}
+function createMemoryPlugin(baseDir, config) {
+  return new MemoryPlugin(baseDir, config);
+}
+// src/env/memory/plugin/recall-memory.ts
+import fs from "fs/promises";
+import path2 from "path";
+async function recallMemory(memoryPaths) {
+  const results = [];
+  for (const memoryPath of memoryPaths) {
+    const scope = memoryPath.type;
+    const baseDir = memoryPath.path;
+    try {
+      const memoryFile = path2.join(baseDir, "memory.md");
+      try {
+        const content = await fs.readFile(memoryFile, "utf-8");
+        if (content.trim()) {
+          results.push(`## [${scope}] memory.md
+${content}`);
+        }
+      } catch {}
+    } catch (error) {
+      console.error(`Error processing memory path ${baseDir}:`, error);
+    }
+  }
+  if (results.length === 0) {
+    return "(No memory files found)";
+  }
+  return results.join(`
+
+`);
+}
+// src/env/memory/plugin/memory-agent.ts
+var PROJECT_MEMORY_AGENT_PROMPT = `你是项目级 Memory Agent，负责整理和更新当前项目的记忆。
+
+## 你的职责
+
+1. **信息收集**：在提取记忆前，先收集项目上下文信息
+2. **从对话中提取记忆**：分析 messages，提取与项目相关的知识、决策、解决方案
+3. **生成 memory.md**：更新项目记忆索引
+
+## 信息收集步骤（重要！）
+
+在提取记忆之前，请先使用可用工具收集项目上下文：
+
+1. **阅读项目 README**：了解项目概述、功能、使用方法
+   - 路径示例：README.md, README.zh-CN.md, docs/README.md
+
+2. **检查设计文档**：了解项目架构和设计决策
+   - 路径示例：docs/design.md, docs/ARCHITECTURE.md, docs/superpowers/specs/*.md
+
+3. **查看代码实现**：了解关键模块和实现细节
+   - 路径示例：src/**/*.ts, packages/*/src/**/*.ts
+
+4. **回顾现有 memory**：了解已有的项目记忆
+   - 路径：当前目录下的 .roy/memory/memory.md
+
+## 输入信息
+
+- 当前项目的 memory.md 内容
+- 当前对话消息
+
+## 输出要求
+
+请以 JSON 格式输出结果，包含以下字段：
+- memoryMdContent: 新的 memory.md 内容
+- projectSummary: 项目摘要（包含 summary, shortSummary 等）
+- hasUpdates: 是否有更新
+
+## 记忆组织原则
+
+- 优先记录具体、可操作的记忆（代码位置、配置项、命令）
+- 避免过于抽象或通用的描述
+- 记录设计决策及其理由`;
+var GLOBAL_MEMORY_AGENT_PROMPT = `你是全局 Memory Agent，负责整理跨项目的通用记忆。
+
+## 你的职责
+
+1. **聚合项目摘要**：分析 projectSummaries，提取共性知识
+2. **维护全局记忆**：更新全局 memory.md
+3. **维护项目索引**：在 memory.md 中维护项目列表
+4. **提取共性经验**：将项目经验提炼为通用最佳实践
+
+## 输入信息
+
+- 全局 memory.md 内容
+- 当前对话消息
+- 项目摘要列表（projectSummaries）
+
+## 输出要求
+
+请以 JSON 格式输出结果，包含以下字段：
+- memoryMdContent: 新的 memory.md 内容
+- hasUpdates: 是否有更新
+
+## 记忆组织原则
+
+- 关注跨项目共性（工作流、规范、偏好）
+- 项目索引只记录摘要和路径，不复制内容
+- 用户个人偏好（饮食、工作习惯）优先记录`;
+function createMemoryAgent(scope) {
+  const name = `memory-agent-${scope}-${Date.now()}`;
+  const systemPrompt = scope === "project" ? PROJECT_MEMORY_AGENT_PROMPT : GLOBAL_MEMORY_AGENT_PROMPT;
+  return {
+    name,
+    systemPrompt,
+    maxIterations: 5
+  };
+}
+function formatMemoryInput(input) {
+  const lines = [];
+  lines.push(`# Memory Agent Input (${input.scope} scope)
+`);
+  lines.push("## Current memory.md");
+  lines.push(input.currentMemoryMd || "_No existing memory_");
+  lines.push("");
+  lines.push("## Recent Messages");
+  if (input.messages.length === 0) {
+    lines.push("_No messages_");
+  } else {
+    for (const msg of input.messages.slice(-10)) {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      lines.push(`**${msg.role}**: ${content.substring(0, 500)}`);
+    }
+  }
+  lines.push("");
+  if (input.scope === "global" && input.projectSummaries && input.projectSummaries.length > 0) {
+    lines.push("## Project Summaries");
+    for (const ps of input.projectSummaries) {
+      lines.push(`### ${ps.projectName}`);
+      lines.push(`Path: ${ps.projectPath}`);
+      lines.push(`Last Updated: ${new Date(ps.lastUpdated).toLocaleString()}`);
+      lines.push(`Summary: ${ps.summary}`);
+      lines.push(`Memory: ${ps.memoryMdPath}`);
+      lines.push("---");
+    }
+    lines.push("");
+  }
+  lines.push("## Task");
+  lines.push("请分析以上信息，更新记忆并以 JSON 格式输出结果。");
+  return lines.join(`
+`);
+}
+function parseMemoryAgentOutput(output, scope) {
+  let jsonStr = output;
+  const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/) || output.match(/```\s*([\s\S]*?)\s*```/) || output.match(/(\{[\s\S]*\})/);
+  if (jsonMatch) {
+    jsonStr = jsonMatch[1] || jsonMatch[0];
+  }
+  try {
+    const parsed = JSON.parse(jsonStr);
+    return {
+      scope,
+      memoryMdContent: parsed.memoryMdContent || "",
+      projectSummary: parsed.projectSummary,
+      hasUpdates: parsed.hasUpdates ?? false
+    };
+  } catch {
+    return {
+      scope,
+      memoryMdContent: output,
+      hasUpdates: false
+    };
+  }
+}
+function createEmptyResult(scope) {
+  return {
+    scope,
+    memoryMdContent: "",
+    hasUpdates: false
+  };
+}
+async function buildProjectInput(params) {
+  const baseDir = params.projectPath + "/.roy/memory";
+  return {
+    scope: "project",
+    baseDir,
+    currentMemoryMd: params.currentMemoryMd,
+    messages: params.messages
+  };
+}
+function buildGlobalInput(params) {
+  return {
+    scope: "global",
+    baseDir: params.baseDir,
+    currentMemoryMd: params.currentMemoryMd,
+    messages: params.messages,
+    projectSummaries: params.projectSummaries
+  };
+}
+async function applyMemoryResult(result, baseDir) {
+  const fs2 = await import("fs/promises");
+  const path3 = await import("path");
+  const memoryMdPath = path3.join(baseDir, "memory.md");
+  await fs2.mkdir(path3.dirname(memoryMdPath), { recursive: true });
+  await fs2.writeFile(memoryMdPath, result.memoryMdContent, "utf-8");
+}
+function generateProjectSummary(params) {
+  const paragraphs = params.memoryMdContent.split(/\n\n+/);
+  const firstParagraph = paragraphs[0] || "";
+  const summary = firstParagraph.replace(/^#+\s*/g, "").trim() || "No summary available";
+  const firstSentence = summary.split(/[.!?]/)[0] || summary;
+  const shortSummary = firstSentence.substring(0, 50) + (firstSentence.length > 50 ? "..." : "");
+  return {
+    projectPath: params.projectPath,
+    projectName: params.projectName,
+    lastUpdated: Date.now(),
+    summary,
+    shortSummary,
+    memoryMdPath: params.memoryMdPath
+  };
+}
+export { MemoryManager, MemoryPlugin, createMemoryPlugin, recallMemory, PROJECT_MEMORY_AGENT_PROMPT, GLOBAL_MEMORY_AGENT_PROMPT, createMemoryAgent, formatMemoryInput, parseMemoryAgentOutput, createEmptyResult, buildProjectInput, buildGlobalInput, applyMemoryResult, generateProjectSummary };

package/dist/shared/@ai-setting/roy-agent-core-7fgf85wc.js

@@ -0,0 +1,284 @@
+import {
+  init_decorator_node
+} from "./roy-agent-core-1ce3fqrk.js";
+
+// src/env/workflow/decorators/workflow.ts
+import"reflect-metadata";
+
+// src/env/workflow/metadata/keys.ts
+var WORKFLOW_METADATA_KEY = Symbol("workflow:metadata");
+var NODE_METADATA_KEY = Symbol("workflow:node");
+var EDGE_METADATA_KEY = Symbol("workflow:edges");
+
+// src/env/workflow/decorators/workflow.ts
+function Workflow(options) {
+  return function(target) {
+    const metadata = {
+      name: options.name,
+      version: options.version || "1.0",
+      description: options.description,
+      entry: options.entry,
+      config: options.config,
+      tags: options.tags || [],
+      author: options.author
+    };
+    Reflect.defineMetadata(WORKFLOW_METADATA_KEY, metadata, target);
+    return target;
+  };
+}
+function getWorkflowMetadata(target) {
+  return Reflect.getMetadata(WORKFLOW_METADATA_KEY, target);
+}
+// src/env/workflow/decorators/node-as.ts
+import"reflect-metadata";
+function NodeAs(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    const nodeMetadata = {
+      nodeId: options.nodeId || methodName,
+      nodeType: options.nodeType || "tool",
+      name: options.name,
+      dependsOn: normalizeDependsOn(options.dependsOn),
+      condition: options.condition,
+      retry: options.retry,
+      timeout: options.timeout,
+      config: options.config || {},
+      methodName,
+      method: descriptor.value
+    };
+    const existingNodes = Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+    const existingIndex = existingNodes.findIndex((n) => n.methodName === methodName);
+    if (existingIndex >= 0) {
+      existingNodes[existingIndex] = nodeMetadata;
+    } else {
+      existingNodes.push(nodeMetadata);
+    }
+    Reflect.defineMetadata(NODE_METADATA_KEY, existingNodes, target);
+    return descriptor;
+  };
+}
+function normalizeDependsOn(dependsOn) {
+  if (!dependsOn) {
+    return [];
+  }
+  return Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+}
+function getNodeMetadatas(target) {
+  return Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+}
+// src/env/workflow/decorators/edge.ts
+import"reflect-metadata";
+function Edge(from, to) {
+  return function(target, propertyKey, descriptor) {
+    const edge = { from, to };
+    const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+    existingEdges.push(edge);
+    Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
+    return descriptor;
+  };
+}
+function WorkflowEdges(edges) {
+  return function(target) {
+    const edgeMetadatas = edges.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      condition: edge.condition
+    }));
+    Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
+    return target;
+  };
+}
+function getEdgeMetadatas(target) {
+  return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+}
+
+// src/env/workflow/decorators/index.ts
+init_decorator_node();
+
+// src/env/workflow/extractor/workflow-converter.ts
+import"reflect-metadata";
+class WorkflowConverter {
+  static extractWorkflowMetadata(targetClass) {
+    return getWorkflowMetadata(targetClass);
+  }
+  static extractNodeMetadatas(targetClass) {
+    return getNodeMetadatas(targetClass.prototype);
+  }
+  static extractEdgeMetadatas(targetClass) {
+    return getEdgeMetadatas(targetClass);
+  }
+  static fromClass(targetClass, instance) {
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      throw new Error("Class must be decorated with @Workflow");
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      throw new Error("At least one method must be decorated with @NodeAs");
+    }
+    const edgeMetadatas = this.extractEdgeMetadatas(targetClass);
+    const nodeMap = this.buildNodeMap(nodeMetadatas, edgeMetadatas);
+    const nodes = Array.from(nodeMap.values()).map((meta) => ({
+      id: meta.nodeId,
+      type: meta.nodeType,
+      name: meta.name,
+      config: {
+        ...meta.config,
+        _methodName: meta.methodName,
+        _instance: instance
+      },
+      depends_on: meta.dependsOn,
+      condition: meta.condition,
+      retry: meta.retry,
+      timeout: meta.timeout
+    }));
+    const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
+    return {
+      name: workflowMeta.name,
+      version: workflowMeta.version || "1.0",
+      description: workflowMeta.description,
+      config: workflowMeta.config || {},
+      nodes,
+      entry,
+      outputs: [],
+      metadata: {
+        tags: workflowMeta.tags || [],
+        author: workflowMeta.author
+      }
+    };
+  }
+  static buildNodeMap(nodeMetadatas, edgeMetadatas) {
+    const nodeMap = new Map;
+    for (const nodeMeta of nodeMetadatas) {
+      nodeMap.set(nodeMeta.nodeId, { ...nodeMeta });
+    }
+    for (const edge of edgeMetadatas) {
+      const targetNode = nodeMap.get(edge.to);
+      if (targetNode) {
+        if (!targetNode.dependsOn.includes(edge.from)) {
+          targetNode.dependsOn = [...targetNode.dependsOn, edge.from];
+        }
+        if (edge.condition) {
+          if (targetNode.condition) {
+            targetNode.condition = `(${targetNode.condition}) AND (${edge.condition})`;
+          } else {
+            targetNode.condition = edge.condition;
+          }
+        }
+      }
+    }
+    return nodeMap;
+  }
+  static validateWorkflowClass(targetClass) {
+    const errors = [];
+    const warnings = [];
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      errors.push("Class must be decorated with @Workflow");
+      return { valid: false, errors, warnings };
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      errors.push("At least one method must be decorated with @NodeAs");
+      return { valid: false, errors, warnings };
+    }
+    const entry = workflowMeta.entry;
+    if (entry) {
+      const entries = Array.isArray(entry) ? entry : [entry];
+      for (const e of entries) {
+        if (!nodeMetadatas.find((n) => n.nodeId === e)) {
+          errors.push(`Entry node '${e}' not found`);
+        }
+      }
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        if (!nodeMetadatas.find((n) => n.nodeId === dep)) {
+          errors.push(`Node '${node.nodeId}' depends on non-existent node '${dep}'`);
+        }
+      }
+    }
+    if (this.hasCycle(nodeMetadatas)) {
+      errors.push("Workflow contains a cycle");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  static hasCycle(nodeMetadatas) {
+    const visited = new Set;
+    const recStack = new Set;
+    const adjList = new Map;
+    for (const node of nodeMetadatas) {
+      adjList.set(node.nodeId, []);
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        const deps = adjList.get(dep);
+        if (deps) {
+          deps.push(node.nodeId);
+        }
+      }
+    }
+    const dfs = (nodeId) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const neighbors = adjList.get(nodeId) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor)) {
+            return true;
+          }
+        } else if (recStack.has(neighbor)) {
+          return true;
+        }
+      }
+      recStack.delete(nodeId);
+      return false;
+    };
+    for (const node of nodeMetadatas) {
+      if (!visited.has(node.nodeId)) {
+        if (dfs(node.nodeId)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  static async executeNode(nodeDef, context) {
+    const instance = nodeDef.config._instance;
+    const methodName = nodeDef.config._methodName;
+    if (!instance || !methodName) {
+      return { output: undefined, error: new Error("Missing method information") };
+    }
+    const method = instance[methodName];
+    if (typeof method !== "function") {
+      return { output: undefined, error: new Error(`Method ${methodName} is not a function`) };
+    }
+    const deps = nodeDef.depends_on || [];
+    let input = context.input;
+    if (deps.length > 0) {
+      input = {};
+      for (const depId of deps) {
+        input[depId] = context.previousOutputs.get(depId);
+      }
+    }
+    try {
+      const result = await method.call(instance, input);
+      return { output: result };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+}
+// src/env/workflow/utils/create-workflow.ts
+function createWorkflowFromClass(targetClass, options) {
+  const instance = options?.instance ?? new targetClass(...options?.constructorArgs ?? []);
+  return WorkflowConverter.fromClass(targetClass, instance);
+}
+export { Workflow, getWorkflowMetadata, NodeAs, getNodeMetadatas, Edge, WorkflowEdges, getEdgeMetadatas, WorkflowConverter, createWorkflowFromClass };