@stackmemoryai/stackmemory 0.2.9 → 0.3.0

package/dist/core/trace/db-trace-wrapper.js

@@ -0,0 +1,215 @@
+import Database from "better-sqlite3";
+import { trace } from "./debug-trace.js";
+import { logger } from "../monitoring/logger.js";
+function createTracedDatabase(filename, options) {
+  const db = new Database(filename, options);
+  if (options?.traceEnabled !== false) {
+    return wrapDatabase(db, options?.slowQueryThreshold);
+  }
+  return db;
+}
+function wrapDatabase(db, slowQueryThreshold = 100) {
+  const originalPrepare = db.prepare.bind(db);
+  db.prepare = function(source) {
+    const statement = originalPrepare(source);
+    return wrapStatement(statement, source, slowQueryThreshold);
+  };
+  const originalExec = db.exec.bind(db);
+  db.exec = function(source) {
+    return trace.traceSync("query", `EXEC: ${source.substring(0, 50)}...`, {}, () => {
+      const startTime = performance.now();
+      const result = originalExec(source);
+      const duration = performance.now() - startTime;
+      if (duration > slowQueryThreshold) {
+        logger.warn(`Slow query detected: ${duration.toFixed(0)}ms`, {
+          query: source.substring(0, 200),
+          duration
+        });
+      }
+      return result;
+    });
+  };
+  const originalTransaction = db.transaction.bind(db);
+  db.transaction = function(fn) {
+    return originalTransaction(function(...args) {
+      return trace.traceSync("query", "TRANSACTION", { args: args.length }, () => {
+        return fn.apply(this, args);
+      });
+    });
+  };
+  db.__queryStats = {
+    totalQueries: 0,
+    slowQueries: 0,
+    totalDuration: 0,
+    queryTypes: {}
+  };
+  return db;
+}
+function wrapStatement(statement, source, slowQueryThreshold) {
+  const queryType = source.trim().split(/\s+/)[0].toUpperCase();
+  const shortQuery = source.substring(0, 100).replace(/\s+/g, " ");
+  const originalRun = statement.run.bind(statement);
+  statement.run = function(...params) {
+    return trace.traceSync("query", `${queryType}: ${shortQuery}`, params, () => {
+      const startTime = performance.now();
+      const result = originalRun(...params);
+      const duration = performance.now() - startTime;
+      updateQueryStats(statement, queryType, duration, slowQueryThreshold);
+      if (duration > slowQueryThreshold) {
+        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {
+          query: shortQuery,
+          params,
+          duration,
+          changes: result.changes
+        });
+      }
+      return result;
+    });
+  };
+  const originalGet = statement.get.bind(statement);
+  statement.get = function(...params) {
+    return trace.traceSync("query", `${queryType} (get): ${shortQuery}`, params, () => {
+      const startTime = performance.now();
+      const result = originalGet(...params);
+      const duration = performance.now() - startTime;
+      updateQueryStats(statement, queryType, duration, slowQueryThreshold);
+      if (duration > slowQueryThreshold) {
+        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {
+          query: shortQuery,
+          params,
+          duration,
+          found: result != null
+        });
+      }
+      return result;
+    });
+  };
+  const originalAll = statement.all.bind(statement);
+  statement.all = function(...params) {
+    return trace.traceSync("query", `${queryType} (all): ${shortQuery}`, params, () => {
+      const startTime = performance.now();
+      const result = originalAll(...params);
+      const duration = performance.now() - startTime;
+      updateQueryStats(statement, queryType, duration, slowQueryThreshold);
+      if (duration > slowQueryThreshold) {
+        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {
+          query: shortQuery,
+          params,
+          duration,
+          rows: result.length
+        });
+      }
+      if (result.length > 100 && queryType === "SELECT") {
+        logger.warn(`Large result set: ${result.length} rows`, {
+          query: shortQuery,
+          suggestion: "Consider pagination or more specific queries"
+        });
+      }
+      return result;
+    });
+  };
+  const originalIterate = statement.iterate.bind(statement);
+  statement.iterate = function(...params) {
+    const startTime = performance.now();
+    let rowCount = 0;
+    const iterator = originalIterate(...params);
+    const wrappedIterator = {
+      [Symbol.iterator]() {
+        return this;
+      },
+      next() {
+        const result = iterator.next();
+        if (!result.done) {
+          rowCount++;
+        } else {
+          const duration = performance.now() - startTime;
+          updateQueryStats(statement, queryType, duration, slowQueryThreshold);
+          if (duration > slowQueryThreshold) {
+            logger.warn(`Slow ${queryType} iteration: ${duration.toFixed(0)}ms`, {
+              query: shortQuery,
+              params,
+              duration,
+              rows: rowCount
+            });
+          }
+        }
+        return result;
+      }
+    };
+    return wrappedIterator;
+  };
+  return statement;
+}
+function updateQueryStats(statement, queryType, duration, slowQueryThreshold) {
+  const db = statement.database;
+  if (db.__queryStats) {
+    db.__queryStats.totalQueries++;
+    db.__queryStats.totalDuration += duration;
+    if (duration > slowQueryThreshold) {
+      db.__queryStats.slowQueries++;
+    }
+    if (!db.__queryStats.queryTypes[queryType]) {
+      db.__queryStats.queryTypes[queryType] = 0;
+    }
+    db.__queryStats.queryTypes[queryType]++;
+  }
+}
+function getQueryStatistics(db) {
+  const stats = db.__queryStats;
+  if (!stats) return null;
+  return {
+    ...stats,
+    averageDuration: stats.totalQueries > 0 ? stats.totalDuration / stats.totalQueries : 0
+  };
+}
+async function traceQuery(db, queryName, query, params, fn) {
+  return trace.traceAsync("query", queryName, { query, params }, async () => {
+    try {
+      const result = fn();
+      if (query.includes("JOIN") || query.includes("GROUP BY")) {
+        logger.debug(`Complex query executed: ${queryName}`, {
+          query: query.substring(0, 200),
+          params
+        });
+      }
+      return result;
+    } catch (error) {
+      logger.error(`Database query failed: ${queryName}`, error, {
+        query,
+        params,
+        errorCode: error.code
+      });
+      throw error;
+    }
+  });
+}
+function createTracedTransaction(db, name, fn) {
+  return trace.traceSync("query", `TRANSACTION: ${name}`, {}, () => {
+    const startTime = performance.now();
+    try {
+      const tx = db.transaction(fn);
+      const result = tx.deferred();
+      const duration = performance.now() - startTime;
+      logger.info(`Transaction completed: ${name}`, {
+        duration,
+        success: true
+      });
+      return result;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      logger.error(`Transaction failed: ${name}`, error, {
+        duration,
+        success: false
+      });
+      throw error;
+    }
+  });
+}
+export {
+  createTracedDatabase,
+  createTracedTransaction,
+  getQueryStatistics,
+  traceQuery,
+  wrapDatabase
+};
+//# sourceMappingURL=db-trace-wrapper.js.map

