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

package/dist/env/memory/plugin/index.js

@@ -1,1263 +0,0 @@
-// @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/log-trace/span-storage.ts
-var exports_span_storage = {};
-__export(exports_span_storage, {
-  SQLiteSpanStorage: () => SQLiteSpanStorage
-});
-
-class SQLiteSpanStorage {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-    }
-    if (dbPath === ":memory:") {
-      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-    }
-    this.dbPath = dbPath;
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { Database } = __require("bun:sqlite");
-    const fs = __require("fs");
-    const path = __require("path");
-    const dir = path.dirname(this.dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(this.dbPath);
-    this.db.run("PRAGMA journal_mode=WAL");
-    this.db.run("PRAGMA busy_timeout=5000");
-    this.db.run("PRAGMA synchronous=NORMAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-    this.initialized = true;
-  }
-  save(span) {
-    if (!this.db)
-      return;
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
-    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-  }
-  saveBatch(spans) {
-    for (const span of spans) {
-      this.save(span);
-    }
-  }
-  findByTraceId(traceId) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-    return this.buildTree(rows.map(this.rowToSpan));
-  }
-  findBySpanId(spanId) {
-    if (!this.db)
-      return;
-    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-    return row ? this.rowToSpan(row) : undefined;
-  }
-  listTraces(limit = 10) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-    return rows.map((row) => ({
-      traceId: row.trace_id,
-      rootSpanName: "unknown",
-      startTime: row.start_time,
-      endTime: row.end_time,
-      duration: row.end_time - row.start_time,
-      spanCount: row.span_count,
-      status: "ok"
-    }));
-  }
-  deleteByTraceId(traceId) {
-    if (this.db) {
-      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-    }
-  }
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  rowToSpan(row) {
-    return {
-      traceId: row.trace_id,
-      spanId: row.span_id,
-      parentSpanId: row.parent_span_id,
-      name: row.name,
-      kind: row.kind,
-      status: row.status,
-      startTime: row.start_time,
-      endTime: row.end_time,
-      attributes: row.attributes ? JSON.parse(row.attributes) : {},
-      result: row.result || undefined,
-      error: row.error || undefined
-    };
-  }
-  buildTree(spans) {
-    const spanMap = new Map;
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanId, { ...span, children: [] });
-    }
-    for (const span of spanMap.values()) {
-      if (span.parentSpanId) {
-        const parent = spanMap.get(span.parentSpanId);
-        if (parent) {
-          parent.children.push(span);
-        } else {
-          roots.push(span);
-        }
-      } else {
-        roots.push(span);
-      }
-    }
-    return roots;
-  }
-}
-
-// packages/core/src/env/log-trace/opentelemetry/propagation.ts
-function padLeft(str, length) {
-  return str.padStart(length, "0");
-}
-function isValidHex(str) {
-  return /^[0-9a-f]+$/i.test(str);
-}
-function serialize(context) {
-  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
-  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
-  const parts = [
-    TRACE_CONTEXT_VERSION,
-    traceId,
-    spanId,
-    TRACE_FLAGS_SAMPLED
-  ];
-  return parts.join("-");
-}
-function parse(traceparent) {
-  if (!traceparent || typeof traceparent !== "string") {
-    return;
-  }
-  const trimmed = traceparent.trim();
-  const parts = trimmed.split("-");
-  if (parts.length !== 4) {
-    return;
-  }
-  const [version, traceId, senderSpanId, flags] = parts;
-  if (version !== TRACE_CONTEXT_VERSION) {
-    if (version > TRACE_CONTEXT_VERSION) {
-      return;
-    }
-  }
-  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
-    return;
-  }
-  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
-    return;
-  }
-  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
-    return;
-  }
-  return {
-    traceId: traceId.toLowerCase(),
-    spanId: senderSpanId.toLowerCase()
-  };
-}
-var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
-var init_propagation = __esm(() => {
-  propagation = {
-    inject(carrier, context) {
-      carrier[TRACEPARENT_HEADER] = serialize(context);
-    },
-    extract(carrier) {
-      const traceparent = carrier[TRACEPARENT_HEADER];
-      if (!traceparent) {
-        return;
-      }
-      return parse(traceparent);
-    },
-    getTraceparentHeader() {
-      return TRACEPARENT_HEADER;
-    }
-  };
-});
-
-// packages/core/src/env/log-trace/types.ts
-var SpanKind, SpanStatus;
-var init_types = __esm(() => {
-  ((SpanKind2) => {
-    SpanKind2["CLIENT"] = "client";
-    SpanKind2["SERVER"] = "server";
-    SpanKind2["INTERNAL"] = "internal";
-  })(SpanKind ||= {});
-  ((SpanStatus2) => {
-    SpanStatus2["OK"] = "ok";
-    SpanStatus2["ERROR"] = "error";
-  })(SpanStatus ||= {});
-});
-
-// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
-var exports_tracer_provider = {};
-__export(exports_tracer_provider, {
-  resetTracerProvider: () => resetTracerProvider,
-  getTracerProvider: () => getTracerProvider,
-  OTelTracerProvider: () => OTelTracerProvider
-});
-
-class OTelSpanImpl {
-  name;
-  kind;
-  spanContext;
-  attributes = {};
-  startTime;
-  endTime;
-  error;
-  storage;
-  parentSpanContext;
-  onEnd;
-  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
-    this.name = name;
-    this.kind = "internal";
-    this.spanContext = spanContext;
-    this.parentSpanContext = parentSpanContext;
-    this.startTime = Date.now();
-    this.storage = storage;
-    this.onEnd = onEnd;
-  }
-  setAttribute(key, value) {
-    this.attributes[key] = value;
-  }
-  addEvent(name, attributes) {
-    const events = this.attributes._events || [];
-    events.push({ name, attributes });
-    this.attributes._events = events;
-  }
-  end(result, error) {
-    this.endTime = Date.now();
-    if (error) {
-      this.error = error.message;
-    }
-    this.storage.save({
-      traceId: this.spanContext.traceId,
-      spanId: this.spanContext.spanId,
-      parentSpanId: this.spanContext.parentSpanId,
-      name: this.name,
-      kind: this.kind,
-      status: error ? "error" /* ERROR */ : "ok" /* OK */,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      result,
-      error: this.error
-    });
-    this.onEnd?.();
-  }
-}
-
-class OTelTracerImpl {
-  name;
-  version;
-  storage;
-  currentContext;
-  activeSpans = new Map;
-  onSpanEndCallback;
-  provider;
-  constructor(name, version, storage, provider) {
-    this.name = name;
-    this.version = version;
-    this.storage = storage;
-    this.provider = provider;
-  }
-  setOnSpanEndCallback(callback) {
-    this.onSpanEndCallback = callback;
-  }
-  getActiveSpanCount() {
-    return this.activeSpans.size;
-  }
-  startSpan(name, options) {
-    const parentFromOptions = options?.parent;
-    const hasExplicitParent = options && "parent" in options;
-    const globalContext = this.provider.getGlobalContext();
-    let effectiveParentContext;
-    if (hasExplicitParent) {
-      effectiveParentContext = parentFromOptions;
-    } else if (this.currentContext) {
-      effectiveParentContext = this.currentContext;
-    } else if (globalContext) {
-      effectiveParentContext = globalContext;
-    }
-    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
-    const spanId = this.generateSpanId();
-    let parentSpanId;
-    if (hasExplicitParent && parentFromOptions) {
-      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
-    } else if (this.currentContext) {
-      parentSpanId = this.currentContext.spanId;
-    } else if (globalContext) {
-      parentSpanId = globalContext.spanId;
-    }
-    const spanContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    this.currentContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
-    if (options?.attributes) {
-      for (const [key, value] of Object.entries(options.attributes)) {
-        span.setAttribute(key, value);
-      }
-    }
-    this.activeSpans.set(spanId, span);
-    return span;
-  }
-  injectToEnv(env) {
-    if (this.currentContext) {
-      propagation.inject(env, this.currentContext);
-    }
-  }
-  getCurrentContext() {
-    return this.currentContext;
-  }
-  setCurrentContext(context) {
-    this.currentContext = context;
-  }
-  endSpan(span) {
-    const spanContext = span.spanContext;
-    this.activeSpans.delete(spanContext.spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (spanContext.parentSpanId) {
-      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
-      if (parentSpan) {
-        const parentContext = {
-          traceId: spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-      if (currentTraceId) {
-        const parentContext = {
-          traceId: currentTraceId,
-          spanId: spanContext.parentSpanId,
-          parentSpanId: undefined
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-    }
-    this.currentContext = undefined;
-    return;
-  }
-  generateTraceId() {
-    const timestamp = Date.now().toString(16).padStart(12, "0");
-    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
-    return (timestamp + random).slice(0, 32).padStart(32, "0");
-  }
-  generateSpanId() {
-    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
-  }
-  handleSpanEnd(spanId, parentSpanId) {
-    this.activeSpans.delete(spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (parentSpanId) {
-      const parentSpan = this.activeSpans.get(parentSpanId);
-      if (parentSpan) {
-        this.currentContext = {
-          traceId: parentSpan.spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        return;
-      }
-      if (currentTraceId) {
-        this.currentContext = {
-          traceId: currentTraceId,
-          spanId: parentSpanId,
-          parentSpanId: undefined
-        };
-        return;
-      }
-    }
-    this.currentContext = undefined;
-  }
-}
-
-class OTelTracerProvider {
-  tracers = new Map;
-  storage;
-  initialized = false;
-  globalContext;
-  constructor(storage, dbPath) {
-    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.storage.initialize();
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  getGlobalContext() {
-    return this.globalContext;
-  }
-  setGlobalContext(context) {
-    this.globalContext = context;
-  }
-  getTracer(name, version) {
-    const key = `${name}@${version || "0.0.0"}`;
-    let tracer = this.tracers.get(key);
-    if (!tracer) {
-      tracer = new OTelTracerImpl(name, version, this.storage, this);
-      this.tracers.set(key, tracer);
-      if (this.initialized) {
-        this.restoreFromEnv(tracer);
-      }
-    }
-    return tracer;
-  }
-  restoreFromEnv(tracer) {
-    const extracted = propagation.extract(process.env);
-    if (extracted) {
-      tracer.setCurrentContext({
-        traceId: extracted.traceId,
-        spanId: extracted.spanId,
-        parentSpanId: undefined
-      });
-    }
-  }
-  shutdown() {
-    for (const tracer of this.tracers.values()) {}
-    this.tracers.clear();
-    this.storage.close();
-    this.initialized = false;
-    this.globalContext = undefined;
-    delete process.env["TRACEPARENT"];
-    delete process.env["TRACE_ID"];
-    delete process.env["LOG_TRACE_REQUEST_ID"];
-  }
-  getStorage() {
-    return this.storage;
-  }
-}
-function getTracerProvider() {
-  if (!providerInstance) {
-    providerInstance = new OTelTracerProvider;
-  }
-  return providerInstance;
-}
-function resetTracerProvider() {
-  if (providerInstance) {
-    providerInstance.shutdown();
-    providerInstance = null;
-  }
-}
-function getDefaultDbPath() {
-  const os = __require("os");
-  const path = __require("path");
-  const home = os.homedir();
-  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
-  return path.join(dataHome, "roy-agent", "traces.db");
-}
-var providerInstance = null;
-var init_tracer_provider = __esm(() => {
-  init_propagation();
-  init_types();
-});
-
-// packages/core/src/env/log-trace/logger.ts
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-function simplifyFilePath(fullPath) {
-  let path = fullPath.replace(/\\/g, "/");
-  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
-  if (bunfsMatch) {
-    const virtualPath = bunfsMatch[1];
-    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-    if (packagesMatch) {
-      return packagesMatch[1];
-    }
-    return virtualPath;
-  }
-  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
-  if (fileProtocolMatch) {
-    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
-    const remaining = fileProtocolMatch[2];
-    const prefix = rootPkg;
-    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
-    return `${prefix}/${suffix}`;
-  }
-  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-  if (packagesRootMatch) {
-    return packagesRootMatch[1];
-  }
-  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
-  for (const marker of rootMarkers) {
-    const idx = path.indexOf(marker);
-    if (idx !== -1) {
-      return path.substring(idx);
-    }
-  }
-  return path;
-}
-function getDefaultLogDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  try {
-    const xdg = __require("xdg-basedir");
-    if (xdg.xdgData) {
-      return join(xdg.xdgData, "roy-agent", "logs");
-    }
-  } catch {}
-  return join(home, ".local", "share", "roy-agent", "logs");
-}
-function isQuietMode() {
-  return quietMode;
-}
-function setQuietMode(enabled) {
-  quietMode = enabled;
-}
-function setConfigComponent(component) {
-  configComponentInstance = component;
-}
-function getLogLevel() {
-  if (configComponentInstance) {
-    const level = configComponentInstance.get("log_trace.logging.level");
-    if (level && ["debug", "info", "warn", "error"].includes(level)) {
-      return level;
-    }
-  }
-  const envLevel = process.env.LOG_LEVEL;
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return "info";
-}
-function getCategoryLogLevel(category) {
-  if (configComponentInstance) {
-    const levels = configComponentInstance.get("log_trace.logging.levels");
-    if (levels && typeof levels === "object") {
-      const categoryLevel = levels[category];
-      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
-        return categoryLevel;
-      }
-    }
-    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
-    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
-      return directLevel;
-    }
-  }
-  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
-  const envLevel = process.env[envKey];
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return getLogLevel();
-}
-function isAbsolutePath(path) {
-  if (path.startsWith("/")) {
-    return true;
-  }
-  if (/^[a-zA-Z]:[/\\]/.test(path)) {
-    return true;
-  }
-  return false;
-}
-function expandHomeDir(path) {
-  if (path.startsWith("~")) {
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    return join(home, path.slice(1));
-  }
-  return path;
-}
-function getLogFile() {
-  if (configComponentInstance) {
-    const file = configComponentInstance.get("log_trace.logging.file");
-    if (file) {
-      return file;
-    }
-  }
-  return "app.log";
-}
-function getLogDir() {
-  if (configComponentInstance) {
-    const dir = configComponentInstance.get("log_trace.logging.dir");
-    if (dir) {
-      return dir;
-    }
-  }
-  return getDefaultLogDir();
-}
-function getMaxOutput() {
-  if (configComponentInstance) {
-    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
-    if (typeof maxOutput === "number") {
-      return maxOutput;
-    }
-  }
-  return;
-}
-function setLogDirOverride(dir) {
-  logDirOverride = dir;
-}
-function getLogDirOverride() {
-  return logDirOverride;
-}
-
-class Logger {
-  prefix;
-  constructor(prefix) {
-    this.prefix = prefix;
-  }
-  shouldLog(level) {
-    const categoryLevel = getCategoryLogLevel(this.prefix);
-    return levelPriority[level] >= levelPriority[categoryLevel];
-  }
-  ensureLogDirectory(dir) {
-    if (!existsSync(dir)) {
-      try {
-        mkdirSync(dir, { recursive: true });
-      } catch (err) {
-        console.error("[Logger] Failed to create log directory:", dir, err);
-      }
-    }
-  }
-  getCallerLocation() {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 10;
-    const err = new Error;
-    Error.captureStackTrace(err, this.formatMessage);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
-        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-        if (match) {
-          const filePath = match[1];
-          const relativePath = this.getRelativePath(filePath);
-          return {
-            file: relativePath,
-            line: parseInt(match[2], 10)
-          };
-        }
-      }
-    }
-    return null;
-  }
-  getRelativePath(fullPath) {
-    return simplifyFilePath(fullPath);
-  }
-  formatMessage(level, message, data) {
-    const now = new Date;
-    const timestamp = now.toLocaleString("zh-CN", {
-      timeZone: "Asia/Shanghai",
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false
-    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
-    const prefix = this.prefix ? `[${this.prefix}]` : "";
-    let traceIdStr = "";
-    try {
-      const provider = getTracerProvider();
-      const tracer = provider.getTracer("roy-tracer");
-      const context = tracer.getCurrentContext();
-      if (context?.traceId) {
-        traceIdStr = `[traceId=${context.traceId}]`;
-      }
-    } catch {}
-    let locationStr = "";
-    if (data && typeof data === "object" && "callerLocation" in data) {
-      const logData = data;
-      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
-      const { callerLocation: _callerLocation, ...rest } = logData;
-      data = Object.keys(rest).length > 0 ? rest : undefined;
-    } else {
-      const location = this.getCallerLocation();
-      if (location) {
-        locationStr = ` [${location.file}:${location.line}]`;
-      }
-    }
-    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
-    if (data !== undefined) {
-      if (typeof data === "object") {
-        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
-      } else {
-        formatted += " " + String(data);
-      }
-    }
-    const maxOutput = getMaxOutput();
-    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
-      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
-    }
-    return formatted;
-  }
-  writeToFile(message) {
-    try {
-      const dir = getLogDir();
-      const filename = getLogFile();
-      const expandedDir = expandHomeDir(dir);
-      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
-      this.ensureLogDirectory(resolvedDir);
-      const logFile = join(resolvedDir, filename);
-      appendFileSync(logFile, message + `
-`, "utf-8");
-    } catch (err) {
-      console.error("[Logger] Failed to write to log file:", err);
-    }
-  }
-  log(level, message, data) {
-    if (!this.shouldLog(level))
-      return;
-    const formatted = this.formatMessage(level, message, data);
-    this.writeToFile(formatted);
-    if (!isQuietMode()) {
-      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
-      consoleMethod(formatted);
-    }
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  error(message, data) {
-    this.log("error", message, data);
-  }
-}
-function createLogger(prefix) {
-  if (!loggerCache.has(prefix)) {
-    loggerCache.set(prefix, new Logger(prefix));
-  }
-  return loggerCache.get(prefix);
-}
-function getLogLevels() {
-  return ["debug", "info", "warn", "error"];
-}
-var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
-var init_logger = __esm(() => {
-  init_tracer_provider();
-  levelPriority = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
-  };
-  loggerCache = new Map;
-});
-
-// packages/core/src/env/memory/plugin/memory-manager.ts
-init_logger();
-var logger = createLogger("MemoryManagerV3");
-function generateTaskId() {
-  return `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-class MemoryManager {
-  static MAX_QUEUE_SIZE = 100;
-  queue = [];
-  processing = false;
-  shuttingDown = false;
-  config;
-  processingPromise = null;
-  resolveProcessing = null;
-  constructor(config = {}) {
-    this.config = config;
-  }
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  enqueue(task) {
-    if (this.shuttingDown) {
-      logger.debug("MemoryManager is shutting down, ignoring new task");
-      return;
-    }
-    const fullTask = {
-      ...task,
-      id: generateTaskId()
-    };
-    if (this.queue.length >= MemoryManager.MAX_QUEUE_SIZE) {
-      const dropped = this.queue.shift();
-      logger.warn(`Queue full (${MemoryManager.MAX_QUEUE_SIZE}), dropping oldest task: ${dropped?.id}`);
-    }
-    this.queue.push(fullTask);
-    logger.debug(`Task enqueued: ${task.type}, queue size: ${this.queue.length}`);
-    if (!this.processing) {
-      this.startProcessingLoop();
-    }
-  }
-  startProcessingLoop() {
-    const runLoop = async () => {
-      while (this.queue.length > 0 && !this.shuttingDown) {
-        const task = this.queue.shift();
-        try {
-          await this.processTask(task);
-        } catch (error) {
-          logger.error(`Task ${task.id} failed:`, error);
-        }
-      }
-      this.processing = false;
-      if (this.resolveProcessing) {
-        this.resolveProcessing();
-        this.resolveProcessing = null;
-        this.processingPromise = null;
-      }
-    };
-    this.processing = true;
-    this.processingPromise = new Promise((resolve) => {
-      this.resolveProcessing = resolve;
-    });
-    setImmediate(() => {
-      runLoop().catch((error) => {
-        logger.error("Processing loop error:", error);
-        this.processing = false;
-      });
-    });
-  }
-  hasPendingTasks() {
-    return this.queue.length > 0 || this.processing;
-  }
-  async waitForCompletion() {
-    if (this.queue.length === 0 && !this.processing) {
-      return;
-    }
-    if (this.processingPromise) {
-      await this.processingPromise;
-    }
-  }
-  prepareShutdown() {
-    this.shuttingDown = true;
-    logger.info("MemoryManager preparing for shutdown");
-  }
-  async dispose() {
-    await this.waitForCompletion();
-    this.queue = [];
-    logger.info("MemoryManager disposed");
-  }
-  async processTask(task) {
-    logger.debug(`Processing task: ${task.type}`);
-    switch (task.type) {
-      case "extract_memory":
-        await this.handleExtractMemory(task.payload);
-        break;
-      default:
-        logger.warn(`Unknown task type: ${task.type}`);
-    }
-  }
-  async handleExtractMemory(payload) {
-    const messageCount = payload.messages?.length || 0;
-    logger.info(`Extracting memory from ${messageCount} messages`);
-    if (this.config.onExtractMemory) {
-      try {
-        await this.config.onExtractMemory(payload);
-      } catch (error) {
-        logger.error("Memory extraction failed", { error });
-      }
-    }
-  }
-}
-// packages/core/src/env/memory/plugin/types.ts
-var DEFAULT_MEMORY_PLUGIN_CONFIG = {
-  enabled: true
-};
-
-// packages/core/src/env/memory/plugin/memory-plugin.ts
-init_logger();
-import path from "path";
-import os from "os";
-var logger2 = createLogger("MemoryPlugin");
-
-class MemoryPlugin {
-  config;
-  disposed = false;
-  initialized = false;
-  projectBaseDir = "";
-  globalBaseDir = "";
-  workDir = "";
-  agentComponent = null;
-  constructor(baseDir, config = {}) {
-    this.config = { ...DEFAULT_MEMORY_PLUGIN_CONFIG, ...config };
-    this.workDir = baseDir;
-    this.projectBaseDir = path.join(baseDir, ".roy", "memory");
-    this.globalBaseDir = path.join(os.homedir(), ".config", "roy-agent", "memory");
-    logger2.info("MemoryPlugin (simplified) created", { baseDir, config: this.config });
-  }
-  get name() {
-    return "MemoryPlugin";
-  }
-  get hookPoint() {
-    return "agent:after.react";
-  }
-  get priority() {
-    return 50;
-  }
-  get description() {
-    return "Memory management plugin. Use 'roy memory recall --extract' to extract memories.";
-  }
-  get hooks() {
-    return [
-      {
-        point: this.hookPoint,
-        priority: this.priority
-      }
-    ];
-  }
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    this.initialized = true;
-    logger2.info("MemoryPlugin (simplified) initialized");
-  }
-  async execute(ctx) {
-    if (this.disposed || !this.config.enabled || !this.initialized) {
-      return;
-    }
-    logger2.debug("MemoryPlugin hook executed. Use 'roy memory recall --extract' for memory extraction.");
-  }
-  prepareShutdown() {}
-  hasPendingTasks() {
-    return false;
-  }
-  async waitForCompletion() {}
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    logger2.info("MemoryPlugin (simplified) disposed");
-  }
-  getProjectBaseDir() {
-    return this.projectBaseDir;
-  }
-  getGlobalBaseDir() {
-    return this.globalBaseDir;
-  }
-}
-function createMemoryPlugin(baseDir, config) {
-  return new MemoryPlugin(baseDir, config);
-}
-// packages/core/src/env/memory/plugin/recall-memory.ts
-import fs from "fs/promises";
-import path2 from "path";
-async function recallMemory(memoryPaths) {
-  const results = [];
-  for (const memoryPath of memoryPaths) {
-    const scope = memoryPath.type;
-    const baseDir = memoryPath.path;
-    try {
-      const memoryFile = path2.join(baseDir, "memory.md");
-      try {
-        const content = await fs.readFile(memoryFile, "utf-8");
-        if (content.trim()) {
-          results.push(`## [${scope}] memory.md
-${content}`);
-        }
-      } catch {}
-    } catch (error) {
-      console.error(`Error processing memory path ${baseDir}:`, error);
-    }
-  }
-  if (results.length === 0) {
-    return "(No memory files found)";
-  }
-  return results.join(`
-
-`);
-}
-// packages/core/src/env/memory/plugin/memory-agent.ts
-var PROJECT_MEMORY_AGENT_PROMPT = `\u4F60\u662F\u9879\u76EE\u7EA7 Memory Agent\uFF0C\u8D1F\u8D23\u6574\u7406\u548C\u66F4\u65B0\u5F53\u524D\u9879\u76EE\u7684\u8BB0\u5FC6\u3002
-
-## \u4F60\u7684\u804C\u8D23
-
-1. **\u4FE1\u606F\u6536\u96C6**\uFF1A\u5728\u63D0\u53D6\u8BB0\u5FC6\u524D\uFF0C\u5148\u6536\u96C6\u9879\u76EE\u4E0A\u4E0B\u6587\u4FE1\u606F
-2. **\u4ECE\u5BF9\u8BDD\u4E2D\u63D0\u53D6\u8BB0\u5FC6**\uFF1A\u5206\u6790 messages\uFF0C\u63D0\u53D6\u4E0E\u9879\u76EE\u76F8\u5173\u7684\u77E5\u8BC6\u3001\u51B3\u7B56\u3001\u89E3\u51B3\u65B9\u6848
-3. **\u751F\u6210 memory.md**\uFF1A\u66F4\u65B0\u9879\u76EE\u8BB0\u5FC6\u7D22\u5F15
-
-## \u4FE1\u606F\u6536\u96C6\u6B65\u9AA4\uFF08\u91CD\u8981\uFF01\uFF09
-
-\u5728\u63D0\u53D6\u8BB0\u5FC6\u4E4B\u524D\uFF0C\u8BF7\u5148\u4F7F\u7528\u53EF\u7528\u5DE5\u5177\u6536\u96C6\u9879\u76EE\u4E0A\u4E0B\u6587\uFF1A
-
-1. **\u9605\u8BFB\u9879\u76EE README**\uFF1A\u4E86\u89E3\u9879\u76EE\u6982\u8FF0\u3001\u529F\u80FD\u3001\u4F7F\u7528\u65B9\u6CD5
-   - \u8DEF\u5F84\u793A\u4F8B\uFF1AREADME.md, README.zh-CN.md, docs/README.md
-
-2. **\u68C0\u67E5\u8BBE\u8BA1\u6587\u6863**\uFF1A\u4E86\u89E3\u9879\u76EE\u67B6\u6784\u548C\u8BBE\u8BA1\u51B3\u7B56
-   - \u8DEF\u5F84\u793A\u4F8B\uFF1Adocs/design.md, docs/ARCHITECTURE.md, docs/superpowers/specs/*.md
-
-3. **\u67E5\u770B\u4EE3\u7801\u5B9E\u73B0**\uFF1A\u4E86\u89E3\u5173\u952E\u6A21\u5757\u548C\u5B9E\u73B0\u7EC6\u8282
-   - \u8DEF\u5F84\u793A\u4F8B\uFF1Asrc/**/*.ts, packages/*/src/**/*.ts
-
-4. **\u56DE\u987E\u73B0\u6709 memory**\uFF1A\u4E86\u89E3\u5DF2\u6709\u7684\u9879\u76EE\u8BB0\u5FC6
-   - \u8DEF\u5F84\uFF1A\u5F53\u524D\u76EE\u5F55\u4E0B\u7684 .roy/memory/memory.md
-
-## \u8F93\u5165\u4FE1\u606F
-
-- \u5F53\u524D\u9879\u76EE\u7684 memory.md \u5185\u5BB9
-- \u5F53\u524D\u5BF9\u8BDD\u6D88\u606F
-
-## \u8F93\u51FA\u8981\u6C42
-
-\u8BF7\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF0C\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A
-- memoryMdContent: \u65B0\u7684 memory.md \u5185\u5BB9
-- projectSummary: \u9879\u76EE\u6458\u8981\uFF08\u5305\u542B summary, shortSummary \u7B49\uFF09
-- hasUpdates: \u662F\u5426\u6709\u66F4\u65B0
-
-## \u8BB0\u5FC6\u7EC4\u7EC7\u539F\u5219
-
-- \u4F18\u5148\u8BB0\u5F55\u5177\u4F53\u3001\u53EF\u64CD\u4F5C\u7684\u8BB0\u5FC6\uFF08\u4EE3\u7801\u4F4D\u7F6E\u3001\u914D\u7F6E\u9879\u3001\u547D\u4EE4\uFF09
-- \u907F\u514D\u8FC7\u4E8E\u62BD\u8C61\u6216\u901A\u7528\u7684\u63CF\u8FF0
-- \u8BB0\u5F55\u8BBE\u8BA1\u51B3\u7B56\u53CA\u5176\u7406\u7531`;
-var GLOBAL_MEMORY_AGENT_PROMPT = `\u4F60\u662F\u5168\u5C40 Memory Agent\uFF0C\u8D1F\u8D23\u6574\u7406\u8DE8\u9879\u76EE\u7684\u901A\u7528\u8BB0\u5FC6\u3002
-
-## \u4F60\u7684\u804C\u8D23
-
-1. **\u805A\u5408\u9879\u76EE\u6458\u8981**\uFF1A\u5206\u6790 projectSummaries\uFF0C\u63D0\u53D6\u5171\u6027\u77E5\u8BC6
-2. **\u7EF4\u62A4\u5168\u5C40\u8BB0\u5FC6**\uFF1A\u66F4\u65B0\u5168\u5C40 memory.md
-3. **\u7EF4\u62A4\u9879\u76EE\u7D22\u5F15**\uFF1A\u5728 memory.md \u4E2D\u7EF4\u62A4\u9879\u76EE\u5217\u8868
-4. **\u63D0\u53D6\u5171\u6027\u7ECF\u9A8C**\uFF1A\u5C06\u9879\u76EE\u7ECF\u9A8C\u63D0\u70BC\u4E3A\u901A\u7528\u6700\u4F73\u5B9E\u8DF5
-
-## \u8F93\u5165\u4FE1\u606F
-
-- \u5168\u5C40 memory.md \u5185\u5BB9
-- \u5F53\u524D\u5BF9\u8BDD\u6D88\u606F
-- \u9879\u76EE\u6458\u8981\u5217\u8868\uFF08projectSummaries\uFF09
-
-## \u8F93\u51FA\u8981\u6C42
-
-\u8BF7\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF0C\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A
-- memoryMdContent: \u65B0\u7684 memory.md \u5185\u5BB9
-- hasUpdates: \u662F\u5426\u6709\u66F4\u65B0
-
-## \u8BB0\u5FC6\u7EC4\u7EC7\u539F\u5219
-
-- \u5173\u6CE8\u8DE8\u9879\u76EE\u5171\u6027\uFF08\u5DE5\u4F5C\u6D41\u3001\u89C4\u8303\u3001\u504F\u597D\uFF09
-- \u9879\u76EE\u7D22\u5F15\u53EA\u8BB0\u5F55\u6458\u8981\u548C\u8DEF\u5F84\uFF0C\u4E0D\u590D\u5236\u5185\u5BB9
-- \u7528\u6237\u4E2A\u4EBA\u504F\u597D\uFF08\u996E\u98DF\u3001\u5DE5\u4F5C\u4E60\u60EF\uFF09\u4F18\u5148\u8BB0\u5F55`;
-function createMemoryAgent(scope) {
-  const name = `memory-agent-${scope}-${Date.now()}`;
-  const systemPrompt = scope === "project" ? PROJECT_MEMORY_AGENT_PROMPT : GLOBAL_MEMORY_AGENT_PROMPT;
-  return {
-    name,
-    systemPrompt,
-    maxIterations: 5
-  };
-}
-function formatMemoryInput(input) {
-  const lines = [];
-  lines.push(`# Memory Agent Input (${input.scope} scope)
-`);
-  lines.push("## Current memory.md");
-  lines.push(input.currentMemoryMd || "_No existing memory_");
-  lines.push("");
-  lines.push("## Recent Messages");
-  if (input.messages.length === 0) {
-    lines.push("_No messages_");
-  } else {
-    for (const msg of input.messages.slice(-10)) {
-      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-      lines.push(`**${msg.role}**: ${content.substring(0, 500)}`);
-    }
-  }
-  lines.push("");
-  if (input.scope === "global" && input.projectSummaries && input.projectSummaries.length > 0) {
-    lines.push("## Project Summaries");
-    for (const ps of input.projectSummaries) {
-      lines.push(`### ${ps.projectName}`);
-      lines.push(`Path: ${ps.projectPath}`);
-      lines.push(`Last Updated: ${new Date(ps.lastUpdated).toLocaleString()}`);
-      lines.push(`Summary: ${ps.summary}`);
-      lines.push(`Memory: ${ps.memoryMdPath}`);
-      lines.push("---");
-    }
-    lines.push("");
-  }
-  lines.push("## Task");
-  lines.push("\u8BF7\u5206\u6790\u4EE5\u4E0A\u4FE1\u606F\uFF0C\u66F4\u65B0\u8BB0\u5FC6\u5E76\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\u3002");
-  return lines.join(`
-`);
-}
-function parseMemoryAgentOutput(output, scope) {
-  let jsonStr = output;
-  const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/) || output.match(/```\s*([\s\S]*?)\s*```/) || output.match(/(\{[\s\S]*\})/);
-  if (jsonMatch) {
-    jsonStr = jsonMatch[1] || jsonMatch[0];
-  }
-  try {
-    const parsed = JSON.parse(jsonStr);
-    return {
-      scope,
-      memoryMdContent: parsed.memoryMdContent || "",
-      projectSummary: parsed.projectSummary,
-      hasUpdates: parsed.hasUpdates ?? false
-    };
-  } catch {
-    return {
-      scope,
-      memoryMdContent: output,
-      hasUpdates: false
-    };
-  }
-}
-function createEmptyResult(scope) {
-  return {
-    scope,
-    memoryMdContent: "",
-    hasUpdates: false
-  };
-}
-async function buildProjectInput(params) {
-  const baseDir = params.projectPath + "/.roy/memory";
-  return {
-    scope: "project",
-    baseDir,
-    currentMemoryMd: params.currentMemoryMd,
-    messages: params.messages
-  };
-}
-function buildGlobalInput(params) {
-  return {
-    scope: "global",
-    baseDir: params.baseDir,
-    currentMemoryMd: params.currentMemoryMd,
-    messages: params.messages,
-    projectSummaries: params.projectSummaries
-  };
-}
-async function applyMemoryResult(result, baseDir) {
-  const fs2 = await import("fs/promises");
-  const path3 = await import("path");
-  const memoryMdPath = path3.join(baseDir, "memory.md");
-  await fs2.mkdir(path3.dirname(memoryMdPath), { recursive: true });
-  await fs2.writeFile(memoryMdPath, result.memoryMdContent, "utf-8");
-}
-function generateProjectSummary(params) {
-  const paragraphs = params.memoryMdContent.split(/\n\n+/);
-  const firstParagraph = paragraphs[0] || "";
-  const summary = firstParagraph.replace(/^#+\s*/g, "").trim() || "No summary available";
-  const firstSentence = summary.split(/[.!?]/)[0] || summary;
-  const shortSummary = firstSentence.substring(0, 50) + (firstSentence.length > 50 ? "..." : "");
-  return {
-    projectPath: params.projectPath,
-    projectName: params.projectName,
-    lastUpdated: Date.now(),
-    summary,
-    shortSummary,
-    memoryMdPath: params.memoryMdPath
-  };
-}
-export {
-  recallMemory,
-  parseMemoryAgentOutput,
-  generateProjectSummary,
-  formatMemoryInput,
-  createMemoryPlugin,
-  createMemoryAgent,
-  createEmptyResult,
-  buildProjectInput,
-  buildGlobalInput,
-  applyMemoryResult,
-  PROJECT_MEMORY_AGENT_PROMPT,
-  MemoryPlugin,
-  MemoryManager,
-  GLOBAL_MEMORY_AGENT_PROMPT
-};