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

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

@@ -1,584 +0,0 @@
-// 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;
-  }
-}
-// 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;
-  }
-}
-// 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 };

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

@@ -1,102 +0,0 @@
-import {
-  __esm,
-  __export
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/session/search-query-parser.ts
-var exports_search_query_parser = {};
-__export(exports_search_query_parser, {
-  parseSearchQuery: () => parseSearchQuery,
-  matchesQuery: () => matchesQuery
-});
-function parseSearchQuery(query) {
-  const result = {
-    required: [],
-    excluded: [],
-    phrases: []
-  };
-  if (!query || !query.trim()) {
-    return result;
-  }
-  const phraseRegex = /"([^"]+)"/g;
-  let match;
-  while ((match = phraseRegex.exec(query)) !== null) {
-    result.phrases.push(match[1].toLowerCase());
-  }
-  query = query.replace(phraseRegex, "");
-  query = query.replace(/\s+/g, " ").trim();
-  if (!query) {
-    return result;
-  }
-  const parts = [];
-  let remaining = query;
-  const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
-  let opMatch;
-  while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
-    const op = opMatch[1].toUpperCase();
-    const beforeText = remaining.slice(0, opMatch.index).trim();
-    if (beforeText) {
-      parts.push({ text: beforeText, operator: undefined });
-    }
-    parts.push({ text: op, operator: op });
-    remaining = remaining.slice(opMatch.index + opMatch[0].length);
-    singleOpRegex.lastIndex = 0;
-  }
-  if (remaining.trim()) {
-    parts.push({ text: remaining.trim(), operator: undefined });
-  }
-  let currentOperator = "AND";
-  for (const part of parts) {
-    if (part.operator) {
-      currentOperator = part.operator;
-    } else {
-      const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
-      const words = part.text.match(wordRegex) || [];
-      for (const word of words) {
-        const lowerWord = word.toLowerCase();
-        if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
-          currentOperator = lowerWord.toUpperCase();
-          continue;
-        }
-        if (currentOperator === "NOT") {
-          if (!result.excluded.includes(lowerWord)) {
-            result.excluded.push(lowerWord);
-          }
-        } else {
-          if (!result.required.includes(lowerWord)) {
-            result.required.push(lowerWord);
-          }
-        }
-        currentOperator = "AND";
-      }
-    }
-  }
-  return result;
-}
-function matchesQuery(content, query) {
-  if (!content) {
-    return query.required.length === 0 && query.phrases.length === 0;
-  }
-  const lowerContent = content.toLowerCase();
-  for (const term of query.excluded) {
-    if (lowerContent.includes(term.toLowerCase())) {
-      return false;
-    }
-  }
-  for (const phrase of query.phrases) {
-    if (!lowerContent.includes(phrase)) {
-      return false;
-    }
-  }
-  if (query.required.length > 0) {
-    for (const term of query.required) {
-      if (!lowerContent.includes(term)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-var init_search_query_parser = () => {};
-
-export { parseSearchQuery, matchesQuery, exports_search_query_parser, init_search_query_parser };