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

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

@@ -0,0 +1,11 @@
+import {
+  AgentComponentAdapter,
+  init_agent_component_adapter
+} from "./roy-agent-core-rr9p1g43.js";
+import"./roy-agent-core-8dvbn7tw.js";
+import"./roy-agent-core-fs0mn2jk.js";
+init_agent_component_adapter();
+
+export {
+  AgentComponentAdapter
+};

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

@@ -0,0 +1,20 @@
+import {
+  closeDatabase,
+  getDatabase,
+  getDatabasePath,
+  initDatabase,
+  initializeTables,
+  resetDatabase
+} from "./roy-agent-core-qxybm159.js";
+import"./roy-agent-core-yn761yve.js";
+import"./roy-agent-core-1k28kg7h.js";
+import"./roy-agent-core-j8zx62zr.js";
+import"./roy-agent-core-fs0mn2jk.js";
+export {
+  resetDatabase,
+  initializeTables,
+  initDatabase,
+  getDatabasePath,
+  getDatabase,
+  closeDatabase
+};

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

@@ -0,0 +1,82 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/storage/sqlite.ts
+init_logger();
+import { join } from "path";
+var logger = createLogger("workflow:sqlite");
+function getDefaultDataDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share", "roy-agent");
+}
+function getDatabasePath() {
+  return join(getDefaultDataDir(), "workflows.db");
+}
+var dbInstance = null;
+function getDatabase(path) {
+  if (!dbInstance) {
+    const dbPath = path ?? getDatabasePath();
+    const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+    if (dbDir && dbDir !== "/") {
+      try {
+        const { mkdirSync } = __require("fs");
+        mkdirSync(dbDir, { recursive: true });
+      } catch {}
+    }
+    const { Database } = __require("bun:sqlite");
+    dbInstance = new Database(dbPath);
+    try {
+      if (typeof dbInstance.pragma === "function") {
+        dbInstance.pragma("journal_mode = WAL");
+      }
+    } catch {
+      logger?.debug("WAL mode not available, using default journal mode");
+    }
+  }
+  return dbInstance;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+function initializeTables() {
+  const db = getDatabase();
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      version TEXT NOT NULL DEFAULT '1.0',
+      description TEXT,
+      definition TEXT NOT NULL,
+      config TEXT NOT NULL DEFAULT '{}',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      task_id INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
+    CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
+    CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
+  `);
+}
+function resetDatabase() {
+  closeDatabase();
+  dbInstance = null;
+}
+function initDatabase(path) {
+  const db = getDatabase(path);
+  initializeTables();
+  return db;
+}
+
+export { getDatabasePath, getDatabase, closeDatabase, initializeTables, resetDatabase, initDatabase };

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

@@ -0,0 +1,549 @@
+import {
+  exports_tracer_provider,
+  init_propagation,
+  init_tracer_provider,
+  propagation
+} from "./roy-agent-core-1k28kg7h.js";
+import {
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/tool/built-in/bash.ts
+init_propagation();
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function getCurrentSpanContext() {
+  try {
+    const { getTracerProvider } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+    const provider = getTracerProvider();
+    if (!provider.isInitialized()) {
+      throw new Error("Provider not initialized");
+    }
+    const tracer = provider.getTracer("roy-tracer");
+    const ctx = tracer.getCurrentContext();
+    if (ctx && ctx.traceId && ctx.spanId) {
+      return ctx;
+    }
+  } catch {}
+  return;
+}
+function getCurrentTraceId() {
+  const ctx = getCurrentSpanContext();
+  if (ctx) {
+    return ctx.traceId;
+  }
+  return process.env.TRACE_ID;
+}
+var bashTool = {
+  name: "bash",
+  description: "Execute shell commands in the terminal. Use this to run system commands, scripts, or interact with the file system.",
+  parameters: z.object({
+    command: z.string().describe("The shell command to execute"),
+    workdir: z.string().optional().describe("Working directory for the command"),
+    timeout: z.number().int().positive().optional().describe("Timeout in milliseconds"),
+    env: z.record(z.string()).optional().describe("Additional environment variables")
+  }),
+  sandbox: {
+    enabled: true,
+    config: {
+      filesystem: {
+        denyRead: ["/etc/shadow", "/etc/sudoers", "/etc/sudoers.d/*"],
+        denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+      }
+    }
+  },
+  permission: {
+    requireConfirmation: true,
+    level: "dangerous"
+  },
+  metadata: {
+    category: "system",
+    tags: ["shell", "command", "terminal", "exec"],
+    version: "1.2.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const { command, workdir, timeout = 60000, env } = args;
+    const currentSpanCtx = getCurrentSpanContext();
+    const traceId = currentSpanCtx?.traceId || getCurrentTraceId();
+    const options = {
+      timeout
+    };
+    if (workdir || ctx.workdir) {
+      options.cwd = workdir || ctx.workdir;
+    }
+    const childEnv = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) {
+        childEnv[key] = value;
+      }
+    }
+    if (currentSpanCtx) {
+      const carrier = {};
+      propagation.inject(carrier, currentSpanCtx);
+      if (carrier["TRACEPARENT"]) {
+        childEnv["TRACEPARENT"] = carrier["TRACEPARENT"];
+      }
+      childEnv["TRACE_ID"] = currentSpanCtx.traceId;
+      childEnv["PARENT_SPAN_ID"] = currentSpanCtx.spanId;
+    } else if (traceId) {
+      const spanId2 = Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+      childEnv["TRACEPARENT"] = `00-${traceId}-${spanId2}-01`;
+      childEnv["TRACE_ID"] = traceId;
+    }
+    if (env) {
+      Object.assign(childEnv, env);
+    }
+    options.env = childEnv;
+    let otelSpan = undefined;
+    try {
+      const { getTracerProvider } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+      const provider = getTracerProvider();
+      const tracer = provider.getTracer("roy-tracer");
+      otelSpan = tracer.startSpan(`bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`, {
+        attributes: {
+          "bash.command": command.slice(0, 200),
+          "bash.workdir": workdir || ctx.workdir || "",
+          "bash.timeout": timeout
+        }
+      });
+    } catch {}
+    const spanId = otelSpan?.spanContext?.spanId;
+    try {
+      const { stdout, stderr } = await execAsync(command, options);
+      if (otelSpan) {
+        otelSpan.end({ stdout, stderr });
+      }
+      return {
+        success: true,
+        output: stdout || "(no output)",
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          stdout,
+          stderr,
+          exit_code: 0,
+          trace_id: traceId,
+          parent_span_id: currentSpanCtx?.spanId,
+          span_id: spanId
+        }
+      };
+    } catch (error) {
+      const exitCode = error.code || 1;
+      const stdout = error.stdout || "";
+      const stderr = error.stderr || error.message;
+      const execError = new Error(stderr);
+      execError.name = "BashExecutionError";
+      if (otelSpan) {
+        otelSpan.end(undefined, execError);
+      }
+      return {
+        success: exitCode === 0,
+        output: stdout || "(no output)",
+        error: stderr,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          stdout,
+          stderr,
+          exit_code: exitCode,
+          trace_id: traceId,
+          parent_span_id: currentSpanCtx?.spanId,
+          span_id: spanId
+        }
+      };
+    }
+  }
+};
+
+// packages/core/src/env/tool/built-in/echo.ts
+var echoTool = {
+  name: "echo",
+  description: "Echo a message to the console. Useful for logging in workflows.",
+  parameters: {
+    name: "message",
+    schema: {
+      type: "string",
+      description: "The message to echo"
+    }
+  },
+  execute: async (args, _ctx) => {
+    const message = args?.message || "(no message)";
+    return {
+      success: true,
+      output: message,
+      metadata: {
+        execution_time_ms: 0
+      }
+    };
+  }
+};
+
+// packages/core/src/env/tool/built-in/glob.ts
+import { z as z2 } from "zod";
+import { glob as globAsync } from "glob";
+var globTool = {
+  name: "glob",
+  description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
+  parameters: z2.object({
+    pattern: z2.string().describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
+    cwd: z2.string().optional().describe("Working directory to search in"),
+    maxResults: z2.number().int().positive().optional().describe("Maximum number of results to return"),
+    ignore: z2.array(z2.string()).optional().describe("Patterns to ignore")
+  }),
+  sandbox: {
+    enabled: true
+  },
+  metadata: {
+    category: "file",
+    tags: ["search", "file", "glob", "pattern"],
+    version: "1.0.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const { pattern, cwd, maxResults = 100, ignore } = args;
+    const searchDir = cwd || ctx.workdir || process.cwd();
+    try {
+      const files = await globAsync(pattern, {
+        cwd: searchDir,
+        ignore: ignore || ["**/node_modules/**", "**/.git/**"],
+        maxDepth: 20
+      });
+      const limitedFiles = files.slice(0, maxResults);
+      const output = limitedFiles.join(`
+`);
+      return {
+        success: true,
+        output,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          output_size: output.length,
+          total_matches: files.length,
+          returned_matches: limitedFiles.length
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+    }
+  }
+};
+
+// packages/core/src/env/tool/built-in/read-file.ts
+import { z as z3 } from "zod";
+import { readFile } from "fs/promises";
+var readFileTool = {
+  name: "read_file",
+  description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
+  parameters: z3.object({
+    path: z3.string().describe("The file path to read"),
+    offset: z3.number().int().nonnegative().optional().describe("Line offset to start reading from"),
+    limit: z3.number().int().positive().optional().describe("Number of lines to read"),
+    encoding: z3.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding")
+  }),
+  sandbox: {
+    enabled: true,
+    config: {
+      filesystem: {
+        denyRead: ["/etc/shadow", "/etc/sudoers", "/root/.ssh"]
+      }
+    }
+  },
+  permission: {
+    level: "safe"
+  },
+  metadata: {
+    category: "file",
+    tags: ["read", "file", "io"],
+    version: "1.0.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const { path: filePath, offset, limit, encoding = "utf-8" } = args;
+    try {
+      const content = await readFile(filePath, encoding);
+      let output;
+      const contentBuffer = content;
+      const contentStr = typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString(encoding);
+      if (offset !== undefined || limit !== undefined) {
+        const lines = contentStr.split(`
+`);
+        const startLine = offset || 0;
+        const endLine = limit ? startLine + limit : lines.length;
+        output = lines.slice(startLine, endLine).join(`
+`);
+      } else {
+        output = contentStr;
+      }
+      return {
+        success: true,
+        output,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          output_size: output.length,
+          file_path: filePath
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+    }
+  }
+};
+
+// packages/core/src/env/tool/built-in/write-file.ts
+import { z as z4 } from "zod";
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var writeFileTool = {
+  name: "write_file",
+  description: "Write content to a file. Use this to create new files or overwrite existing ones.",
+  parameters: z4.object({
+    path: z4.string().describe("The file path to write to"),
+    content: z4.string().describe("The content to write"),
+    createDirs: z4.boolean().default(false).optional().describe("Create parent directories if they don't exist"),
+    append: z4.boolean().default(false).optional().describe("Append to file instead of overwrite")
+  }),
+  sandbox: {
+    enabled: true,
+    config: {
+      filesystem: {
+        denyWrite: ["/etc", "/usr", "/bin", "/sbin", "/boot", "/sys"]
+      }
+    }
+  },
+  permission: {
+    requireConfirmation: true,
+    level: "dangerous"
+  },
+  metadata: {
+    category: "file",
+    tags: ["write", "file", "io", "create"],
+    version: "1.0.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const { path: filePath, content, createDirs = false, append = false } = args;
+    try {
+      if (createDirs) {
+        await mkdir(dirname(filePath), { recursive: true });
+      }
+      const flags = append ? "a" : "w";
+      await writeFile(filePath, content, { flag: flags });
+      return {
+        success: true,
+        output: append ? `Content appended to: ${filePath}` : `File written: ${filePath}`,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          output_size: content.length,
+          file_path: filePath
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+    }
+  }
+};
+
+// packages/core/src/env/tool/built-in/edit-file.ts
+import { z as z5 } from "zod";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+var editFileTool = {
+  name: "edit_file",
+  description: "Edit a file by replacing specific text. Use this to make targeted changes to files by specifying what to find and what to replace.",
+  parameters: z5.object({
+    path: z5.string().describe("The file path to edit"),
+    oldString: z5.string().describe("The text to find and replace"),
+    newString: z5.string().describe("The replacement text"),
+    replaceAll: z5.boolean().default(false).optional().describe("Replace all occurrences instead of just the first")
+  }),
+  sandbox: {
+    enabled: true,
+    config: {
+      filesystem: {
+        denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+      }
+    }
+  },
+  permission: {
+    requireConfirmation: true,
+    level: "dangerous"
+  },
+  metadata: {
+    category: "file",
+    tags: ["edit", "file", "replace", "modify"],
+    version: "1.0.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const { path: filePath, oldString, newString, replaceAll = false } = args;
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const searchPattern = replaceAll ? new RegExp(escapeRegExp(oldString), "g") : new RegExp(escapeRegExp(oldString));
+      if (!searchPattern.test(content)) {
+        return {
+          success: false,
+          output: "",
+          error: `Could not find "${oldString}" in file ${filePath}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+      const newContent = replaceAll ? content.replace(new RegExp(escapeRegExp(oldString), "g"), newString) : content.replace(oldString, newString);
+      await writeFile2(filePath, newContent, "utf-8");
+      return {
+        success: true,
+        output: replaceAll ? `Replaced all occurrences in: ${filePath}` : `Replaced text in: ${filePath}`,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          file_path: filePath
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+    }
+  }
+};
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// packages/core/src/env/tool/built-in/grep.ts
+import { z as z6 } from "zod";
+import { readFile as readFile3 } from "fs/promises";
+import { glob as globAsync2 } from "glob";
+var grepTool = {
+  name: "grep",
+  description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
+  parameters: z6.object({
+    pattern: z6.string().describe("The pattern to search for"),
+    path: z6.string().optional().describe("File or directory path to search in"),
+    include: z6.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
+    caseSensitive: z6.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
+    maxResults: z6.number().int().positive().default(50).optional().describe("Maximum number of results"),
+    showLineNumbers: z6.boolean().default(true).optional().describe("Show line numbers in results")
+  }),
+  sandbox: {
+    enabled: true
+  },
+  metadata: {
+    category: "file",
+    tags: ["search", "grep", "find", "pattern"],
+    version: "1.0.0"
+  },
+  execute: async (args, ctx) => {
+    const startTime = Date.now();
+    const {
+      pattern,
+      path: searchPath,
+      include,
+      caseSensitive = true,
+      maxResults = 50,
+      showLineNumbers = true
+    } = args;
+    const basePath = searchPath || ctx.workdir || process.cwd();
+    try {
+      let files = [];
+      if (include) {
+        files = await globAsync2(include, {
+          cwd: basePath,
+          ignore: ["**/node_modules/**", "**/.git/**"],
+          maxDepth: 10
+        });
+      } else {
+        files = await globAsync2("**/*", {
+          cwd: basePath,
+          ignore: ["**/node_modules/**", "**/.git/**"],
+          maxDepth: 10
+        });
+      }
+      const results = [];
+      const regexFlags = caseSensitive ? "" : "i";
+      const regex = new RegExp(pattern, regexFlags);
+      for (const file of files) {
+        if (results.length >= maxResults)
+          break;
+        try {
+          const content = await readFile3(`${basePath}/${file}`, "utf-8");
+          const lines = content.split(`
+`);
+          for (let i = 0;i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              const lineNum = showLineNumbers ? `${i + 1}:` : "";
+              results.push(`${file}:${lineNum}${lines[i]}`);
+              if (results.length >= maxResults)
+                break;
+            }
+          }
+        } catch {}
+      }
+      const output = results.join(`
+`) || "(no matches found)";
+      return {
+        success: true,
+        output,
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          output_size: output.length,
+          matches_count: results.length,
+          files_searched: files.length
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+    }
+  }
+};
+
+// packages/core/src/env/tool/built-in/index.ts
+function getAllBuiltInTools() {
+  return [
+    bashTool,
+    echoTool,
+    globTool,
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    grepTool
+  ];
+}
+function getBuiltInTool(name) {
+  const tools = getAllBuiltInTools();
+  return tools.find((t) => t.name === name);
+}
+
+export { bashTool, echoTool, globTool, readFileTool, writeFileTool, editFileTool, grepTool, getAllBuiltInTools, getBuiltInTool };