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

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

@@ -0,0 +1,200 @@
+import {
+  getDatabase
+} from "./roy-agent-core-qxybm159.js";
+import {
+  exports_search_query_parser,
+  init_search_query_parser
+} from "./roy-agent-core-0sgn3de4.js";
+import {
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/storage/workflow-repo.ts
+import { randomUUID } from "crypto";
+function rowToWorkflow(row) {
+  const metadata = JSON.parse(row.metadata);
+  if (row.task_id !== null) {
+    metadata.taskId = row.task_id;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    version: row.version,
+    description: row.description || undefined,
+    definition: JSON.parse(row.definition),
+    config: JSON.parse(row.config),
+    metadata,
+    tags: JSON.parse(row.tags),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+
+class WorkflowRepository {
+  db;
+  constructor(db) {
+    this.db = db || getDatabase();
+  }
+  create(workflow) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, workflow.name, workflow.version, workflow.description || null, JSON.stringify(workflow.definition), JSON.stringify(workflow.config), JSON.stringify(workflow.metadata), JSON.stringify(workflow.tags), workflow.metadata?.taskId || null, now, now);
+    return {
+      ...workflow,
+      id,
+      createdAt: new Date(now),
+      updatedAt: new Date(now)
+    };
+  }
+  createFromDefinition(definition, options) {
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: options?.config || definition.config || {},
+      metadata: options?.metadata || definition.metadata || {},
+      tags: options?.tags || definition.metadata?.tags || []
+    };
+    return this.create(workflow);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByName(name) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get(name);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByNameAndVersion(name, version) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  list(options) {
+    let sql = "SELECT * FROM workflows";
+    const params = [];
+    const conditions = [];
+    if (options?.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%${options.tag}%`);
+    }
+    if (options?.taskId !== undefined) {
+      conditions.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    const orderBy = options?.orderBy || "updated_at";
+    const order = options?.order || "desc";
+    sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+    if (options?.limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += " OFFSET ?";
+      params.push(options.offset);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let workflows = rows.map(rowToWorkflow);
+    if (options?.search) {
+      const { parseSearchQuery, matchesQuery } = (init_search_query_parser(), __toCommonJS(exports_search_query_parser));
+      const query = parseSearchQuery(options.search);
+      workflows = workflows.filter((w) => {
+        const descMatch = w.description ? matchesQuery(w.description, query) : false;
+        const tagsMatch = w.tags.some((tag) => matchesQuery(tag, query));
+        return descMatch || tagsMatch;
+      });
+    }
+    return workflows;
+  }
+  listVersions(name) {
+    const rows = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY version DESC").all(name);
+    return rows.map(rowToWorkflow);
+  }
+  update(id, updates) {
+    const existing = this.getById(id);
+    if (!existing)
+      return;
+    const now = new Date().toISOString();
+    const setClauses = ["updated_at = ?"];
+    const params = [now];
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.version !== undefined) {
+      setClauses.push("version = ?");
+      params.push(updates.version);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      params.push(updates.description);
+    }
+    if (updates.definition !== undefined) {
+      setClauses.push("definition = ?");
+      params.push(JSON.stringify(updates.definition));
+    }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      params.push(JSON.stringify(updates.config));
+    }
+    if (updates.metadata !== undefined) {
+      setClauses.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
+      if (updates.metadata.taskId !== undefined) {
+        setClauses.push("task_id = ?");
+        params.push(updates.metadata.taskId);
+      }
+    }
+    if (updates.tags !== undefined) {
+      setClauses.push("tags = ?");
+      params.push(JSON.stringify(updates.tags));
+    }
+    params.push(id);
+    this.db.prepare(`UPDATE workflows SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+    return this.getById(id);
+  }
+  delete(id) {
+    const existing = this.getById(id);
+    if (!existing)
+      return false;
+    this.db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+    return true;
+  }
+  exists(id) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE id = ?").get(id);
+    return result !== undefined;
+  }
+  existsByNameAndVersion(name, version) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    return result !== undefined;
+  }
+  count() {
+    const result = this.db.prepare("SELECT COUNT(*) as count FROM workflows").get();
+    return result.count;
+  }
+  search(query, limit) {
+    let sql = "SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC";
+    const params = [`%${query}%`];
+    if (limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToWorkflow);
+  }
+}
+
+export { rowToWorkflow, WorkflowRepository };

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

