@ai-setting/roy-agent-core 1.5.87 → 1.5.89

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

@@ -0,0 +1,581 @@
+import {
+  builtInPrompts
+} from "./roy-agent-core-83d035pp.js";
+import {
+  getXDGPath
+} from "./roy-agent-core-qxnbvgwe.js";
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-rgckng3p.js";
+import {
+  createHook
+} from "./roy-agent-core-b8r4tfqq.js";
+import {
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-7tp56w6n.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
+
+// 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"
+};
+
+// 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, "\\$&");
+}
+
+// src/env/prompt/prompt-store.ts
+import { mkdir, readFile, writeFile, unlink, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+init_logger();
+var logger = createLogger("prompt:store");
+
+class PromptStore {
+  configDir;
+  constructor(options = {}) {
+    if (options.configDir && options.configDir.length > 0) {
+      this.configDir = options.configDir;
+    } else if (options.baseDir) {
+      this.configDir = join(options.baseDir, "prompts");
+    } else {
+      this.configDir = join(getXDGPath("data"), "prompts");
+    }
+  }
+  getConfigDir() {
+    return this.configDir;
+  }
+  configDirExists() {
+    return existsSync(this.configDir);
+  }
+  getPromptFilePath(name) {
+    return join(this.configDir, `${name}.md`);
+  }
+  async savePrompt(name, content) {
+    await this.ensureConfigDir();
+    const filePath = this.getPromptFilePath(name);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+    logger.info(`[PromptStore] Saved prompt: ${name} -> ${filePath}`);
+    return filePath;
+  }
+  async deletePrompt(name) {
+    const filePath = this.getPromptFilePath(name);
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    await unlink(filePath);
+    logger.info(`[PromptStore] Deleted prompt file: ${filePath}`);
+    return true;
+  }
+  async loadAll() {
+    if (!existsSync(this.configDir)) {
+      return [];
+    }
+    const prompts = [];
+    await this.collectPrompts(this.configDir, "", prompts);
+    return prompts;
+  }
+  async collectPrompts(directory, prefix, out) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(directory, entry.name);
+      if (entry.isDirectory()) {
+        const nextPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
+        await this.collectPrompts(fullPath, nextPrefix, out);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const baseName = entry.name.slice(0, -3);
+      const name = prefix ? `${prefix}/${baseName}` : baseName;
+      const content = (await readFile(fullPath, "utf-8")).trim();
+      out.push({ name, content, filePath: fullPath });
+    }
+  }
+  async ensureConfigDir() {
+    if (!existsSync(this.configDir)) {
+      await mkdir(this.configDir, { recursive: true });
+      logger.debug(`[PromptStore] Created config directory: ${this.configDir}`);
+    }
+  }
+}
+
+// src/env/prompt/prompt-component.ts
+init_logger();
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join2, basename, extname } from "path";
+
+// src/env/prompt/prompt-config-registration.ts
+var PROMPT_DEFAULTS = {
+  "prompt.defaultName": "default",
+  "prompt.variablePrefix": "{{",
+  "prompt.variableSuffix": "}}",
+  "prompt.configDir": ""
+};
+var PROMPT_CONFIG_REGISTRATION = {
+  name: "prompt",
+  sources: [
+    { type: "env", envPrefix: "PROMPT", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "prompt.promptPaths", sources: ["env", "file"] },
+    { key: "prompt.configDir", sources: ["env", "file"] },
+    { key: "prompt.defaultName", sources: ["env", "file"] },
+    { key: "prompt.variablePrefix", sources: ["env", "file"] },
+    { key: "prompt.variableSuffix", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/prompt/prompt-component.ts
+init_global_hook_manager();
+var logger2 = createLogger("prompt");
+
+class PromptComponent extends BaseComponent {
+  name = "prompt";
+  version = "1.0.0";
+  prompts = new Map;
+  config;
+  configComponent;
+  renderer;
+  promptStore;
+  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();
+    this.initPromptStore();
+    await this.loadPrompts();
+    this.setStatus("running");
+    logger2.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;
+    logger2.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) => {
+        logger2.warn(`Undefined variable: ${name}`);
+        return `{{${name}}}`;
+      }
+    });
+  }
+  async onStart() {
+    logger2.info("[PromptComponent] Started");
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.prompts.clear();
+    this.setStatus("stopped");
+    logger2.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) {
+      logger2.debug(`[PromptComponent] Skip override for non-overridable prompt: ${name}`);
+      return;
+    }
+    this.prompts.set(name, entry);
+    logger2.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());
+  }
+  listEntries() {
+    return Array.from(this.prompts.values());
+  }
+  getPromptStore() {
+    if (!this.promptStore) {
+      this.initPromptStore();
+    }
+    return this.promptStore;
+  }
+  getPromptConfigDir() {
+    return this.getPromptStore().getConfigDir();
+  }
+  async savePrompt(name, content) {
+    const filePath = await this.getPromptStore().savePrompt(name, content.trim());
+    this.add(name, content.trim(), "file");
+    const entry = this.prompts.get(name);
+    if (entry) {
+      entry.filePath = filePath;
+    }
+    return filePath;
+  }
+  async deletePromptFile(name) {
+    const deleted = await this.getPromptStore().deletePrompt(name);
+    if (deleted) {
+      this.delete(name);
+    }
+    return deleted;
+  }
+  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) {
+      logger2.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 globalHookManager.execute(PromptHookPoints.BEFORE_RENDER, hookContext);
+    hookContext.renderedContent = this.renderer.render(hookContext.originalContent, variables);
+    await globalHookManager.execute(PromptHookPoints.AFTER_RENDER, hookContext);
+    return hookContext.renderedContent;
+  }
+  extractVariables(content) {
+    return this.renderer.extractVariables(content);
+  }
+  initPromptStore() {
+    const customDir = this.configComponent?.get?.("prompt.configDir");
+    this.promptStore = new PromptStore({
+      configDir: typeof customDir === "string" && customDir.length > 0 ? customDir : undefined
+    });
+  }
+  async loadPrompts() {
+    await this.loadBuiltInPrompts();
+    await this.loadUserPrompts();
+    await this.loadExternalPrompts();
+  }
+  async loadUserPrompts() {
+    const store = this.getPromptStore();
+    const prompts = await store.loadAll();
+    for (const prompt of prompts) {
+      this.add(prompt.name, prompt.content, "file");
+      const entry = this.prompts.get(prompt.name);
+      if (entry) {
+        entry.filePath = prompt.filePath;
+      }
+    }
+    if (prompts.length > 0) {
+      logger2.info(`[PromptComponent] Loaded ${prompts.length} prompts from ${store.getConfigDir()}`);
+    }
+  }
+  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()
+        });
+        logger2.debug(`[PromptComponent] Loaded built-in prompt: ${name}`);
+      }
+    }
+    logger2.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) {
+        logger2.error(`[PromptComponent] Failed to load from ${pathConfig.path}:`, error);
+      }
+    }
+  }
+  async loadFromFile(filePath, name) {
+    try {
+      const content = await readFile2(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;
+      logger2.debug(`[PromptComponent] Loaded prompt from file: ${filePath}`);
+      return true;
+    } catch (error) {
+      logger2.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 readFile2(filePath, "utf-8");
+        this.add(promptName, content.trim(), "directory");
+        const entry = this.prompts.get(promptName);
+        if (entry)
+          entry.filePath = filePath;
+        loaded++;
+      }
+      logger2.info(`[PromptComponent] Loaded ${loaded} prompts from directory: ${directory}`);
+    } catch (error) {
+      logger2.error(`[PromptComponent] Failed to load directory ${directory}:`, error);
+    }
+    return loaded;
+  }
+  async findFiles(dir, extension, recursive) {
+    const files = [];
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join2(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) {
+      logger2.warn(`[PromptComponent] Cannot read directory ${dir}:`, error);
+    }
+    return files;
+  }
+  registerPromptHook(hookPoint, name, fn, priority) {
+    globalHookManager.register(hookPoint, createHook({ name, priority }, fn));
+  }
+  unregisterPromptHook(hookPoint, name) {
+    return globalHookManager.unregister(hookPoint, name);
+  }
+  getHookPoints() {
+    return [PromptHookPoints.BEFORE_RENDER, PromptHookPoints.AFTER_RENDER];
+  }
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { PromptPathSchema, PromptConfigSchema, PromptRenderer, PromptStore, PromptComponent };

