@bonginkan/maria 3.0.6 → 3.0.9

package/dist/index.js

@@ -24,32 +24,32 @@ var NaturalLanguageProcessor = class {
     }
     this.initialized = true;
   }
-  async process(input2, language2 = "en") {
-    const normalized = this.normalize(input2, language2);
-    const tokens = this.tokenize(normalized, language2);
-    const stems = this.stem(tokens, language2);
+  async process(input2, language = "en") {
+    const normalized = this.normalize(input2, language);
+    const tokens = this.tokenize(normalized, language);
+    const stems = this.stem(tokens, language);
     const entities = this.extractEntities(input2);
-    const keywords2 = this.extractKeywords(tokens, language2);
+    const _keywords = this.extractKeywords(tokens, language);
     return {
       original: input2,
       normalized,
       tokens,
       stems,
       entities,
-      language: language2,
-      keywords: keywords2
+      language,
+      _keywords
     };
   }
-  normalize(text, language2) {
+  normalize(text, language) {
     let normalized = text.toLowerCase().trim();
-    if (language2 === "en") {
+    if (language === "en") {
       this.contractionMap.forEach((expanded, contraction) => {
-        const regex2 = new RegExp(`\\b${contraction}\\b`, "gi");
-        normalized = normalized.replace(regex2, expanded);
+        const _regex = new RegExp(`\\b${contraction}\\b`, "gi");
+        normalized = normalized.replace(_regex, expanded);
       });
     }
     normalized = normalized.replace(/\s+/g, " ");
-    switch (language2) {
+    switch (language) {
       case "ja":
         normalized = this.normalizeJapanese(normalized);
         break;
@@ -65,8 +65,8 @@ var NaturalLanguageProcessor = class {
     }
     return normalized;
   }
-  tokenize(text, language2) {
-    switch (language2) {
+  tokenize(text, language) {
+    switch (language) {
       case "ja":
         return this.tokenizeJapanese(text);
       case "cn":
@@ -85,8 +85,8 @@ var NaturalLanguageProcessor = class {
   tokenizeJapanese(text) {
     const tokens = [];
     patterns.forEach((pattern2) => {
-      text.match(pattern2);
-      if (matches) {
+      const _matches = text.match(pattern2);
+      if (_matches) {
         tokens.push(...matches);
       }
     });
@@ -94,11 +94,11 @@ var NaturalLanguageProcessor = class {
   }
   tokenizeChinese(text) {
     const tokens = [];
-    for (const char2 of text) {
-      if (/[\u4e00-\u9faf]/.test(char2)) {
-        tokens.push(char2);
-      } else if (/[a-zA-Z0-9]+/.test(char2)) {
-        tokens.push(char2);
+    for (const char of text) {
+      if (/[\u4e00-\u9faf]/.test(char)) {
+        tokens.push(char);
+      } else if (/[a-zA-Z0-9]+/.test(char)) {
+        tokens.push(char);
       }
     }
     return tokens;
@@ -106,15 +106,15 @@ var NaturalLanguageProcessor = class {
   tokenizeKorean(text) {
     const tokens = [];
     patterns.forEach((pattern2) => {
-      text.match(pattern2);
-      if (matches) {
+      const _matches = text.match(pattern2);
+      if (_matches) {
         tokens.push(...matches);
       }
     });
     return tokens;
   }
-  stem(tokens, language2) {
-    if (language2 !== "en") {
+  stem(tokens, language) {
+    if (language !== "en") {
       return tokens;
     }
     return tokens.map((token) => {
@@ -135,40 +135,41 @@ var NaturalLanguageProcessor = class {
   }
   extractEntities(text) {
     const entities = [];
-    const filePattern2 = /(?:\/[\w.-]+)+(?:\.\w+)?|(?:[a-zA-Z]:[\\/][\w\\/.-]+)/g;
-    const fileMatches = text.match(filePattern2);
+    const filePattern = /(?:\/[\w.-]+)+(?:\.\w+)?|(?:[a-zA-Z]:[\\/][\w\\/.-]+)/g;
+    const fileMatches = text.match(filePattern);
     if (fileMatches) {
-      fileMatches.forEach((match2) => {
+      fileMatches.forEach((match) => {
         entities.push({
-          text: match2,
+          text: match,
           type: "file",
-          value: match2,
-          position: text.indexOf(match2)
+          value: match,
+          position: text.indexOf(match)
         });
       });
     }
-    text.match(urlPattern);
-    if (urlMatches) {
-      urlMatches.forEach((match2) => {
+    const _urlPattern = /https?:\/\/[^\s]+/g;
+    const _urlMatches = text.match(_urlPattern);
+    if (_urlMatches) {
+      urlMatches.forEach((match) => {
         entities.push({
-          text: match2,
+          text: match,
           type: "url",
-          value: match2,
-          position: text.indexOf(match2)
+          value: match,
+          position: text.indexOf(match)
         });
       });
     }
     languages.forEach((lang) => {
-      lang.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      new RegExp(`\\b${escapedLang}\\b`, "gi");
-      text.match(regex);
-      if (matches) {
-        matches.forEach((match2) => {
+      const _escapedLang = lang.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const _regex = new RegExp(`\\b${_escapedLang}\\b`, "gi");
+      const _matches = text.match(_regex);
+      if (_matches) {
+        matches.forEach((match) => {
           entities.push({
-            text: match2,
+            text: match,
             type: "language",
             value: lang,
-            position: text.indexOf(match2)
+            position: text.indexOf(match)
           });
         });
       }
@@ -184,36 +185,36 @@ var NaturalLanguageProcessor = class {
       "rails",
       "spring"
     ];
-    frameworks.forEach((framework2) => {
-      const regex2 = new RegExp(`\\b${framework2}\\b`, "gi");
-      const matches2 = text.match(regex2);
-      if (matches2) {
-        matches2.forEach((match2) => {
+    frameworks.forEach((framework) => {
+      const _regex = new RegExp(`\\b${framework}\\b`, "gi");
+      const _matches = text.match(_regex);
+      if (_matches) {
+        matches.forEach((match) => {
           entities.push({
-            text: match2,
+            text: match,
             type: "framework",
-            value: framework2,
-            position: text.indexOf(match2)
+            value: framework,
+            position: text.indexOf(match)
           });
         });
       }
     });
     return entities;
   }
-  extractKeywords(tokens, language2) {
-    const stopWords = this.stopWords.get(language2) ?? /* @__PURE__ */ new Set();
-    const keywords2 = tokens.filter((token) => {
+  extractKeywords(tokens, language) {
+    const stopWords = this.stopWords.get(language) ?? /* @__PURE__ */ new Set();
+    tokens.filter((token) => {
       return token.length > 2 && !stopWords.has(token.toLowerCase());
     });
-    const frequency2 = /* @__PURE__ */ new Map();
-    keywords2.forEach((keyword) => {
-      frequency2.set(keyword, (frequency2.get(keyword) ?? 0) + 1);
+    const frequency = /* @__PURE__ */ new Map();
+    keywords.forEach((keyword) => {
+      frequency.set(keyword, (frequency.get(keyword) ?? 0) + 1);
     });
-    return Array.from(frequency2.entries()).sort((a2, b) => b[1] - a2[1]).slice(0, 10).map(([keyword]) => keyword);
+    return Array.from(frequency.entries()).sort((a2, b) => b[1] - a2[1]).slice(0, 10).map(([keyword]) => keyword);
   }
   normalizeJapanese(text) {
-    return text.replace(/[Ａ-Ｚａ-ｚ０-９]/g, (char2) => {
-      return String.fromCharCode(char2.charCodeAt(0) - 65248);
+    return text.replace(/[Ａ-Ｚａ-ｚ０-９]/g, (char) => {
+      return String.fromCharCode(char.charCodeAt(0) - 65248);
     });
   }
   normalizeChinese(text) {
@@ -431,20 +432,20 @@ var NaturalLanguageProcessor = class {
   }
   async detectIntent(processedInput) {
     const intents = [];
-    `${processedInput.keywords.join(" ")} ${processedInput.normalized}`;
-    if (/\b(write|create|generate|implement|build|code|program|develop)\b/i.test(keywords)) {
+    const _keywords = `${processedInput.keywords.join(" ")} ${processedInput.normalized}`;
+    if (/\b(write|create|generate|implement|build|code|program|develop)\b/i.test(_keywords)) {
       intents.push("code_generation");
     }
-    if (/\b(image|picture|photo|draw|illustrate|visual|graphic)\b/i.test(keywords)) {
+    if (/\b(image|picture|photo|draw|illustrate|visual|graphic)\b/i.test(_keywords)) {
       intents.push("image_generation");
     }
-    if (/\b(video|movie|animation|clip|film)\b/i.test(keywords)) {
+    if (/\b(video|movie|animation|clip|film)\b/i.test(_keywords)) {
       intents.push("video_generation");
     }
-    if (/\b(test|testing|unit test|integration test|e2e)\b/i.test(keywords)) {
+    if (/\b(test|testing|unit test|integration test|e2e)\b/i.test(_keywords)) {
       intents.push("test_generation");
     }
-    if (/\b(review|check|analyze|improve|refactor|optimize)\b/i.test(keywords)) {
+    if (/\b(review|check|analyze|improve|refactor|optimize)\b/i.test(_keywords)) {
       intents.push("code_review");
     }
     return intents;
@@ -479,7 +480,7 @@ var IntentRecognizer = class {
     this.initialized = true;
   }
   async recognize(input2) {
-    const startTime2 = performance.now();
+    const startTime = performance.now();
     this.metrics.totalCalls++;
     if ((input2.normalized?.length ?? 0) > 8192) {
       this.metrics.nullReturns++;
@@ -500,7 +501,7 @@ var IntentRecognizer = class {
     const candidates = Array.from(scores.entries()).sort((a2, b) => b[1] - a2[1]).slice(0, this.config.maxAlternatives + 1);
     if (candidates.length === 0) {
       this.metrics.nullReturns++;
-      const elapsed2 = performance.now() - startTime2;
+      const elapsed2 = performance.now() - startTime;
       this.metrics.responseTimes.push(elapsed2);
       return null;
     }
@@ -513,7 +514,7 @@ var IntentRecognizer = class {
     const minConfidence = 0.35;
     if (normalizedCandidates[0]?.confidence < minConfidence) {
       this.metrics.nullReturns++;
-      const elapsed2 = performance.now() - startTime2;
+      const elapsed2 = performance.now() - startTime;
       this.metrics.responseTimes.push(elapsed2);
       return null;
     }
@@ -522,7 +523,7 @@ var IntentRecognizer = class {
       throw new Error("No candidates found for intent recognition");
     }
     const alternatives = normalizedCandidates.slice(1);
-    const elapsed = performance.now() - startTime2;
+    const elapsed = performance.now() - startTime;
     this.metrics.responseTimes.push(elapsed);
     return {
       command: topCandidate.command,
@@ -568,7 +569,7 @@ var IntentRecognizer = class {
       }
     });
   }
-  calculateContextScores(input2, scores) {
+  calculateContextScores(_input, scores) {
     if (this.commandHistory.length > 0) {
       const lastCommand = this.commandHistory[this.commandHistory.length - 1];
       const relatedCommands = this.getRelatedCommands(lastCommand ?? "");
@@ -611,7 +612,7 @@ var IntentRecognizer = class {
       }
     });
   }
-  calculateHistoricalScores(input2, scores) {
+  calculateHistoricalScores(_input, scores) {
     if (this.commandHistory.length === 0) {
       return;
     }
@@ -644,7 +645,7 @@ var IntentRecognizer = class {
     };
     return relationships[command2] ?? [];
   }
-  generateReasoning(input2, command2) {
+  generateReasoning(input2, _command) {
     const reasons = [];
     if (input2.keywords.length > 0) {
       reasons.push(`Keywords detected: ${input2.keywords.slice(0, 3).join(", ")}`);
@@ -655,7 +656,7 @@ var IntentRecognizer = class {
     }
     return reasons.join("; ");
   }
-  async updateModel(input2, correctCommand, wasCorrect) {
+  async updateModel(_input, correctCommand, _wasCorrect) {
     this.commandHistory.push(correctCommand);
     if (this.commandHistory.length > 100) {
       this.commandHistory.shift();
@@ -1104,10 +1105,10 @@ var IntentRecognizer = class {
     const knownCommands = this.dependencies.knownCommands;
     const inputText = input2.normalized.trim();
     knownCommands.forEach((command2) => {
-      const distance2 = this.calculateEditDistance(inputText, command2);
+      const distance = this.calculateEditDistance(inputText, command2);
       const commandWithoutSlash = command2.substring(1);
       const distanceWithoutSlash = this.calculateEditDistance(inputText, commandWithoutSlash);
-      const bestDistance = Math.min(distance2, distanceWithoutSlash);
+      const bestDistance = Math.min(distance, distanceWithoutSlash);
       if (bestDistance <= 1) {
         const fuzzyScore = 5;
         const currentScore = scores.get(command2) ?? 0;
@@ -1143,26 +1144,26 @@ var IntentRecognizer = class {
 
 // src/services/intelligent-router/analysis/ParameterExtractor.ts
 var ParameterExtractor = class {
-  async extract(input2, command2, language2) {
+  async extract(input2, command2, language) {
     switch (command2) {
       case "/code":
-        return this.extractCodeParameters(input2, language2);
+        return this.extractCodeParameters(input2, language);
       case "/image":
-        return this.extractImageParameters(input2, language2);
+        return this.extractImageParameters(input2, language);
       case "/video":
-        return this.extractVideoParameters(input2, language2);
+        return this.extractVideoParameters(input2, language);
       case "/test":
-        return this.extractTestParameters(input2, language2);
+        return this.extractTestParameters(input2, language);
       case "/review":
-        return this.extractReviewParameters(input2, language2);
+        return this.extractReviewParameters(input2, language);
       case "/lang":
-        return this.extractLanguageParameters(input2, language2);
+        return this.extractLanguageParameters(input2, language);
       default:
-        return this.extractGenericParameters(input2, language2);
+        return this.extractGenericParameters(input2, language);
     }
   }
-  extractCodeParameters(_input, language2) {
-    this.cleanDescription(input, language2, [
+  extractCodeParameters(_input, language) {
+    const _description = this.cleanDescription(input, language, [
       "write",
       "create",
       "generate",
@@ -1192,23 +1193,14 @@ var ParameterExtractor = class {
       "m\xE3",
       "ch\u01B0\u01A1ng tr\xECnh"
     ]);
-    _params.description = description;
+    _params.description = _description;
     this.detectProgrammingLanguage(input);
-    if (progLang) {
-      progLang;
-    }
     this.detectFramework(input);
-    if (framework) {
-      framework;
-    }
     this.extractFilePath(input);
-    if (filePath) {
-      filePath;
-    }
     return _params;
   }
-  extractImageParameters(_input, language2) {
-    this.cleanDescription(input, language2, [
+  extractImageParameters(_input, language) {
+    const _prompt = this.cleanDescription(input, language, [
       "create",
       "generate",
       "make",
@@ -1235,20 +1227,17 @@ var ParameterExtractor = class {
       "h\xECnh \u1EA3nh",
       "\u1EA3nh"
     ]);
-    _params.prompt = prompt;
+    _params.prompt = _prompt;
     this.detectArtStyle(input);
-    if (style) {
-      style;
-    }
-    this.extractDimensions(input);
-    if (dimensions) {
+    const _dimensions = this.extractDimensions(input);
+    if (_dimensions) {
       dimensions.width;
       _params.height = dimensions.height;
     }
     return _params;
   }
-  extractVideoParameters(_input, language2) {
-    this.cleanDescription(input, language2, [
+  extractVideoParameters(_input, language) {
+    const _description = this.cleanDescription(input, language, [
       "create",
       "generate",
       "make",
@@ -1272,19 +1261,13 @@ var ParameterExtractor = class {
       "video",
       "ho\u1EA1t h\xECnh"
     ]);
-    _params.description = description;
+    _params.description = _description;
     this.extractDuration(input);
-    if (duration) {
-      duration;
-    }
     this.detectVideoFormat(input);
-    if (format) {
-      format;
-    }
     return _params;
   }
-  extractTestParameters(_input, language2) {
-    this.cleanDescription(input, language2, [
+  extractTestParameters(_input, language) {
+    const _description = this.cleanDescription(input, language, [
       "write",
       "create",
       "generate",
@@ -1304,19 +1287,13 @@ var ParameterExtractor = class {
       "t\u1EA1o",
       "ki\u1EC3m tra"
     ]);
-    _params.description = description;
+    _params.description = _description;
     this.detectTestType(input);
-    if (testType) {
-      testType;
-    }
     this.extractFilePath(input);
-    if (filePath) {
-      filePath;
-    }
     return _params;
   }
-  extractReviewParameters(_input, language2) {
-    this.cleanDescription(input, language2, [
+  extractReviewParameters(_input, language) {
+    const _description = this.cleanDescription(input, language, [
       "review",
       "check",
       "analyze",
@@ -1339,34 +1316,26 @@ var ParameterExtractor = class {
       "ph\xE2n t\xEDch",
       "c\u1EA3i thi\u1EC7n"
     ]);
-    _params.description = description;
+    _params.description = _description;
     this.extractFilePath(input);
-    if (filePath) {
-      filePath;
-    }
     this.detectReviewFocus(input);
     return _params;
   }
-  extractLanguageParameters(_input, language2) {
+  extractLanguageParameters(_input, language) {
     this.extractTargetLanguage(input);
-    if (targetLang) {
-      targetLang;
-    }
     return _params;
   }
-  extractGenericParameters(_input, language2) {
-    this.cleanDescription(input, language2, []);
-    _params.input = cleanedInput;
+  extractGenericParameters(_input, language) {
+    const _cleanedInput = this.cleanDescription(input, language, []);
+    _params.input = _cleanedInput;
     this.extractFilePath(input);
-    if (filePath) {
-      filePath;
-    }
     return _params;
   }
-  cleanDescription(_input, language2, keywords2) {
+  cleanDescription(_input, _language2, keywords2) {
     let cleaned = input.toLowerCase();
     keywords2.forEach((keyword) => {
-      cleaned = cleaned.replace(regex, "");
+      const _regex = new RegExp(`\\b${keyword}\\b`, "gi");
+      cleaned = cleaned.replace(_regex, "");
     });
     cleaned = cleaned.replace(/\s+/g, " ").trim();
     return cleaned;
@@ -1386,8 +1355,8 @@ var ParameterExtractor = class {
       swift: /\b(swift)\b/i,
       kotlin: /\b(kotlin)\b/i
     };
-    for (const [lang, pattern2] of Object.entries(languages2)) {
-      if (pattern2.test(input2)) {
+    for (const [lang, _pattern] of Object.entries(languages2)) {
+      if (pattern.test(input2)) {
         return lang;
       }
     }
@@ -1406,9 +1375,9 @@ var ParameterExtractor = class {
       spring: /\b(spring)\b/i,
       laravel: /\b(laravel)\b/i
     };
-    for (const [framework2, pattern2] of Object.entries(frameworks)) {
-      if (pattern2.test(input2)) {
-        return framework2;
+    for (const [_framework, _pattern] of Object.entries(frameworks)) {
+      if (pattern.test(input2)) {
+        return _framework;
       }
     }
     return null;
@@ -1424,57 +1393,61 @@ var ParameterExtractor = class {
       "3d": /\b(3d|three dimensional)\b/i,
       pixel: /\b(pixel art|pixelated)\b/i
     };
-    for (const [style2, pattern2] of Object.entries(styles)) {
-      if (pattern2.test(input2)) {
-        return style2;
+    for (const [_style, _pattern] of Object.entries(styles)) {
+      if (pattern.test(input2)) {
+        return _style;
       }
     }
     return null;
   }
   extractFilePath(input2) {
-    input2.match(filePattern);
-    return match ? match[1] : null;
+    const _filePattern = /(?:["'])?([/\w\-._]+\.\w+)(?:["'])?/;
+    const _match = input2.match(_filePattern);
+    return _match ? _match[1] : null;
   }
   extractDimensions(input2) {
-    input2.match(dimensionPattern);
-    if (match) {
+    const _dimensionPattern = /(\d+)\s*[x×]\s*(\d+)/i;
+    const _match = input2.match(_dimensionPattern);
+    if (_match) {
       return {
-        width: parseInt(match[1], 10),
-        height: parseInt(match[2], 10)
+        width: parseInt(_match[1], 10),
+        height: parseInt(_match[2], 10)
       };
     }
     return null;
   }
   extractDuration(input2) {
-    input2.match(durationPattern);
-    if (match) {
-      parseInt(match[1], 10);
-      match[2].toLowerCase();
+    const _durationPattern = /(\d+)\s*(seconds?|secs?|minutes?|mins?)/i;
+    const _match = input2.match(_durationPattern);
+    if (_match) {
+      const _value = parseInt(_match[1], 10);
+      _match[2].toLowerCase();
       if (unit.startsWith("min")) {
-        return value * 60;
+        return _value * 60;
       }
-      return value;
+      return _value;
     }
     return null;
   }
   detectVideoFormat(input2) {
-    for (const format2 of formats) {
+    const _formats = ["mp4", "avi", "mov", "webm", "gif"];
+    for (const _format of _formats) {
       if (pattern.test(input2)) {
-        return format2;
+        return _format;
       }
     }
     return null;
   }
   detectTestType(input2) {
     const types = {
-      unit: /\b(unit)\b/i,
+      _unit: /\b(_unit)\b/i,
       integration: /\b(integration)\b/i,
       e2e: /\b(e2e|end to end)\b/i,
       performance: /\b(performance|perf)\b/i,
       snapshot: /\b(snapshot)\b/i
     };
-    for (const [type2, pattern2] of Object.entries(types)) {
-      if (pattern2.test(input2)) {
+    for (const [type2, _pattern] of Object.entries(types)) {
+      if (pattern.test(input2)) {
         return type2;
       }
     }
@@ -1485,12 +1458,12 @@ var ParameterExtractor = class {
       performance: /\b(performance|speed|optimization)\b/i,
       security: /\b(security|vulnerability|safe)\b/i,
       quality: /\b(quality|clean|maintainability)\b/i,
-      style: /\b(style|format|convention)\b/i,
+      _style: /\b(_style|_format|convention)\b/i,
       bugs: /\b(bugs?|errors?|issues?)\b/i
     };
-    for (const [focus2, pattern2] of Object.entries(focuses)) {
-      if (pattern2.test(input2)) {
-        return focus2;
+    for (const [_focus, _pattern] of Object.entries(focuses)) {
+      if (pattern.test(input2)) {
+        return _focus;
       }
     }
     return null;
@@ -1505,8 +1478,8 @@ var ParameterExtractor = class {
     };
     input2.toLowerCase();
     for (const [code2, patterns2] of Object.entries(languageMap)) {
-      for (const pattern2 of patterns2) {
-        if (lowerInput.includes(pattern2)) {
+      for (const _pattern of patterns2) {
+        if (lowerInput.includes(_pattern)) {
           return code2;
         }
       }
@@ -1529,29 +1502,29 @@ var MultilingualDictionary = class {
     this.loadTranslations();
     this.initialized = true;
   }
-  getTranslation(_command, language2 = "en") {
+  getTranslation(_command, _language2 = "en") {
     return this.dictionary.get(command) ?? null;
   }
-  getExplanation(_command, language2 = "en") {
-    this.dictionary.get(command);
-    if (!translation) {
+  getExplanation(_command, language = "en") {
+    const _translation = this.dictionary.get(command);
+    if (!_translation) {
       return `Command ${command} not found`;
     }
-    return translation.description[language2] ?? translation.description["en"] ?? "";
+    return translation.description[language] ?? translation.description["en"] ?? "";
   }
-  getKeywords(_command, language2 = "en") {
-    this.dictionary.get(command);
-    if (!translation) {
+  getKeywords(_command, language = "en") {
+    const _translation = this.dictionary.get(command);
+    if (!_translation) {
       return [];
     }
-    return translation.keywords[language2] ?? translation.keywords["en"] ?? [];
+    return translation.keywords[language] ?? translation.keywords["en"] ?? [];
   }
-  getExamples(_command, language2 = "en") {
-    this.dictionary.get(command);
-    if (!translation) {
+  getExamples(_command, language = "en") {
+    const _translation = this.dictionary.get(command);
+    if (!_translation) {
       return [];
     }
-    return translation.examples[language2] ?? translation.examples["en"] ?? [];
+    return translation.examples[language] ?? translation.examples["en"] ?? [];
   }
   getAllCommands() {
     return Array.from(this.dictionary.keys());
@@ -1904,21 +1877,21 @@ var LanguageDetector = class {
       { language: "ko", score: 0 },
       { language: "vn", score: 0 }
     ];
-    this.characterRanges.forEach((patterns2, language2) => {
+    this.characterRanges.forEach((patterns2, language) => {
       patterns2.forEach((pattern2) => {
         const matches2 = text.match(pattern2);
         if (matches2) {
-          const score = scores.find((s) => s.language === language2);
+          const score = scores.find((s) => s.language === language);
           if (score) {
             score.score += matches2.length * 2;
           }
         }
       });
     });
-    this.languagePatterns.forEach((patterns2, language2) => {
+    this.languagePatterns.forEach((patterns2, language) => {
       patterns2.forEach((pattern2) => {
         if (pattern2.test(text)) {
-          const score = scores.find((s) => s.language === language2);
+          const score = scores.find((s) => s.language === language);
           if (score) {
             score.score += 3;
           }
@@ -2041,34 +2014,34 @@ var CommandMappings = class {
     this.loadMappings();
     this.initialized = true;
   }
-  async getSuggestions(_input, language2, maxResults = 5) {
-    input.toLowerCase();
-    const suggestions2 = [];
+  async getSuggestions(_input, language, maxResults = 5) {
+    const _lowerInput = input.toLowerCase();
+    const suggestions = [];
     for (const mapping of this.mappings) {
-      mapping.naturalPhrases.get(language2) ?? mapping.naturalPhrases.get("en") ?? [];
+      const _phrases = mapping.naturalPhrases.get(language) ?? mapping.naturalPhrases.get("en") ?? [];
       let score = 0;
-      for (const phrase2 of phrases) {
-        if (phrase2.toLowerCase().includes(lowerInput)) {
+      for (const phrase2 of _phrases) {
+        if (phrase2.toLowerCase().includes(_lowerInput)) {
           score += 2;
         }
-        if (phrase2.toLowerCase().startsWith(lowerInput)) {
+        if (phrase2.toLowerCase().startsWith(_lowerInput)) {
           score += 3;
         }
       }
-      if (mapping.command.toLowerCase().includes(lowerInput)) {
+      if (mapping.command.toLowerCase().includes(_lowerInput)) {
         score += 5;
       }
       if (score > 0) {
-        suggestions2.push({ command: mapping.command, score: score * mapping.priority });
+        suggestions.push({ command: mapping.command, score: score * mapping.priority });
       }
     }
-    return suggestions2.sort((a2, b) => b.score - a2.score).slice(0, maxResults).map((s) => s.command);
+    return suggestions.sort((a2, b) => b.score - a2.score).slice(0, maxResults).map((s) => s.command);
   }
-  getCommandForPhrase(_phrase, language2) {
+  getCommandForPhrase(_phrase, language) {
     phrase.toLowerCase();
     for (const mapping of this.mappings) {
-      mapping.naturalPhrases.get(language2) ?? mapping.naturalPhrases.get("en") ?? [];
-      for (const naturalPhrase of phrases) {
+      const _phrases = mapping.naturalPhrases.get(language) ?? mapping.naturalPhrases.get("en") ?? [];
+      for (const naturalPhrase of _phrases) {
         if (lowerPhrase.includes(naturalPhrase.toLowerCase())) {
           return mapping.command;
         }
@@ -2527,7 +2500,7 @@ var UserPatternAnalyzer = class {
     this.initialized = true;
   }
   async recordPattern(_input, intent) {
-    const pattern2 = {
+    const _pattern = {
       input,
       command: intent.command,
       confidence: intent.confidence,
@@ -2535,15 +2508,15 @@ var UserPatternAnalyzer = class {
       success: true
       // Will be updated by feedback
     };
-    this.patterns.push(pattern2);
+    this.patterns.push(_pattern);
     if (this.patterns.length > 1e3) {
       this.patterns = this.patterns.slice(-1e3);
     }
     this.savePatterns();
   }
   async recordFeedback(_input, correctCommand, wasCorrect) {
-    this.patterns.slice().reverse().find((p) => p.input === input);
-    if (pattern) {
+    const _pattern = this.patterns.slice().reverse().find((p) => p.input === input);
+    if (_pattern) {
       pattern.success = wasCorrect;
       if (!wasCorrect) {
         this.patterns.push({
@@ -2559,9 +2532,9 @@ var UserPatternAnalyzer = class {
   }
   getPatternStats() {
     const stats2 = {};
-    this.patterns.forEach((pattern2) => {
-      if (pattern2.success) {
-        stats2[pattern2.command] = (stats2[pattern2.command] ?? 0) + 1;
+    this.patterns.forEach((_pattern) => {
+      if (pattern.success) {
+        stats2[pattern.command] = (stats2[pattern.command] ?? 0) + 1;
       }
     });
     return stats2;
@@ -2587,13 +2560,13 @@ var UserPatternAnalyzer = class {
     return mostCommon;
   }
   calculateSimilarity(_str1, str2) {
-    str1.length > str2.length ? str1 : str2;
-    str1.length > str2.length ? str2 : str1;
+    const _longer = str1.length > str2.length ? str1 : str2;
+    const _shorter = str1.length > str2.length ? str2 : str1;
     if (longer.length === 0) {
       return 1;
     }
-    this.levenshteinDistance(longer, shorter);
-    return (longer.length - distance) / longer.length;
+    const _distance = this.levenshteinDistance(_longer, _shorter);
+    return (longer.length - _distance) / longer.length;
   }
   levenshteinDistance(_str1, str2) {
     const matrix = [];
@@ -2695,38 +2668,39 @@ var IntelligentRouterService = class extends EventEmitter {
     if (!this.isInitialized) {
       await this.initialize();
     }
+    const _startTime = Date.now();
     this.metrics.totalRequests++;
     try {
-      const language2 = await this.languageDetector.detect(input2);
-      if (!this.config.supportedLanguages.includes(language2)) {
+      const _language2 = await this.languageDetector.detect(input2);
+      if (!this.config.supportedLanguages.includes(_language2)) {
       }
-      const processedInput = await this.nlpProcessor.process(input2, language2);
+      const processedInput = await this.nlpProcessor.process(input2, _language2);
       const intent = await this.intentRecognizer.recognize(processedInput);
       if (!intent || intent.confidence < this.config.confidenceThreshold) {
         this.metrics.failedRoutes++;
-        this.emit("route:failed", { input: input2, language: language2, confidence: intent?.confidence ?? 0 });
+        this.emit("route:failed", { input: input2, _language: _language2, confidence: intent?.confidence ?? 0 });
         return null;
       }
-      const _parameters = await this.parameterExtractor.extract(input2, intent.command, language2);
+      const _parameters = await this.parameterExtractor.extract(input2, intent.command, _language2);
       const commandIntent = {
         command: intent.command,
         confidence: intent.confidence,
-        parameters,
+        _parameters,
         originalInput: input2,
-        language: language2,
+        _language: _language2,
         alternatives: intent.alternatives
       };
       if (this.config.enableLearning) {
         await this.userPatternAnalyzer.recordPattern(input2, commandIntent);
       }
       this.metrics.successfulRoutes++;
-      this.updateMetrics(intent.confidence, Date.now() - startTime, intent.command);
+      this.updateMetrics(intent.confidence, Date.now() - _startTime, intent.command);
       this.emit("route:success", commandIntent);
       return commandIntent;
     } catch (_error) {
       this.metrics.failedRoutes++;
-      this.emit("route:error", { input: input2, _error });
-      console.error(chalk2.red("Routing error:"), _error);
+      this.emit("route:_error", { input: input2, _error });
+      console.error(chalk2.red("Routing _error:"), _error);
       return null;
     }
   }
@@ -2738,25 +2712,25 @@ var IntelligentRouterService = class extends EventEmitter {
       const _language2 = await this.languageDetector.detect(partialInput);
       const _suggestions = await this.commandMappings.getSuggestions(
         partialInput,
-        language,
+        _language2,
         this.config.maxAlternatives
       );
-      return suggestions;
+      return _suggestions;
     } catch (_error) {
-      console.error("Failed to get suggestions:", _error);
+      console.error("Failed to get _suggestions:", _error);
       return [];
     }
   }
-  async getCommandExplanation(_command, language2 = "en") {
-    return this.dictionary.getExplanation(command, language2);
+  async getCommandExplanation(_command, language = "en") {
+    return this.dictionary.getExplanation(command, language);
   }
   async needsConfirmation(intent) {
     if (!this.config.enableConfirmation) {
       return false;
     }
-    destructiveCommands.includes(intent.command);
-    intent.confidence < 0.9;
-    return isDestructive || isLowConfidence;
+    const _isDestructive = destructiveCommands.includes(intent.command);
+    const _isLowConfidence = intent.confidence < 0.9;
+    return _isDestructive || _isLowConfidence;
   }
   getMetrics() {
     return { ...this.metrics };
@@ -2772,12 +2746,12 @@ var IntelligentRouterService = class extends EventEmitter {
     };
   }
   updateMetrics(_confidence, responseTime, command2) {
-    this.metrics.averageConfidence * (this.metrics.successfulRoutes - 1);
-    this.metrics.averageConfidence = (totalConfidence + confidence) / this.metrics.successfulRoutes;
-    this.metrics.averageResponseTime * (this.metrics.successfulRoutes - 1);
-    this.metrics.averageResponseTime = (totalResponseTime + responseTime) / this.metrics.successfulRoutes;
-    this.metrics.commandUsageStats.get(command2) ?? 0;
-    this.metrics.commandUsageStats.set(command2, currentCount + 1);
+    const _totalConfidence = this.metrics.averageConfidence * (this.metrics.successfulRoutes - 1);
+    this.metrics.averageConfidence = (_totalConfidence + confidence) / this.metrics.successfulRoutes;
+    const _totalResponseTime = this.metrics.averageResponseTime * (this.metrics.successfulRoutes - 1);
+    this.metrics.averageResponseTime = (_totalResponseTime + responseTime) / this.metrics.successfulRoutes;
+    const _currentCount = this.metrics.commandUsageStats.get(command2) ?? 0;
+    this.metrics.commandUsageStats.set(command2, _currentCount + 1);
   }
   async trainOnFeedback(_input, correctCommand, wasCorrect) {
     if (!this.config.enableLearning) {
@@ -2803,8 +2777,8 @@ var IntelligentRouterService = class extends EventEmitter {
   getSupportedLanguages() {
     return [...this.config.supportedLanguages];
   }
-  isLanguageSupported(language2) {
-    return this.config.supportedLanguages.includes(language2);
+  isLanguageSupported(language) {
+    return this.config.supportedLanguages.includes(language);
   }
   async exportLearningData() {
     return this.userPatternAnalyzer.exportData();
@@ -2839,7 +2813,7 @@ var System1MemoryManager = class {
     this.interactionHistory = {
       sessions: [],
       commands: [],
-      patterns: []
+      _patterns: []
     };
     this.patternLibrary = {
       codePatterns: [],
@@ -2850,7 +2824,7 @@ var System1MemoryManager = class {
     this.userPreferences = this.initializeDefaultPreferences();
   }
   get programmingConcepts() {
-    return Array.from(this.knowledgeNodes.values()).filter((node2) => ["function", "class", "module", "concept"].includes(node2.type)).sort((a2, b) => b.confidence - a2.confidence);
+    return Array.from(this.knowledgeNodes.values()).filter((_node) => ["function", "class", "module", "concept"].includes(node.type)).sort((a2, b) => b.confidence - a2.confidence);
   }
   get businessLogic() {
     return this.conceptGraph;
@@ -2862,61 +2836,62 @@ var System1MemoryManager = class {
     return this.patternLibrary;
   }
   // Knowledge Node Management
-  async addKnowledgeNode(type2, name2, content2, embedding, metadata = {}) {
-    const node2 = {
-      id: this.generateNodeId(type2, name2),
+  async addKnowledgeNode(type2, name, content, embedding, metadata = {}) {
+    const _node = {
+      id: this.generateNodeId(type2, name),
       type: type2,
-      name: name2,
-      content: content2,
+      name,
+      content,
       embedding,
-      confidence: 0.8,
+      _confidence: 0.8,
       lastAccessed: /* @__PURE__ */ new Date(),
       accessCount: 1,
       metadata: {
         complexity: "medium",
-        quality: 0.8,
+        _quality: 0.8,
         relevance: 0.8,
         ...metadata
       }
     };
-    this.knowledgeNodes.set(node2.id, node2);
-    this.conceptGraph.nodes.set(node2.id, node2);
+    this.knowledgeNodes.set(node.id, _node);
+    this.conceptGraph.nodes.set(node.id, _node);
     if (this.knowledgeNodes.size > this.config.maxKnowledgeNodes) {
       await this.cleanupLeastUsedNodes();
     }
-    return node2;
+    return _node;
   }
   async getKnowledgeNode(id2) {
-    this.knowledgeNodes.get(id2);
-    if (node) {
+    const _node = this.knowledgeNodes.get(id2);
+    if (_node) {
       node.lastAccessed = /* @__PURE__ */ new Date();
       node.accessCount++;
       this.lastAccessTimes.set(id2, /* @__PURE__ */ new Date());
-      this.applyAccessDecay(node);
+      this.applyAccessDecay(_node);
     }
-    return node || null;
+    return _node || null;
   }
   async searchKnowledgeNodes(query, queryEmbedding, limit = 10) {
-    this.cache.get(cacheKey);
-    if (cached) {
-      return cached;
+    const _cacheKey = `search:${query}:${limit}`;
+    const _cached = this.cache.get(_cacheKey);
+    if (_cached) {
+      return _cached;
     }
-    Array.from(this.knowledgeNodes.values()).map((node2) => ({
+    const _results = Array.from(this.knowledgeNodes.values()).map((node2) => ({
       node: node2,
       similarity: this.calculateCosineSimilarity(queryEmbedding, node2.embedding)
-    })).filter(({ similarity }) => similarity > 0.5).sort((a2, b) => b.similarity - a2.similarity).slice(0, limit).map(({ node: node2 }) => node2);
-    this.cache.set(cacheKey, results);
-    return results;
+    })).filter(({ similarity }) => similarity > 0.5).sort((a2, b) => b.similarity - a2.similarity).slice(0, limit).map(({ _node }) => _node);
+    this.cache.set(_cacheKey, _results);
+    return _results;
   }
   async updateKnowledgeNode(_id, updates) {
-    this.knowledgeNodes.get(id);
-    if (!node) {
+    const _node = this.knowledgeNodes.get(id);
+    if (!_node) {
       return false;
     }
-    Object.assign(node, updates);
+    Object.assign(_node, updates);
     node.lastAccessed = /* @__PURE__ */ new Date();
-    this.conceptGraph.nodes.set(id, node);
-    this.invalidateCache(`node:${id}`);
+    this.conceptGraph.nodes.set(id, _node);
+    this.invalidateCache(`_node:${id}`);
     return true;
   }
   // Concept Graph Management
@@ -2933,11 +2908,12 @@ var System1MemoryManager = class {
     return edge;
   }
   async getRelatedConcepts(_nodeId, maxDepth = 2) {
-    `related:${nodeId}:${maxDepth}`;
-    this.cache.get(cacheKey);
-    if (cached) {
-      return cached;
+    const _cacheKey = `_related:${nodeId}:${maxDepth}`;
+    const _cached = this.cache.get(_cacheKey);
+    if (_cached) {
+      return _cached;
     }
+    const _related = /* @__PURE__ */ new Set();
     const queue = [{ id: nodeId, depth: 0 }];
     while (queue.length > 0) {
       const { id: id2, depth } = queue.shift();
@@ -2956,9 +2932,9 @@ var System1MemoryManager = class {
         }
       }
     }
-    Array.from(related).map((id2) => this.knowledgeNodes.get(id2)).filter((node2) => node2 !== void 0);
-    this.cache.set(cacheKey, results);
-    return results;
+    const _results = Array.from(_related).map((id2) => this.knowledgeNodes.get(id2)).filter((node2) => node2 !== void 0);
+    this.cache.set(_cacheKey, _results);
+    return _results;
   }
   // Pattern Management
   async addCodePattern(_pattern) {
@@ -2969,34 +2945,36 @@ var System1MemoryManager = class {
     this.patternLibrary.codePatterns.push(codePattern);
     return codePattern;
   }
-  async findCodePatterns(language2, framework2, useCase, limit = 10) {
-    this.cache.get(cacheKey);
-    if (cached) {
-      return cached;
+  async findCodePatterns(language, framework, useCase, limit = 10) {
+    const _cacheKey = `_patterns:${language}:${framework}:${useCase}:${limit}`;
+    const _cached = this.cache.get(_cacheKey);
+    if (_cached) {
+      return _cached;
     }
-    let patterns2 = this.patternLibrary.codePatterns;
-    if (language2) {
-      patterns2 = patterns2.filter((p) => p.language === language2);
+    let _patterns = this.patternLibrary.codePatterns;
+    if (language) {
+      _patterns = patterns.filter((p) => p.language === language);
     }
-    if (framework2) {
-      patterns2 = patterns2.filter((p) => p.framework === framework2);
+    if (framework) {
+      _patterns = patterns.filter((p) => p.framework === framework);
     }
     if (useCase) {
-      patterns2 = patterns2.filter((p) => p.useCase.toLowerCase().includes(useCase.toLowerCase()));
+      _patterns = patterns.filter((p) => p.useCase.toLowerCase().includes(useCase.toLowerCase()));
     }
-    patterns2.sort((a2, b) => {
-      return (complexityWeight[a2.complexity] || 0) - (complexityWeight[b.complexity] || 0);
+    const _results = _patterns.sort((a2, b) => {
+      const _complexityWeight = { beginner: 3, intermediate: 2, advanced: 1 };
+      return (_complexityWeight[a2.complexity] || 0) - (_complexityWeight[b.complexity] || 0);
     }).slice(0, limit);
-    this.cache.set(cacheKey, results);
-    return results;
+    this.cache.set(_cacheKey, _results);
+    return _results;
   }
   async addAntiPattern(_antiPattern) {
-    const pattern2 = {
+    const _pattern = {
       id: this.generatePatternId(antiPattern.name),
       ...antiPattern
     };
-    this.patternLibrary.antiPatterns.push(pattern2);
-    return pattern2;
+    this.patternLibrary.antiPatterns.push(_pattern);
+    return _pattern;
   }
   async detectAntiPatterns(code2) {
     const detected = [];
@@ -3009,12 +2987,13 @@ var System1MemoryManager = class {
             break;
           }
         } catch (_error) {
-          console.warn(`Invalid regex pattern: ${rule.pattern}`, error);
+          console.warn(`Invalid _regex _pattern: ${rule.pattern}`, _error);
         }
       }
     }
     return detected.sort((a2, b) => {
-      return (severityWeight[b.severity] || 0) - (severityWeight[a2.severity] || 0);
+      const _severityWeight = { critical: 4, high: 3, medium: 2, low: 1 };
+      return (_severityWeight[b.severity] || 0) - (_severityWeight[a2.severity] || 0);
     });
   }
   // Interaction History Management
@@ -3033,7 +3012,7 @@ var System1MemoryManager = class {
     if (!commandHist) {
       commandHist = {
         command: command2,
-        frequency: 0,
+        _frequency: 0,
         lastUsed: /* @__PURE__ */ new Date(),
         successRate: 1,
         averageExecutionTime: 0,
@@ -3076,35 +3055,36 @@ var System1MemoryManager = class {
   // Performance Optimization
   async cleanupLeastUsedNodes() {
     Array.from(this.knowledgeNodes.entries());
-    nodeEntries.sort((a2, b) => {
-      this.calculateUsageScore(a2[1]);
-      this.calculateUsageScore(b[1]);
-      return aScore - bScore;
+    const _sortedByUsage = nodeEntries.sort((a2, b) => {
+      const _aScore = this.calculateUsageScore(a2[1]);
+      const _bScore = this.calculateUsageScore(b[1]);
+      return _aScore - _bScore;
     });
-    Math.floor(this.config.maxKnowledgeNodes * 0.1);
-    for (let i = 0; i < removeCount && i < sortedByUsage.length; i++) {
-      sortedByUsage[i];
-      if (entry) {
-        const [nodeId2] = entry;
+    const _removeCount = Math.floor(this.config.maxKnowledgeNodes * 0.1);
+    for (let i = 0; i < _removeCount && i < sortedByUsage.length; i++) {
+      const _entry = _sortedByUsage[i];
+      if (_entry) {
+        const [nodeId2] = _entry;
         this.knowledgeNodes.delete(nodeId2);
         this.conceptGraph.nodes.delete(nodeId2);
-        this.invalidateCache(`node:${nodeId2}`);
+        this.invalidateCache(`_node:${nodeId2}`);
       }
     }
   }
   async compressMemory() {
+    const _cutoffDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
     this.interactionHistory.sessions = this.interactionHistory.sessions.filter(
-      (session) => session.startTime > cutoffDate
+      (session) => session.startTime > _cutoffDate
     );
     await this.mergeimilarPatterns();
     this.cache.clear();
   }
   // Private Helper Methods
-  generateNodeId(_type, name2) {
-    return `${type}:${name2}:${Date.now()}`;
+  generateNodeId(_type, name) {
+    return `${type}:${name}:${Date.now()}`;
   }
-  generatePatternId(name2) {
-    return `pattern:${name2}:${Date.now()}`;
+  generatePatternId(name) {
+    return `_pattern:${name}:${Date.now()}`;
   }
   calculateCosineSimilarity(_a, b) {
     if (a.length !== b.length) {
@@ -3114,26 +3094,26 @@ var System1MemoryManager = class {
     let normA = 0;
     let normB = 0;
     for (let i = 0; i < a.length && i < b.length; i++) {
-      a[i] ?? 0;
-      b[i] ?? 0;
-      dotProduct += aVal * bVal;
-      normA += aVal * aVal;
-      normB += bVal * bVal;
+      const _aVal = a[i] ?? 0;
+      const _bVal = b[i] ?? 0;
+      dotProduct += _aVal * _bVal;
+      normA += _aVal * _aVal;
+      normB += _bVal * _bVal;
     }
     return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
   }
-  applyAccessDecay(node2) {
-    (Date.now() - node2.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
-    Math.exp(-this.config.accessDecayRate * daysSinceAccess);
-    node2.confidence *= decayFactor;
-    node2.confidence = Math.max(node2.confidence, 0.1);
+  applyAccessDecay(_node) {
+    const _daysSinceAccess = (Date.now() - node.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
+    const _decayFactor = Math.exp(-this.config.accessDecayRate * _daysSinceAccess);
+    node.confidence *= _decayFactor;
+    node.confidence = Math.max(node.confidence, 0.1);
   }
-  calculateUsageScore(node2) {
-    (Date.now() - node2.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
-    Math.log(node2.accessCount + 1);
-    node2.confidence;
-    node2.metadata.quality;
-    return (frequency + confidence + quality) / (1 + recency * 0.1);
+  calculateUsageScore(_node) {
+    const _recency = (Date.now() - node.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
+    const _frequency = Math.log(node.accessCount + 1);
+    const _confidence = node.confidence;
+    const _quality = node.metadata.quality;
+    return (_frequency + _confidence + _quality) / (1 + _recency * 0.1);
   }
   invalidateCache(pattern2) {
     for (const key of this.cache.keys()) {
@@ -3143,47 +3123,47 @@ var System1MemoryManager = class {
     }
   }
   async detectUsagePatterns() {
-    this.interactionHistory.sessions.slice(-20);
-    for (const session of recentSessions) {
-      session.startTime.getHours();
-      hourlyUsage.set(hour, (hourlyUsage.get(hour) || 0) + 1);
+    const _recentSessions = this.interactionHistory.sessions.slice(-20);
+    for (const session of _recentSessions) {
+      const _hour = session.startTime.getHours();
+      hourlyUsage.set(_hour, (hourlyUsage.get(_hour) || 0) + 1);
     }
-    for (const session of recentSessions) {
+    for (const session of _recentSessions) {
       for (let i = 0; i < session.commands.length - 1; i++) {
-        `${session.commands[i]} -> ${session.commands[i + 1]}`;
-        sequences.set(sequence, (sequences.get(sequence) || 0) + 1);
+        const _sequence = `${session.commands[i]} -> ${session.commands[i + 1]}`;
+        sequences.set(_sequence, (sequences.get(_sequence) || 0) + 1);
       }
     }
-    for (const [sequence2, frequency2] of sequences.entries()) {
-      if (frequency2 >= 3) {
-        const pattern2 = {
-          id: `seq:${sequence2}:${Date.now()}`,
+    for (const [_sequence, _frequency] of sequences.entries()) {
+      if (_frequency >= 3) {
+        const _pattern = {
+          id: `seq:${_sequence}:${Date.now()}`,
           type: "sequential",
-          pattern: sequence2,
-          frequency: frequency2,
-          confidence: Math.min(frequency2 / 10, 1),
+          _pattern: _sequence,
+          _frequency,
+          _confidence: Math.min(_frequency / 10, 1),
           conditions: []
         };
-        this.interactionHistory.patterns.push(pattern2);
+        this.interactionHistory.patterns.push(_pattern);
       }
     }
   }
   async processCodeGenerationEvent(event) {
     event.data;
     if (data.code && data.language) {
-      this.extractCodePatterns(data.code, data.language);
-      for (const pattern2 of patterns) {
-        await this.addCodePattern(pattern2);
+      const _patterns = this.extractCodePatterns(data.code, data.language);
+      for (const _pattern of _patterns) {
+        await this.addCodePattern(_pattern);
       }
     }
   }
   async processPatternRecognitionEvent(event) {
     event.data;
     if (data.patternId) {
-      this.patternLibrary.codePatterns.find((p) => p.id === data.patternId);
-      if (pattern && data.success !== void 0) {
-        data.success ? 0.1 : -0.05;
-        console.log(`Pattern ${data.patternId} adjustment: ${adjustment}`);
+      const _pattern = this.patternLibrary.codePatterns.find((p) => p.id === data.patternId);
+      if (_pattern && data.success !== void 0) {
+        const _adjustment = data.success ? 0.1 : -0.05;
+        console.log(`Pattern ${data.patternId} _adjustment: ${_adjustment}`);
       }
     }
   }
@@ -3193,15 +3173,15 @@ var System1MemoryManager = class {
       await this.adaptUserPreferences(data.preference, data.value, data.confidence || 0.8);
     }
   }
-  extractCodePatterns(_code, language2) {
-    const patterns2 = [];
-    let match2;
-    while ((match2 = functionRegex.exec(code)) !== null) {
-      patterns2.push({
-        name: `Function: ${match2[1]}`,
-        description: `Function pattern extracted from code`,
-        code: match2[0],
-        language: language2,
+  extractCodePatterns(_code, language) {
+    const _patterns = [];
+    let match;
+    while ((match = functionRegex.exec(code)) !== null) {
+      patterns.push({
+        name: `Function: ${match[1]}`,
+        description: `Function _pattern extracted from code`,
+        code: match[0],
+        language,
         useCase: "Function definition",
         complexity: "intermediate",
         performance: {
@@ -3211,44 +3191,44 @@ var System1MemoryManager = class {
         examples: []
       });
     }
-    return patterns2;
+    return _patterns;
   }
-  async adaptUserPreferences(preference, value2, confidence2) {
-    console.log(`Adapting preference ${preference} to ${value2} (confidence: ${confidence2})`);
+  async adaptUserPreferences(preference, value, confidence2) {
+    console.log(`Adapting preference ${preference} to ${value} (_confidence: ${confidence2})`);
   }
   async mergeimilarPatterns() {
-    this.patternLibrary.codePatterns;
+    const _patterns = this.patternLibrary.codePatterns;
     const merged = [];
     for (let i = 0; i < patterns.length; i++) {
-      patterns[i];
-      if (!currentPattern || processed.has(currentPattern.id)) {
+      const _currentPattern = _patterns[i];
+      if (!_currentPattern || processed.has(currentPattern.id)) {
         continue;
       }
-      patterns.slice(i + 1).filter(
-        (p) => p && !processed.has(p.id) && p.language === currentPattern.language && this.calculatePatternSimilarity(currentPattern, p) > 0.8
+      const _similar = _patterns.slice(i + 1).filter(
+        (p) => p && !processed.has(p.id) && p.language === currentPattern.language && this.calculatePatternSimilarity(_currentPattern, p) > 0.8
       );
       if (similar.length > 0) {
-        this.mergePatterns(currentPattern, similar);
-        merged.push(mergedPattern);
+        const _mergedPattern = this.mergePatterns(_currentPattern, _similar);
+        merged.push(_mergedPattern);
         processed.add(currentPattern.id);
         similar.forEach((p) => processed.add(p.id));
       } else {
-        merged.push(currentPattern);
+        merged.push(_currentPattern);
         processed.add(currentPattern.id);
       }
     }
     this.patternLibrary.codePatterns = merged;
   }
   calculatePatternSimilarity(_a, b) {
-    a.name.toLowerCase().includes(b.name.toLowerCase()) || b.name.toLowerCase().includes(a.name.toLowerCase());
-    a.useCase.toLowerCase() === b.useCase.toLowerCase();
-    return (namesSimilar ? 0.5 : 0) + (useCasesSimilar ? 0.5 : 0);
+    const _namesSimilar = a.name.toLowerCase().includes(b.name.toLowerCase()) || b.name.toLowerCase().includes(a.name.toLowerCase());
+    const _useCasesSimilar = a.useCase.toLowerCase() === b.useCase.toLowerCase();
+    return (_namesSimilar ? 0.5 : 0) + (_useCasesSimilar ? 0.5 : 0);
   }
-  mergePatterns(_primary, similar2) {
+  mergePatterns(_primary, _similar) {
     return {
       ...primary,
-      description: `${primary.description} (merged from ${similar2.length + 1} patterns)`,
-      examples: [...primary.examples, ...similar2.flatMap((p) => p.examples)]
+      description: `${primary.description} (merged from ${similar.length + 1} _patterns)`,
+      examples: [...primary.examples, ...similar.flatMap((p) => p.examples)]
     };
   }
   initializeDefaultPreferences() {
@@ -3256,8 +3236,8 @@ var System1MemoryManager = class {
       developmentStyle: {
         approach: "iterative",
         preferredLanguages: [
-          { language: "typescript", proficiency: "intermediate", frequency: 0.8, preference: 4 },
-          { language: "javascript", proficiency: "intermediate", frequency: 0.6, preference: 3 }
+          { language: "typescript", proficiency: "intermediate", _frequency: 0.8, preference: 4 },
+          { language: "javascript", proficiency: "intermediate", _frequency: 0.6, preference: 3 }
         ],
         architecturalPatterns: [
           { name: "MVC", familiarity: 0.7, preference: 3, usageFrequency: 0.5 }
@@ -3353,7 +3333,7 @@ var System2MemoryManager = class {
   }
   get improvementSuggestions() {
     return Array.from(this.enhancements.values()).filter(
-      (enhancement2) => enhancement2.status === "proposed" || enhancement2.status === "approved"
+      (_enhancement) => enhancement.status === "proposed" || enhancement.status === "approved"
     ).sort((a2, b) => b.priority - a2.priority);
   }
   get reflectionData() {
@@ -3363,7 +3343,7 @@ var System2MemoryManager = class {
   }
   // Reasoning Trace Management
   async startReasoningTrace(_context, initialStep) {
-    const trace2 = {
+    const _trace = {
       id: this.generateTraceId(),
       timestamp: /* @__PURE__ */ new Date(),
       context,
@@ -3372,7 +3352,7 @@ var System2MemoryManager = class {
       confidence: 0,
       alternatives: [],
       metadata: {
-        complexity: this.assessComplexity(context),
+        _complexity: this.assessComplexity(context),
         domain: this.identifyDomain(context),
         techniques: [],
         qualityScore: 0,
@@ -3380,25 +3360,26 @@ var System2MemoryManager = class {
       }
     };
     if (initialStep) {
-      await this.addReasoningStep(trace2.id, {
+      await this.addReasoningStep(trace.id, {
         type: "analysis",
-        description: "Initial problem analysis",
+        description: "Initial _problem analysis",
         input: context.problem,
         output: initialStep
       });
     }
-    this.reasoningTraces.set(trace2.id, trace2);
+    this.reasoningTraces.set(trace.id, _trace);
     await this.manageTraceLimit();
-    return trace2;
+    return _trace;
   }
   async addReasoningStep(traceId, stepData) {
-    this.reasoningTraces.get(traceId);
-    if (!trace) {
-      throw new Error(`Reasoning trace ${traceId} not found`);
+    const _trace = this.reasoningTraces.get(traceId);
+    if (!_trace) {
+      throw new Error(`Reasoning _trace ${traceId} not _found`);
     }
+    const _startTime = Date.now();
     const step = {
       id: this.generateStepId(traceId),
-      confidence: this.calculateStepConfidence(stepData, trace),
+      confidence: this.calculateStepConfidence(stepData, _trace),
       duration: 0,
       // Will be updated when step completes
       dependencies: this.identifyDependencies(stepData, trace.steps),
@@ -3406,27 +3387,27 @@ var System2MemoryManager = class {
     };
     trace.steps.push(step);
     trace.metadata.techniques.push(stepData.type);
-    step.duration = Date.now() - startTime;
-    await this.updateTraceQuality(trace);
+    step.duration = Date.now() - _startTime;
+    await this.updateTraceQuality(_trace);
     return step;
   }
   async completeReasoningTrace(traceId, conclusion, confidence2) {
-    this.reasoningTraces.get(traceId);
-    if (!trace) {
-      throw new Error(`Reasoning trace ${traceId} not found`);
+    const _trace = this.reasoningTraces.get(traceId);
+    if (!_trace) {
+      throw new Error(`Reasoning _trace ${traceId} not _found`);
     }
     trace.conclusion = conclusion;
     trace.confidence = confidence2;
-    trace.metadata.qualityScore = await this.calculateReasoningQuality(trace);
+    trace.metadata.qualityScore = await this.calculateReasoningQuality(_trace);
     trace.metadata.reviewRequired = trace.metadata.qualityScore < this.config.qualityThreshold;
-    await this.generateImprovementSuggestions(trace);
-    await this.updateGlobalQualityMetrics(trace);
-    return trace;
+    await this.generateImprovementSuggestions(_trace);
+    await this.updateGlobalQualityMetrics(_trace);
+    return _trace;
   }
   async addAlternativeReasoning(traceId, alternative) {
-    this.reasoningTraces.get(traceId);
-    if (!trace) {
-      throw new Error(`Reasoning trace ${traceId} not found`);
+    const _trace = this.reasoningTraces.get(traceId);
+    if (!_trace) {
+      throw new Error(`Reasoning _trace ${traceId} not _found`);
     }
     const altReasoning = {
       id: this.generateAlternativeId(traceId),
@@ -3439,33 +3420,33 @@ var System2MemoryManager = class {
     return this.reasoningTraces.get(traceId) || null;
   }
   async searchReasoningTraces(query, limit = 10) {
-    `search:reasoning:${JSON.stringify(query)}:${limit}`;
-    this.analysisCache.get(cacheKey);
-    if (cached) {
-      return cached;
+    const _cacheKey = `search:reasoning:${JSON.stringify(query)}:${limit}`;
+    const _cached = this.analysisCache.get(_cacheKey);
+    if (_cached) {
+      return _cached;
     }
-    let traces2 = Array.from(this.reasoningTraces.values());
+    let _traces = Array.from(this.reasoningTraces.values());
     if (query.domain) {
-      traces2 = traces2.filter((trace2) => trace2.metadata.domain === query.domain);
+      _traces = traces.filter((_trace) => trace.metadata.domain === query.domain);
     }
     if (query.complexity) {
-      traces2 = traces2.filter((trace2) => trace2.metadata.complexity === query.complexity);
+      _traces = traces.filter((_trace) => trace.metadata.complexity === query.complexity);
     }
     if (query.minQuality !== void 0) {
-      traces2 = traces2.filter((trace2) => trace2.metadata.qualityScore >= (query.minQuality ?? 0));
+      _traces = traces.filter((_trace) => trace.metadata.qualityScore >= (query.minQuality ?? 0));
     }
     if (query.timeframe) {
-      traces2 = traces2.filter(
-        (trace2) => trace2.timestamp >= query.timeframe.start && trace2.timestamp <= query.timeframe.end
+      _traces = traces.filter(
+        (_trace) => trace.timestamp >= query.timeframe.start && trace.timestamp <= query.timeframe.end
       );
     }
-    traces2.sort((a2, b) => b.metadata.qualityScore - a2.metadata.qualityScore).slice(0, limit);
-    this.analysisCache.set(cacheKey, results);
-    return results;
+    const _results = _traces.sort((a2, b) => b.metadata.qualityScore - a2.metadata.qualityScore).slice(0, limit);
+    this.analysisCache.set(_cacheKey, _results);
+    return _results;
   }
   // Decision Tree Management
   async createDecisionTree(_domain, initialCondition) {
-    const tree2 = {
+    const _tree = {
       id: this.generateDecisionTreeId(domain),
       rootNode: {
         id: "root",
@@ -3478,26 +3459,26 @@ var System2MemoryManager = class {
       },
       metadata: {
         domain,
-        complexity: 1,
+        _complexity: 1,
         accuracy: 0.8,
         lastUpdated: /* @__PURE__ */ new Date(),
         usageCount: 0
       }
     };
-    this.decisionTrees.set(tree2.id, tree2);
-    return tree2;
+    this.decisionTrees.set(tree.id, _tree);
+    return _tree;
   }
-  async addDecisionNode(treeId2, parentNodeId, node2) {
-    this.decisionTrees.get(treeId2);
-    if (!tree) {
-      throw new Error(`Decision tree ${treeId2} not found`);
+  async addDecisionNode(treeId2, parentNodeId, _node) {
+    const _tree = this.decisionTrees.get(treeId2);
+    if (!_tree) {
+      throw new Error(`Decision _tree ${treeId2} not _found`);
     }
     const newNode = {
       id: this.generateNodeId(treeId2),
-      ...node2
+      ...node
     };
-    this.findDecisionNode(tree.rootNode, parentNodeId);
-    if (parentNode) {
+    const _parentNode = this.findDecisionNode(tree.rootNode, parentNodeId);
+    if (_parentNode) {
       parentNode.children.push(newNode);
       tree.metadata.complexity = this.calculateTreeComplexity(tree.rootNode);
       tree.metadata.lastUpdated = /* @__PURE__ */ new Date();
@@ -3505,20 +3486,20 @@ var System2MemoryManager = class {
     return newNode;
   }
   async addEvidence(_treeId, nodeId2, evidence) {
-    this.decisionTrees.get(treeId);
-    if (!tree) {
-      throw new Error(`Decision tree ${treeId} not found`);
+    const _tree = this.decisionTrees.get(treeId);
+    if (!_tree) {
+      throw new Error(`Decision _tree ${treeId} not _found`);
     }
-    this.findDecisionNode(tree.rootNode, nodeId2);
-    if (node) {
+    const _node = this.findDecisionNode(tree.rootNode, nodeId2);
+    if (_node) {
       node.evidence.push(evidence);
       node.confidence = this.calculateNodeConfidence(node.evidence);
       tree.metadata.lastUpdated = /* @__PURE__ */ new Date();
     }
   }
   async queryDecisionTree(treeId2, context2) {
-    this.decisionTrees.get(treeId2);
-    if (!tree) {
+    const _tree = this.decisionTrees.get(treeId2);
+    if (!_tree) {
       return [];
     }
     tree.metadata.usageCount++;
@@ -3538,8 +3519,8 @@ var System2MemoryManager = class {
     return newEnhancement;
   }
   async updateEnhancementStatus(enhancementId, status, feedback) {
-    this.enhancements.get(enhancementId);
-    if (!enhancement) {
+    const _enhancement = this.enhancements.get(enhancementId);
+    if (!_enhancement) {
       return false;
     }
     if (feedback) {
@@ -3547,16 +3528,16 @@ var System2MemoryManager = class {
     }
     enhancement.status = status;
     if (status === "completed") {
-      await this.evaluateEnhancementImpact(enhancement);
+      await this.evaluateEnhancementImpact(_enhancement);
     }
     return true;
   }
   async getEnhancementsByType(type2) {
-    return Array.from(this.enhancements.values()).filter((enhancement2) => enhancement2.type === type2).sort((a2, b) => b.priority - a2.priority);
+    return Array.from(this.enhancements.values()).filter((_enhancement) => enhancement.type === type2).sort((a2, b) => b.priority - a2.priority);
   }
   // Reflection Management
   async addReflectionEntry(trigger, observation, analysis, insight2, confidence2 = 0.8) {
-    const reflection2 = {
+    const _reflection = {
       id: this.generateReflectionId(),
       timestamp: /* @__PURE__ */ new Date(),
       trigger,
@@ -3566,14 +3547,14 @@ var System2MemoryManager = class {
       actionItems: [],
       confidence: confidence2
     };
-    this.reflectionEntries.set(reflection2.id, reflection2);
-    await this.generateActionItems(reflection2);
-    return reflection2;
+    this.reflectionEntries.set(reflection.id, _reflection);
+    await this.generateActionItems(_reflection);
+    return _reflection;
   }
   async addActionItem(reflectionId, actionItem) {
-    this.reflectionEntries.get(reflectionId);
-    if (!reflection) {
-      throw new Error(`Reflection entry ${reflectionId} not found`);
+    const _reflection = this.reflectionEntries.get(reflectionId);
+    if (!_reflection) {
+      throw new Error(`Reflection entry ${reflectionId} not _found`);
     }
     const action = {
       id: this.generateActionItemId(reflectionId),
@@ -3610,14 +3591,14 @@ var System2MemoryManager = class {
     }
   }
   // Quality Assessment
-  async assessCodeQuality(code2, language2, context2) {
+  async assessCodeQuality(code2, language, context2) {
     if (context2) {
-      console.log("Code quality context:", Object.keys(context2));
+      console.log("Code _quality context:", Object.keys(context2));
     }
-    `quality:${this.hashCode(code2)}:${language2}`;
-    this.analysisCache.get(cacheKey);
-    if (cached) {
-      return cached;
+    const _cacheKey = `_quality:${this.hashCode(code2)}:${language}`;
+    const _cached = this.analysisCache.get(_cacheKey);
+    if (_cached) {
+      return _cached;
     }
     const metrics2 = {
       maintainability: await this.calculateMaintainability(code2, _language),
@@ -3626,9 +3607,9 @@ var System2MemoryManager = class {
       performance: await this.calculatePerformance(code2, _language),
       security: await this.calculateSecurity(code2, _language),
       bugDensity: await this.calculateBugDensity(code2, _language),
-      complexity: await this.calculateCyclomaticComplexity(code2, _language)
+      _complexity: await this.calculateCyclomaticComplexity(code2, _language)
     };
-    this.analysisCache.set(cacheKey, metrics2);
+    this.analysisCache.set(_cacheKey, metrics2);
     return metrics2;
   }
   async updateQualityMetrics(metrics2) {
@@ -3636,7 +3617,7 @@ var System2MemoryManager = class {
   }
   // Private Helper Methods
   generateTraceId() {
-    return `trace:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
+    return `_trace:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
   }
   generateStepId(traceId) {
     return `${traceId}:step:${Date.now()}`;
@@ -3645,16 +3626,16 @@ var System2MemoryManager = class {
     return `${traceId}:alt:${Date.now()}`;
   }
   generateDecisionTreeId(domain2) {
-    return `tree:${domain2}:${Date.now()}`;
+    return `_tree:${domain2}:${Date.now()}`;
   }
   generateNodeId(treeId2) {
-    return `${treeId2}:node:${Date.now()}`;
+    return `${treeId2}:_node:${Date.now()}`;
   }
   generateEnhancementId() {
-    return `enhancement:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
+    return `_enhancement:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
   }
   generateReflectionId() {
-    return `reflection:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
+    return `_reflection:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
   }
   generateActionItemId(reflectionId) {
     return `${reflectionId}:action:${Date.now()}`;
@@ -3666,14 +3647,14 @@ var System2MemoryManager = class {
       context.assumptions.length > 3,
       context.problem.length > 500
     ];
-    factors.filter(Boolean).length;
-    if (complexityScore === 0) {
+    const _complexityScore = factors.filter(Boolean).length;
+    if (_complexityScore === 0) {
       return "simple";
     }
-    if (complexityScore === 1) {
+    if (_complexityScore === 1) {
       return "moderate";
     }
-    if (complexityScore === 2) {
+    if (_complexityScore === 2) {
       return "complex";
     }
     return "very_complex";
@@ -3694,7 +3675,7 @@ var System2MemoryManager = class {
     }
     return "general";
   }
-  calculateStepConfidence(stepData, trace2) {
+  calculateStepConfidence(stepData, _trace) {
     let confidence2 = 0.8;
     switch (stepData.type) {
       case "analysis":
@@ -3716,10 +3697,10 @@ var System2MemoryManager = class {
     if (stepData.output.length > 100) {
       confidence2 += 0.1;
     }
-    if (trace2.metadata.complexity === "simple") {
+    if (trace.metadata.complexity === "simple") {
       confidence2 += 0.1;
     }
-    if (trace2.metadata.complexity === "very_complex") {
+    if (trace.metadata.complexity === "very_complex") {
       confidence2 -= 0.1;
     }
     return Math.max(0.1, Math.min(1, confidence2));
@@ -3733,68 +3714,68 @@ var System2MemoryManager = class {
     }
     return dependencies;
   }
-  async updateTraceQuality(trace2) {
-    trace2.steps.length;
-    trace2.steps.reduce((sum, step) => sum + step.confidence, 0) / stepCount;
-    trace2.steps.some((step) => step.type === "analysis");
-    trace2.steps.some((step) => step.type === "evaluation");
-    let quality2 = avgConfidence * 0.6;
-    if (hasAnalysis) {
-      quality2 += 0.2;
+  async updateTraceQuality(_trace) {
+    const _stepCount = trace.steps.length;
+    const _avgConfidence = trace.steps.reduce((sum, step) => sum + step.confidence, 0) / _stepCount;
+    const _hasAnalysis = trace.steps.some((step) => step.type === "analysis");
+    const _hasEvaluation = trace.steps.some((step) => step.type === "evaluation");
+    let _quality = _avgConfidence * 0.6;
+    if (_hasAnalysis) {
+      _quality += 0.2;
     }
-    if (hasEvaluation) {
-      quality2 += 0.2;
+    if (_hasEvaluation) {
+      _quality += 0.2;
     }
-    trace2.metadata.qualityScore = Math.max(0, Math.min(1, quality2));
+    trace.metadata.qualityScore = Math.max(0, Math.min(1, _quality));
   }
   async calculateReasoningQuality(trace2) {
-    ({
-      coherence: this.calculateCoherence(trace2),
-      completeness: this.calculateCompleteness(trace2),
+    const _factors = {
+      _coherence: this.calculateCoherence(trace2),
+      _completeness: this.calculateCompleteness(trace2),
       accuracy: this.calculateAccuracy(trace2),
       efficiency: this.calculateEfficiency(trace2),
-      creativity: this.calculateCreativity(trace2)
-    });
-    return Object.values(factors).reduce((sum, value2) => sum + value2, 0) / Object.keys(factors).length;
+      _creativity: this.calculateCreativity(trace2)
+    };
+    return Object.values(_factors).reduce((sum, value) => sum + value, 0) / Object.keys(_factors).length;
   }
-  calculateCoherence(trace2) {
+  calculateCoherence(_trace) {
     let coherenceSum = 0;
     let pairCount = 0;
-    for (let i = 1; i < trace2.steps.length; i++) {
-      trace2.steps[i - 1];
-      trace2.steps[i];
-      curr?.input.includes(prev?.output.slice(0, 30) || "") ? 1 : 0.5;
-      coherenceSum += coherence;
+    for (let i = 1; i < trace.steps.length; i++) {
+      const _prev = trace.steps[i - 1];
+      const _curr = trace.steps[i];
+      const _coherence = _curr?.input.includes(_prev?.output.slice(0, 30) || "") ? 1 : 0.5;
+      coherenceSum += _coherence;
       pairCount++;
     }
     return pairCount > 0 ? coherenceSum / pairCount : 0.8;
   }
-  calculateCompleteness(trace2) {
-    new Set(trace2.steps.map((step) => step.type));
-    requiredStepTypes.filter((type2) => presentTypes.has(type2)).length / requiredStepTypes.length;
-    return completeness;
-  }
-  calculateAccuracy(trace2) {
-    trace2.steps.reduce((sum, step) => sum + step.confidence, 0) / trace2.steps.length;
-    trace2.alternatives.length > 0 ? 0.1 : 0;
-    return Math.min(1, avgConfidence + alternativeBonus);
-  }
-  calculateEfficiency(trace2) {
-    ({ simple: 1, moderate: 2, complex: 3, verycomplex: 4 })[trace2.metadata.complexity];
-    Math.max(0.2, 1 - (trace2.steps.length - complexity) * 0.1);
-    return stepEfficiency;
-  }
-  calculateCreativity(trace2) {
-    new Set(trace2.metadata.techniques).size;
-    trace2.alternatives.length;
-    Math.min(1, uniqueTechniques * 0.3 + alternativeCount * 0.2 + 0.5);
-    return creativity;
-  }
-  async generateImprovementSuggestions(trace2) {
-    if (trace2.metadata.qualityScore < 0.7) {
+  calculateCompleteness(_trace) {
+    new Set(trace.steps.map((step) => step.type));
+    const _completeness = requiredStepTypes.filter((type2) => presentTypes.has(type2)).length / requiredStepTypes.length;
+    return _completeness;
+  }
+  calculateAccuracy(_trace) {
+    const _avgConfidence = trace.steps.reduce((sum, step) => sum + step.confidence, 0) / trace.steps.length;
+    const _alternativeBonus = trace.alternatives.length > 0 ? 0.1 : 0;
+    return Math.min(1, _avgConfidence + _alternativeBonus);
+  }
+  calculateEfficiency(_trace) {
+    const _complexity = { simple: 1, moderate: 2, complex: 3, verycomplex: 4 }[trace.metadata.complexity];
+    const _stepEfficiency = Math.max(0.2, 1 - (trace.steps.length - _complexity) * 0.1);
+    return _stepEfficiency;
+  }
+  calculateCreativity(_trace) {
+    const _uniqueTechniques = new Set(trace.metadata.techniques).size;
+    const _alternativeCount = trace.alternatives.length;
+    const _creativity = Math.min(1, _uniqueTechniques * 0.3 + _alternativeCount * 0.2 + 0.5);
+    return _creativity;
+  }
+  async generateImprovementSuggestions(_trace) {
+    if (trace.metadata.qualityScore < 0.7) {
       await this.proposeEnhancement({
-        type: "quality",
-        description: `Improve reasoning quality for ${trace2.metadata.domain} problems`,
+        type: "_quality",
+        description: `Improve reasoning _quality for ${trace.metadata.domain} problems`,
         impact: {
           benefitScore: 7,
           effortScore: 5,
@@ -3807,7 +3788,7 @@ var System2MemoryManager = class {
             {
               id: "analysis",
               name: "Quality Analysis",
-              description: "Analyze low-quality reasoning patterns",
+              description: "Analyze low-_quality reasoning patterns",
               duration: 3,
               deliverables: ["Pattern analysis", "Improvement plan"],
               dependencies: []
@@ -3824,8 +3805,8 @@ var System2MemoryManager = class {
           dependencies: [],
           risks: [
             {
-              id: "complexity",
-              description: "Reasoning improvement may add complexity",
+              id: "_complexity",
+              description: "Reasoning improvement may add _complexity",
               probability: 0.3,
               impact: 4,
               mitigation: "Gradual implementation with testing",
@@ -3840,11 +3821,11 @@ var System2MemoryManager = class {
   async updateGlobalQualityMetrics(trace2) {
     this.qualityMetrics.reasoningQuality;
     this.qualityMetrics.reasoningQuality = {
-      coherence: (currentReasoning.coherence + this.calculateCoherence(trace2)) / 2,
-      completeness: (currentReasoning.completeness + this.calculateCompleteness(trace2)) / 2,
+      _coherence: (currentReasoning.coherence + this.calculateCoherence(trace2)) / 2,
+      _completeness: (currentReasoning.completeness + this.calculateCompleteness(trace2)) / 2,
       accuracy: (currentReasoning.accuracy + this.calculateAccuracy(trace2)) / 2,
       efficiency: (currentReasoning.efficiency + this.calculateEfficiency(trace2)) / 2,
-      creativity: (currentReasoning.creativity + this.calculateCreativity(trace2)) / 2
+      _creativity: (currentReasoning.creativity + this.calculateCreativity(trace2)) / 2
     };
   }
   createEmptyDecisionTree() {
@@ -3861,7 +3842,7 @@ var System2MemoryManager = class {
       },
       metadata: {
         domain: "unknown",
-        complexity: 0,
+        _complexity: 0,
         accuracy: 0,
         lastUpdated: /* @__PURE__ */ new Date(),
         usageCount: 0
@@ -3873,9 +3854,9 @@ var System2MemoryManager = class {
       return root;
     }
     for (const child of root.children) {
-      this.findDecisionNode(child, nodeId2);
-      if (found) {
-        return found;
+      const _found = this.findDecisionNode(child, nodeId2);
+      if (_found) {
+        return _found;
       }
     }
     return null;
@@ -3883,15 +3864,22 @@ var System2MemoryManager = class {
   calculateTreeComplexity(root2) {
     let maxDepth = 0;
     let nodeCount = 0;
-    traverse(root2, 1);
+    const _traverse = (_node, depth) => {
+      nodeCount++;
+      maxDepth = Math.max(maxDepth, depth);
+      for (const child of node.children) {
+        _traverse(child, depth + 1);
+      }
+    };
+    _traverse(root2, 1);
     return maxDepth + Math.log(nodeCount);
   }
   calculateNodeConfidence(evidence) {
     if (evidence.length === 0) {
       return 0.5;
     }
-    evidence.reduce((sum, e) => sum + e.strength, 0);
-    return Math.min(1, weightedSum / evidence.length);
+    const _weightedSum = evidence.reduce((sum, e) => sum + e.strength, 0);
+    return Math.min(1, _weightedSum / evidence.length);
   }
   traverseDecisionTree(node2, context2) {
     const path2 = [node2];
@@ -3903,28 +3891,28 @@ var System2MemoryManager = class {
     }
     return path2;
   }
-  evaluateCondition(_node, context2) {
+  evaluateCondition(_node, _context) {
     return node.confidence > 0.5;
   }
-  shouldAutoApprove(enhancement2) {
-    return enhancement2.impact.riskScore <= 3 && enhancement2.impact.benefitScore >= 7 && enhancement2.priority >= 7;
+  shouldAutoApprove(_enhancement) {
+    return enhancement.impact.riskScore <= 3 && enhancement.impact.benefitScore >= 7 && enhancement.priority >= 7;
   }
-  async evaluateEnhancementImpact(enhancement2) {
-    console.log(`Evaluating impact of enhancement: ${enhancement2.description}`);
+  async evaluateEnhancementImpact(_enhancement) {
+    console.log(`Evaluating impact of _enhancement: ${enhancement.description}`);
   }
-  async generateActionItems(reflection2) {
-    reflection2.insight.toLowerCase();
+  async generateActionItems(_reflection) {
+    reflection.insight.toLowerCase();
     if (insight.includes("improve") || insight.includes("optimize")) {
-      await this.addActionItem(reflection2.id, {
-        description: `Implement improvement based on: ${reflection2.insight}`,
+      await this.addActionItem(reflection.id, {
+        description: `Implement improvement based on: ${reflection.insight}`,
         priority: 7,
         dueDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3)
         // 1 week
       });
     }
     if (insight.includes("learn") || insight.includes("study")) {
-      await this.addActionItem(reflection2.id, {
-        description: `Research and learn: ${reflection2.insight}`,
+      await this.addActionItem(reflection.id, {
+        description: `Research and learn: ${reflection.insight}`,
         priority: 5,
         dueDate: new Date(Date.now() + 14 * 24 * 60 * 60 * 1e3)
         // 2 weeks
@@ -3962,14 +3950,14 @@ var System2MemoryManager = class {
     event.data;
     if (data.improvement) {
       await this.proposeEnhancement({
-        type: "quality",
+        type: "_quality",
         description: `Quality improvement: ${data.improvement}`,
         impact: {
           benefitScore: data.impact || 5,
           effortScore: 3,
           riskScore: 2,
           affectedUsers: 1,
-          affectedComponents: ["code-quality"]
+          affectedComponents: ["code-_quality"]
         },
         implementation: {
           phases: [],
@@ -3988,104 +3976,136 @@ var System2MemoryManager = class {
   async manageTraceLimit() {
     if (this.reasoningTraces.size > this.config.maxReasoningTraces) {
       Array.from(this.reasoningTraces.entries());
-      traces.sort(
+      const _sortedByQuality = traces.sort(
         (a2, b) => a2[1].metadata.qualityScore - b[1].metadata.qualityScore
       );
-      Math.min(
+      const _removeCount = Math.min(
         Math.floor(this.config.maxReasoningTraces * 0.2),
         sortedByQuality.length
       );
-      for (let i = 0; i < removeCount; i++) {
-        sortedByQuality[i];
-        if (traceEntry) {
-          this.reasoningTraces.delete(traceEntry[0]);
+      for (let i = 0; i < _removeCount; i++) {
+        const _traceEntry = _sortedByQuality[i];
+        if (_traceEntry) {
+          this.reasoningTraces.delete(_traceEntry[0]);
         }
       }
     }
   }
   // Quality calculation methods
-  async calculateMaintainability(_code, language2) {
-    ({
+  async calculateMaintainability(_code, _language2) {
+    const _factors = {
       length: Math.max(0, 100 - code.length / 100),
       // Shorter is better
       comments: (code.match(/\/\/|\/\*|\#/g) || []).length / code.split("\n").length * 100,
-      complexity: 100 - this.calculateBasicComplexity(code) * 10
-    });
+      _complexity: 100 - this.calculateBasicComplexity(code) * 10
+    };
     return Math.max(
       0,
-      Math.min(100, Object.values(factors).reduce((sum, val) => sum + val, 0) / 3)
+      Math.min(100, Object.values(_factors).reduce((sum, val) => sum + val, 0) / 3)
     );
   }
-  async calculateReadability(_code, language2) {
+  async calculateReadability(_code, _language2) {
     code.split("\n");
-    lines.length > 0 ? lines.reduce((sum, line) => sum + line.length, 0) / lines.length : 0;
-    Math.max(0, 100 - (avgLineLength - 50) * 2);
-    return Math.max(0, Math.min(100, readabilityScore));
-  }
-  async calculateTestability(_code, language2) {
-    /function|def|public|private/.test(code);
-    /class|interface/.test(code);
-    !/global|window|document/.test(code);
+    const _avgLineLength = lines.length > 0 ? lines.reduce((sum, line) => sum + line.length, 0) / lines.length : 0;
+    const _readabilityScore = Math.max(0, 100 - (_avgLineLength - 50) * 2);
+    return Math.max(0, Math.min(100, _readabilityScore));
+  }
+  async calculateTestability(_code, _language2) {
+    const _hasFunctions = /function|def|public|private/.test(code);
+    const _hasClasses = /class|interface/.test(code);
+    const _lowCoupling = !/global|window|document/.test(code);
     let score = 50;
-    if (hasFunctions) {
+    if (_hasFunctions) {
       score += 20;
     }
-    if (hasClasses) {
+    if (_hasClasses) {
       score += 15;
     }
-    if (lowCoupling) {
+    if (_lowCoupling) {
       score += 15;
     }
     return Math.max(0, Math.min(100, score));
   }
-  async calculatePerformance(_code, language2) {
-    (code.match(/for|while/g) || []).length > 2;
-    /return.*\w+\(/.test(code);
-    (code.match(/return/g) || []).length > 1;
+  async calculatePerformance(_code, _language2) {
+    const _hasNestedLoops = (code.match(/for|while/g) || []).length > 2;
+    const _hasRecursion = /return.*\w+\(/.test(code);
+    const _hasEarlyReturns = (code.match(/return/g) || []).length > 1;
     let score = 80;
-    if (hasNestedLoops) {
+    if (_hasNestedLoops) {
       score -= 20;
     }
-    if (hasRecursion && !hasEarlyReturns) {
+    if (_hasRecursion && !_hasEarlyReturns) {
       score -= 15;
     }
-    if (hasEarlyReturns) {
+    if (_hasEarlyReturns) {
       score += 10;
     }
     return Math.max(0, Math.min(100, score));
   }
-  async calculateSecurity(_code, language2) {
+  async calculateSecurity(_code, _language2) {
+    const _vulnerabilities = [
+      /eval\(/g,
+      /innerHTML\s*=/g,
+      /document\.write/g,
+      /\$\{.*\}/g,
+      // Template injection potential
+      /sql|query.*\+/gi
+      // SQL injection potential
+    ];
     let score = 90;
-    for (const pattern2 of vulnerabilities) {
+    for (const pattern2 of _vulnerabilities) {
       if (pattern2.test(code)) {
         score -= 15;
       }
     }
     return Math.max(0, Math.min(100, score));
   }
-  async calculateBugDensity(_code, language2) {
-    code.split("\n").length;
+  async calculateBugDensity(_code, _language2) {
+    const _bugPatterns = [
+      /==\s*null/g,
+      // Null comparison
+      /undefined/g,
+      /NaN/g,
+      /catch\s*\(\s*\)/g,
+      // Empty catch blocks
+      /if\s*\([^)]*=[^=]/g
+      // Assignment in condition
+    ];
+    const _lines = code.split("\n").length;
     let bugCount = 0;
-    for (const pattern2 of bugPatterns) {
+    for (const pattern2 of _bugPatterns) {
       bugCount += (code.match(pattern2) || []).length;
     }
-    return bugCount / lines * 1e3;
+    return bugCount / _lines * 1e3;
   }
-  async calculateCyclomaticComplexity(_code, language2) {
+  async calculateCyclomaticComplexity(_code, _language2) {
     return this.calculateBasicComplexity(code);
   }
   calculateBasicComplexity(code2) {
-    let complexity2 = 1;
-    for (const pattern2 of complexityPatterns) {
-      complexity2 += (code2.match(pattern2) || []).length;
+    const _complexityPatterns = [
+      /if\s*\(/g,
+      /else\s*if/g,
+      /while\s*\(/g,
+      /for\s*\(/g,
+      /switch\s*\(/g,
+      /case\s+/g,
+      /catch\s*\(/g,
+      /\?\s*.*:/g,
+      // Ternary operators
+      /&&|\|\|/g
+      // Logical operators
+    ];
+    let _complexity = 1;
+    for (const pattern2 of _complexityPatterns) {
+      _complexity += (code2.match(pattern2) || []).length;
     }
-    return complexity2;
+    return _complexity;
   }
   hashCode(str) {
     let hash = 0;
     for (let i = 0; i < str.length; i++) {
-      str.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
+      const _char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + _char;
       hash = hash & hash;
     }
     return hash.toString(36);
@@ -4099,14 +4119,14 @@ var System2MemoryManager = class {
         performance: 85,
         security: 90,
         bugDensity: 2.5,
-        complexity: 5
+        _complexity: 5
       },
       reasoningQuality: {
-        coherence: 0.8,
-        completeness: 0.75,
+        _coherence: 0.8,
+        _completeness: 0.75,
         accuracy: 0.85,
         efficiency: 0.7,
-        creativity: 0.6
+        _creativity: 0.6
       },
       userSatisfaction: {
         userRating: 4.2,
@@ -4152,13 +4172,13 @@ var DualMemoryEngine = class {
   // ========== Core Memory Operations ==========
   async query(memoryQuery) {
     const _startTime = Date.now();
-    const cacheKey2 = this.generateCacheKey(memoryQuery);
-    const cached2 = this.performanceCache.get(cacheKey2);
-    if (cached2 && this.isCacheValid(cached2)) {
-      cached2.hits++;
+    const cacheKey = this.generateCacheKey(memoryQuery);
+    const cached = this.performanceCache.get(cacheKey);
+    if (cached && this.isCacheValid(cached)) {
+      cached.hits++;
       this.operationMetrics.totalOperations++;
       return {
-        data: cached2.result,
+        _data: cached.result,
         source: "both",
         confidence: 0.9,
         latency: Date.now() - _startTime,
@@ -4167,20 +4187,20 @@ var DualMemoryEngine = class {
     }
     try {
       const _strategy = await this.selectMemoryStrategy(memoryQuery);
-      const _result = await this.executeMemoryOperation(memoryQuery, strategy);
+      const _result = await this.executeMemoryOperation(memoryQuery, _strategy);
       if (result.confidence > 0.7) {
-        this.performanceCache.set(cacheKey2, {
-          result: result._data,
+        this.performanceCache.set(cacheKey, {
+          _result: result._data,
           timestamp: /* @__PURE__ */ new Date(),
           hits: 1
         });
       }
-      this.updateOperationMetrics(strategy, Date.now() - startTime, true);
-      return result;
-    } catch (error2) {
-      this.updateOperationMetrics("both", Date.now() - startTime, false);
+      this.updateOperationMetrics(_strategy, Date.now() - _startTime, true);
+      return _result;
+    } catch (_error) {
+      this.updateOperationMetrics("both", Date.now() - _startTime, false);
       throw new Error(
-        `Memory query failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+        `Memory query failed: ${_error instanceof Error ? error.message : "Unknown _error"}`
       );
     }
   }
@@ -4197,7 +4217,7 @@ var DualMemoryEngine = class {
       timestamp: /* @__PURE__ */ new Date(),
       userId: context2["userId"] || "anonymous",
       sessionId: context2["sessionId"] || "default",
-      data: { input: input2, output, context: context2, success },
+      _data: { input: input2, output, context: context2, success },
       metadata: {
         confidence: success ? 0.9 : 0.3,
         source: "user_input",
@@ -4217,27 +4237,27 @@ var DualMemoryEngine = class {
       urgency: "medium"
     });
   }
-  async findPatterns(language2, framework2, useCase, limit = 10) {
+  async findPatterns(language, framework, useCase, limit = 10) {
     return this.query({
       type: "pattern",
-      query: `${language2 || ""} ${framework2 || ""} ${useCase || ""}`.trim(),
-      context: { language: language2, framework: framework2, useCase },
+      query: `${language || ""} ${framework || ""} ${useCase || ""}`.trim(),
+      context: { language, framework, useCase },
       limit,
       urgency: "low"
     });
   }
-  async getReasoning(domain2, complexity2, minQuality) {
+  async getReasoning(domain2, complexity, minQuality) {
     return this.query({
       type: "reasoning",
-      query: `${domain2 || ""} ${complexity2 || ""}`.trim(),
-      context: { domain: domain2, complexity: complexity2, minQuality },
+      query: `${domain2 || ""} ${complexity || ""}`.trim(),
+      context: { domain: domain2, complexity, minQuality },
       urgency: "low"
     });
   }
   async getQualityInsights() {
     return this.query({
       type: "quality",
-      query: "current quality metrics",
+      query: "current quality _metrics",
       urgency: "low"
     });
   }
@@ -4256,8 +4276,8 @@ var DualMemoryEngine = class {
         limit: options.limit || 10
       });
       return Array.isArray(result._data) ? result._data : [result._data];
-    } catch (error2) {
-      console.warn("Memory recall failed:", error2);
+    } catch (_error) {
+      console.warn("Memory recall failed:", _error);
       return [];
     }
   }
@@ -4267,32 +4287,32 @@ var DualMemoryEngine = class {
       this.eventQueue.length = 0;
       this.resetMetrics();
       console.log("Memory cleared successfully");
-    } catch (error2) {
-      console.error("Failed to clear memory:", error2);
-      throw error2;
+    } catch (_error) {
+      console.error("Failed to clear memory:", _error);
+      throw _error;
     }
   }
   // ========== Memory Strategy Selection ==========
   async selectMemoryStrategy(query) {
-    ({
+    const _factors = {
       urgency: this.getUrgencyScore(query.urgency),
       complexity: this.assessQueryComplexity(query),
       type: this.getTypePreference(query.type),
       cacheStatus: this.getCacheStatus(query)
-    });
-    this.calculateSystem1Score(factors);
-    this.calculateSystem2Score(factors);
+    };
+    const _system1Score = this.calculateSystem1Score(_factors);
+    const _system2Score = this.calculateSystem2Score(_factors);
     switch (this.config.coordinator.conflictResolutionStrategy) {
       case "system1_priority":
-        return system1Score > 0.6 ? "system1" : "both";
+        return _system1Score > 0.6 ? "system1" : "both";
       case "system2_priority":
-        return system2Score > 0.6 ? "system2" : "both";
+        return _system2Score > 0.6 ? "system2" : "both";
       case "balanced":
       default:
-        if (Math.abs(system1Score - system2Score) < 0.2) {
+        if (Math.abs(_system1Score - _system2Score) < 0.2) {
           return "both";
         }
-        return system1Score > system2Score ? "system1" : "system2";
+        return _system1Score > _system2Score ? "system1" : "system2";
     }
   }
   getUrgencyScore(urgency) {
@@ -4310,34 +4330,34 @@ var DualMemoryEngine = class {
     }
   }
   assessQueryComplexity(query) {
-    let complexity2 = 0.3;
+    let complexity = 0.3;
     if (query.query.length > 100) {
-      complexity2 += 0.2;
+      complexity += 0.2;
     }
     if (query.query.length > 200) {
-      complexity2 += 0.2;
+      complexity += 0.2;
     }
     if (query.context && Object.keys(query.context).length > 3) {
-      complexity2 += 0.2;
+      complexity += 0.2;
     }
     switch (query.type) {
       case "reasoning":
-        complexity2 += 0.4;
+        complexity += 0.4;
         break;
       case "quality":
-        complexity2 += 0.3;
+        complexity += 0.3;
         break;
       case "pattern":
-        complexity2 += 0.2;
+        complexity += 0.2;
         break;
       case "knowledge":
-        complexity2 += 0.1;
+        complexity += 0.1;
         break;
       case "preference":
-        complexity2 += 0;
+        complexity += 0;
         break;
     }
-    return Math.min(1, complexity2);
+    return Math.min(1, complexity);
   }
   getTypePreference(type2) {
     switch (type2) {
@@ -4356,26 +4376,27 @@ var DualMemoryEngine = class {
     }
   }
   getCacheStatus(query) {
-    const cacheKey2 = this.generateCacheKey(query);
-    const cached2 = this.performanceCache.get(cacheKey2);
-    return cached2 ? 0.8 : 0.2;
-  }
-  calculateSystem1Score(factors2) {
-    factors2.urgency * 0.4;
-    (1 - factors2.complexity) * 0.3;
-    factors2.type.system1 * 0.2;
-    factors2.cacheStatus * 0.1;
-    return urgencyWeight + complexityPenalty + typePreference + cacheBonus;
-  }
-  calculateSystem2Score(factors2) {
-    factors2.complexity * 0.4;
-    (1 - factors2.urgency) * 0.2;
-    factors2.type.system2 * 0.3;
-    return complexityBonus + urgencyPenalty + typePreference + qualityBonus;
+    const cacheKey = this.generateCacheKey(query);
+    const cached = this.performanceCache.get(cacheKey);
+    return cached ? 0.8 : 0.2;
+  }
+  calculateSystem1Score(_factors) {
+    const _urgencyWeight = factors.urgency * 0.4;
+    const _complexityPenalty = (1 - factors.complexity) * 0.3;
+    const _typePreference = factors.type.system1 * 0.2;
+    const _cacheBonus = factors.cacheStatus * 0.1;
+    return _urgencyWeight + _complexityPenalty + _typePreference + _cacheBonus;
+  }
+  calculateSystem2Score(_factors) {
+    const _complexityBonus = factors.complexity * 0.4;
+    const _urgencyPenalty = (1 - factors.urgency) * 0.2;
+    const _typePreference = factors.type.system2 * 0.3;
+    const _qualityBonus = 0.1;
+    return _complexityBonus + _urgencyPenalty + _typePreference + _qualityBonus;
   }
   // ========== Memory Operation Execution ==========
-  async executeMemoryOperation(query, strategy2) {
-    switch (strategy2) {
+  async executeMemoryOperation(query, strategy) {
+    switch (strategy) {
       case "system1":
         return this.executeSystem1Operation(query);
       case "system2":
@@ -4383,38 +4404,38 @@ var DualMemoryEngine = class {
       case "both":
         return this.executeCombinedOperation(query);
       default:
-        throw new Error(`Unknown strategy: ${strategy2}`);
+        throw new Error(`Unknown _strategy: ${strategy}`);
     }
   }
   async executeSystem1Operation(query) {
     const _startTime = Date.now();
-    let result2;
+    let _result;
     switch (query.type) {
       case "knowledge":
-        result2 = await this.system1.searchKnowledgeNodes(
+        _result = await this.system1.searchKnowledgeNodes(
           query.query,
           query.embedding || [],
           query.limit
         );
         break;
       case "pattern": {
-        const { language: language2, framework: framework2, useCase } = query.context || {};
-        result2 = await this.system1.findCodePatterns(
-          language2,
-          framework2,
+        const { language, framework, useCase } = query.context || {};
+        _result = await this.system1.findCodePatterns(
+          language,
+          framework,
           useCase,
           query.limit
         );
         break;
       }
       case "preference":
-        result2 = await this.system1.getUserPreference("learningStyle");
+        _result = await this.system1.getUserPreference("learningStyle");
         break;
       default:
         throw new Error(`System 1 cannot handle query type: ${query.type}`);
     }
     return {
-      data: result2,
+      _data: _result,
       source: "system1",
       confidence: 0.8,
       latency: Date.now() - _startTime,
@@ -4423,14 +4444,14 @@ var DualMemoryEngine = class {
   }
   async executeSystem2Operation(query) {
     const _startTime = Date.now();
-    let result2;
+    let _result;
     switch (query.type) {
       case "reasoning": {
-        const { domain: domain2, complexity: complexity2, minQuality } = query.context || {};
-        result2 = await this.system2.searchReasoningTraces(
+        const { domain: domain2, complexity, minQuality } = query.context || {};
+        _result = await this.system2.searchReasoningTraces(
           {
             domain: domain2,
-            complexity: complexity2,
+            complexity,
             minQuality
           },
           query.limit
@@ -4438,13 +4459,13 @@ var DualMemoryEngine = class {
         break;
       }
       case "quality":
-        result2 = this.system2.qualityEvaluation;
+        _result = this.system2.qualityEvaluation;
         break;
       default:
         throw new Error(`System 2 cannot handle query type: ${query.type}`);
     }
     return {
-      data: result2,
+      _data: _result,
       source: "system2",
       confidence: 0.9,
       latency: Date.now() - _startTime,
@@ -4460,7 +4481,7 @@ var DualMemoryEngine = class {
       ]);
       const _combinedResult = this.combineResults(query, system1Result, system2Result);
       return {
-        data: combinedResult._data,
+        _data: combinedResult._data,
         source: "both",
         confidence: combinedResult.confidence,
         latency: Date.now() - _startTime,
@@ -4468,30 +4489,30 @@ var DualMemoryEngine = class {
         suggestions: combinedResult.suggestions
       };
     } catch (_error) {
-      query.type === "reasoning" || query.type === "quality" ? "system2" : "system1";
-      return this.executeMemoryOperation(query, fallbackStrategy);
+      const _fallbackStrategy = query.type === "reasoning" || query.type === "quality" ? "system2" : "system1";
+      return this.executeMemoryOperation(query, _fallbackStrategy);
     }
   }
   combineResults(query, system1Result, system2Result) {
-    system1Result.status === "fulfilled" ? system1Result.value?._data : null;
-    system2Result.status === "fulfilled" ? system2Result.value?._data : null;
-    if (s2Data && s1Data) {
-      this.assessQueryComplexity(query) > 0.6;
+    const _s1Data = system1Result.status === "fulfilled" ? system1Result.value?._data : null;
+    const _s2Data = system2Result.status === "fulfilled" ? system2Result.value?._data : null;
+    if (_s2Data && _s1Data) {
+      const _useSystem2 = this.assessQueryComplexity(query) > 0.6;
       return {
-        data: useSystem2 ? s2Data : s1Data,
+        _data: _useSystem2 ? _s2Data : _s1Data,
         confidence: 0.95,
-        suggestions: this.generateCombinedSuggestions(s1Data, s2Data)
+        suggestions: this.generateCombinedSuggestions(_s1Data, _s2Data)
       };
     }
-    if (s1Data) {
-      return { data: s1Data, confidence: 0.8 };
+    if (_s1Data) {
+      return { _data: _s1Data, confidence: 0.8 };
     }
-    if (s2Data) {
-      return { data: s2Data, confidence: 0.85 };
+    if (_s2Data) {
+      return { _data: _s2Data, confidence: 0.85 };
     }
     throw new Error("No memory systems could provide results");
   }
-  generateCombinedSuggestions(_s1Data, s2Data2) {
+  generateCombinedSuggestions(_s1Data, _s2Data) {
     return [
       {
         id: `suggestion:${Date.now()}`,
@@ -4525,8 +4546,8 @@ var DualMemoryEngine = class {
         routingStrategy.system2 ? this.system2.processMemoryEvent(event) : Promise.resolve()
       ]);
       await this.adaptFromEvent(event);
-    } catch (error2) {
-      console.error(`Error processing memory event ${event.id}:`, error2);
+    } catch (_error) {
+      console.error(`Error processing memory event ${event.id}:`, _error);
     }
   }
   determineEventRouting(event) {
@@ -4595,7 +4616,7 @@ var DualMemoryEngine = class {
     this.processingLock = true;
     try {
       const _batchSize = this.config.performance.batchSize;
-      const _batch = this.eventQueue.splice(0, batchSize);
+      const _batch = this.eventQueue.splice(0, _batchSize);
       await Promise.all(batch.map((event) => this.processEvent(event)));
     } finally {
       this.processingLock = false;
@@ -4603,9 +4624,9 @@ var DualMemoryEngine = class {
   }
   cleanupCache() {
     const _maxAge = 30 * 60 * 1e3;
-    for (const [key, cached2] of this.performanceCache.entries()) {
-      const age = now.getTime() - cached2.timestamp.getTime();
-      if (age > _maxAge || cached2.hits < 2) {
+    for (const [key, cached] of this.performanceCache.entries()) {
+      const age = now.getTime() - cached.timestamp.getTime();
+      if (age > _maxAge || cached.hits < 2) {
         this.performanceCache.delete(key);
       }
     }
@@ -4617,12 +4638,12 @@ var DualMemoryEngine = class {
         const _entries = Array.from(this.performanceCache.entries());
         const _sortedByUsage = entries.sort((a2, b) => b[1].hits - a2[1].hits);
         this.performanceCache.clear();
-        sortedByUsage.slice(0, 500).forEach(([key, value2]) => {
-          this.performanceCache.set(key, value2);
+        sortedByUsage.slice(0, 500).forEach(([key, value]) => {
+          this.performanceCache.set(key, value);
         });
       }
-    } catch (error2) {
-      console.error("Memory optimization failed:", error2);
+    } catch (_error) {
+      console.error("Memory optimization failed:", _error);
     }
   }
   // ========== System Access Methods ==========
@@ -4642,22 +4663,22 @@ var DualMemoryEngine = class {
   }
   // ========== Utility Methods ==========
   generateCacheKey(query) {
-    query.context ? JSON.stringify(query.context) : "";
-    query.embedding ? query.embedding.slice(0, 5).join(",") : "";
-    return `${query.type}:${query.query}:${contextStr}:${embeddingStr}:${query.limit || 10}`;
+    const _contextStr = query.context ? JSON.stringify(query.context) : "";
+    const _embeddingStr = query.embedding ? query.embedding.slice(0, 5).join(",") : "";
+    return `${query.type}:${query.query}:${_contextStr}:${_embeddingStr}:${query.limit || 10}`;
   }
-  isCacheValid(cached2) {
-    const age = Date.now() - cached2.timestamp.getTime();
-    const maxAge = 10 * 60 * 1e3;
-    return age < maxAge;
+  isCacheValid(cached) {
+    const age = Date.now() - cached.timestamp.getTime();
+    const _maxAge = 10 * 60 * 1e3;
+    return age < _maxAge;
   }
-  updateOperationMetrics(strategy2, latency, success) {
+  updateOperationMetrics(strategy, latency, success) {
     this.operationMetrics.totalOperations++;
     this.operationMetrics.averageLatency = (this.operationMetrics.averageLatency + latency) / 2;
-    if (strategy2 === "system1" || strategy2 === "both") {
+    if (strategy === "system1" || strategy === "both") {
       this.operationMetrics.system1Operations++;
     }
-    if (strategy2 === "system2" || strategy2 === "both") {
+    if (strategy === "system2" || strategy === "both") {
       this.operationMetrics.system2Operations++;
     }
     if (!success) {
@@ -4677,11 +4698,11 @@ var DualMemoryEngine = class {
   }
   // ========== Public API for Monitoring ==========
   getMetrics() {
-    Array.from(this.performanceCache.values()).reduce(
-      (sum, cached2) => sum + cached2.hits,
+    const _totalCacheAccess = Array.from(this.performanceCache.values()).reduce(
+      (sum, cached) => sum + cached.hits,
       0
     );
-    this.operationMetrics.cacheHitRate = this.operationMetrics.totalOperations > 0 ? totalCacheAccess / this.operationMetrics.totalOperations : 0;
+    this.operationMetrics.cacheHitRate = this.operationMetrics.totalOperations > 0 ? _totalCacheAccess / this.operationMetrics.totalOperations : 0;
     return { ...this.operationMetrics };
   }
   resetMetrics() {
@@ -4698,9 +4719,9 @@ var DualMemoryEngine = class {
     try {
       this.resetMetrics();
       this.performanceCache.clear();
-    } catch (error2) {
-      console.error("Failed to initialize DualMemoryEngine:", error2);
-      throw error2;
+    } catch (_error) {
+      console.error("Failed to initialize DualMemoryEngine:", _error);
+      throw _error;
     }
   }
   // ========== Configuration Management ==========
@@ -4733,8 +4754,8 @@ var DualMemoryEngine = class {
         // Will be populated when system2 interface is stable
       };
       return {
-        system1: system1Stats,
-        system2: system2Stats,
+        system1: _system1Stats,
+        system2: _system2Stats,
         performance: {
           avgResponseTime: metrics.averageLatency || 50,
           memoryUsage: process.memoryUsage().heapUsed
@@ -4795,27 +4816,27 @@ var FileSystemService = class _FileSystemService {
   async readFile(_filePath, encoding = "utf8") {
     try {
       const _resolvedPath = path.resolve(filePath);
-      const _content = await fsAsync.readFile(resolvedPath, encoding);
-      this.logOperation("read", resolvedPath, true);
-      return content;
+      const _content = await fsAsync.readFile(_resolvedPath, encoding);
+      this.logOperation("read", _resolvedPath, true);
+      return _content;
     } catch (_error) {
       this.logOperation("read", filePath, false);
       throw new Error(`Failed to read file ${filePath}: ${error.message}`);
     }
   }
-  async writeFile(filePath2, content2, options = {}) {
+  async writeFile(filePath2, content, options = {}) {
     try {
       const _resolvedPath = path.resolve(filePath2);
-      if (options.backup && await this.exists(resolvedPath)) {
-        await this.createBackup(resolvedPath);
+      if (options.backup && await this.exists(_resolvedPath)) {
+        await this.createBackup(_resolvedPath);
       }
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would write to: ${resolvedPath}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would write to: ${_resolvedPath}`));
         return;
       }
-      await this.ensureDirectoryExists(path.dirname(resolvedPath));
-      await fsAsync.writeFile(resolvedPath, content2);
-      this.logOperation("write", resolvedPath, true);
+      await this.ensureDirectoryExists(path.dirname(_resolvedPath));
+      await fsAsync.writeFile(_resolvedPath, content);
+      this.logOperation("write", _resolvedPath, true);
     } catch (_error) {
       this.logOperation("write", filePath2, false);
       throw new Error(`Failed to write file ${filePath2}: ${error.message}`);
@@ -4824,18 +4845,18 @@ var FileSystemService = class _FileSystemService {
   async deleteFile(_filePath, options = {}) {
     try {
       const _resolvedPath = path.resolve(filePath);
-      if (!await this.exists(resolvedPath)) {
-        throw new Error(`File does not exist: ${resolvedPath}`);
+      if (!await this.exists(_resolvedPath)) {
+        throw new Error(`File does not exist: ${_resolvedPath}`);
       }
       if (options.backup) {
-        await this.createBackup(resolvedPath);
+        await this.createBackup(_resolvedPath);
       }
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would delete: ${resolvedPath}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would delete: ${_resolvedPath}`));
         return;
       }
-      await fsAsync.unlink(resolvedPath);
-      this.logOperation("delete", resolvedPath, true);
+      await fsAsync.unlink(_resolvedPath);
+      this.logOperation("delete", _resolvedPath, true);
     } catch (_error) {
       this.logOperation("delete", filePath, false);
       throw new Error(`Failed to delete file ${filePath}: ${error.message}`);
@@ -4846,11 +4867,11 @@ var FileSystemService = class _FileSystemService {
     try {
       const _resolvedPath = path.resolve(dirPath);
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would create directory: ${resolvedPath}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would create directory: ${_resolvedPath}`));
         return;
       }
-      await fsAsync.mkdir(resolvedPath, { recursive: options.recursive ?? true });
-      this.logOperation("mkdir", resolvedPath, true);
+      await fsAsync.mkdir(_resolvedPath, { recursive: options.recursive ?? true });
+      this.logOperation("mkdir", _resolvedPath, true);
     } catch (_error) {
       this.logOperation("mkdir", dirPath, false);
       throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
@@ -4859,19 +4880,19 @@ var FileSystemService = class _FileSystemService {
   async deleteDirectory(_dirPath, options = {}) {
     try {
       const _resolvedPath = path.resolve(dirPath);
-      if (!await this.exists(resolvedPath)) {
-        throw new Error(`Directory does not exist: ${resolvedPath}`);
+      if (!await this.exists(_resolvedPath)) {
+        throw new Error(`Directory does not exist: ${_resolvedPath}`);
       }
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would delete directory: ${resolvedPath}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would delete directory: ${_resolvedPath}`));
         return;
       }
       if (options.recursive) {
-        await this.deleteDirectoryRecursive(resolvedPath);
+        await this.deleteDirectoryRecursive(_resolvedPath);
       } else {
-        await fsAsync.rmdir(resolvedPath);
+        await fsAsync.rmdir(_resolvedPath);
       }
-      this.logOperation("rmdir", resolvedPath, true);
+      this.logOperation("rmdir", _resolvedPath, true);
     } catch (_error) {
       this.logOperation("rmdir", dirPath, false);
       throw new Error(`Failed to delete directory ${dirPath}: ${error.message}`);
@@ -4880,14 +4901,14 @@ var FileSystemService = class _FileSystemService {
   async listDirectory(_dirPath, options = {}) {
     try {
       const _resolvedPath = path.resolve(dirPath);
-      const _entries = await fsAsync.readdir(resolvedPath);
-      const results2 = [];
-      for (const entry2 of entries) {
-        if (!options.includeHidden && entry2.startsWith(".")) {
+      const _entries = await fsAsync.readdir(_resolvedPath);
+      const results = [];
+      for (const entry of _entries) {
+        if (!options.includeHidden && entry.startsWith(".")) {
           continue;
         }
-        const _entryPath = path.join(resolvedPath, entry2);
-        const _stats = await this.getFileStats(entryPath);
+        const _entryPath = path.join(_resolvedPath, entry);
+        const _stats = await this.getFileStats(_entryPath);
         if (options.type) {
           if (options.type === "file" && !stats.isFile) {
             continue;
@@ -4898,14 +4919,14 @@ var FileSystemService = class _FileSystemService {
         }
         if (options.pattern) {
           const _match = options.caseSensitive ? stats.name.includes(options.pattern) : stats.name.toLowerCase().includes(options.pattern.toLowerCase());
-          if (!match) {
+          if (!_match) {
             continue;
           }
         }
-        results2.push(stats);
+        results.push(_stats);
       }
-      this.logOperation("readdir", resolvedPath, true);
-      return results2.sort((a2, b) => {
+      this.logOperation("readdir", _resolvedPath, true);
+      return results.sort((a2, b) => {
         if (a2.isDirectory && !b.isDirectory) {
           return -1;
         }
@@ -4924,23 +4945,23 @@ var FileSystemService = class _FileSystemService {
     try {
       const _resolvedSource = path.resolve(sourcePath);
       const _resolvedDest = path.resolve(destPath);
-      if (!await this.exists(resolvedSource)) {
-        throw new Error(`Source file does not exist: ${resolvedSource}`);
+      if (!await this.exists(_resolvedSource)) {
+        throw new Error(`Source file does not exist: ${_resolvedSource}`);
       }
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would copy: ${resolvedSource} \u2192 ${resolvedDest}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would copy: ${_resolvedSource} \u2192 ${_resolvedDest}`));
         return;
       }
-      await this.ensureDirectoryExists(path.dirname(resolvedDest));
-      if (await this.exists(resolvedDest) && !options.force) {
-        throw new Error(`Destination file already exists: ${resolvedDest}`);
+      await this.ensureDirectoryExists(path.dirname(_resolvedDest));
+      if (await this.exists(_resolvedDest) && !options.force) {
+        throw new Error(`Destination file already exists: ${_resolvedDest}`);
       }
-      await fsAsync.copyFile(resolvedSource, resolvedDest);
+      await fsAsync.copyFile(_resolvedSource, _resolvedDest);
       if (options.preserveTimestamps) {
-        const _sourceStats = await fsAsync.stat(resolvedSource);
-        await fs.promises.utimes(resolvedDest, sourceStats.atime, sourceStats.mtime);
+        const _sourceStats = await fsAsync.stat(_resolvedSource);
+        await fs.promises.utimes(_resolvedDest, sourceStats.atime, sourceStats.mtime);
       }
-      this.logOperation("copy", `${resolvedSource} \u2192 ${resolvedDest}`, true);
+      this.logOperation("copy", `${_resolvedSource} \u2192 ${_resolvedDest}`, true);
     } catch (_error) {
       this.logOperation("copy", `${sourcePath} \u2192 ${destPath}`, false);
       throw new Error(`Failed to copy file: ${error.message}`);
@@ -4950,19 +4971,19 @@ var FileSystemService = class _FileSystemService {
     try {
       const _resolvedSource = path.resolve(sourcePath);
       const _resolvedDest = path.resolve(destPath);
-      if (!await this.exists(resolvedSource)) {
-        throw new Error(`Source file does not exist: ${resolvedSource}`);
+      if (!await this.exists(_resolvedSource)) {
+        throw new Error(`Source file does not exist: ${_resolvedSource}`);
       }
       if (options.dryRun) {
-        console.log(chalk2.yellow(`[DRY RUN] Would move: ${resolvedSource} \u2192 ${resolvedDest}`));
+        console.log(chalk2.yellow(`[DRY RUN] Would move: ${_resolvedSource} \u2192 ${_resolvedDest}`));
         return;
       }
-      await this.ensureDirectoryExists(path.dirname(resolvedDest));
-      if (await this.exists(resolvedDest) && !options.force) {
-        throw new Error(`Destination file already exists: ${resolvedDest}`);
+      await this.ensureDirectoryExists(path.dirname(_resolvedDest));
+      if (await this.exists(_resolvedDest) && !options.force) {
+        throw new Error(`Destination file already exists: ${_resolvedDest}`);
       }
-      await fsAsync.rename(resolvedSource, resolvedDest);
-      this.logOperation("move", `${resolvedSource} \u2192 ${resolvedDest}`, true);
+      await fsAsync.rename(_resolvedSource, _resolvedDest);
+      this.logOperation("move", `${_resolvedSource} \u2192 ${_resolvedDest}`, true);
     } catch (_error) {
       this.logOperation("move", `${sourcePath} \u2192 ${destPath}`, false);
       throw new Error(`Failed to move file: ${error.message}`);
@@ -4975,13 +4996,13 @@ var FileSystemService = class _FileSystemService {
   async findFiles(_searchPath, options = {}) {
     try {
       const _resolvedPath = path.resolve(searchPath);
-      const results2 = [];
-      await this.findFilesRecursive(resolvedPath, options, results2, 0);
-      this.logOperation("find", resolvedPath, true);
-      return results2;
+      const results = [];
+      await this.findFilesRecursive(_resolvedPath, options, results, 0);
+      this.logOperation("find", _resolvedPath, true);
+      return results;
     } catch (_error) {
       this.logOperation("find", searchPath, false);
-      throw new Error(`Failed to search files: ${error.message}`);
+      throw new Error(`Failed to search _files: ${error.message}`);
     }
   }
   async which(command2) {
@@ -5000,21 +5021,21 @@ var FileSystemService = class _FileSystemService {
       });
     });
   }
-  async glob(_pattern, options = {}) {
-    pattern.split(path.sep);
-    patternParts.slice(0, -1).join(path.sep) || "./";
-    patternParts[patternParts.length - 1];
+  async glob(pattern2, options = {}) {
+    const _patternParts = pattern2.split(path.sep);
+    const _basePath = patternParts.slice(0, -1).join(path.sep) || "./";
+    const _filePattern = _patternParts[patternParts.length - 1];
     try {
-      const _regexPattern = filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
-      const _files = await this.findFiles(basePath, {
+      const _regexPattern = _filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+      const _files = await this.findFiles(_basePath, {
         ...options,
-        pattern: `^${regexPattern}$`,
+        _pattern: `^${_regexPattern}$`,
         regex: true,
         type: "file"
       });
       return files.map((f) => f.path);
     } catch (_error) {
-      throw new Error(`Failed to glob pattern ${pattern}: ${error.message}`);
+      throw new Error(`Failed to glob _pattern ${pattern2}: ${error.message}`);
     }
   }
   // Utility Methods
@@ -5029,11 +5050,11 @@ var FileSystemService = class _FileSystemService {
   async getFileStats(filePath2) {
     try {
       const _resolvedPath = path.resolve(filePath2);
-      const _stats = await fsAsync.lstat(resolvedPath);
-      const _name = path.basename(resolvedPath);
+      const _stats = await fsAsync.lstat(_resolvedPath);
+      const _name = path.basename(_resolvedPath);
       return {
-        name,
-        path: resolvedPath,
+        _name,
+        path: _resolvedPath,
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory(),
         isSymlink: stats.isSymbolicLink(),
@@ -5043,7 +5064,7 @@ var FileSystemService = class _FileSystemService {
         permissions: (stats.mode & parseInt("777", 8)).toString(8)
       };
     } catch (_error) {
-      throw new Error(`Failed to get file stats for ${filePath2}: ${error.message}`);
+      throw new Error(`Failed to get file _stats for ${filePath2}: ${error.message}`);
     }
   }
   async getRealPath(filePath2) {
@@ -5065,73 +5086,74 @@ var FileSystemService = class _FileSystemService {
       await fsAsync.mkdir(dirPath2, { recursive: true });
     } catch (_error) {
       if (error.code !== "EEXIST") {
-        throw error;
+        throw _error;
       }
     }
   }
   async createBackup(filePath2) {
-    await fsAsync.copyFile(filePath2, backupPath);
+    const _backupPath = `${filePath2}.backup.${Date.now()}`;
+    await fsAsync.copyFile(filePath2, _backupPath);
   }
   async deleteDirectoryRecursive(dirPath2) {
-    await fsAsync.readdir(dirPath2);
-    for (const entry2 of entries) {
-      path.join(dirPath2, entry2);
-      await fsAsync.lstat(entryPath);
+    const _entries = await fsAsync.readdir(dirPath2);
+    for (const entry of _entries) {
+      const _entryPath = path.join(dirPath2, entry);
+      await fsAsync.lstat(_entryPath);
       if (stats.isDirectory()) {
-        await this.deleteDirectoryRecursive(entryPath);
+        await this.deleteDirectoryRecursive(_entryPath);
       } else {
-        await fsAsync.unlink(entryPath);
+        await fsAsync.unlink(_entryPath);
       }
     }
     await fsAsync.rmdir(dirPath2);
   }
-  async findFilesRecursive(searchPath2, options, results2, depth) {
+  async findFilesRecursive(searchPath2, options, results, depth) {
     if (options.maxDepth && depth >= options.maxDepth) {
       return;
     }
     try {
       const _entries = await fsAsync.readdir(searchPath2);
-      for (const entry2 of entries) {
-        if (!options.includeHidden && entry2.startsWith(".")) {
+      for (const entry of _entries) {
+        if (!options.includeHidden && entry.startsWith(".")) {
           continue;
         }
-        const _entryPath = path.join(searchPath2, entry2);
-        const _stats = await this.getFileStats(entryPath);
+        const _entryPath = path.join(searchPath2, entry);
+        const _stats = await this.getFileStats(_entryPath);
         if (options.pattern) {
           const _pattern = options.regex ? new RegExp(options.pattern, options.caseSensitive ? "g" : "gi") : null;
-          const _match = pattern ? pattern.test(stats.name) : options.caseSensitive ? stats.name.includes(options.pattern) : stats.name.toLowerCase().includes(options.pattern.toLowerCase());
-          if (match) {
+          const _match = _pattern ? pattern.test(stats.name) : options.caseSensitive ? stats.name.includes(options.pattern) : stats.name.toLowerCase().includes(options.pattern.toLowerCase());
+          if (_match) {
             if (options.type) {
               if (options.type === "file" && stats.isFile) {
-                results2.push(stats);
+                results.push(_stats);
               }
               if (options.type === "directory" && stats.isDirectory) {
-                results2.push(stats);
+                results.push(_stats);
               }
               if (options.type === "both") {
-                results2.push(stats);
+                results.push(_stats);
               }
             } else {
-              results2.push(stats);
+              results.push(_stats);
             }
           }
         } else if (!options.pattern) {
           if (options.type) {
             if (options.type === "file" && stats.isFile) {
-              results2.push(stats);
+              results.push(_stats);
             }
             if (options.type === "directory" && stats.isDirectory) {
-              results2.push(stats);
+              results.push(_stats);
             }
             if (options.type === "both") {
-              results2.push(stats);
+              results.push(_stats);
             }
           } else {
-            results2.push(stats);
+            results.push(_stats);
           }
         }
         if (stats.isDirectory && (options.followSymlinks || !stats.isSymlink)) {
-          await this.findFilesRecursive(entryPath, options, results2, depth + 1);
+          await this.findFilesRecursive(_entryPath, options, results, depth + 1);
         }
       }
     } catch (_error) {