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

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

@@ -1,549 +0,0 @@
-import {
-  exports_tracer_provider,
-  init_propagation,
-  init_tracer_provider,
-  propagation
-} from "./roy-agent-core-xs5rsgat.js";
-import {
-  __toCommonJS
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// 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
-        }
-      };
-    }
-  }
-};
-
-// 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
-      }
-    };
-  }
-};
-
-// 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
-        }
-      };
-    }
-  }
-};
-
-// 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
-        }
-      };
-    }
-  }
-};
-
-// 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
-        }
-      };
-    }
-  }
-};
-
-// 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, "\\$&");
-}
-
-// 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
-        }
-      };
-    }
-  }
-};
-
-// 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 };

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

@@ -1,15 +0,0 @@
-import {
-  OTelTracerProvider,
-  getTracerProvider,
-  init_tracer_provider,
-  resetTracerProvider
-} from "./roy-agent-core-xs5rsgat.js";
-import"./roy-agent-core-psv4v63c.js";
-import"./roy-agent-core-fs0mn2jk.js";
-init_tracer_provider();
-
-export {
-  resetTracerProvider,
-  getTracerProvider,
-  OTelTracerProvider
-};