@@ -0,0 +1,303 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/src/env/mcp/tool/adapter.ts
+init_logger();
+import { z } from "zod";
+var logger = createLogger("mcp-adapter");
+function adaptMcpTool(mcpTool, mcpClient, serverName) {
+  const toolName = `mcp_${serverName}_${mcpTool.name}`;
+  const description = `MCP tool [${serverName}/${mcpTool.name}]: ${mcpTool.description ?? ""}`;
+  const paramsSchema = convertInputSchemaToZod(mcpTool.inputSchema);
+  return {
+    name: toolName,
+    description,
+    parameters: paramsSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const result = await mcpClient.callTool({
+          name: mcpTool.name,
+          arguments: args ?? {}
+        });
+        return convertMcpCallResult(result);
+      } catch (error) {
+        logger.error(`[McpAdapter] Tool call failed: ${toolName}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    metadata: {
+      category: "mcp",
+      tags: ["mcp", serverName],
+      mcpTool: {
+        originalName: mcpTool.name,
+        originalDescription: mcpTool.description || "",
+        inputSchema: mcpTool.inputSchema
+      }
+    }
+  };
+}
+function convertInputSchemaToZod(inputSchema) {
+  if (!inputSchema) {
+    return z.unknown();
+  }
+  const schema = inputSchema;
+  const properties = schema.properties ?? {};
+  const required = schema.required ?? [];
+  if (schema.anyOf || schema.oneOf) {
+    const unions = schema.anyOf || schema.oneOf || [];
+    const zodUnions = unions.map((s) => jsonSchemaToZod(s, false)).filter((t) => t);
+    if (zodUnions.length > 0) {
+      return z.union(zodUnions);
+    }
+  }
+  if (schema.allOf) {
+    const schemas = [];
+    for (const subSchema of schema.allOf) {
+      const sub = jsonSchemaToZod(subSchema, false);
+      schemas.push(sub);
+    }
+    if (schemas.length === 1) {
+      return schemas[0];
+    }
+    let combined = schemas[0];
+    for (let i = 1;i < schemas.length; i++) {
+      combined = z.intersection(combined, schemas[i]);
+    }
+    return combined;
+  }
+  const zodFields = {};
+  const fieldDescriptions = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    const isRequired = required.includes(key);
+    const fieldResult = jsonSchemaToZod(prop, !isRequired);
+    const propSchema = prop;
+    if (propSchema.description) {
+      fieldDescriptions[key] = propSchema.description;
+    }
+    if (!isRequired) {
+      zodFields[key] = fieldResult.optional();
+    } else {
+      zodFields[key] = fieldResult;
+    }
+  }
+  if (Object.keys(zodFields).length === 0) {
+    return schema.description ? z.unknown().describe(schema.description) : z.unknown();
+  }
+  const result = z.object(zodFields);
+  if (schema.description) {
+    return result.describe(schema.description);
+  }
+  return result;
+}
+function jsonSchemaToZod(prop, isOptional) {
+  const description = prop.description;
+  let baseType;
+  if (prop.nullable === true) {
+    const innerType = jsonSchemaToZod({ ...prop, nullable: undefined }, isOptional);
+    baseType = z.union([innerType, z.null()]);
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  if (prop.anyOf || prop.oneOf) {
+    const unions = prop.anyOf || prop.oneOf || [];
+    const zodUnions = unions.map((s) => jsonSchemaToZod(s, false)).filter((t) => t);
+    if (zodUnions.length > 0) {
+      baseType = z.union(zodUnions);
+      if (description) {
+        return baseType.describe(description);
+      }
+      return baseType;
+    }
+  }
+  if (prop.allOf) {
+    const schemas = [];
+    for (const subSchema of prop.allOf) {
+      const sub = jsonSchemaToZod(subSchema, false);
+      schemas.push(sub);
+    }
+    if (schemas.length === 1) {
+      baseType = schemas[0];
+    } else {
+      baseType = z.intersection(schemas[0], schemas[1]);
+      for (let i = 2;i < schemas.length; i++) {
+        baseType = z.intersection(baseType, schemas[i]);
+      }
+    }
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  const types = prop.types || (prop.type ? [prop.type] : []);
+  if (types.length > 1) {
+    const zodTypes = types.map((t) => getZodTypeForBasicType(t, prop)).filter((t) => t);
+    if (zodTypes.length > 0) {
+      baseType = z.union(zodTypes);
+      if (description) {
+        return baseType.describe(description);
+      }
+      return baseType;
+    }
+  }
+  const type = types[0];
+  if (!type) {
+    if (prop.enum) {
+      return handleEnum(prop, description);
+    }
+    baseType = z.unknown();
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  baseType = getZodTypeForBasicType(type, prop);
+  if (description) {
+    const schemaDescription = baseType._def?.description;
+    if (schemaDescription) {
+      return baseType.describe(`${schemaDescription}. ${description}`);
+    }
+    return baseType.describe(description);
+  }
+  return baseType;
+}
+function getZodTypeForBasicType(type, prop) {
+  switch (type) {
+    case "string": {
+      if (prop.enum && prop.enum.length > 0 && prop.enum.every((v) => typeof v === "string")) {
+        return handleEnum(prop, prop.description);
+      }
+      let schema = z.string();
+      if (typeof prop.minLength === "number") {
+        schema = schema.min(prop.minLength);
+      }
+      if (typeof prop.maxLength === "number") {
+        schema = schema.max(prop.maxLength);
+      }
+      if (prop.pattern) {
+        try {
+          schema = schema.regex(new RegExp(prop.pattern));
+        } catch {}
+      }
+      if (prop.format) {
+        schema = schema.describe(`Format: ${prop.format}`);
+      }
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "number":
+    case "integer": {
+      let schema = type === "integer" ? z.number().int() : z.number();
+      if (typeof prop.minimum === "number") {
+        schema = schema.min(prop.minimum);
+      }
+      if (typeof prop.maximum === "number") {
+        schema = schema.max(prop.maximum);
+      }
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "boolean": {
+      let schema = z.boolean();
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "array": {
+      let itemSchema = z.unknown();
+      if (prop.items) {
+        itemSchema = jsonSchemaToZod(prop.items, false);
+      }
+      let schema = z.array(itemSchema);
+      if (prop.additionalProperties && typeof prop.additionalProperties !== "boolean") {
+        const additionalItems = jsonSchemaToZod(prop.additionalProperties, false);
+        schema = z.array(z.union([itemSchema, additionalItems]));
+      }
+      return schema;
+    }
+    case "object": {
+      if (prop.properties) {
+        const fields = {};
+        const required = prop.required ?? [];
+        for (const [key, value] of Object.entries(prop.properties)) {
+          const isRequired = required.includes(key);
+          fields[key] = isRequired ? jsonSchemaToZod(value, false) : jsonSchemaToZod(value, true).optional();
+        }
+        return z.object(fields);
+      }
+      if (prop.additionalProperties) {
+        if (typeof prop.additionalProperties === "boolean") {
+          return z.record(z.string(), z.unknown());
+        }
+        return z.record(z.string(), jsonSchemaToZod(prop.additionalProperties, false));
+      }
+      return z.record(z.string(), z.unknown());
+    }
+    case "null":
+      return z.null();
+    case "null | string":
+    case "string | null":
+      return z.union([z.string(), z.null()]);
+    case "null | number":
+    case "number | null":
+      return z.union([z.number(), z.null()]);
+    default:
+      if (prop.enum) {
+        return handleEnum(prop);
+      }
+      return z.unknown();
+  }
+}
+function handleEnum(prop, existingDescription) {
+  if (!prop.enum || prop.enum.length === 0) {
+    return z.unknown();
+  }
+  const stringValues = prop.enum.filter((v) => typeof v === "string");
+  if (stringValues.length === 0) {
+    return z.any();
+  }
+  let schema;
+  if (stringValues.length === 1) {
+    schema = z.literal(stringValues[0]);
+  } else {
+    schema = z.enum([stringValues[0], ...stringValues.slice(1)]);
+  }
+  const valuesList = stringValues.map((v) => `"${v}"`).join(", ");
+  const valuesDescription = `Valid values: ${valuesList}`;
+  if (existingDescription) {
+    return schema.describe(`${existingDescription}. ${valuesDescription}`);
+  }
+  return schema.describe(valuesDescription);
+}
+function convertMcpCallResult(result) {
+  const content = result.content;
+  const textContent = content?.filter((c) => c.type === "text")?.map((c) => c.text)?.join("") ?? "";
+  return {
+    success: !result.isError,
+    output: textContent,
+    error: result.isError ? textContent : undefined
+  };
+}
+function createMcpToolsDescription(tools) {
+  if (tools.length === 0) {
+    return "  No MCP tools currently available.";
+  }
+  return tools.map((t) => `  - ${t.name}: ${t.description}`).join(`
+`);
+}
+
+export { adaptMcpTool, convertInputSchemaToZod, createMcpToolsDescription };

package/dist/{env/hook/index.js → shared/@ai-setting/roy-agent-core-w75rafhy.js}

@@ -1,64 +1,3 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/core/src/env/hook/types.ts
-function createHook(meta, fn) {
-  return {
-    ...meta,
-    execute: fn
-  };
-}
-function createPriorityHook(name, fn, priority) {
-  return createHook({ name, priority }, fn);
-}
 // packages/core/src/env/hook/hook-manager.ts
 class HookManager {
   _hooks = new Map;
@@ -203,6 +142,7 @@ class HookManager {
     }
   }
 }
+
 // packages/core/src/env/hook/global-hook-manager.ts
 var globalHookManager = new HookManager;
 var AgentHookPoints = {
@@ -258,16 +198,5 @@ async function executeLLMHook(hookPoint, data, metadata = {}) {
 async function executeToolHook(hookPoint, data, metadata = {}) {
   await globalHookManager.execute(hookPoint, data, metadata);
 }
-export {
-  globalHookManager,
-  executeToolHook,
-  executeLLMHook,
-  executeAgentHookWithIntervention,
-  executeAgentHook,
-  createPriorityHook,
-  createHook,
-  ToolHookPoints,
-  LLMHookPoints,
-  HookManager,
-  AgentHookPoints
-};
+
+export { HookManager, globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, executeAgentHook, executeAgentHookWithIntervention, executeLLMHook, executeToolHook };

package/dist/{env/debug/formatters/index.js → shared/@ai-setting/roy-agent-core-w76hqkmg.js}

@@ -1,54 +1,3 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
 // packages/core/src/env/debug/formatters/trace-formatter.ts
 class TraceFormatter {
   formatEntry(entry, options = {}) {
@@ -201,13 +150,13 @@ function color(text, colorCode) {
   return `${colorCode}${text}${Colors.reset}`;
 }
 var CHARS = {
-  VERTICAL: "\u2502",
-  VERTICAL_CONNECTOR: "\u251C\u2500\u2500",
-  LAST_CONNECTOR: "\u2514\u2500\u2500",
+  VERTICAL: "│",
+  VERTICAL_CONNECTOR: "├──",
+  LAST_CONNECTOR: "└──",
   SPACE: " ",
-  BAR: "\u2588",
-  EMPTY: "\u2591",
-  DASH: "\u2500"
+  BAR: "█",
+  EMPTY: "░",
+  DASH: "─"
 };
 
 class TreeFormatter {
@@ -321,12 +270,12 @@ class TreeFormatter {
 === Duration Summary ===`, Colors.bold));
     lines.push(color(`(sorted by time consumption)
 `, Colors.dim));
-    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
+    lines.push(color(`  ${"─".repeat(65)}`, Colors.dim));
     lines.push(color(`  ${"FUNCTION".padEnd(35)} ${"TIME".padEnd(12)} %`, Colors.dim));
-    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
+    lines.push(color(`  ${"─".repeat(65)}`, Colors.dim));
     for (const row of rows) {
       const indent = "  ".repeat(row.depth);
-      const funcDisplay = row.depth > 0 ? "\u2514\u2500 ".repeat(row.depth) + row.func : row.func;
+      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)}`);
@@ -507,7 +456,7 @@ exit                  - Exit REPL
     const childPrefix = prefix + "  ";
     for (let i = 0;i < node.children.length; i++) {
       const isLast = i === node.children.length - 1;
-      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const connector = isLast ? "└── " : "├── ";
       output += this.formatTreeNode(node.children[i], childPrefix + connector);
     }
     return output;
@@ -632,8 +581,4 @@ exit                  - Exit REPL
     return [...this.history];
   }
 }
-export {
-  TreeFormatter,
-  TraceFormatter,
-  ReplFormatter
-};
+export { TraceFormatter, TreeFormatter, ReplFormatter };