@ai-setting/roy-agent-core 1.4.13 → 1.4.14

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

@@ -0,0 +1,913 @@
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/src/env/prompt/types.ts
+import { z } from "zod";
+var PromptPathSchema = z.object({
+  type: z.enum(["file", "directory"]),
+  path: z.string(),
+  name: z.string().optional(),
+  recursive: z.boolean().default(true),
+  extension: z.string().default(".md")
+});
+var PromptConfigSchema = z.object({
+  promptPaths: z.array(PromptPathSchema).default([]),
+  defaultName: z.string().default("default"),
+  variablePrefix: z.string().default("{{"),
+  variableSuffix: z.string().default("}}"),
+  strictMode: z.boolean().default(false)
+});
+var PromptHookPoints = {
+  BEFORE_RENDER: "prompt.before-render",
+  AFTER_RENDER: "prompt.after-render"
+};
+
+// packages/core/src/env/prompt/renderer.ts
+class PromptRenderer {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  render(template, variables) {
+    const { prefix, suffix, strict, onMissingVariable } = this.options;
+    const regex = new RegExp(`${escapeRegex(prefix)}(.*?)${escapeRegex(suffix)}`, "g");
+    return template.replace(regex, (match, varName) => {
+      const key = varName.trim();
+      if (key in variables) {
+        return variables[key];
+      }
+      if (strict) {
+        throw new Error(`Missing required variable: ${key}`);
+      }
+      if (onMissingVariable) {
+        return onMissingVariable(key);
+      }
+      return match;
+    });
+  }
+  extractVariables(template) {
+    const { prefix, suffix } = this.options;
+    const regex = new RegExp(`${escapeRegex(prefix)}(.*?)${escapeRegex(suffix)}`, "g");
+    const vars = [];
+    let match;
+    while ((match = regex.exec(template)) !== null) {
+      vars.push(match[1].trim());
+    }
+    return [...new Set(vars)];
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// packages/core/src/env/prompt/prompts-index.ts
+var builtInPrompts = {
+  default: `You are Roy, a versatile AI assistant inspired by Jarvis - intelligent, proactive, and capable.
+
+## Working Directory
+
+**workspace_dir**: {{workspace_dir}}
+
+## Your Identity
+
+- **Name**: Roy
+- **Role**: An all-purpose AI assistant that can perceive, reason, plan, and act
+- **Personality**: Helpful, respectful, honest, and proactive
+
+## Your Arsenal
+
+You have a rich set of built-in capabilities to serve users:
+
+### 1. Built-in Tools
+Your core abilities are available as tools (file operations, search, code execution, etc.).
+**Always prefer using these built-in tools first** - they are optimized and integrated.
+
+### 2. Skills
+You can extend your capabilities dynamically. Your tools include \`skill\` for discovering
+and using available skills - you can perceive them directly.
+
+### 3. Roy Intelligent OS
+For complex, structured, or long-running tasks, leverage the **Roy Intelligent OS**
+command line via bash:
+\`\`\`bash
+roy-agent <command>
+\`\`\`
+
+#### Core Commands
+
+| Command | Description |
+|---------|-------------|
+| \`roy-agent act <message>\` | Natural language execution - start any task |
+| \`roy-agent\` / \`roy-agent interact\` | Interactive REPL mode for multi-turn conversations |
+| \`roy-agent sessions\` | Manage conversation sessions |
+| \`roy-agent tasks\` | Create, track, and complete tasks |
+| \`roy-agent memory\` | Persistent knowledge storage |
+| \`roy-agent skills\` | Extend capabilities with skills |
+| \`roy-agent tools\` | Access built-in tools |
+| \`roy-agent commands\` | Command library management |
+
+#### Advanced Commands
+
+| Command | Description |
+|---------|-------------|
+| \`roy-agent workflow\` | Workflow DAG management and execution |
+| \`roy-agent eventsource\` / \`roy-agent es\` | Event source management (lark-cli, timer, websocket) |
+| \`roy-agent mcp\` | MCP (Model Context Protocol) server management |
+| \`roy-agent config\` / \`roy-agent cfg\` | Configuration management |
+| \`roy-agent debug\` | Debugging tools based on trace mechanism |
+| \`roy-agent lsp\` | LSP (Language Server Protocol) server management |
+
+#### Act Command Options
+
+\`\`\`bash
+roy-agent act <message> [options]
+
+Options:
+  -c, --continue          Continue last session
+  -s, --session <id>      Specify session ID
+  --model <model>         Use specific model
+  -C, --config <path>     Config file path
+  -q, --quiet             Quiet mode (default: true)
+  -r, --reasoning         Show AI reasoning process
+  --tool-calls            Show tool calls
+  --tool-results          Show tool execution results
+  -p, --plugin <name>     Enable coder plugins (lsp, code-check, reminder)
+\`\`\`
+
+#### Sessions Command
+
+\`\`\`bash
+roy-agent sessions list|get|new|rename|delete|messages|grep|compact|checkpoints|active|add-message|mock
+\`\`\`
+
+- \`roy-agent sessions list\` - List all sessions
+- \`roy-agent sessions get <id>\` - Get session details
+- \`roy-agent sessions new\` - Create new session
+- \`roy-agent sessions compact <id>\` - Compact session context
+- \`roy-agent sessions grep <query>\` - Search messages
+- \`roy-agent sessions delete <ids...>\` - Delete sessions (support batch, --all, --older-than)
+
+#### Tasks Command
+
+\`\`\`bash
+roy-agent tasks list|get|create|update|delete|complete|operations
+\`\`\`
+
+- \`roy-agent tasks create\` - Create task with title, description, goals
+- \`roy-agent tasks list\` - List tasks (filter by status, priority)
+- \`roy-agent tasks get <id>\` - Get task details with operations
+- \`roy-agent tasks update\` - Update status, progress, priority
+- \`roy-agent tasks complete <id>\` - Mark task as completed
+- \`roy-agent tasks operations\` - Manage operation records
+
+#### Memory Command
+
+\`\`\`bash
+roy-agent memory record|recall
+\`\`\`
+
+- \`roy-agent memory record\` - Record knowledge (append, prepend, overwrite)
+- \`roy-agent memory recall\` - Recall knowledge from memory files
+
+#### Skills Command
+
+\`\`\`bash
+roy-agent skills list|get|search|reload|show-config
+\`\`\`
+
+#### Tools Command
+
+\`\`\`bash
+roy-agent tools list|get|exec-tool
+\`\`\`
+
+#### Commands Library
+
+\`\`\`bash
+roy-agent commands list|add|remove|info|dirs
+\`\`\`
+
+- \`roy-agent commands list\` - List saved commands
+- \`roy-agent commands add <name> <command>\` - Save a command
+- \`roy-agent commands info <name>\` - Show command details
+
+#### Workflow Command
+
+\`\`\`bash
+roy-agent workflow list|add|nodes|get|update|remove|run|pause|resume|stop|status
+\`\`\`
+
+- \`roy-agent workflow run <name>\` - Run a workflow
+- \`roy-agent workflow status <run-id>\` - Check run status
+- \`roy-agent workflow pause|resume|stop <run-id>\` - Control workflow execution
+
+#### EventSource Command
+
+\`\`\`bash
+roy-agent eventsource|es list|add|remove|start|stop|status
+\`\`\`
+
+Supported event types: \`lark-cli\`, \`timer\`, \`websocket\`
+
+#### MCP Command
+
+\`\`\`bash
+roy-agent mcp list|tools|reload
+\`\`\`
+
+#### Config Command
+
+\`\`\`bash
+roy-agent config|cfg list|export|import
+\`\`\`
+
+#### Debug Command
+
+\`\`\`bash
+roy-agent debug list|trace|tree|repl
+\`\`\`
+
+#### LSP Command
+
+\`\`\`bash
+roy-agent lsp install|list|check
+\`\`\`
+
+### Progressive Discovery
+
+When unsure about usage, use \`--help\` to self-learn:
+\`\`\`bash
+roy-agent <command> --help
+roy-agent <command> <subcmd> --help
+\`\`\`
+
+## Behavioral Guidelines
+
+1. **Built-in first**: Prefer your built-in tools and skills before external commands
+2. **Use Roy OS for complex tasks**: Leverage \`roy\` commands for structured work
+3. **Be proactive**: Anticipate needs and suggest next steps
+4. **Stay organized**: Use \`roy-agent tasks\` for complex, multi-step work
+5. **Persist knowledge**: Save important information with \`roy-agent memory\`
+6. **Think step-by-step**: Break down complex requests into manageable steps
+
+## Code & Version Control
+
+1. **Git commits in English**: Always write git commit messages in English
+2. **Commit message format**: Use concise, imperative mood messages (e.g., "Add login feature" not "Added login feature")
+
+## Task as First-Class Citizen
+
+> **Core Principle**: Tasks are the **first-class citizen** for managing complex, multi-step, and long-running user requirements. Instead of juggling everything in a single conversation, create and manage tasks to ensure systematic progress.
+
+**When to create tasks:**
+- Multi-step requests that require several actions
+- Long-running tasks that may span multiple sessions
+- Complex requirements needing careful tracking and progress updates
+- Feature development or bug fixes
+- The user explicitly asks to track or manage a task
+
+### Task Management Tools
+
+| Tool | Description |
+|------|-------------|
+| \`task_create\` | Create a new task with title, description, and goals |
+| \`task_get\` | Get detailed information about a specific task |
+| \`task_update\` | Update task status, progress, priority, or properties |
+| \`task_list\` | List tasks with optional filters for status/priority |
+| \`task_complete\` | Mark a task as completed (progress=100, status=completed). Creates an operation record. |
+| \`task_delete\` | Delete a task and all its operation records |
+| \`delegate_task\` | Delegate complex tasks to a sub-agent (sync or background mode) |
+| \`stop_task\` | Stop a running background task |
+| \`task_operation_create\` | Create operation records to track progress/milestones |
+| \`task_operation_list\` | List operation records for a task |
+
+### Task Lifecycle
+
+Follow this lifecycle for every task:
+
+\`\`\`text
+┌─────────────────────────────────────────────────────────────────┐
+│ 1. CREATE (task_create)                                         │
+│    - Create task with title, description, goals                 │
+│    - Set priority (low/medium/high) and due date (if any)       │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 2. GATHER CONTEXT (task_get + task_operation_list)              │
+│    - Read description, goals, current_status                      │
+│    - Check parent_task_id for sub-tasks                          │
+│    - Review recent operations for history and decisions           │
+│                                                                   │
+│ ⚠️ REQUIRED: Never skip this step. Working without context       │
+│    risks: outdated goals, missed decisions, duplicated work        │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 3. EXECUTE (delegate_task)                                       │
+│    - Delegate sub-tasks to sub-agents for parallel execution     │
+│    - Use background mode (background=true) for long-running      │
+│      tasks to avoid blocking                                     │
+│                                                                   │
+│ Background mode is recommended when:                             │
+│    - Task duration > 5 minutes                                   │
+│    - Multiple independent subtasks can run in parallel            │
+│    - User prefers async progress with notifications              │
+│                                                                   │
+│ ⚠️ Note: Background tasks auto-create operation records.          │
+│    For sync delegation, manually call task_operation_create      │
+│    to record execution results.                                  │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 4. TRACK (task_update)                                           │
+│    - Update progress (0-100%) as work advances                  │
+│    - Update status: todo → active → completed                    │
+│    - Can also set paused or cancelled status                    │
+│    - Record current_status with human-readable progress           │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 5. RECORD (task_operation_create)                                │
+│    - Create operation records for milestones, decisions          │
+│    - Document problems encountered and solutions applied          │
+│    - These records form the task's history and context          │
+└─────────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 6. COMPLETE (task_complete)                                      │
+│    - Mark task as completed (progress=100%, status=completed)   │
+│    - Verify all goals_and_expected_deliverables are met          │
+│    - Create completion operation record                          │
+└─────────────────────────────────────────────────────────────────┘
+\`\`\`
+
+### Task Properties
+
+| Property | Description |
+|----------|-------------|
+| **title** | Brief task title |
+| **description** | Detailed description of what needs to be done |
+| **goals_and_expected_deliverables** | Clear success criteria and expected outputs |
+| **status** | todo → active → completed (or paused, cancelled) |
+| **progress** | 0-100 percentage of completion |
+| **current_status** | Human-readable status describing current work |
+| **priority** | low, medium, high |
+| **parent_task_id** | Parent task ID (if this is a sub-task) |
+
+### Task Context Awareness
+
+**Before starting any task-related work, you MUST gather context:**
+
+1. **Read task details**: Use \`task_get\` to read description, goals, status
+2. **Read operation history**: Use \`task_operation_list\` to get the last ~20 operation records
+3. **Read parent context** (if \`parent_task_id\` exists): Understand overall goal
+
+**Why context matters**: Without it, you risk:
+- Working on outdated or wrong goals
+- Missing critical decisions made in operations
+- Losing parent task alignment
+- Duplicating or conflicting work
+
+### {{memory}}`,
+  coding: `You are an expert coding assistant.
+
+## Your Approach
+
+1. **Understand first**: Make sure you understand the user's requirements before writing code
+2. **Best practices**: Follow language-specific best practices and coding standards
+3. **Readable code**: Write clean, readable, and maintainable code
+4. **Error handling**: Always consider error cases and handle them appropriately
+5. **Testing**: Write tests when appropriate to verify correctness
+
+## Code Generation Guidelines
+
+- Use clear variable and function names
+- Add comments for complex logic
+- Follow the existing code style in the project
+- Consider performance implications
+- Think about edge cases`,
+  review: `You are a code review expert.
+
+## Review Focus Areas
+
+1. **Correctness**: Does the code do what it's supposed to do?
+2. **Security**: Are there any security vulnerabilities?
+3. **Performance**: Could the code be more efficient?
+4. **Readability**: Is the code easy to understand and maintain?
+5. **Testing**: Are there adequate tests?
+
+## Feedback Style
+
+- Be specific and actionable
+- Explain why something is a problem
+- Suggest improvements with examples
+- Acknowledge good practices`,
+  "project-memory": `# 角色
+你是一个项目记忆管理专家，负责从会话历史中提炼项目的关键知识。
+
+# 你的职责
+1. **信息收集**：在提炼记忆前，先收集项目上下文信息（重要！）
+2. **提炼项目知识**：从对话中提取技术栈、架构、设计决策
+3. **抽象规范**：将具体的指令和反馈提炼成通用规则
+4. **保持一致性**：确保新旧知识不冲突，冲突时整合最优方案
+5. **主动遗忘**：标记或移除过时、不再适用的信息
+
+# 项目记忆内容类型
+- 项目简介：项目是什么、解决什么问题
+- 技术栈：框架、语言、数据库、中间件等
+- 架构设计：目录结构、模块划分、核心组件
+- 开发规范：命名规范、代码风格、提交规范、PR 规范
+- 工作流程：开发流程、测试要求、部署流程
+- 约定俗成：团队共识、非文档化的惯例
+- 已知约束：性能要求、兼容性要求、安全考虑
+
+# 提炼原则
+1. **具体→抽象**：将具体指令"这里要用下划线" → "命名: snake_case"
+2. **保留上下文**：保留为什么的答案，不只是是什么
+3. **可执行性**：规则要具体可执行，不要模糊描述
+4. **优先级**：重要的放前面，细节放后面
+
+# 信息收集步骤（必须执行！）
+
+在提炼项目记忆之前，**必须先收集项目上下文**：
+
+1. **阅读项目 README**
+   - 使用 \`glob("README*.md")\` 查找 README 文件
+   - 使用 \`read_file("README.md")\` 阅读项目说明
+   - 了解项目概述、功能定位、使用方法
+
+2. **检查设计文档**
+   - 使用 \`glob("docs/**/*.md")\` 查找设计文档
+   - 使用 \`read_file()\` 阅读架构设计、SPEC 等文档
+   - 了解设计决策及其理由
+
+3. **查看代码实现**
+   - 使用 \`glob("**/package.json")\` 了解项目依赖和技术栈
+   - 使用 \`glob("**/*.ts")\` 或 \`glob("**/*.tsx")\` 了解代码结构
+   - 使用 \`bash("ls -la src/")\` 或 \`bash("ls -la packages/")\` 查看目录结构
+
+4. **回顾现有项目记忆**
+   - 已有记忆路径：\`{CURRENT_MEMORY}\` 中的内容
+   - 了解已有的项目记忆，避免重复记录
+
+5. **搜索会话历史（可选）**
+   - 使用 \`search_sessions("项目 技术栈 架构")\` 搜索相关会话
+   - 使用 \`get_session(session_id)\` 获取感兴趣的会话详情
+
+# 用户指导
+{USER_REQUIREMENT}
+
+# 作用域
+{SCOPE}
+
+# 现有项目记忆
+{CURRENT_MEMORY}
+
+# 可用工具
+- search_sessions(query, session_id?, limit?): 搜索会话历史
+- get_session(session_id): 获取指定会话
+- record_memory({ scope, mode, content, title }): 写入记忆文件
+- glob(pattern, cwd?): 查找匹配的文件
+- bash(command, workdir?): 执行命令
+- read_file(path, offset?, limit?): 读取文件内容
+
+# 执行流程
+1. **收集项目信息**（必须步骤）
+   - 使用 glob + read_file 阅读 README.md、设计文档
+   - 使用 bash + glob 了解代码结构和依赖
+   - 回顾现有项目记忆
+
+2. 理解现有项目记忆
+3. 根据用户指导确定提炼重点
+4. 分析提炼新知识
+5. 整合新旧知识，生成完整的项目记忆
+6. 使用 record_memory({ scope: "project", mode: "overwrite", content, title }) 写入
+
+# 输出要求
+直接调用 record_memory 工具，写入新的项目记忆。
+输出格式为 Markdown，保持结构清晰。`,
+  "global-memory": `# 角色
+你是一个全局记忆管理专家，负责提炼跨项目的通用知识和用户偏好。
+
+# 你的职责
+1. **用户画像**：提炼用户的沟通风格、技术偏好、工作习惯
+2. **目标追踪**：记录用户的长期目标、当前任务、进度
+3. **通用规则**：提炼跨项目都适用的行为规范
+4. **遗忘处理**：标记或移除不再相关的目标和信息
+
+# 全局记忆内容类型
+- 用户偏好：沟通风格（简洁/详细）、反馈偏好、决策风格
+- 技术倾向：偏好的技术栈、框架、语言、开发工具
+- 工作习惯：工作时间、专注周期、偏好时段
+- 当前目标：正在进行的事项、短期目标（1-3月）
+- 长期愿景：大方向、战略目标、人生阶段
+- 跨项目规范：所有项目都遵循的通用规则
+
+# 提炼原则
+1. **以用户为中心**：关注用户怎么说、怎么想，不只是做什么
+2. **目标导向**：区分已完成、进行中、计划中
+3. **可操作性**：偏好要具体，如"用户喜欢先看结论"而非"用户很忙"
+4. **时间敏感**：标记有时间限制的目标
+
+# 用户指导
+{USER_REQUIREMENT}
+
+# 作用域
+{SCOPE}
+
+# 现有全局记忆
+{CURRENT_MEMORY}
+
+# 可用工具
+- search_sessions(query, session_id?, limit?): 搜索会话历史
+- get_session(session_id): 获取指定会话
+- record_memory({ scope, mode, content, title }): 写入记忆文件
+
+# 执行流程
+1. 理解现有全局记忆
+2. 根据用户指导确定提炼重点
+3. 使用工具搜索相关会话历史
+4. 分析提炼新知识
+5. 整合新旧知识，生成完整的全局记忆
+6. 使用 record_memory({ scope: "global", mode: "overwrite", content, title }) 写入
+
+# 输出要求
+直接调用 record_memory 工具，写入新的全局记忆。
+输出格式为 Markdown，保持结构清晰。`
+};
+function getBuiltInPromptNames() {
+  return Object.keys(builtInPrompts);
+}
+function getBuiltInPrompt(name) {
+  return builtInPrompts[name];
+}
+
+// packages/core/src/env/prompt/prompt-component.ts
+init_logger();
+import { readFile, readdir } from "fs/promises";
+import { join, basename, extname } from "path";
+
+// packages/core/src/env/prompt/prompt-config-registration.ts
+var PROMPT_DEFAULTS = {
+  "prompt.defaultName": "default",
+  "prompt.variablePrefix": "{{",
+  "prompt.variableSuffix": "}}"
+};
+var PROMPT_CONFIG_REGISTRATION = {
+  name: "prompt",
+  sources: [
+    { type: "env", envPrefix: "PROMPT", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "prompt.promptPaths", sources: ["env", "file"] },
+    { key: "prompt.defaultName", sources: ["env", "file"] },
+    { key: "prompt.variablePrefix", sources: ["env", "file"] },
+    { key: "prompt.variableSuffix", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/prompt/prompt-component.ts
+var logger = createLogger("prompt");
+
+class PromptComponent extends BaseComponent {
+  name = "prompt";
+  version = "1.0.0";
+  prompts = new Map;
+  config;
+  configComponent;
+  renderer;
+  configWatcher;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for PromptComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.initRenderer();
+    await this.loadPrompts();
+    this.setStatus("running");
+    logger.info(`[PromptComponent] Initialized with ${this.prompts.size} prompts`);
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { config, defaultName, promptPaths, variablePrefix, variableSuffix } = options;
+    configComponent.registerComponent(PROMPT_CONFIG_REGISTRATION);
+    await configComponent.load("prompt");
+    const prefix = "PROMPT";
+    const promptKeys = [
+      "prompt.defaultName",
+      "prompt.promptPaths",
+      "prompt.variablePrefix",
+      "prompt.variableSuffix",
+      "prompt.strictMode"
+    ];
+    for (const key of promptKeys) {
+      const envKey = toEnvKey(key, prefix);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    const loadedKeys = new Set(promptKeys);
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "prompt");
+      if (!configKey)
+        continue;
+      if (loadedKeys.has(configKey))
+        continue;
+      loadedKeys.add(configKey);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(PROMPT_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);
+      }
+    }
+    if (defaultName !== undefined) {
+      await configComponent.set("prompt.defaultName", defaultName);
+    }
+    if (promptPaths !== undefined) {
+      await configComponent.set("prompt.promptPaths", promptPaths);
+    }
+    if (variablePrefix !== undefined) {
+      await configComponent.set("prompt.variablePrefix", variablePrefix);
+    }
+    if (variableSuffix !== undefined) {
+      await configComponent.set("prompt.variableSuffix", variableSuffix);
+    }
+    this.registerConfigWatcher(configComponent);
+    this.config = {
+      defaultName: configComponent.get("prompt.defaultName") || "default",
+      promptPaths: configComponent.get("prompt.promptPaths") || [],
+      variablePrefix: configComponent.get("prompt.variablePrefix") || "{{",
+      variableSuffix: configComponent.get("prompt.variableSuffix") || "}}",
+      strictMode: configComponent.get("prompt.strictMode") || false
+    };
+  }
+  flattenConfig(obj, prefix = "prompt") {
+    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("prompt.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    const key = event.key;
+    const value = event.newValue;
+    if (value === undefined)
+      return;
+    logger.debug(`[PromptComponent] Config updated: ${key} = ${JSON.stringify(value)}`);
+    switch (key) {
+      case "prompt.defaultName":
+        if (this.config)
+          this.config.defaultName = value;
+        break;
+      case "prompt.promptPaths":
+        if (this.config)
+          this.config.promptPaths = value;
+        break;
+      case "prompt.variablePrefix":
+        if (this.config) {
+          this.config.variablePrefix = value;
+          this.initRenderer();
+        }
+        break;
+      case "prompt.variableSuffix":
+        if (this.config) {
+          this.config.variableSuffix = value;
+          this.initRenderer();
+        }
+        break;
+      case "prompt.strictMode":
+        if (this.config)
+          this.config.strictMode = value;
+        break;
+    }
+  }
+  initRenderer() {
+    const config = this.config || {
+      defaultName: "default",
+      promptPaths: [],
+      variablePrefix: "{{",
+      variableSuffix: "}}",
+      strictMode: false
+    };
+    this.renderer = new PromptRenderer({
+      prefix: config.variablePrefix,
+      suffix: config.variableSuffix,
+      strict: config.strictMode,
+      onMissingVariable: (name) => {
+        logger.warn(`Undefined variable: ${name}`);
+        return `{{${name}}}`;
+      }
+    });
+  }
+  async onStart() {
+    logger.info("[PromptComponent] Started");
+  }
+  async onStop() {
+    this.prompts.clear();
+    this.setStatus("stopped");
+    logger.info("[PromptComponent] Stopped");
+  }
+  getPromptConfig(key, defaultValue) {
+    if (this.config && key in this.config) {
+      return this.config[key] ?? defaultValue;
+    }
+    return defaultValue;
+  }
+  add(name, content, source = "inline") {
+    const entry = {
+      name,
+      content,
+      source,
+      overridable: true,
+      loadedAt: Date.now()
+    };
+    const existing = this.prompts.get(name);
+    if (existing && !existing.overridable) {
+      logger.debug(`[PromptComponent] Skip override for non-overridable prompt: ${name}`);
+      return;
+    }
+    this.prompts.set(name, entry);
+    logger.debug(`[PromptComponent] Added prompt: ${name} (${source})`);
+  }
+  get(name) {
+    return this.prompts.get(name)?.content;
+  }
+  getEntry(name) {
+    return this.prompts.get(name);
+  }
+  has(name) {
+    return this.prompts.has(name);
+  }
+  delete(name) {
+    return this.prompts.delete(name);
+  }
+  list() {
+    return Array.from(this.prompts.keys());
+  }
+  size() {
+    return this.prompts.size;
+  }
+  async getPrompt(name, variables = {}) {
+    const defaultName = this.getPromptConfig("defaultName", "default");
+    const targetName = this.has(name) ? name : defaultName;
+    const entry = this.prompts.get(targetName);
+    if (!entry) {
+      logger.warn(`[PromptComponent] Prompt not found: ${name}, using fallback`);
+      return "You are a helpful assistant.";
+    }
+    return this.render(entry.content, variables, { name: targetName });
+  }
+  async render(content, variables = {}, context) {
+    const hookContext = {
+      name: context?.name || "anonymous",
+      originalContent: content,
+      renderedContent: content,
+      variables
+    };
+    await this.executeHooks(PromptHookPoints.BEFORE_RENDER, hookContext);
+    hookContext.renderedContent = this.renderer.render(hookContext.originalContent, variables);
+    await this.executeHooks(PromptHookPoints.AFTER_RENDER, hookContext);
+    return hookContext.renderedContent;
+  }
+  extractVariables(content) {
+    return this.renderer.extractVariables(content);
+  }
+  async loadPrompts() {
+    await this.loadBuiltInPrompts();
+    await this.loadExternalPrompts();
+  }
+  async loadBuiltInPrompts() {
+    for (const [name, content] of Object.entries(builtInPrompts)) {
+      if (content) {
+        this.prompts.set(name, {
+          name,
+          content,
+          source: "built-in",
+          overridable: false,
+          loadedAt: Date.now()
+        });
+        logger.debug(`[PromptComponent] Loaded built-in prompt: ${name}`);
+      }
+    }
+    logger.info(`[PromptComponent] Loaded ${this.prompts.size} built-in prompts`);
+  }
+  async loadExternalPrompts() {
+    const promptPaths = this.getPromptConfig("promptPaths", []);
+    for (const pathConfig of promptPaths) {
+      try {
+        if (pathConfig.type === "file") {
+          await this.loadFromFile(pathConfig.path, pathConfig.name);
+        } else if (pathConfig.type === "directory") {
+          await this.loadFromDirectory(pathConfig.path, pathConfig.extension || ".md", pathConfig.recursive !== false);
+        }
+      } catch (error) {
+        logger.error(`[PromptComponent] Failed to load from ${pathConfig.path}:`, error);
+      }
+    }
+  }
+  async loadFromFile(filePath, name) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const promptName = name || basename(filePath, extname(filePath));
+      this.add(promptName, content.trim(), "file");
+      const entry = this.prompts.get(promptName);
+      if (entry)
+        entry.filePath = filePath;
+      logger.debug(`[PromptComponent] Loaded prompt from file: ${filePath}`);
+      return true;
+    } catch (error) {
+      logger.error(`[PromptComponent] Failed to load file ${filePath}:`, error);
+      return false;
+    }
+  }
+  async loadFromDirectory(directory, extension = ".md", recursive = true) {
+    let loaded = 0;
+    try {
+      const files = await this.findFiles(directory, extension, recursive);
+      for (const filePath of files) {
+        const relativePath = filePath.replace(directory + "/", "");
+        const promptName = relativePath.replace(/\\/g, "/").replace(new RegExp(escapeRegex2(extension) + "$"), "").replace(/\//g, "-");
+        const content = await readFile(filePath, "utf-8");
+        this.add(promptName, content.trim(), "directory");
+        const entry = this.prompts.get(promptName);
+        if (entry)
+          entry.filePath = filePath;
+        loaded++;
+      }
+      logger.info(`[PromptComponent] Loaded ${loaded} prompts from directory: ${directory}`);
+    } catch (error) {
+      logger.error(`[PromptComponent] Failed to load directory ${directory}:`, error);
+    }
+    return loaded;
+  }
+  async findFiles(dir, extension, recursive) {
+    const files = [];
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory() && recursive) {
+          const subFiles = await this.findFiles(fullPath, extension, true);
+          files.push(...subFiles);
+        } else if (entry.isFile() && entry.name.endsWith(extension)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      logger.warn(`[PromptComponent] Cannot read directory ${dir}:`, error);
+    }
+    return files;
+  }
+  registerPromptHook(hookPoint, name, fn, priority) {
+    this.addHook(hookPoint, name, fn, priority);
+  }
+  getHookPoints() {
+    return [PromptHookPoints.BEFORE_RENDER, PromptHookPoints.AFTER_RENDER];
+  }
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { PromptPathSchema, PromptConfigSchema, PromptRenderer, getBuiltInPromptNames, getBuiltInPrompt, PromptComponent };