package/dist/core/trace/db-trace-wrapper.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/trace/db-trace-wrapper.ts"],
+  "sourcesContent": ["/**\n * Database Operations Trace Wrapper\n * Wraps SQLite operations with comprehensive tracing for debugging\n */\n\nimport Database from 'better-sqlite3';\nimport { trace } from './debug-trace.js';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface TracedDatabaseOptions extends Database.Options {\n  traceEnabled?: boolean;\n  slowQueryThreshold?: number;\n}\n\n/**\n * Create a traced database instance\n */\nexport function createTracedDatabase(\n  filename: string,\n  options?: TracedDatabaseOptions\n): Database.Database {\n  const db = new Database(filename, options);\n  \n  if (options?.traceEnabled !== false) {\n    return wrapDatabase(db, options?.slowQueryThreshold);\n  }\n  \n  return db;\n}\n\n/**\n * Wrap an existing database with tracing\n */\nexport function wrapDatabase(\n  db: Database.Database,\n  slowQueryThreshold = 100\n): Database.Database {\n  // Wrap prepare method to trace all queries\n  const originalPrepare = db.prepare.bind(db);\n  \n  db.prepare = function(source: string) {\n    const statement = originalPrepare(source);\n    return wrapStatement(statement, source, slowQueryThreshold);\n  } as typeof db.prepare;\n  \n  // Wrap exec for direct SQL execution\n  const originalExec = db.exec.bind(db);\n  \n  db.exec = function(source: string): Database.Database {\n    return trace.traceSync('query', `EXEC: ${source.substring(0, 50)}...`, {}, () => {\n      const startTime = performance.now();\n      const result = originalExec(source);\n      const duration = performance.now() - startTime;\n      \n      if (duration > slowQueryThreshold) {\n        logger.warn(`Slow query detected: ${duration.toFixed(0)}ms`, {\n          query: source.substring(0, 200),\n          duration,\n        });\n      }\n      \n      return result;\n    });\n  };\n  \n  // Wrap transaction for transaction tracking\n  const originalTransaction = db.transaction.bind(db);\n  \n  db.transaction = function(fn: any) {\n    return originalTransaction(function(this: any, ...args: any[]) {\n      return trace.traceSync('query', 'TRANSACTION', { args: args.length }, () => {\n        return fn.apply(this, args);\n      });\n    });\n  } as typeof db.transaction;\n  \n  // Add query statistics tracking\n  (db as any).__queryStats = {\n    totalQueries: 0,\n    slowQueries: 0,\n    totalDuration: 0,\n    queryTypes: {} as Record<string, number>,\n  };\n  \n  return db;\n}\n\n/**\n * Wrap a statement with tracing\n */\nfunction wrapStatement<T extends any[] = any[]>(\n  statement: Database.Statement<T>,\n  source: string,\n  slowQueryThreshold: number\n): Database.Statement<T> {\n  const queryType = source.trim().split(/\\s+/)[0].toUpperCase();\n  const shortQuery = source.substring(0, 100).replace(/\\s+/g, ' ');\n  \n  // Wrap run method\n  const originalRun = statement.run.bind(statement);\n  statement.run = function(...params: T): Database.RunResult {\n    return trace.traceSync('query', `${queryType}: ${shortQuery}`, params, () => {\n      const startTime = performance.now();\n      const result = originalRun(...params);\n      const duration = performance.now() - startTime;\n      \n      // Track statistics\n      updateQueryStats(statement, queryType, duration, slowQueryThreshold);\n      \n      // Log slow queries\n      if (duration > slowQueryThreshold) {\n        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {\n          query: shortQuery,\n          params,\n          duration,\n          changes: result.changes,\n        });\n      }\n      \n      return result;\n    });\n  };\n  \n  // Wrap get method\n  const originalGet = statement.get.bind(statement);\n  statement.get = function(...params: T): any {\n    return trace.traceSync('query', `${queryType} (get): ${shortQuery}`, params, () => {\n      const startTime = performance.now();\n      const result = originalGet(...params);\n      const duration = performance.now() - startTime;\n      \n      updateQueryStats(statement, queryType, duration, slowQueryThreshold);\n      \n      if (duration > slowQueryThreshold) {\n        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {\n          query: shortQuery,\n          params,\n          duration,\n          found: result != null,\n        });\n      }\n      \n      return result;\n    });\n  };\n  \n  // Wrap all method\n  const originalAll = statement.all.bind(statement);\n  statement.all = function(...params: T): any[] {\n    return trace.traceSync('query', `${queryType} (all): ${shortQuery}`, params, () => {\n      const startTime = performance.now();\n      const result = originalAll(...params);\n      const duration = performance.now() - startTime;\n      \n      updateQueryStats(statement, queryType, duration, slowQueryThreshold);\n      \n      if (duration > slowQueryThreshold) {\n        logger.warn(`Slow ${queryType} query: ${duration.toFixed(0)}ms`, {\n          query: shortQuery,\n          params,\n          duration,\n          rows: result.length,\n        });\n      }\n      \n      // Warn about potential N+1 queries\n      if (result.length > 100 && queryType === 'SELECT') {\n        logger.warn(`Large result set: ${result.length} rows`, {\n          query: shortQuery,\n          suggestion: 'Consider pagination or more specific queries',\n        });\n      }\n      \n      return result;\n    });\n  };\n  \n  // Wrap iterate method for cursor operations\n  const originalIterate = statement.iterate.bind(statement);\n  statement.iterate = function(...params: T): IterableIterator<any> {\n    const startTime = performance.now();\n    let rowCount = 0;\n    \n    const iterator = originalIterate(...params);\n    const wrappedIterator: IterableIterator<any> = {\n      [Symbol.iterator]() {\n        return this;\n      },\n      next() {\n        const result = iterator.next();\n        if (!result.done) {\n          rowCount++;\n        } else {\n          const duration = performance.now() - startTime;\n          updateQueryStats(statement, queryType, duration, slowQueryThreshold);\n          \n          if (duration > slowQueryThreshold) {\n            logger.warn(`Slow ${queryType} iteration: ${duration.toFixed(0)}ms`, {\n              query: shortQuery,\n              params,\n              duration,\n              rows: rowCount,\n            });\n          }\n        }\n        return result;\n      },\n    };\n    \n    return wrappedIterator;\n  };\n  \n  return statement;\n}\n\n/**\n * Update query statistics\n */\nfunction updateQueryStats(\n  statement: Database.Statement,\n  queryType: string,\n  duration: number,\n  slowQueryThreshold: number\n): void {\n  const db = statement.database as any;\n  if (db.__queryStats) {\n    db.__queryStats.totalQueries++;\n    db.__queryStats.totalDuration += duration;\n    \n    if (duration > slowQueryThreshold) {\n      db.__queryStats.slowQueries++;\n    }\n    \n    if (!db.__queryStats.queryTypes[queryType]) {\n      db.__queryStats.queryTypes[queryType] = 0;\n    }\n    db.__queryStats.queryTypes[queryType]++;\n  }\n}\n\n/**\n * Get query statistics from a traced database\n */\nexport function getQueryStatistics(db: Database.Database): {\n  totalQueries: number;\n  slowQueries: number;\n  averageDuration: number;\n  totalDuration: number;\n  queryTypes: Record<string, number>;\n} | null {\n  const stats = (db as any).__queryStats;\n  if (!stats) return null;\n  \n  return {\n    ...stats,\n    averageDuration: stats.totalQueries > 0 \n      ? stats.totalDuration / stats.totalQueries \n      : 0,\n  };\n}\n\n/**\n * Helper to trace a specific query with context\n */\nexport async function traceQuery<T>(\n  db: Database.Database,\n  queryName: string,\n  query: string,\n  params: any[],\n  fn: () => T\n): Promise<T> {\n  return trace.traceAsync('query', queryName, { query, params }, async () => {\n    try {\n      const result = fn();\n      \n      // Log successful complex queries for debugging\n      if (query.includes('JOIN') || query.includes('GROUP BY')) {\n        logger.debug(`Complex query executed: ${queryName}`, {\n          query: query.substring(0, 200),\n          params,\n        });\n      }\n      \n      return result;\n    } catch (error) {\n      // Enhanced error logging for database errors\n      logger.error(`Database query failed: ${queryName}`, error as Error, {\n        query,\n        params,\n        errorCode: (error as any).code,\n      });\n      throw error;\n    }\n  });\n}\n\n/**\n * Create a traced transaction with automatic rollback on error\n */\nexport function createTracedTransaction<T>(\n  db: Database.Database,\n  name: string,\n  fn: (tx: Database.Transaction<(args: any) => T>) => T\n): T {\n  return trace.traceSync('query', `TRANSACTION: ${name}`, {}, () => {\n    const startTime = performance.now();\n    \n    try {\n      const tx = db.transaction(fn);\n      const result = (tx as any).deferred();\n      \n      const duration = performance.now() - startTime;\n      logger.info(`Transaction completed: ${name}`, {\n        duration,\n        success: true,\n      });\n      \n      return result;\n    } catch (error) {\n      const duration = performance.now() - startTime;\n      logger.error(`Transaction failed: ${name}`, error as Error, {\n        duration,\n        success: false,\n      });\n      throw error;\n    }\n  });\n}"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/trace/debug-trace.js

@@ -0,0 +1,385 @@
+import { performance } from "perf_hooks";
+import { logger } from "../monitoring/logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import { v4 as uuidv4 } from "uuid";
+class TraceContext {
+  static instance;
+  config;
+  currentTrace = null;
+  traceStack = [];
+  allTraces = [];
+  outputFile;
+  startTime = Date.now();
+  sensitivePatterns = [
+    /api[_-]?key/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /bearer/i,
+    /authorization/i,
+    /client[_-]?id/i,
+    /client[_-]?secret/i
+  ];
+  constructor() {
+    this.config = this.loadConfig();
+    if (this.config.output === "file" || this.config.output === "both") {
+      this.initializeOutputFile();
+    }
+  }
+  static getInstance() {
+    if (!TraceContext.instance) {
+      TraceContext.instance = new TraceContext();
+    }
+    return TraceContext.instance;
+  }
+  loadConfig() {
+    return {
+      enabled: process.env.DEBUG_TRACE === "true" || process.env.STACKMEMORY_DEBUG === "true",
+      verbosity: process.env.TRACE_VERBOSITY || "full",
+      output: process.env.TRACE_OUTPUT || "console",
+      includeParams: process.env.TRACE_PARAMS !== "false",
+      includeResults: process.env.TRACE_RESULTS !== "false",
+      maskSensitive: process.env.TRACE_MASK_SENSITIVE !== "false",
+      performanceThreshold: parseInt(process.env.TRACE_PERF_THRESHOLD || "100"),
+      maxDepth: parseInt(process.env.TRACE_MAX_DEPTH || "20"),
+      captureMemory: process.env.TRACE_MEMORY === "true"
+    };
+  }
+  initializeOutputFile() {
+    const traceDir = path.join(process.env.HOME || ".", ".stackmemory", "traces");
+    if (!fs.existsSync(traceDir)) {
+      fs.mkdirSync(traceDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    this.outputFile = path.join(traceDir, `trace-${timestamp}.jsonl`);
+  }
+  maskSensitiveData(obj) {
+    if (!this.config.maskSensitive) return obj;
+    if (typeof obj !== "object" || obj === null) return obj;
+    const masked = Array.isArray(obj) ? [...obj] : { ...obj };
+    for (const key in masked) {
+      if (typeof key === "string") {
+        const isSensitive = this.sensitivePatterns.some((pattern) => pattern.test(key));
+        if (isSensitive) {
+          masked[key] = "[MASKED]";
+        } else if (typeof masked[key] === "object") {
+          masked[key] = this.maskSensitiveData(masked[key]);
+        } else if (typeof masked[key] === "string" && masked[key].length > 20) {
+          if (/^[a-zA-Z0-9_-]{20,}$/.test(masked[key])) {
+            masked[key] = masked[key].substring(0, 8) + "...[MASKED]";
+          }
+        }
+      }
+    }
+    return masked;
+  }
+  captureMemory() {
+    if (!this.config.captureMemory) return void 0;
+    return process.memoryUsage();
+  }
+  formatDuration(ms) {
+    if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
+    return `${(ms / 6e4).toFixed(2)}m`;
+  }
+  formatMemory(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${mb.toFixed(2)}MB`;
+  }
+  getIndent(depth) {
+    return "  ".repeat(depth);
+  }
+  formatTraceEntry(entry, includeChildren = true) {
+    const indent = this.getIndent(entry.depth);
+    const duration = entry.duration ? ` [${this.formatDuration(entry.duration)}]` : "";
+    const memory = entry.memory?.delta ? ` (\u0394mem: ${this.formatMemory(entry.memory.delta.heapUsed)})` : "";
+    let output = `${indent}\u2192 [${entry.type.toUpperCase()}:${entry.id.substring(0, 8)}] ${entry.name}${duration}${memory}`;
+    if (entry.error) {
+      output += `
+${indent}  \u2717 ERROR: ${entry.error.message || entry.error}`;
+      if (entry.error.stack && this.config.verbosity === "full") {
+        output += `
+${indent}    Stack: ${entry.error.stack.split("\n")[1]?.trim()}`;
+      }
+    }
+    if (this.config.includeParams && entry.params && Object.keys(entry.params).length > 0) {
+      const maskedParams = this.maskSensitiveData(entry.params);
+      output += `
+${indent}  \u25B8 Params: ${JSON.stringify(maskedParams, null, 2).replace(/\n/g, "\n" + indent + "    ")}`;
+    }
+    if (this.config.includeResults && entry.result !== void 0 && !entry.error) {
+      const maskedResult = this.maskSensitiveData(entry.result);
+      const resultStr = JSON.stringify(maskedResult, null, 2);
+      if (resultStr.length < 200) {
+        output += `
+${indent}  \u25C2 Result: ${resultStr.replace(/\n/g, "\n" + indent + "    ")}`;
+      } else {
+        output += `
+${indent}  \u25C2 Result: [${typeof maskedResult}] ${resultStr.substring(0, 100)}...`;
+      }
+    }
+    if (entry.duration && entry.duration > this.config.performanceThreshold) {
+      output += `
+${indent}  \u26A0 SLOW: Exceeded ${this.config.performanceThreshold}ms threshold`;
+    }
+    if (includeChildren && entry.children.length > 0) {
+      for (const child of entry.children) {
+        output += "\n" + this.formatTraceEntry(child, true);
+      }
+    }
+    if (entry.endTime && entry.depth > 0) {
+      output += `
+${indent}\u2190 [${entry.type.toUpperCase()}:${entry.id.substring(0, 8)}] completed`;
+    }
+    return output;
+  }
+  outputTrace(entry) {
+    if (!this.config.enabled) return;
+    const formatted = this.formatTraceEntry(entry, false);
+    if (this.config.output === "console" || this.config.output === "both") {
+      console.log(formatted);
+    }
+    if ((this.config.output === "file" || this.config.output === "both") && this.outputFile) {
+      const jsonLine = JSON.stringify({
+        ...entry,
+        formatted,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }) + "\n";
+      fs.appendFileSync(this.outputFile, jsonLine);
+    }
+  }
+  startTrace(type, name, params, metadata) {
+    if (!this.config.enabled) return "";
+    const id = uuidv4();
+    const parentId = this.currentTrace?.id;
+    const depth = this.traceStack.length;
+    if (depth > this.config.maxDepth) {
+      return id;
+    }
+    const entry = {
+      id,
+      parentId,
+      type,
+      name,
+      startTime: performance.now(),
+      depth,
+      params: this.config.includeParams ? params : void 0,
+      metadata,
+      children: [],
+      memory: this.captureMemory() ? { before: this.captureMemory() } : void 0
+    };
+    if (this.currentTrace) {
+      this.currentTrace.children.push(entry);
+    } else {
+      this.allTraces.push(entry);
+    }
+    this.traceStack.push(entry);
+    this.currentTrace = entry;
+    this.outputTrace(entry);
+    return id;
+  }
+  endTrace(id, result, error) {
+    if (!this.config.enabled) return;
+    const index = this.traceStack.findIndex((t) => t.id === id);
+    if (index === -1) return;
+    const entry = this.traceStack[index];
+    entry.endTime = performance.now();
+    entry.duration = entry.endTime - entry.startTime;
+    entry.result = this.config.includeResults && !error ? result : void 0;
+    entry.error = error;
+    if (entry.memory?.before) {
+      entry.memory.after = this.captureMemory();
+      if (entry.memory.after) {
+        entry.memory.delta = {
+          rss: entry.memory.after.rss - entry.memory.before.rss,
+          heapUsed: entry.memory.after.heapUsed - entry.memory.before.heapUsed
+        };
+      }
+    }
+    this.outputTrace(entry);
+    this.traceStack.splice(index);
+    this.currentTrace = this.traceStack[this.traceStack.length - 1] || null;
+  }
+  async traceAsync(type, name, params, fn) {
+    const id = this.startTrace(type, name, params);
+    try {
+      const result = await fn();
+      this.endTrace(id, result);
+      return result;
+    } catch (error) {
+      this.endTrace(id, void 0, error);
+      throw error;
+    }
+  }
+  traceSync(type, name, params, fn) {
+    const id = this.startTrace(type, name, params);
+    try {
+      const result = fn();
+      this.endTrace(id, result);
+      return result;
+    } catch (error) {
+      this.endTrace(id, void 0, error);
+      throw error;
+    }
+  }
+  async command(name, options, fn) {
+    return this.traceAsync("command", name, options, fn);
+  }
+  async step(name, fn) {
+    return this.traceAsync("step", name, void 0, fn);
+  }
+  async query(sql, params, fn) {
+    return this.traceAsync("query", sql.substring(0, 50), params, fn);
+  }
+  async api(method, url, body, fn) {
+    return this.traceAsync("api", `${method} ${url}`, { body }, fn);
+  }
+  getExecutionSummary() {
+    if (!this.config.enabled) return "Tracing disabled";
+    const totalDuration = Date.now() - this.startTime;
+    const errorCount = this.countErrors(this.allTraces);
+    const slowCount = this.countSlowOperations(this.allTraces);
+    let summary = `
+${"=".repeat(80)}
+`;
+    summary += `EXECUTION SUMMARY
+`;
+    summary += `${"=".repeat(80)}
+`;
+    summary += `Total Duration: ${this.formatDuration(totalDuration)}
+`;
+    summary += `Total Operations: ${this.countOperations(this.allTraces)}
+`;
+    summary += `Errors: ${errorCount}
+`;
+    summary += `Slow Operations (>${this.config.performanceThreshold}ms): ${slowCount}
+`;
+    if (this.config.captureMemory) {
+      const memUsage = process.memoryUsage();
+      summary += `Final Memory: RSS=${this.formatMemory(memUsage.rss)}, Heap=${this.formatMemory(memUsage.heapUsed)}
+`;
+    }
+    if (this.outputFile) {
+      summary += `Trace Log: ${this.outputFile}
+`;
+    }
+    summary += `${"=".repeat(80)}`;
+    return summary;
+  }
+  countOperations(traces) {
+    let count = traces.length;
+    for (const trace2 of traces) {
+      count += this.countOperations(trace2.children);
+    }
+    return count;
+  }
+  countErrors(traces) {
+    let count = 0;
+    for (const trace2 of traces) {
+      if (trace2.error) count++;
+      count += this.countErrors(trace2.children);
+    }
+    return count;
+  }
+  countSlowOperations(traces) {
+    let count = 0;
+    for (const trace2 of traces) {
+      if (trace2.duration && trace2.duration > this.config.performanceThreshold) count++;
+      count += this.countSlowOperations(trace2.children);
+    }
+    return count;
+  }
+  getLastError() {
+    const findLastError = (traces) => {
+      for (let i = traces.length - 1; i >= 0; i--) {
+        const trace2 = traces[i];
+        if (trace2.error) return trace2;
+        const childError = findLastError(trace2.children);
+        if (childError) return childError;
+      }
+      return null;
+    };
+    return findLastError(this.allTraces);
+  }
+  exportTraces() {
+    return this.allTraces;
+  }
+  reset() {
+    this.currentTrace = null;
+    this.traceStack = [];
+    this.allTraces = [];
+    this.startTime = Date.now();
+  }
+}
+const trace = TraceContext.getInstance();
+function Trace(type = "function") {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const isAsync = originalMethod.constructor.name === "AsyncFunction";
+    if (isAsync) {
+      descriptor.value = async function(...args) {
+        const className = target.constructor.name;
+        const methodName = `${className}.${propertyKey}`;
+        return trace.traceAsync(type, methodName, args, async () => {
+          return originalMethod.apply(this, args);
+        });
+      };
+    } else {
+      descriptor.value = function(...args) {
+        const className = target.constructor.name;
+        const methodName = `${className}.${propertyKey}`;
+        return trace.traceSync(type, methodName, args, () => {
+          return originalMethod.apply(this, args);
+        });
+      };
+    }
+    return descriptor;
+  };
+}
+function TraceClass(type = "function") {
+  return function(constructor) {
+    const prototype = constructor.prototype;
+    const propertyNames = Object.getOwnPropertyNames(prototype);
+    for (const propertyName of propertyNames) {
+      if (propertyName === "constructor") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, propertyName);
+      if (!descriptor || typeof descriptor.value !== "function") continue;
+      Trace(type)(prototype, propertyName, descriptor);
+      Object.defineProperty(prototype, propertyName, descriptor);
+    }
+    return constructor;
+  };
+}
+function TraceCritical(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = async function(...args) {
+    const className = target.constructor.name;
+    const methodName = `${className}.${propertyKey} [CRITICAL]`;
+    const contextBefore = {
+      memory: process.memoryUsage(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      args: trace["maskSensitiveData"](args)
+    };
+    try {
+      return await trace.traceAsync("function", methodName, contextBefore, async () => {
+        return originalMethod.apply(this, args);
+      });
+    } catch (error) {
+      logger.error(`Critical operation failed: ${methodName}`, error, {
+        context: contextBefore,
+        stack: error.stack
+      });
+      throw error;
+    }
+  };
+  return descriptor;
+}
+export {
+  Trace,
+  TraceClass,
+  TraceContext,
+  TraceCritical,
+  trace
+};
+//# sourceMappingURL=debug-trace.js.map