@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/core/trace/trace-detector.js

@@ -0,0 +1,528 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { v4 as uuidv4 } from "uuid";
+import {
+  TraceType,
+  DEFAULT_TRACE_CONFIG,
+  TRACE_PATTERNS,
+  CompressionStrategy
+} from "./types.js";
+import { ConfigManager } from "../config/config-manager.js";
+import { TraceStore } from "./trace-store.js";
+class TraceDetector {
+  config;
+  activeTrace = [];
+  lastToolTime = 0;
+  traces = [];
+  configManager;
+  traceStore;
+  constructor(config = {}, configManager, db) {
+    this.config = { ...DEFAULT_TRACE_CONFIG, ...config };
+    this.configManager = configManager || new ConfigManager();
+    if (db) {
+      this.traceStore = new TraceStore(db);
+      this.loadTracesFromStore();
+    }
+  }
+  /**
+   * Load traces from the database
+   */
+  loadTracesFromStore() {
+    if (!this.traceStore) return;
+    try {
+      const recentTraces = this.traceStore.getAllTraces();
+      const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+      this.traces = recentTraces.filter((t) => t.metadata.startTime >= cutoff);
+    } catch (error) {
+      console.error("Failed to load traces from store:", error);
+      this.traces = [];
+    }
+  }
+  /**
+   * Add a tool call and check if it belongs to current trace
+   */
+  addToolCall(tool) {
+    const now = Date.now();
+    if (this.shouldStartNewTrace(tool)) {
+      if (this.activeTrace.length > 0) {
+        this.finalizeTrace();
+      }
+      this.activeTrace = [tool];
+    } else {
+      this.activeTrace.push(tool);
+    }
+    this.lastToolTime = tool.timestamp;
+    if (this.activeTrace.length >= this.config.maxTraceSize) {
+      this.finalizeTrace();
+    }
+  }
+  /**
+   * Determine if a tool call should start a new trace
+   */
+  shouldStartNewTrace(tool) {
+    if (this.activeTrace.length === 0) {
+      return false;
+    }
+    const lastTool = this.activeTrace[this.activeTrace.length - 1];
+    const timeDiff = tool.timestamp - lastTool.timestamp;
+    if (timeDiff > this.config.timeProximityMs) {
+      return true;
+    }
+    if (this.config.sameDirThreshold) {
+      const lastFiles = lastTool.filesAffected || [];
+      const currentFiles = tool.filesAffected || [];
+      if (lastFiles.length > 0 && currentFiles.length > 0) {
+        const lastDirs = lastFiles.map((f) => this.getDirectory(f));
+        const currentDirs = currentFiles.map((f) => this.getDirectory(f));
+        const hasCommonDir = lastDirs.some((d) => currentDirs.includes(d));
+        if (!hasCommonDir) {
+          return true;
+        }
+      }
+    }
+    if (this.config.causalRelationship) {
+      if (lastTool.error && !this.isFixAttempt(tool, lastTool)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool is attempting to fix an error from previous tool
+   */
+  isFixAttempt(current, previous) {
+    if (previous.error && (current.tool === "edit" || current.tool === "write")) {
+      return true;
+    }
+    if (current.tool === "test" || current.tool === "bash") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Finalize current trace and add to traces list
+   */
+  finalizeTrace() {
+    if (this.activeTrace.length === 0) return;
+    const trace = this.createTrace(this.activeTrace);
+    this.traces.push(trace);
+    if (this.traceStore) {
+      try {
+        this.traceStore.saveTrace(trace);
+      } catch (error) {
+        console.error("Failed to persist trace:", error);
+      }
+    }
+    this.activeTrace = [];
+  }
+  /**
+   * Create a trace from a sequence of tool calls
+   */
+  createTrace(tools) {
+    const id = uuidv4();
+    const type = this.detectTraceType(tools);
+    const metadata = this.extractMetadata(tools);
+    const score = this.calculateTraceScore(tools, metadata);
+    const summary = this.generateSummary(tools, type, metadata);
+    const trace = {
+      id,
+      type,
+      tools,
+      score,
+      summary,
+      metadata
+    };
+    const ageHours = (Date.now() - metadata.startTime) / (1e3 * 60 * 60);
+    if (ageHours > this.config.compressionThreshold) {
+      trace.compressed = this.compressTrace(trace);
+    }
+    return trace;
+  }
+  /**
+   * Detect the type of trace based on tool patterns
+   */
+  detectTraceType(tools) {
+    const toolSequence = tools.map((t) => t.tool);
+    for (const pattern of TRACE_PATTERNS) {
+      if (this.matchesPattern(toolSequence, pattern.pattern)) {
+        return pattern.type;
+      }
+    }
+    if (toolSequence.includes("search") || toolSequence.includes("grep")) {
+      if (toolSequence.includes("edit")) {
+        return TraceType.SEARCH_DRIVEN;
+      }
+      return TraceType.EXPLORATION;
+    }
+    if (tools.some((t) => t.error)) {
+      return TraceType.ERROR_RECOVERY;
+    }
+    if (toolSequence.includes("test")) {
+      return TraceType.TESTING;
+    }
+    if (toolSequence.includes("write")) {
+      return TraceType.FEATURE_IMPLEMENTATION;
+    }
+    return TraceType.UNKNOWN;
+  }
+  /**
+   * Check if tool sequence matches a pattern
+   */
+  matchesPattern(sequence, pattern) {
+    if (pattern instanceof RegExp) {
+      return pattern.test(sequence.join("\u2192"));
+    }
+    if (Array.isArray(pattern)) {
+      let patternIndex = 0;
+      for (const tool of sequence) {
+        if (tool === pattern[patternIndex]) {
+          patternIndex++;
+          if (patternIndex >= pattern.length) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Extract metadata from tool calls
+   */
+  extractMetadata(tools) {
+    const startTime = tools[0].timestamp;
+    const endTime = tools[tools.length - 1].timestamp;
+    const filesModified = /* @__PURE__ */ new Set();
+    const errorsEncountered = [];
+    const decisionsRecorded = [];
+    let hasCausalChain = false;
+    for (let i = 0; i < tools.length; i++) {
+      const tool = tools[i];
+      if (tool.filesAffected) {
+        tool.filesAffected.forEach((f) => filesModified.add(f));
+      }
+      if (tool.error) {
+        errorsEncountered.push(tool.error);
+        if (i < tools.length - 1) {
+          const nextTool = tools[i + 1];
+          if (this.isFixAttempt(nextTool, tool)) {
+            hasCausalChain = true;
+          }
+        }
+      }
+      if (tool.tool === "decision_recording" && tool.arguments?.decision) {
+        decisionsRecorded.push(tool.arguments.decision);
+      }
+    }
+    return {
+      startTime,
+      endTime,
+      filesModified: Array.from(filesModified),
+      errorsEncountered,
+      decisionsRecorded,
+      causalChain: hasCausalChain
+    };
+  }
+  /**
+   * Calculate importance score for a trace
+   */
+  calculateTraceScore(tools, metadata) {
+    const toolScores = tools.map(
+      (t) => this.configManager.calculateScore(t.tool, {
+        filesAffected: t.filesAffected?.length || 0,
+        isPermanent: this.isPermanentChange(t),
+        referenceCount: 0
+        // Would need to track references
+      })
+    );
+    const maxScore = Math.max(...toolScores);
+    let score = maxScore;
+    if (metadata.causalChain) {
+      score = Math.min(score + 0.1, 1);
+    }
+    if (metadata.decisionsRecorded.length > 0) {
+      score = Math.min(score + 0.05 * metadata.decisionsRecorded.length, 1);
+    }
+    if (metadata.errorsEncountered.length > 0 && !metadata.causalChain) {
+      score = Math.max(score - 0.1, 0);
+    }
+    return score;
+  }
+  /**
+   * Check if a tool call represents a permanent change
+   */
+  isPermanentChange(tool) {
+    const permanentTools = ["write", "edit", "decision_recording"];
+    return permanentTools.includes(tool.tool);
+  }
+  /**
+   * Generate a summary for the trace
+   */
+  generateSummary(tools, type, metadata) {
+    const toolChain = tools.map((t) => t.tool).join("\u2192");
+    switch (type) {
+      case TraceType.SEARCH_DRIVEN:
+        return `Search-driven modification: ${toolChain}`;
+      case TraceType.ERROR_RECOVERY:
+        const error = metadata.errorsEncountered[0] || "unknown error";
+        return `Error recovery: ${error} via ${toolChain}`;
+      case TraceType.FEATURE_IMPLEMENTATION:
+        const files = metadata.filesModified.length;
+        return `Feature implementation: ${files} files via ${toolChain}`;
+      case TraceType.REFACTORING:
+        return `Code refactoring: ${toolChain}`;
+      case TraceType.TESTING:
+        return `Test execution: ${toolChain}`;
+      case TraceType.EXPLORATION:
+        return `Codebase exploration: ${toolChain}`;
+      case TraceType.DEBUGGING:
+        return `Debugging session: ${toolChain}`;
+      case TraceType.BUILD_DEPLOY:
+        return `Build and deploy: ${toolChain}`;
+      default:
+        return `Tool sequence: ${toolChain}`;
+    }
+  }
+  /**
+   * Compress a trace for long-term storage using strategy
+   */
+  compressTrace(trace, strategy = CompressionStrategy.PATTERN_BASED) {
+    switch (strategy) {
+      case CompressionStrategy.SUMMARY_ONLY:
+        return this.compressSummaryOnly(trace);
+      case CompressionStrategy.PATTERN_BASED:
+        return this.compressPatternBased(trace);
+      case CompressionStrategy.SELECTIVE:
+        return this.compressSelective(trace);
+      case CompressionStrategy.FULL_COMPRESSION:
+        return this.compressMaximal(trace);
+      default:
+        return this.compressPatternBased(trace);
+    }
+  }
+  /**
+   * Summary-only compression - minimal data retention
+   */
+  compressSummaryOnly(trace) {
+    return {
+      pattern: "",
+      // No pattern stored
+      summary: trace.summary.substring(0, 100),
+      // Limit summary
+      score: trace.score,
+      toolCount: trace.tools.length,
+      duration: trace.metadata.endTime - trace.metadata.startTime,
+      timestamp: trace.metadata.startTime
+    };
+  }
+  /**
+   * Pattern-based compression - keep tool sequence
+   */
+  compressPatternBased(trace) {
+    const pattern = trace.tools.map((t) => t.tool).join("\u2192");
+    const duration = trace.metadata.endTime - trace.metadata.startTime;
+    return {
+      pattern,
+      summary: trace.summary,
+      score: trace.score,
+      toolCount: trace.tools.length,
+      duration,
+      timestamp: trace.metadata.startTime
+    };
+  }
+  /**
+   * Selective compression - keep high-score tools only
+   */
+  compressSelective(trace, threshold = 0.5) {
+    const significantTools = trace.tools.filter((tool) => {
+      const score = this.configManager.calculateScore(tool.tool, {
+        filesAffected: tool.filesAffected?.length || 0,
+        isPermanent: this.isPermanentChange(tool),
+        referenceCount: 0
+      });
+      return score >= threshold;
+    });
+    const pattern = significantTools.length > 0 ? significantTools.map((t) => t.tool).join("\u2192") : trace.tools.map((t) => t.tool).join("\u2192");
+    return {
+      pattern,
+      summary: `${trace.summary} [${significantTools.length}/${trace.tools.length} significant]`,
+      score: trace.score,
+      toolCount: significantTools.length,
+      duration: trace.metadata.endTime - trace.metadata.startTime,
+      timestamp: trace.metadata.startTime
+    };
+  }
+  /**
+   * Maximal compression - absolute minimum data
+   */
+  compressMaximal(trace) {
+    const typeAbbrev = this.getTraceTypeAbbreviation(trace.type);
+    const pattern = `${typeAbbrev}:${trace.tools.length}`;
+    return {
+      pattern,
+      summary: trace.type,
+      // Just the type
+      score: Math.round(trace.score * 10) / 10,
+      // Round to 1 decimal
+      toolCount: trace.tools.length,
+      duration: Math.round((trace.metadata.endTime - trace.metadata.startTime) / 1e3) * 1e3,
+      // Round to seconds
+      timestamp: trace.metadata.startTime
+    };
+  }
+  /**
+   * Get abbreviated trace type
+   */
+  getTraceTypeAbbreviation(type) {
+    const abbreviations = {
+      [TraceType.SEARCH_DRIVEN]: "SD",
+      [TraceType.ERROR_RECOVERY]: "ER",
+      [TraceType.FEATURE_IMPLEMENTATION]: "FI",
+      [TraceType.REFACTORING]: "RF",
+      [TraceType.TESTING]: "TS",
+      [TraceType.EXPLORATION]: "EX",
+      [TraceType.DEBUGGING]: "DB",
+      [TraceType.DOCUMENTATION]: "DC",
+      [TraceType.BUILD_DEPLOY]: "BD",
+      [TraceType.UNKNOWN]: "UN"
+    };
+    return abbreviations[type] || "UN";
+  }
+  /**
+   * Choose compression strategy based on trace age and importance
+   */
+  selectCompressionStrategy(trace) {
+    const ageHours = (Date.now() - trace.metadata.startTime) / (1e3 * 60 * 60);
+    const score = trace.score;
+    if (ageHours < 24 && score > 0.7) {
+      return CompressionStrategy.PATTERN_BASED;
+    }
+    if (ageHours < 24) {
+      return CompressionStrategy.SELECTIVE;
+    }
+    if (ageHours < 168 && score > 0.5) {
+      return CompressionStrategy.SELECTIVE;
+    }
+    if (ageHours < 720) {
+      return CompressionStrategy.SUMMARY_ONLY;
+    }
+    return CompressionStrategy.FULL_COMPRESSION;
+  }
+  /**
+   * Get directory from file path
+   */
+  getDirectory(filePath) {
+    const parts = filePath.split("/");
+    parts.pop();
+    return parts.join("/");
+  }
+  /**
+   * Flush any pending trace
+   */
+  flush() {
+    if (this.activeTrace.length > 0) {
+      this.finalizeTrace();
+    }
+  }
+  /**
+   * Get all detected traces
+   */
+  getTraces() {
+    return this.traces;
+  }
+  /**
+   * Get traces by type
+   */
+  getTracesByType(type) {
+    return this.traces.filter((t) => t.type === type);
+  }
+  /**
+   * Get high-importance traces
+   */
+  getHighImportanceTraces(threshold = 0.7) {
+    return this.traces.filter((t) => t.score >= threshold);
+  }
+  /**
+   * Compress old traces with intelligent strategy selection
+   */
+  compressOldTraces(ageHours = 24) {
+    let compressed = 0;
+    const now = Date.now();
+    for (const trace of this.traces) {
+      const age = (now - trace.metadata.startTime) / (1e3 * 60 * 60);
+      if (age > ageHours && !trace.compressed) {
+        const strategy = this.selectCompressionStrategy(trace);
+        trace.compressed = this.compressTrace(trace, strategy);
+        if (strategy === CompressionStrategy.FULL_COMPRESSION || strategy === CompressionStrategy.SUMMARY_ONLY) {
+          trace.tools = [];
+        } else if (strategy === CompressionStrategy.SELECTIVE) {
+          trace.tools = trace.tools.filter((tool) => {
+            const score = this.configManager.calculateScore(tool.tool, {
+              filesAffected: tool.filesAffected?.length || 0,
+              isPermanent: this.isPermanentChange(tool),
+              referenceCount: 0
+            });
+            return score >= 0.5;
+          });
+        }
+        compressed++;
+        if (this.traceStore) {
+          try {
+            this.traceStore.updateCompression(
+              trace.id,
+              trace.compressed,
+              strategy
+            );
+          } catch (error) {
+            console.error(
+              "Failed to update trace compression in store:",
+              error
+            );
+          }
+        }
+      }
+    }
+    return compressed;
+  }
+  /**
+   * Export traces for analysis
+   */
+  exportTraces() {
+    return JSON.stringify(this.traces, null, 2);
+  }
+  /**
+   * Get statistics about traces
+   */
+  getStatistics() {
+    const stats = {
+      totalTraces: this.traces.length,
+      tracesByType: {},
+      averageScore: 0,
+      averageLength: 0,
+      compressedCount: 0,
+      highImportanceCount: 0
+    };
+    if (this.traces.length === 0) return stats;
+    let totalScore = 0;
+    let totalLength = 0;
+    for (const trace of this.traces) {
+      stats.tracesByType[trace.type] = (stats.tracesByType[trace.type] || 0) + 1;
+      totalScore += trace.score;
+      totalLength += trace.tools.length;
+      if (trace.compressed) {
+        stats.compressedCount++;
+      }
+      if (trace.score >= 0.7) {
+        stats.highImportanceCount++;
+      }
+    }
+    stats.averageScore = totalScore / this.traces.length;
+    stats.averageLength = totalLength / this.traces.length;
+    return stats;
+  }
+}
+export {
+  TraceDetector
+};
+//# sourceMappingURL=trace-detector.js.map

package/dist/src/core/trace/trace-detector.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/trace/trace-detector.ts"],
+  "sourcesContent": ["/**\n * Trace Detection and Bundling System\n * Identifies chains of related tool calls and bundles them as single traces\n */\n\nimport { v4 as uuidv4 } from 'uuid';\nimport {\n  ToolCall,\n  Trace,\n  TraceType,\n  TraceBoundaryConfig,\n  DEFAULT_TRACE_CONFIG,\n  TRACE_PATTERNS,\n  TraceMetadata,\n  TraceScoringFactors,\n  CompressedTrace,\n  CompressionStrategy,\n} from './types.js';\nimport { ConfigManager } from '../config/config-manager.js';\nimport { TraceStore } from './trace-store.js';\nimport Database from 'better-sqlite3';\n\nexport class TraceDetector {\n  private config: TraceBoundaryConfig;\n  private activeTrace: ToolCall[] = [];\n  private lastToolTime: number = 0;\n  private traces: Trace[] = [];\n  private configManager: ConfigManager;\n  private traceStore?: TraceStore;\n\n  constructor(\n    config: Partial<TraceBoundaryConfig> = {},\n    configManager?: ConfigManager,\n    db?: Database.Database\n  ) {\n    this.config = { ...DEFAULT_TRACE_CONFIG, ...config };\n    this.configManager = configManager || new ConfigManager();\n\n    if (db) {\n      this.traceStore = new TraceStore(db);\n      // Load existing traces from database\n      this.loadTracesFromStore();\n    }\n  }\n\n  /**\n   * Load traces from the database\n   */\n  private loadTracesFromStore(): void {\n    if (!this.traceStore) return;\n\n    try {\n      // Load recent traces (last 24 hours)\n      const recentTraces = this.traceStore.getAllTraces();\n      const cutoff = Date.now() - 24 * 60 * 60 * 1000;\n\n      this.traces = recentTraces.filter((t) => t.metadata.startTime >= cutoff);\n    } catch (error: unknown) {\n      // If loading fails, start with empty traces\n      console.error('Failed to load traces from store:', error);\n      this.traces = [];\n    }\n  }\n\n  /**\n   * Add a tool call and check if it belongs to current trace\n   */\n  addToolCall(tool: ToolCall): void {\n    const now = Date.now();\n\n    // Check if this tool belongs to the current trace\n    if (this.shouldStartNewTrace(tool)) {\n      // Finalize current trace if it exists\n      if (this.activeTrace.length > 0) {\n        this.finalizeTrace();\n      }\n      // Start new trace\n      this.activeTrace = [tool];\n    } else {\n      // Add to current trace\n      this.activeTrace.push(tool);\n    }\n\n    this.lastToolTime = tool.timestamp;\n\n    // Check if trace is getting too large\n    if (this.activeTrace.length >= this.config.maxTraceSize) {\n      this.finalizeTrace();\n    }\n  }\n\n  /**\n   * Determine if a tool call should start a new trace\n   */\n  private shouldStartNewTrace(tool: ToolCall): boolean {\n    // First tool always starts a new trace\n    if (this.activeTrace.length === 0) {\n      return false;\n    }\n\n    const lastTool = this.activeTrace[this.activeTrace.length - 1];\n\n    // Time proximity check\n    const timeDiff = tool.timestamp - lastTool.timestamp;\n    if (timeDiff > this.config.timeProximityMs) {\n      return true;\n    }\n\n    // Directory check if enabled\n    if (this.config.sameDirThreshold) {\n      const lastFiles = lastTool.filesAffected || [];\n      const currentFiles = tool.filesAffected || [];\n\n      if (lastFiles.length > 0 && currentFiles.length > 0) {\n        const lastDirs = lastFiles.map((f) => this.getDirectory(f));\n        const currentDirs = currentFiles.map((f) => this.getDirectory(f));\n\n        const hasCommonDir = lastDirs.some((d) => currentDirs.includes(d));\n        if (!hasCommonDir) {\n          return true;\n        }\n      }\n    }\n\n    // Causal relationship check\n    if (this.config.causalRelationship) {\n      // If last tool had an error and current tool is not a fix attempt, start new trace\n      if (lastTool.error && !this.isFixAttempt(tool, lastTool)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Check if a tool is attempting to fix an error from previous tool\n   */\n  private isFixAttempt(current: ToolCall, previous: ToolCall): boolean {\n    // Edit after error is likely a fix\n    if (\n      previous.error &&\n      (current.tool === 'edit' || current.tool === 'write')\n    ) {\n      return true;\n    }\n\n    // Test after fix is validation\n    if (current.tool === 'test' || current.tool === 'bash') {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Finalize current trace and add to traces list\n   */\n  private finalizeTrace(): void {\n    if (this.activeTrace.length === 0) return;\n\n    const trace = this.createTrace(this.activeTrace);\n    this.traces.push(trace);\n\n    // Persist to database if store is available\n    if (this.traceStore) {\n      try {\n        this.traceStore.saveTrace(trace);\n      } catch (error: unknown) {\n        console.error('Failed to persist trace:', error);\n      }\n    }\n\n    this.activeTrace = [];\n  }\n\n  /**\n   * Create a trace from a sequence of tool calls\n   */\n  private createTrace(tools: ToolCall[]): Trace {\n    const id = uuidv4();\n    const type = this.detectTraceType(tools);\n    const metadata = this.extractMetadata(tools);\n    const score = this.calculateTraceScore(tools, metadata);\n    const summary = this.generateSummary(tools, type, metadata);\n\n    const trace: Trace = {\n      id,\n      type,\n      tools,\n      score,\n      summary,\n      metadata,\n    };\n\n    // Check if trace should be compressed\n    const ageHours = (Date.now() - metadata.startTime) / (1000 * 60 * 60);\n    if (ageHours > this.config.compressionThreshold) {\n      trace.compressed = this.compressTrace(trace);\n    }\n\n    return trace;\n  }\n\n  /**\n   * Detect the type of trace based on tool patterns\n   */\n  private detectTraceType(tools: ToolCall[]): TraceType {\n    const toolSequence = tools.map((t) => t.tool);\n\n    // Check against known patterns\n    for (const pattern of TRACE_PATTERNS) {\n      if (this.matchesPattern(toolSequence, pattern.pattern)) {\n        return pattern.type;\n      }\n    }\n\n    // Heuristic detection\n    if (toolSequence.includes('search') || toolSequence.includes('grep')) {\n      if (toolSequence.includes('edit')) {\n        return TraceType.SEARCH_DRIVEN;\n      }\n      return TraceType.EXPLORATION;\n    }\n\n    if (tools.some((t) => t.error)) {\n      return TraceType.ERROR_RECOVERY;\n    }\n\n    if (toolSequence.includes('test')) {\n      return TraceType.TESTING;\n    }\n\n    if (toolSequence.includes('write')) {\n      return TraceType.FEATURE_IMPLEMENTATION;\n    }\n\n    return TraceType.UNKNOWN;\n  }\n\n  /**\n   * Check if tool sequence matches a pattern\n   */\n  private matchesPattern(\n    sequence: string[],\n    pattern: RegExp | string[]\n  ): boolean {\n    if (pattern instanceof RegExp) {\n      return pattern.test(sequence.join('\u2192'));\n    }\n\n    if (Array.isArray(pattern)) {\n      // Check if pattern is a subsequence\n      let patternIndex = 0;\n      for (const tool of sequence) {\n        if (tool === pattern[patternIndex]) {\n          patternIndex++;\n          if (patternIndex >= pattern.length) {\n            return true;\n          }\n        }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Extract metadata from tool calls\n   */\n  private extractMetadata(tools: ToolCall[]): TraceMetadata {\n    const startTime = tools[0].timestamp;\n    const endTime = tools[tools.length - 1].timestamp;\n\n    const filesModified = new Set<string>();\n    const errorsEncountered: string[] = [];\n    const decisionsRecorded: string[] = [];\n\n    let hasCausalChain = false;\n\n    for (let i = 0; i < tools.length; i++) {\n      const tool = tools[i];\n\n      // Collect files\n      if (tool.filesAffected) {\n        tool.filesAffected.forEach((f) => filesModified.add(f));\n      }\n\n      // Collect errors\n      if (tool.error) {\n        errorsEncountered.push(tool.error);\n        // Check if next tool is a fix attempt\n        if (i < tools.length - 1) {\n          const nextTool = tools[i + 1];\n          if (this.isFixAttempt(nextTool, tool)) {\n            hasCausalChain = true;\n          }\n        }\n      }\n\n      // Collect decisions (if tool is decision_recording)\n      if (tool.tool === 'decision_recording' && tool.arguments?.decision) {\n        decisionsRecorded.push(tool.arguments.decision);\n      }\n    }\n\n    return {\n      startTime,\n      endTime,\n      filesModified: Array.from(filesModified),\n      errorsEncountered,\n      decisionsRecorded,\n      causalChain: hasCausalChain,\n    };\n  }\n\n  /**\n   * Calculate importance score for a trace\n   */\n  private calculateTraceScore(\n    tools: ToolCall[],\n    metadata: TraceMetadata\n  ): number {\n    // Get individual tool scores\n    const toolScores = tools.map((t) =>\n      this.configManager.calculateScore(t.tool, {\n        filesAffected: t.filesAffected?.length || 0,\n        isPermanent: this.isPermanentChange(t),\n        referenceCount: 0, // Would need to track references\n      })\n    );\n\n    // Use MAX strategy for trace scoring (highest tool determines trace importance)\n    const maxScore = Math.max(...toolScores);\n\n    // Apply bonuses\n    let score = maxScore;\n\n    // Bonus for causal chains (error\u2192fix\u2192verify)\n    if (metadata.causalChain) {\n      score = Math.min(score + 0.1, 1.0);\n    }\n\n    // Bonus for decisions\n    if (metadata.decisionsRecorded.length > 0) {\n      score = Math.min(score + 0.05 * metadata.decisionsRecorded.length, 1.0);\n    }\n\n    // Penalty for errors without fixes\n    if (metadata.errorsEncountered.length > 0 && !metadata.causalChain) {\n      score = Math.max(score - 0.1, 0);\n    }\n\n    return score;\n  }\n\n  /**\n   * Check if a tool call represents a permanent change\n   */\n  private isPermanentChange(tool: ToolCall): boolean {\n    const permanentTools = ['write', 'edit', 'decision_recording'];\n    return permanentTools.includes(tool.tool);\n  }\n\n  /**\n   * Generate a summary for the trace\n   */\n  private generateSummary(\n    tools: ToolCall[],\n    type: TraceType,\n    metadata: TraceMetadata\n  ): string {\n    const toolChain = tools.map((t) => t.tool).join('\u2192');\n\n    switch (type) {\n      case TraceType.SEARCH_DRIVEN:\n        return `Search-driven modification: ${toolChain}`;\n\n      case TraceType.ERROR_RECOVERY:\n        const error = metadata.errorsEncountered[0] || 'unknown error';\n        return `Error recovery: ${error} via ${toolChain}`;\n\n      case TraceType.FEATURE_IMPLEMENTATION:\n        const files = metadata.filesModified.length;\n        return `Feature implementation: ${files} files via ${toolChain}`;\n\n      case TraceType.REFACTORING:\n        return `Code refactoring: ${toolChain}`;\n\n      case TraceType.TESTING:\n        return `Test execution: ${toolChain}`;\n\n      case TraceType.EXPLORATION:\n        return `Codebase exploration: ${toolChain}`;\n\n      case TraceType.DEBUGGING:\n        return `Debugging session: ${toolChain}`;\n\n      case TraceType.BUILD_DEPLOY:\n        return `Build and deploy: ${toolChain}`;\n\n      default:\n        return `Tool sequence: ${toolChain}`;\n    }\n  }\n\n  /**\n   * Compress a trace for long-term storage using strategy\n   */\n  private compressTrace(\n    trace: Trace,\n    strategy: CompressionStrategy = CompressionStrategy.PATTERN_BASED\n  ): CompressedTrace {\n    switch (strategy) {\n      case CompressionStrategy.SUMMARY_ONLY:\n        return this.compressSummaryOnly(trace);\n\n      case CompressionStrategy.PATTERN_BASED:\n        return this.compressPatternBased(trace);\n\n      case CompressionStrategy.SELECTIVE:\n        return this.compressSelective(trace);\n\n      case CompressionStrategy.FULL_COMPRESSION:\n        return this.compressMaximal(trace);\n\n      default:\n        return this.compressPatternBased(trace);\n    }\n  }\n\n  /**\n   * Summary-only compression - minimal data retention\n   */\n  private compressSummaryOnly(trace: Trace): CompressedTrace {\n    return {\n      pattern: '', // No pattern stored\n      summary: trace.summary.substring(0, 100), // Limit summary\n      score: trace.score,\n      toolCount: trace.tools.length,\n      duration: trace.metadata.endTime - trace.metadata.startTime,\n      timestamp: trace.metadata.startTime,\n    };\n  }\n\n  /**\n   * Pattern-based compression - keep tool sequence\n   */\n  private compressPatternBased(trace: Trace): CompressedTrace {\n    const pattern = trace.tools.map((t) => t.tool).join('\u2192');\n    const duration = trace.metadata.endTime - trace.metadata.startTime;\n\n    return {\n      pattern,\n      summary: trace.summary,\n      score: trace.score,\n      toolCount: trace.tools.length,\n      duration,\n      timestamp: trace.metadata.startTime,\n    };\n  }\n\n  /**\n   * Selective compression - keep high-score tools only\n   */\n  private compressSelective(\n    trace: Trace,\n    threshold: number = 0.5\n  ): CompressedTrace {\n    // Calculate individual tool scores\n    const significantTools = trace.tools.filter((tool: any) => {\n      const score = this.configManager.calculateScore(tool.tool, {\n        filesAffected: tool.filesAffected?.length || 0,\n        isPermanent: this.isPermanentChange(tool),\n        referenceCount: 0,\n      });\n      return score >= threshold;\n    });\n\n    const pattern =\n      significantTools.length > 0\n        ? significantTools.map((t: any) => t.tool).join('\u2192')\n        : trace.tools.map((t: any) => t.tool).join('\u2192');\n\n    return {\n      pattern,\n      summary: `${trace.summary} [${significantTools.length}/${trace.tools.length} significant]`,\n      score: trace.score,\n      toolCount: significantTools.length,\n      duration: trace.metadata.endTime - trace.metadata.startTime,\n      timestamp: trace.metadata.startTime,\n    };\n  }\n\n  /**\n   * Maximal compression - absolute minimum data\n   */\n  private compressMaximal(trace: Trace): CompressedTrace {\n    // Compress pattern to type abbreviation\n    const typeAbbrev = this.getTraceTypeAbbreviation(trace.type);\n    const pattern = `${typeAbbrev}:${trace.tools.length}`;\n\n    return {\n      pattern,\n      summary: trace.type, // Just the type\n      score: Math.round(trace.score * 10) / 10, // Round to 1 decimal\n      toolCount: trace.tools.length,\n      duration:\n        Math.round((trace.metadata.endTime - trace.metadata.startTime) / 1000) *\n        1000, // Round to seconds\n      timestamp: trace.metadata.startTime,\n    };\n  }\n\n  /**\n   * Get abbreviated trace type\n   */\n  private getTraceTypeAbbreviation(type: TraceType): string {\n    const abbreviations: Record<TraceType, string> = {\n      [TraceType.SEARCH_DRIVEN]: 'SD',\n      [TraceType.ERROR_RECOVERY]: 'ER',\n      [TraceType.FEATURE_IMPLEMENTATION]: 'FI',\n      [TraceType.REFACTORING]: 'RF',\n      [TraceType.TESTING]: 'TS',\n      [TraceType.EXPLORATION]: 'EX',\n      [TraceType.DEBUGGING]: 'DB',\n      [TraceType.DOCUMENTATION]: 'DC',\n      [TraceType.BUILD_DEPLOY]: 'BD',\n      [TraceType.UNKNOWN]: 'UN',\n    };\n    return abbreviations[type] || 'UN';\n  }\n\n  /**\n   * Choose compression strategy based on trace age and importance\n   */\n  private selectCompressionStrategy(trace: Trace): CompressionStrategy {\n    const ageHours = (Date.now() - trace.metadata.startTime) / (1000 * 60 * 60);\n    const score = trace.score;\n\n    // Recent and important: pattern-based\n    if (ageHours < 24 && score > 0.7) {\n      return CompressionStrategy.PATTERN_BASED;\n    }\n\n    // Recent but less important: selective\n    if (ageHours < 24) {\n      return CompressionStrategy.SELECTIVE;\n    }\n\n    // Old and important: selective\n    if (ageHours < 168 && score > 0.5) {\n      // 1 week\n      return CompressionStrategy.SELECTIVE;\n    }\n\n    // Old and less important: summary only\n    if (ageHours < 720) {\n      // 30 days\n      return CompressionStrategy.SUMMARY_ONLY;\n    }\n\n    // Very old: maximal compression\n    return CompressionStrategy.FULL_COMPRESSION;\n  }\n\n  /**\n   * Get directory from file path\n   */\n  private getDirectory(filePath: string): string {\n    const parts = filePath.split('/');\n    parts.pop(); // Remove filename\n    return parts.join('/');\n  }\n\n  /**\n   * Flush any pending trace\n   */\n  flush(): void {\n    if (this.activeTrace.length > 0) {\n      this.finalizeTrace();\n    }\n  }\n\n  /**\n   * Get all detected traces\n   */\n  getTraces(): Trace[] {\n    return this.traces;\n  }\n\n  /**\n   * Get traces by type\n   */\n  getTracesByType(type: TraceType): Trace[] {\n    return this.traces.filter((t) => t.type === type);\n  }\n\n  /**\n   * Get high-importance traces\n   */\n  getHighImportanceTraces(threshold: number = 0.7): Trace[] {\n    return this.traces.filter((t) => t.score >= threshold);\n  }\n\n  /**\n   * Compress old traces with intelligent strategy selection\n   */\n  compressOldTraces(ageHours: number = 24): number {\n    let compressed = 0;\n    const now = Date.now();\n\n    for (const trace of this.traces) {\n      const age = (now - trace.metadata.startTime) / (1000 * 60 * 60);\n      if (age > ageHours && !trace.compressed) {\n        // Select compression strategy based on age and importance\n        const strategy = this.selectCompressionStrategy(trace);\n        trace.compressed = this.compressTrace(trace, strategy);\n\n        // Remove full tool data for older traces to save memory\n        if (\n          strategy === CompressionStrategy.FULL_COMPRESSION ||\n          strategy === CompressionStrategy.SUMMARY_ONLY\n        ) {\n          trace.tools = []; // Clear tool data for maximum compression\n        } else if (strategy === CompressionStrategy.SELECTIVE) {\n          // Keep only high-score tools\n          trace.tools = trace.tools.filter((tool: any) => {\n            const score = this.configManager.calculateScore(tool.tool, {\n              filesAffected: tool.filesAffected?.length || 0,\n              isPermanent: this.isPermanentChange(tool),\n              referenceCount: 0,\n            });\n            return score >= 0.5;\n          });\n        }\n\n        compressed++;\n\n        // Update database if available\n        if (this.traceStore) {\n          try {\n            this.traceStore.updateCompression(\n              trace.id,\n              trace.compressed,\n              strategy\n            );\n          } catch (error: unknown) {\n            console.error(\n              'Failed to update trace compression in store:',\n              error\n            );\n          }\n        }\n      }\n    }\n\n    return compressed;\n  }\n\n  /**\n   * Export traces for analysis\n   */\n  exportTraces(): string {\n    return JSON.stringify(this.traces, null, 2);\n  }\n\n  /**\n   * Get statistics about traces\n   */\n  getStatistics() {\n    const stats = {\n      totalTraces: this.traces.length,\n      tracesByType: {} as Record<string, number>,\n      averageScore: 0,\n      averageLength: 0,\n      compressedCount: 0,\n      highImportanceCount: 0,\n    };\n\n    if (this.traces.length === 0) return stats;\n\n    let totalScore = 0;\n    let totalLength = 0;\n\n    for (const trace of this.traces) {\n      // Type distribution\n      stats.tracesByType[trace.type] =\n        (stats.tracesByType[trace.type] || 0) + 1;\n\n      // Scores\n      totalScore += trace.score;\n\n      // Length\n      totalLength += trace.tools.length;\n\n      // Compressed\n      if (trace.compressed) {\n        stats.compressedCount++;\n      }\n\n      // High importance\n      if (trace.score >= 0.7) {\n        stats.highImportanceCount++;\n      }\n    }\n\n    stats.averageScore = totalScore / this.traces.length;\n    stats.averageLength = totalLength / this.traces.length;\n\n    return stats;\n  }\n}\n"],
+  "mappings": ";;;;AAKA,SAAS,MAAM,cAAc;AAC7B;AAAA,EAGE;AAAA,EAEA;AAAA,EACA;AAAA,EAIA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B,SAAS,kBAAkB;AAGpB,MAAM,cAAc;AAAA,EACjB;AAAA,EACA,cAA0B,CAAC;AAAA,EAC3B,eAAuB;AAAA,EACvB,SAAkB,CAAC;AAAA,EACnB;AAAA,EACA;AAAA,EAER,YACE,SAAuC,CAAC,GACxC,eACA,IACA;AACA,SAAK,SAAS,EAAE,GAAG,sBAAsB,GAAG,OAAO;AACnD,SAAK,gBAAgB,iBAAiB,IAAI,cAAc;AAExD,QAAI,IAAI;AACN,WAAK,aAAa,IAAI,WAAW,EAAE;AAEnC,WAAK,oBAAoB;AAAA,IAC3B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,sBAA4B;AAClC,QAAI,CAAC,KAAK,WAAY;AAEtB,QAAI;AAEF,YAAM,eAAe,KAAK,WAAW,aAAa;AAClD,YAAM,SAAS,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK;AAE3C,WAAK,SAAS,aAAa,OAAO,CAAC,MAAM,EAAE,SAAS,aAAa,MAAM;AAAA,IACzE,SAAS,OAAgB;AAEvB,cAAQ,MAAM,qCAAqC,KAAK;AACxD,WAAK,SAAS,CAAC;AAAA,IACjB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,MAAsB;AAChC,UAAM,MAAM,KAAK,IAAI;AAGrB,QAAI,KAAK,oBAAoB,IAAI,GAAG;AAElC,UAAI,KAAK,YAAY,SAAS,GAAG;AAC/B,aAAK,cAAc;AAAA,MACrB;AAEA,WAAK,cAAc,CAAC,IAAI;AAAA,IAC1B,OAAO;AAEL,WAAK,YAAY,KAAK,IAAI;AAAA,IAC5B;AAEA,SAAK,eAAe,KAAK;AAGzB,QAAI,KAAK,YAAY,UAAU,KAAK,OAAO,cAAc;AACvD,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,oBAAoB,MAAyB;AAEnD,QAAI,KAAK,YAAY,WAAW,GAAG;AACjC,aAAO;AAAA,IACT;AAEA,UAAM,WAAW,KAAK,YAAY,KAAK,YAAY,SAAS,CAAC;AAG7D,UAAM,WAAW,KAAK,YAAY,SAAS;AAC3C,QAAI,WAAW,KAAK,OAAO,iBAAiB;AAC1C,aAAO;AAAA,IACT;AAGA,QAAI,KAAK,OAAO,kBAAkB;AAChC,YAAM,YAAY,SAAS,iBAAiB,CAAC;AAC7C,YAAM,eAAe,KAAK,iBAAiB,CAAC;AAE5C,UAAI,UAAU,SAAS,KAAK,aAAa,SAAS,GAAG;AACnD,cAAM,WAAW,UAAU,IAAI,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC;AAC1D,cAAM,cAAc,aAAa,IAAI,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC;AAEhE,cAAM,eAAe,SAAS,KAAK,CAAC,MAAM,YAAY,SAAS,CAAC,CAAC;AACjE,YAAI,CAAC,cAAc;AACjB,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAGA,QAAI,KAAK,OAAO,oBAAoB;AAElC,UAAI,SAAS,SAAS,CAAC,KAAK,aAAa,MAAM,QAAQ,GAAG;AACxD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAa,SAAmB,UAA6B;AAEnE,QACE,SAAS,UACR,QAAQ,SAAS,UAAU,QAAQ,SAAS,UAC7C;AACA,aAAO;AAAA,IACT;AAGA,QAAI,QAAQ,SAAS,UAAU,QAAQ,SAAS,QAAQ;AACtD,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,gBAAsB;AAC5B,QAAI,KAAK,YAAY,WAAW,EAAG;AAEnC,UAAM,QAAQ,KAAK,YAAY,KAAK,WAAW;AAC/C,SAAK,OAAO,KAAK,KAAK;AAGtB,QAAI,KAAK,YAAY;AACnB,UAAI;AACF,aAAK,WAAW,UAAU,KAAK;AAAA,MACjC,SAAS,OAAgB;AACvB,gBAAQ,MAAM,4BAA4B,KAAK;AAAA,MACjD;AAAA,IACF;AAEA,SAAK,cAAc,CAAC;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA,EAKQ,YAAY,OAA0B;AAC5C,UAAM,KAAK,OAAO;AAClB,UAAM,OAAO,KAAK,gBAAgB,KAAK;AACvC,UAAM,WAAW,KAAK,gBAAgB,KAAK;AAC3C,UAAM,QAAQ,KAAK,oBAAoB,OAAO,QAAQ;AACtD,UAAM,UAAU,KAAK,gBAAgB,OAAO,MAAM,QAAQ;AAE1D,UAAM,QAAe;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAGA,UAAM,YAAY,KAAK,IAAI,IAAI,SAAS,cAAc,MAAO,KAAK;AAClE,QAAI,WAAW,KAAK,OAAO,sBAAsB;AAC/C,YAAM,aAAa,KAAK,cAAc,KAAK;AAAA,IAC7C;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,gBAAgB,OAA8B;AACpD,UAAM,eAAe,MAAM,IAAI,CAAC,MAAM,EAAE,IAAI;AAG5C,eAAW,WAAW,gBAAgB;AACpC,UAAI,KAAK,eAAe,cAAc,QAAQ,OAAO,GAAG;AACtD,eAAO,QAAQ;AAAA,MACjB;AAAA,IACF;AAGA,QAAI,aAAa,SAAS,QAAQ,KAAK,aAAa,SAAS,MAAM,GAAG;AACpE,UAAI,aAAa,SAAS,MAAM,GAAG;AACjC,eAAO,UAAU;AAAA,MACnB;AACA,aAAO,UAAU;AAAA,IACnB;AAEA,QAAI,MAAM,KAAK,CAAC,MAAM,EAAE,KAAK,GAAG;AAC9B,aAAO,UAAU;AAAA,IACnB;AAEA,QAAI,aAAa,SAAS,MAAM,GAAG;AACjC,aAAO,UAAU;AAAA,IACnB;AAEA,QAAI,aAAa,SAAS,OAAO,GAAG;AAClC,aAAO,UAAU;AAAA,IACnB;AAEA,WAAO,UAAU;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA,EAKQ,eACN,UACA,SACS;AACT,QAAI,mBAAmB,QAAQ;AAC7B,aAAO,QAAQ,KAAK,SAAS,KAAK,QAAG,CAAC;AAAA,IACxC;AAEA,QAAI,MAAM,QAAQ,OAAO,GAAG;AAE1B,UAAI,eAAe;AACnB,iBAAW,QAAQ,UAAU;AAC3B,YAAI,SAAS,QAAQ,YAAY,GAAG;AAClC;AACA,cAAI,gBAAgB,QAAQ,QAAQ;AAClC,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,gBAAgB,OAAkC;AACxD,UAAM,YAAY,MAAM,CAAC,EAAE;AAC3B,UAAM,UAAU,MAAM,MAAM,SAAS,CAAC,EAAE;AAExC,UAAM,gBAAgB,oBAAI,IAAY;AACtC,UAAM,oBAA8B,CAAC;AACrC,UAAM,oBAA8B,CAAC;AAErC,QAAI,iBAAiB;AAErB,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,YAAM,OAAO,MAAM,CAAC;AAGpB,UAAI,KAAK,eAAe;AACtB,aAAK,cAAc,QAAQ,CAAC,MAAM,cAAc,IAAI,CAAC,CAAC;AAAA,MACxD;AAGA,UAAI,KAAK,OAAO;AACd,0BAAkB,KAAK,KAAK,KAAK;AAEjC,YAAI,IAAI,MAAM,SAAS,GAAG;AACxB,gBAAM,WAAW,MAAM,IAAI,CAAC;AAC5B,cAAI,KAAK,aAAa,UAAU,IAAI,GAAG;AACrC,6BAAiB;AAAA,UACnB;AAAA,QACF;AAAA,MACF;AAGA,UAAI,KAAK,SAAS,wBAAwB,KAAK,WAAW,UAAU;AAClE,0BAAkB,KAAK,KAAK,UAAU,QAAQ;AAAA,MAChD;AAAA,IACF;AAEA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,eAAe,MAAM,KAAK,aAAa;AAAA,MACvC;AAAA,MACA;AAAA,MACA,aAAa;AAAA,IACf;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,oBACN,OACA,UACQ;AAER,UAAM,aAAa,MAAM;AAAA,MAAI,CAAC,MAC5B,KAAK,cAAc,eAAe,EAAE,MAAM;AAAA,QACxC,eAAe,EAAE,eAAe,UAAU;AAAA,QAC1C,aAAa,KAAK,kBAAkB,CAAC;AAAA,QACrC,gBAAgB;AAAA;AAAA,MAClB,CAAC;AAAA,IACH;AAGA,UAAM,WAAW,KAAK,IAAI,GAAG,UAAU;AAGvC,QAAI,QAAQ;AAGZ,QAAI,SAAS,aAAa;AACxB,cAAQ,KAAK,IAAI,QAAQ,KAAK,CAAG;AAAA,IACnC;AAGA,QAAI,SAAS,kBAAkB,SAAS,GAAG;AACzC,cAAQ,KAAK,IAAI,QAAQ,OAAO,SAAS,kBAAkB,QAAQ,CAAG;AAAA,IACxE;AAGA,QAAI,SAAS,kBAAkB,SAAS,KAAK,CAAC,SAAS,aAAa;AAClE,cAAQ,KAAK,IAAI,QAAQ,KAAK,CAAC;AAAA,IACjC;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,kBAAkB,MAAyB;AACjD,UAAM,iBAAiB,CAAC,SAAS,QAAQ,oBAAoB;AAC7D,WAAO,eAAe,SAAS,KAAK,IAAI;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKQ,gBACN,OACA,MACA,UACQ;AACR,UAAM,YAAY,MAAM,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,QAAG;AAEnD,YAAQ,MAAM;AAAA,MACZ,KAAK,UAAU;AACb,eAAO,+BAA+B,SAAS;AAAA,MAEjD,KAAK,UAAU;AACb,cAAM,QAAQ,SAAS,kBAAkB,CAAC,KAAK;AAC/C,eAAO,mBAAmB,KAAK,QAAQ,SAAS;AAAA,MAElD,KAAK,UAAU;AACb,cAAM,QAAQ,SAAS,cAAc;AACrC,eAAO,2BAA2B,KAAK,cAAc,SAAS;AAAA,MAEhE,KAAK,UAAU;AACb,eAAO,qBAAqB,SAAS;AAAA,MAEvC,KAAK,UAAU;AACb,eAAO,mBAAmB,SAAS;AAAA,MAErC,KAAK,UAAU;AACb,eAAO,yBAAyB,SAAS;AAAA,MAE3C,KAAK,UAAU;AACb,eAAO,sBAAsB,SAAS;AAAA,MAExC,KAAK,UAAU;AACb,eAAO,qBAAqB,SAAS;AAAA,MAEvC;AACE,eAAO,kBAAkB,SAAS;AAAA,IACtC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,cACN,OACA,WAAgC,oBAAoB,eACnC;AACjB,YAAQ,UAAU;AAAA,MAChB,KAAK,oBAAoB;AACvB,eAAO,KAAK,oBAAoB,KAAK;AAAA,MAEvC,KAAK,oBAAoB;AACvB,eAAO,KAAK,qBAAqB,KAAK;AAAA,MAExC,KAAK,oBAAoB;AACvB,eAAO,KAAK,kBAAkB,KAAK;AAAA,MAErC,KAAK,oBAAoB;AACvB,eAAO,KAAK,gBAAgB,KAAK;AAAA,MAEnC;AACE,eAAO,KAAK,qBAAqB,KAAK;AAAA,IAC1C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,oBAAoB,OAA+B;AACzD,WAAO;AAAA,MACL,SAAS;AAAA;AAAA,MACT,SAAS,MAAM,QAAQ,UAAU,GAAG,GAAG;AAAA;AAAA,MACvC,OAAO,MAAM;AAAA,MACb,WAAW,MAAM,MAAM;AAAA,MACvB,UAAU,MAAM,SAAS,UAAU,MAAM,SAAS;AAAA,MAClD,WAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,qBAAqB,OAA+B;AAC1D,UAAM,UAAU,MAAM,MAAM,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,QAAG;AACvD,UAAM,WAAW,MAAM,SAAS,UAAU,MAAM,SAAS;AAEzD,WAAO;AAAA,MACL;AAAA,MACA,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,MACb,WAAW,MAAM,MAAM;AAAA,MACvB;AAAA,MACA,WAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,kBACN,OACA,YAAoB,KACH;AAEjB,UAAM,mBAAmB,MAAM,MAAM,OAAO,CAAC,SAAc;AACzD,YAAM,QAAQ,KAAK,cAAc,eAAe,KAAK,MAAM;AAAA,QACzD,eAAe,KAAK,eAAe,UAAU;AAAA,QAC7C,aAAa,KAAK,kBAAkB,IAAI;AAAA,QACxC,gBAAgB;AAAA,MAClB,CAAC;AACD,aAAO,SAAS;AAAA,IAClB,CAAC;AAED,UAAM,UACJ,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,MAAW,EAAE,IAAI,EAAE,KAAK,QAAG,IACjD,MAAM,MAAM,IAAI,CAAC,MAAW,EAAE,IAAI,EAAE,KAAK,QAAG;AAElD,WAAO;AAAA,MACL;AAAA,MACA,SAAS,GAAG,MAAM,OAAO,KAAK,iBAAiB,MAAM,IAAI,MAAM,MAAM,MAAM;AAAA,MAC3E,OAAO,MAAM;AAAA,MACb,WAAW,iBAAiB;AAAA,MAC5B,UAAU,MAAM,SAAS,UAAU,MAAM,SAAS;AAAA,MAClD,WAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,gBAAgB,OAA+B;AAErD,UAAM,aAAa,KAAK,yBAAyB,MAAM,IAAI;AAC3D,UAAM,UAAU,GAAG,UAAU,IAAI,MAAM,MAAM,MAAM;AAEnD,WAAO;AAAA,MACL;AAAA,MACA,SAAS,MAAM;AAAA;AAAA,MACf,OAAO,KAAK,MAAM,MAAM,QAAQ,EAAE,IAAI;AAAA;AAAA,MACtC,WAAW,MAAM,MAAM;AAAA,MACvB,UACE,KAAK,OAAO,MAAM,SAAS,UAAU,MAAM,SAAS,aAAa,GAAI,IACrE;AAAA;AAAA,MACF,WAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,yBAAyB,MAAyB;AACxD,UAAM,gBAA2C;AAAA,MAC/C,CAAC,UAAU,aAAa,GAAG;AAAA,MAC3B,CAAC,UAAU,cAAc,GAAG;AAAA,MAC5B,CAAC,UAAU,sBAAsB,GAAG;AAAA,MACpC,CAAC,UAAU,WAAW,GAAG;AAAA,MACzB,CAAC,UAAU,OAAO,GAAG;AAAA,MACrB,CAAC,UAAU,WAAW,GAAG;AAAA,MACzB,CAAC,UAAU,SAAS,GAAG;AAAA,MACvB,CAAC,UAAU,aAAa,GAAG;AAAA,MAC3B,CAAC,UAAU,YAAY,GAAG;AAAA,MAC1B,CAAC,UAAU,OAAO,GAAG;AAAA,IACvB;AACA,WAAO,cAAc,IAAI,KAAK;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAKQ,0BAA0B,OAAmC;AACnE,UAAM,YAAY,KAAK,IAAI,IAAI,MAAM,SAAS,cAAc,MAAO,KAAK;AACxE,UAAM,QAAQ,MAAM;AAGpB,QAAI,WAAW,MAAM,QAAQ,KAAK;AAChC,aAAO,oBAAoB;AAAA,IAC7B;AAGA,QAAI,WAAW,IAAI;AACjB,aAAO,oBAAoB;AAAA,IAC7B;AAGA,QAAI,WAAW,OAAO,QAAQ,KAAK;AAEjC,aAAO,oBAAoB;AAAA,IAC7B;AAGA,QAAI,WAAW,KAAK;AAElB,aAAO,oBAAoB;AAAA,IAC7B;AAGA,WAAO,oBAAoB;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAa,UAA0B;AAC7C,UAAM,QAAQ,SAAS,MAAM,GAAG;AAChC,UAAM,IAAI;AACV,WAAO,MAAM,KAAK,GAAG;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,QAAI,KAAK,YAAY,SAAS,GAAG;AAC/B,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,YAAqB;AACnB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB,MAA0B;AACxC,WAAO,KAAK,OAAO,OAAO,CAAC,MAAM,EAAE,SAAS,IAAI;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKA,wBAAwB,YAAoB,KAAc;AACxD,WAAO,KAAK,OAAO,OAAO,CAAC,MAAM,EAAE,SAAS,SAAS;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA,EAKA,kBAAkB,WAAmB,IAAY;AAC/C,QAAI,aAAa;AACjB,UAAM,MAAM,KAAK,IAAI;AAErB,eAAW,SAAS,KAAK,QAAQ;AAC/B,YAAM,OAAO,MAAM,MAAM,SAAS,cAAc,MAAO,KAAK;AAC5D,UAAI,MAAM,YAAY,CAAC,MAAM,YAAY;AAEvC,cAAM,WAAW,KAAK,0BAA0B,KAAK;AACrD,cAAM,aAAa,KAAK,cAAc,OAAO,QAAQ;AAGrD,YACE,aAAa,oBAAoB,oBACjC,aAAa,oBAAoB,cACjC;AACA,gBAAM,QAAQ,CAAC;AAAA,QACjB,WAAW,aAAa,oBAAoB,WAAW;AAErD,gBAAM,QAAQ,MAAM,MAAM,OAAO,CAAC,SAAc;AAC9C,kBAAM,QAAQ,KAAK,cAAc,eAAe,KAAK,MAAM;AAAA,cACzD,eAAe,KAAK,eAAe,UAAU;AAAA,cAC7C,aAAa,KAAK,kBAAkB,IAAI;AAAA,cACxC,gBAAgB;AAAA,YAClB,CAAC;AACD,mBAAO,SAAS;AAAA,UAClB,CAAC;AAAA,QACH;AAEA;AAGA,YAAI,KAAK,YAAY;AACnB,cAAI;AACF,iBAAK,WAAW;AAAA,cACd,MAAM;AAAA,cACN,MAAM;AAAA,cACN;AAAA,YACF;AAAA,UACF,SAAS,OAAgB;AACvB,oBAAQ;AAAA,cACN;AAAA,cACA;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,eAAuB;AACrB,WAAO,KAAK,UAAU,KAAK,QAAQ,MAAM,CAAC;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB;AACd,UAAM,QAAQ;AAAA,MACZ,aAAa,KAAK,OAAO;AAAA,MACzB,cAAc,CAAC;AAAA,MACf,cAAc;AAAA,MACd,eAAe;AAAA,MACf,iBAAiB;AAAA,MACjB,qBAAqB;AAAA,IACvB;AAEA,QAAI,KAAK,OAAO,WAAW,EAAG,QAAO;AAErC,QAAI,aAAa;AACjB,QAAI,cAAc;AAElB,eAAW,SAAS,KAAK,QAAQ;AAE/B,YAAM,aAAa,MAAM,IAAI,KAC1B,MAAM,aAAa,MAAM,IAAI,KAAK,KAAK;AAG1C,oBAAc,MAAM;AAGpB,qBAAe,MAAM,MAAM;AAG3B,UAAI,MAAM,YAAY;AACpB,cAAM;AAAA,MACR;AAGA,UAAI,MAAM,SAAS,KAAK;AACtB,cAAM;AAAA,MACR;AAAA,IACF;AAEA,UAAM,eAAe,aAAa,KAAK,OAAO;AAC9C,UAAM,gBAAgB,cAAc,KAAK,OAAO;AAEhD,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}