package/dist/shared/@ai-setting/{roy-agent-core-qhjb153z.js → roy-agent-core-xnxyzaw4.js}

@@ -1,3 +1,7 @@
+import {
+  getCurrentProcessRegistry,
+  killProcessTree
+} from "./roy-agent-core-hvdfgvfz.js";
 import {
   init_decorator,
   wrapFunction
@@ -20,7 +24,16 @@ import { Effect as Effect2 } from "effect";
 
 // src/env/tool/built-in/bash-effect.ts
 import { Effect, Context, Layer } from "effect";
-import { spawn } from "child_process";
+import {
+  spawn as _childProcessSpawn
+} from "child_process";
+var spawnInjector;
+function spawn(command, args, options) {
+  if (spawnInjector) {
+    return spawnInjector(command, args, options);
+  }
+  return _childProcessSpawn(command, args, options);
+}
 var BashSpawner = Context.GenericTag("BashSpawner");
 var isWindows = process.platform === "win32";
 var SIGKILL_TIMEOUT_MS = 200;
@@ -63,10 +76,18 @@ var makeBashSpawner = () => {
           shell: true,
           cwd,
           env: { ...process.env, ...env },
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: !isWindows
         };
         child = spawn(command, [], spawnOpts);
         const checkExited = () => exited || !child || !child.pid || child.killed || child.exitCode !== null;
+        const currentRegistry = getCurrentProcessRegistry();
+        if (currentRegistry && child.pid) {
+          currentRegistry.register(child.pid);
+          child.once("exit", () => {
+            currentRegistry.unregister(child.pid);
+          });
+        }
         if (timeout > 0) {
           timer = setTimeout(() => {
             if (!checkExited()) {
@@ -83,8 +104,10 @@ var makeBashSpawner = () => {
           return Effect.sync(() => {
             if (timer)
               clearTimeout(timer);
-            if (!checkExited() && child) {
-              child.kill("SIGKILL");
+            if (!checkExited() && child && child.pid) {
+              try {
+                killProcessTree(child.pid);
+              } catch {}
             }
           });
         });