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

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

@@ -0,0 +1,584 @@
+// packages/core/src/env/debug/formatters/trace-formatter.ts
+class TraceFormatter {
+  formatEntry(entry, options = {}) {
+    const { pretty = false } = options;
+    const actionSymbol = entry.action === "enter" ? ">>>" : entry.action === "error" ? "!!!" : "<<<";
+    let output = `${actionSymbol} ${entry.function} ${entry.action}`;
+    if (entry.action === "enter" && entry.params) {
+      output += `
+` + this.formatData(entry.params, options);
+    } else if (entry.action === "quit") {
+      if (entry.durationMs !== undefined) {
+        output += ` (${entry.durationMs}ms)`;
+      }
+      if (entry.result) {
+        output += `
+` + this.formatData(entry.result, options);
+      }
+    } else if (entry.action === "error" && entry.error) {
+      output += `: ${entry.error}`;
+    }
+    if (pretty) {
+      output = this.indentMultilineContent(output);
+    }
+    return output;
+  }
+  indentMultilineContent(text, indent = "  ") {
+    const lines = text.split(`
+`);
+    if (lines.length <= 1)
+      return text;
+    return lines.map((line, i) => i === 0 ? line : `${indent}${line}`).join(`
+`);
+  }
+  formatEntries(entries, options = {}) {
+    if (entries.length === 0) {
+      return "No trace entries";
+    }
+    const formatted = entries.map((entry) => this.formatEntry(entry, options));
+    if (options.pretty) {
+      return formatted.join(`
+` + "-".repeat(80) + `
+`);
+    }
+    return formatted.join(`
+`);
+  }
+  formatData(data, options = {}) {
+    const { pretty = false, maxDepth = 10 } = options;
+    if (pretty) {
+      return this.formatPretty(data, 0, maxDepth);
+    }
+    return JSON.stringify(data);
+  }
+  formatPretty(data, indent = 0, maxDepth) {
+    const baseIndent = "  ".repeat(indent);
+    const nextIndent = "  ".repeat(indent + 1);
+    if (data === null || data === undefined) {
+      return String(data);
+    }
+    if (typeof data === "string") {
+      if (data.includes(`
+`)) {
+        return data.split(`
+`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
+`);
+      }
+      return data;
+    }
+    if (typeof data === "number" || typeof data === "boolean") {
+      return String(data);
+    }
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return "[]";
+      const items = data.map((item) => {
+        const formatted = this.formatPretty(item, indent + 1, maxDepth);
+        return formatted.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+      });
+      return `[
+` + items.join(`,
+`) + `
+` + baseIndent + "]";
+    }
+    if (typeof data === "object") {
+      const obj = data;
+      const keys = Object.keys(obj);
+      if (keys.length === 0)
+        return "{}";
+      if (indent >= maxDepth) {
+        return "{...}";
+      }
+      const entries = keys.map((key) => {
+        const value = obj[key];
+        let formatted;
+        if (typeof value === "object" && value !== null) {
+          formatted = this.formatPretty(value, indent + 1, maxDepth);
+        } else if (typeof value === "string" && value.includes(`
+`)) {
+          formatted = value.split(`
+`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
+`);
+        } else {
+          formatted = JSON.stringify(value);
+        }
+        return `  ${key}: ` + formatted.split(`
+`).map((line, i) => i === 0 ? line : nextIndent + line).join(`
+`);
+      });
+      return `{
+` + entries.join(`,
+`) + `
+` + baseIndent + "}";
+    }
+    return JSON.stringify(data);
+  }
+  toJSON(entries) {
+    return JSON.stringify(entries, null, 2);
+  }
+  toSummary(entries) {
+    if (entries.length === 0) {
+      return "No trace entries";
+    }
+    const functions = new Set(entries.map((e) => e.function));
+    const actions = entries.reduce((acc, e) => {
+      acc[e.action] = (acc[e.action] || 0) + 1;
+      return acc;
+    }, {});
+    let summary = `Trace Summary (${entries.length} entries)
+`;
+    summary += `Functions: ${[...functions].join(", ")}
+`;
+    summary += `Actions: ${Object.entries(actions).map(([k, v]) => `${k}=${v}`).join(", ")}`;
+    return summary;
+  }
+}
+// packages/core/src/env/debug/formatters/tree-formatter.ts
+var Colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${Colors.reset}`;
+}
+var CHARS = {
+  VERTICAL: "│",
+  VERTICAL_CONNECTOR: "├──",
+  LAST_CONNECTOR: "└──",
+  SPACE: " ",
+  BAR: "█",
+  EMPTY: "░",
+  DASH: "─"
+};
+
+class TreeFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      showPercent: true,
+      showTimeBar: false,
+      barWidth: 10,
+      ...options
+    };
+  }
+  colorByPercent(percent) {
+    if (percent >= 80)
+      return Colors.red;
+    if (percent >= 50)
+      return Colors.yellow;
+    if (percent >= 20)
+      return Colors.cyan;
+    return Colors.dim;
+  }
+  formatTree(node) {
+    const lines = [];
+    const totalDuration = node.durationMs || 0;
+    const percentBase = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0) || totalDuration;
+    lines.push(this.formatNode(node, totalDuration, percentBase, "", true, true));
+    this.formatChildren(node.children, "", lines, totalDuration, percentBase);
+    return lines.join(`
+`);
+  }
+  formatNode(node, totalDuration, percentBase, prefix, isLast, isRoot) {
+    const connector = isRoot ? "" : isLast ? CHARS.LAST_CONNECTOR : CHARS.VERTICAL_CONNECTOR;
+    const prefixStr = isRoot ? "" : prefix;
+    let line = `${prefixStr}${connector} ${node.function}`;
+    if (node.durationMs !== undefined) {
+      line += color(` (${this.formatDuration(node.durationMs)})`, Colors.dim);
+    }
+    if (this.options.showPercent && percentBase > 0 && node.durationMs !== undefined && node.function !== "(root)" && !isRoot) {
+      const percent = Math.round(node.durationMs / percentBase * 100);
+      const percentStr = ` [${percent}%]`;
+      line += color(percentStr, this.colorByPercent(percent));
+    }
+    if (this.options.showTimeBar && node.durationMs !== undefined && totalDuration > 0 && !isRoot) {
+      line += " " + this.renderTimeBar(node.durationMs, totalDuration);
+    }
+    return isRoot ? color(line, Colors.bold) : line;
+  }
+  formatChildren(children, prefix, lines, totalDuration, percentBase) {
+    children.forEach((child, index) => {
+      const isLast = index === children.length - 1;
+      const newPrefix = prefix + (isLast ? "    " : `${CHARS.VERTICAL}   `);
+      lines.push(this.formatNode(child, totalDuration, percentBase, prefix, isLast, false));
+      if (child.children.length > 0) {
+        this.formatChildren(child.children, newPrefix, lines, totalDuration, percentBase);
+      }
+    });
+  }
+  renderTimeBar(duration, total) {
+    const width = this.options.barWidth || 10;
+    const filledWidth = Math.round(duration / total * width);
+    const emptyWidth = width - filledWidth;
+    const bar = CHARS.BAR.repeat(filledWidth) + CHARS.EMPTY.repeat(emptyWidth);
+    return color(`[${bar}]`, Colors.dim);
+  }
+  formatDuration(ms) {
+    if (ms < 1000) {
+      return `${ms}ms`;
+    } else if (ms < 60000) {
+      return `${(ms / 1000).toFixed(2)}s`;
+    } else if (ms < 3600000) {
+      const mins = Math.floor(ms / 60000);
+      const secs = Math.round(ms % 60000 / 1000);
+      return `${mins}m ${secs}s`;
+    } else {
+      const hours = Math.floor(ms / 3600000);
+      const mins = Math.floor(ms % 3600000 / 60000);
+      return `${hours}h ${mins}m`;
+    }
+  }
+  formatTrees(trees) {
+    if (trees.length === 0) {
+      return "No trace trees";
+    }
+    return trees.map((tree) => this.formatTree(tree)).join(`
+
+`);
+  }
+  toJSON(trees) {
+    return JSON.stringify(trees, null, 2);
+  }
+  formatSummary(node) {
+    const rows = [];
+    const total = node.durationMs || 0;
+    const childrenTotal = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0);
+    const percentBase = total > 0 ? total : childrenTotal;
+    const collect = (n, depth) => {
+      if (n.durationMs !== undefined) {
+        rows.push({
+          func: n.function,
+          duration: n.durationMs,
+          percent: percentBase > 0 ? Math.round(n.durationMs / percentBase * 100) : 0,
+          depth
+        });
+      }
+      n.children.forEach((child) => collect(child, depth + 1));
+    };
+    collect(node, 0);
+    rows.sort((a, b) => b.duration - a.duration);
+    const lines = [];
+    lines.push(color(`
+=== Duration Summary ===`, Colors.bold));
+    lines.push(color(`(sorted by time consumption)
+`, Colors.dim));
+    lines.push(color(`  ${"─".repeat(65)}`, Colors.dim));
+    lines.push(color(`  ${"FUNCTION".padEnd(35)} ${"TIME".padEnd(12)} %`, Colors.dim));
+    lines.push(color(`  ${"─".repeat(65)}`, Colors.dim));
+    for (const row of rows) {
+      const indent = "  ".repeat(row.depth);
+      const funcDisplay = row.depth > 0 ? "└─ ".repeat(row.depth) + row.func : row.func;
+      const percentStr = String(row.percent).padStart(3) + "%";
+      const percentColor = row.percent >= 50 ? Colors.red : row.percent >= 20 ? Colors.yellow : Colors.dim;
+      lines.push(`  ${indent}${funcDisplay.substring(0, 35).padEnd(35)}${this.formatDuration(row.duration).padEnd(12)} ${color(percentStr, percentColor)}`);
+    }
+    return lines.join(`
+`);
+  }
+  formatTimeline(node) {
+    const lines = [];
+    const totalDuration = node.durationMs || 0;
+    lines.push(color(`
+=== Timeline: ${node.function} ===`, Colors.bold));
+    lines.push(color(`Total: ${this.formatDuration(totalDuration)}
+`, Colors.dim));
+    const timeline = this.buildTimeline(node, totalDuration, 0, 0);
+    lines.push(...timeline);
+    return lines.join(`
+`);
+  }
+  buildTimeline(node, totalDuration, absoluteOffset, depth) {
+    const lines = [];
+    const width = 40;
+    const startPos = Math.round(absoluteOffset / totalDuration * width);
+    const durationWidth = node.durationMs !== undefined ? Math.max(2, Math.round(node.durationMs / totalDuration * width)) : 2;
+    const bar = " ".repeat(Math.max(0, startPos)) + CHARS.BAR.repeat(durationWidth);
+    const indent = "  ".repeat(depth);
+    const funcName = node.function.length > 25 ? "..." + node.function.slice(-22) : node.function;
+    const time = node.durationMs !== undefined ? this.formatDuration(node.durationMs) : "-";
+    const percent = node.durationMs !== undefined ? ` [${Math.round(node.durationMs / totalDuration * 100)}%]` : "";
+    lines.push(`${indent}${funcName.padEnd(25)} ${bar} ${color(time + percent, Colors.dim)}`);
+    let childOffset = absoluteOffset;
+    for (const child of node.children) {
+      lines.push(...this.buildTimeline(child, totalDuration, childOffset, depth + 1));
+      childOffset += child.durationMs || 0;
+    }
+    return lines;
+  }
+}
+// packages/core/src/env/debug/formatters/repl-formatter.ts
+class ReplFormatter {
+  context = {};
+  history = [];
+  getWelcomeMessage() {
+    return `========================================
+  Debug REPL - Interactive Debugger
+========================================
+
+Commands:
+  list [limit]     - List trace IDs
+  trace [options]  - Show trace details
+  tree [options]   - Show call tree
+  help             - Show this help
+  exit             - Exit REPL
+
+Examples:
+  list 10
+  trace --func llm.invoke
+  tree --trace trace-001
+
+========================================
+`;
+  }
+  formatPrompt(context) {
+    const ctx = { ...this.context, ...context };
+    let prompt = "debug";
+    if (ctx.traceId) {
+      prompt += `:${ctx.traceId}`;
+    } else if (ctx.function) {
+      prompt += `:${ctx.function}`;
+    }
+    return `${prompt}> `;
+  }
+  getHelpText() {
+    return `
+Available Commands:
+==================
+list [n]              - List recent trace IDs (default: 10)
+trace [options]       - Show trace details
+  --func <name>       - Filter by function name
+  --trace <id>        - Show specific trace
+  --pretty            - Pretty print output
+  --limit <n>         - Limit results
+tree [options]        - Show call tree
+  --func <name>       - Show tree for function
+  --trace <id>        - Show tree for trace
+clear                 - Clear screen
+help                  - Show this help
+exit                  - Exit REPL
+`;
+  }
+  formatCommandResult(command, data) {
+    switch (command) {
+      case "list":
+        return this.formatListResult(data);
+      case "trace":
+        return this.formatTraceResult(data);
+      case "tree":
+        return this.formatTreeResult(data);
+      default:
+        return `Unknown command: ${command}`;
+    }
+  }
+  formatListResult(data) {
+    const { traceIds, count } = data;
+    if (traceIds.length === 0) {
+      return "No traces found.";
+    }
+    let output = `
+`;
+    output += `  TraceId            First Time              Count
+`;
+    output += "  " + "-".repeat(70) + `
+`;
+    for (const trace of traceIds) {
+      const time = trace.firstTime.replace("T", " ").substring(0, 19);
+      output += `  ${trace.traceId.padEnd(18)} ${time.padEnd(22)} ${trace.count}
+`;
+    }
+    output += `
+  Total: ${count} traces
+`;
+    return output;
+  }
+  formatTraceResult(entries) {
+    if (entries.length === 0) {
+      return "No traces found.";
+    }
+    let output = "";
+    let currentTraceId = null;
+    for (const entry of entries) {
+      if (entry.traceId !== currentTraceId) {
+        currentTraceId = entry.traceId;
+        output += `
+=== Trace: ${entry.traceId} ===
+
+`;
+      }
+      if (entry.action === "enter") {
+        output += `>>> ${entry.function} enter:`;
+        if (entry.params) {
+          output += `
+` + this.formatJsonCompact(entry.params);
+        }
+        output += `
+`;
+      } else if (entry.action === "quit") {
+        output += `<<< ${entry.function} quit`;
+        if (entry.durationMs !== undefined) {
+          output += ` (${entry.durationMs}ms)`;
+        }
+        if (entry.result) {
+          output += `:
+` + this.formatJsonCompact(entry.result);
+        }
+        output += `
+`;
+      } else if (entry.action === "error") {
+        output += `!!! ${entry.function} error: ${entry.error}
+`;
+      }
+    }
+    return output;
+  }
+  formatTreeResult(trees) {
+    if (trees.length === 0) {
+      return "No trees found.";
+    }
+    let output = "";
+    for (const tree of trees) {
+      output += this.formatTreeNode(tree, "");
+    }
+    return output;
+  }
+  formatTreeNode(node, prefix) {
+    const duration = node.durationMs !== undefined ? ` (${node.durationMs}ms)` : "";
+    let output = `${prefix}${node.function}${duration}
+`;
+    const childPrefix = prefix + "  ";
+    for (let i = 0;i < node.children.length; i++) {
+      const isLast = i === node.children.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+      output += this.formatTreeNode(node.children[i], childPrefix + connector);
+    }
+    return output;
+  }
+  formatJsonCompact(data, indent = 2) {
+    const spaces = "  ".repeat(indent);
+    if (data === null || data === undefined) {
+      return `${spaces}null
+`;
+    }
+    if (typeof data === "string") {
+      if (data.length > 200) {
+        return `${spaces}"${data.substring(0, 200)}..."
+`;
+      }
+      return `${spaces}"${data}"
+`;
+    }
+    if (typeof data === "number" || typeof data === "boolean") {
+      return `${spaces}${data}
+`;
+    }
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return `${spaces}[]
+`;
+      let output = `${spaces}[
+`;
+      for (const item of data) {
+        output += this.formatJsonCompact(item, indent + 1);
+      }
+      output += `${spaces}]
+`;
+      return output;
+    }
+    if (typeof data === "object") {
+      const entries = Object.entries(data);
+      if (entries.length === 0)
+        return `${spaces}{}
+`;
+      let output = `${spaces}{
+`;
+      for (const [key, val] of entries) {
+        output += `${spaces}  ${key}: ${JSON.stringify(val).substring(0, 50)}`;
+        if (JSON.stringify(val).length > 50) {
+          output += "...";
+        }
+        output += `
+`;
+      }
+      output += `${spaces}}
+`;
+      return output;
+    }
+    return `${spaces}${String(data)}
+`;
+  }
+  parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return { command: "help", args: {} };
+    }
+    if (["exit", "quit", "q"].includes(trimmed.toLowerCase())) {
+      return { command: "exit", args: {} };
+    }
+    if (trimmed.toLowerCase() === "clear") {
+      return { command: "clear", args: {} };
+    }
+    if (["help", "?", "h"].includes(trimmed.toLowerCase())) {
+      return { command: "help", args: {} };
+    }
+    const parts = trimmed.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+    if (parts.length === 0) {
+      return { command: "help", args: {} };
+    }
+    const command = parts[0]?.toLowerCase() ?? "";
+    const args = {};
+    for (let i = 1;i < parts.length; i++) {
+      const part = parts[i];
+      if (part.startsWith("--")) {
+        const key = part.substring(2);
+        const next = parts[i + 1];
+        if (next && !next.startsWith("--")) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = "true";
+        }
+      } else if (part.startsWith("-")) {
+        const key = part.substring(1);
+        const next = parts[i + 1];
+        if (next && !next.startsWith("-")) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = "true";
+        }
+      } else {
+        if (command === "list" && !args.limit) {
+          args.limit = part;
+        } else if (command === "trace" && !args.func) {
+          args.func = part;
+        } else if (command === "tree" && !args.func) {
+          args.func = part;
+        }
+      }
+    }
+    return { command, args };
+  }
+  setContext(context) {
+    this.context = { ...this.context, ...context };
+  }
+  getContext() {
+    return { ...this.context };
+  }
+  addToHistory(command) {
+    if (command.trim() && this.history[this.history.length - 1] !== command) {
+      this.history.push(command);
+    }
+  }
+  getHistory() {
+    return [...this.history];
+  }
+}
+export { TraceFormatter, TreeFormatter, ReplFormatter };