@the-magic-tower/fixhive-opencode-plugin 0.1.13 → 0.1.15

package/dist/index.js

@@ -1,3 +1,22 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
 // src/plugin/index.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -5,10 +24,6 @@ import { join } from "path";
 
 // src/core/privacy-filter.ts
 var DEFAULT_FILTER_RULES = [
-  // =====================================
-  // SECRETS (Critical - Always Filter)
-  // =====================================
-  // AWS Keys
   {
     name: "aws_access_key",
     category: "secret",
@@ -16,7 +31,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[AWS_KEY_REDACTED]",
     priority: 100
   },
-  // OpenAI API Keys
   {
     name: "openai_key",
     category: "secret",
@@ -24,7 +38,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[OPENAI_KEY_REDACTED]",
     priority: 100
   },
-  // GitHub Tokens
   {
     name: "github_token",
     category: "secret",
@@ -32,7 +45,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[GITHUB_TOKEN_REDACTED]",
     priority: 100
   },
-  // Google API Keys
   {
     name: "google_api_key",
     category: "secret",
@@ -40,7 +52,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[GOOGLE_API_KEY_REDACTED]",
     priority: 100
   },
-  // Stripe Keys
   {
     name: "stripe_key",
     category: "secret",
@@ -48,7 +59,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[STRIPE_KEY_REDACTED]",
     priority: 100
   },
-  // JWT Tokens (limited length to prevent ReDoS)
   {
     name: "jwt_token",
     category: "secret",
@@ -56,7 +66,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[JWT_REDACTED]",
     priority: 100
   },
-  // Bearer Tokens
   {
     name: "bearer_token",
     category: "secret",
@@ -64,7 +73,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1 [TOKEN_REDACTED]",
     priority: 100
   },
-  // Private Keys
   {
     name: "private_key",
     category: "secret",
@@ -72,7 +80,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[PRIVATE_KEY_REDACTED]",
     priority: 100
   },
-  // Generic API Keys (context-based, limited length to prevent ReDoS)
   {
     name: "generic_api_key",
     category: "secret",
@@ -80,7 +87,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1=[KEY_REDACTED]",
     priority: 95
   },
-  // Secret/Password assignments (limited length to prevent ReDoS)
   {
     name: "secret_assignment",
     category: "secret",
@@ -88,10 +94,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1=[REDACTED]",
     priority: 90
   },
-  // =====================================
-  // IDENTITY (High Risk)
-  // =====================================
-  // Email Addresses
   {
     name: "email",
     category: "identity",
@@ -99,10 +101,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[EMAIL_REDACTED]",
     priority: 80
   },
-  // =====================================
-  // INFRASTRUCTURE (Medium Risk)
-  // =====================================
-  // Database Connection Strings
   {
     name: "db_connection",
     category: "infrastructure",
@@ -110,7 +108,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1://[CONNECTION_REDACTED]",
     priority: 85
   },
-  // Internal URLs
   {
     name: "internal_url",
     category: "infrastructure",
@@ -118,7 +115,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[INTERNAL_URL_REDACTED]",
     priority: 75
   },
-  // IP Addresses (except localhost and common dev IPs)
   {
     name: "ipv4",
     category: "infrastructure",
@@ -131,10 +127,6 @@ var DEFAULT_FILTER_RULES = [
     },
     priority: 70
   },
-  // =====================================
-  // FILE PATHS (Context-dependent)
-  // =====================================
-  // Home Directory Paths (macOS)
   {
     name: "macos_home_path",
     category: "path",
@@ -142,7 +134,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
-  // Home Directory Paths (Linux)
   {
     name: "linux_home_path",
     category: "path",
@@ -150,7 +141,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
-  // Home Directory Paths (Windows)
   {
     name: "windows_home_path",
     category: "path",
@@ -158,10 +148,6 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
-  // =====================================
-  // ENVIRONMENT (Medium Risk)
-  // =====================================
-  // Sensitive Environment Variables
   {
     name: "env_var_value",
     category: "environment",
@@ -189,16 +175,12 @@ var DEFAULT_FILTER_RULES = [
     priority: 65
   }
 ];
-var PrivacyFilter = class {
+
+class PrivacyFilter {
   rules;
   constructor(customRules) {
-    this.rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort(
-      (a, b) => b.priority - a.priority
-    );
+    this.rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort((a, b) => b.priority - a.priority);
   }
-  /**
-   * Sanitize content by applying all filter rules
-   */
   sanitize(content, context) {
     let result = content;
     const appliedFilters = [];
@@ -228,9 +210,6 @@ var PrivacyFilter = class {
       appliedFilters: [...new Set(appliedFilters)]
     };
   }
-  /**
-   * Generalize file paths while keeping meaningful structure
-   */
   generalizePaths(content, context) {
     let result = content;
     if (context.projectRoot) {
@@ -245,16 +224,10 @@ var PrivacyFilter = class {
     result = result.replace(/site-packages\/[\w.-]+\//g, "site-packages/<PKG>/");
     return result;
   }
-  /**
-   * Add a custom filter rule
-   */
   addRule(rule) {
     this.rules.push(rule);
     this.rules.sort((a, b) => b.priority - a.priority);
   }
-  /**
-   * Remove a filter rule by name
-   */
   removeRule(name) {
     const index = this.rules.findIndex((r) => r.name === name);
     if (index !== -1) {
@@ -263,16 +236,9 @@ var PrivacyFilter = class {
     }
     return false;
   }
-  /**
-   * Get all current rules
-   */
   getRules() {
     return this.rules;
   }
-  /**
-   * Check if content contains sensitive data
-   * Note: Always reset regex lastIndex BEFORE testing to prevent state pollution
-   */
   containsSensitiveData(content) {
     for (const rule of this.rules) {
       if (rule.category === "secret") {
@@ -286,13 +252,13 @@ var PrivacyFilter = class {
     }
     return false;
   }
-};
+}
 function createFilterContext(projectDirectory) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
   return {
     projectRoot: projectDirectory,
     homeDir,
-    commonPaths: /* @__PURE__ */ new Map([
+    commonPaths: new Map([
       ["/usr/local/lib/", "<LIB>/"],
       ["/usr/lib/", "<LIB>/"],
       ["/var/log/", "<LOG>/"],
@@ -301,11 +267,10 @@ function createFilterContext(projectDirectory) {
     ])
   };
 }
-var defaultPrivacyFilter = new PrivacyFilter();
+var defaultPrivacyFilter = new PrivacyFilter;
 
 // src/core/error-detector.ts
 var ERROR_PATTERNS = {
-  // Universal error indicators
   universal: [
     /\b(error|failed|failure|fatal|exception|panic)\b/i,
     /\b(cannot|could not|unable to|couldn't)\b/i,
@@ -316,36 +281,26 @@ var ERROR_PATTERNS = {
     /\b(segmentation fault|segfault|core dumped)\b/i,
     /\b(out of memory|oom|memory allocation failed)\b/i
   ],
-  // Error prefixes
   prefixed: [
     /^Error:/m,
     /^ERROR\s/m,
     /^E\s+\d+:/m,
-    // Rust errors
     /^\[ERROR\]/m,
     /^fatal:/m,
     /^FATAL:/m,
     /^panic:/m,
     /^Traceback \(most recent call last\):/m,
-    // Python
     /^Exception in thread/m,
-    // Java
     /^Uncaught \w+Error:/m
-    // JavaScript
   ],
-  // Build/compilation errors
   build: [
     /^.+:\d+:\d+:\s*error:/m,
-    // GCC/Clang format
     /error\[E\d+\]:/m,
-    // Rust compiler
     /error TS\d+:/m,
-    // TypeScript
     /SyntaxError:/m,
     /ParseError:/m,
     /CompileError:/m
   ],
-  // Package manager errors
   package: [
     /npm ERR!/m,
     /npm error/m,
@@ -358,9 +313,7 @@ var ERROR_PATTERNS = {
     /Cannot find module/m,
     /Module not found/m
   ],
-  // Permission errors
   permission: [/EACCES:/m, /EPERM:/m, /Permission denied/m, /Access denied/m, /Insufficient permissions/m],
-  // Network errors
   network: [
     /ECONNREFUSED/m,
     /ETIMEDOUT/m,
@@ -369,7 +322,6 @@ var ERROR_PATTERNS = {
     /Connection refused/m,
     /Network is unreachable/m
   ],
-  // Test failures
   test: [/FAIL /m, /AssertionError/m, /Expected .+ but got/m, /Test failed/i, /\d+ failing/m]
 };
 var STACK_TRACE_PATTERNS = {
@@ -384,37 +336,26 @@ var STACK_TRACE_PATTERNS = {
 };
 var EXIT_CODE_SEVERITY = {
   1: "error",
-  // General errors
   2: "error",
-  // Misuse of shell builtins
   126: "error",
-  // Command cannot execute
   127: "error",
-  // Command not found
   128: "critical",
-  // Invalid exit argument
   130: "warning",
-  // Script terminated by Ctrl+C
   137: "critical",
-  // SIGKILL (OOM, etc.)
   139: "critical",
-  // Segmentation fault
   143: "warning"
-  // SIGTERM
 };
-var ErrorDetector = class {
+
+class ErrorDetector {
   privacyFilter;
   constructor(privacyFilter) {
-    this.privacyFilter = privacyFilter || new PrivacyFilter();
+    this.privacyFilter = privacyFilter || new PrivacyFilter;
   }
-  /**
-   * Detect if output contains an error
-   */
   detect(toolOutput) {
     const signals = [];
     const combinedOutput = `${toolOutput.output || ""}
 ${toolOutput.stderr || ""}`;
-    if (toolOutput.exitCode !== void 0 && toolOutput.exitCode !== 0) {
+    if (toolOutput.exitCode !== undefined && toolOutput.exitCode !== 0) {
       const severity2 = EXIT_CODE_SEVERITY[toolOutput.exitCode] || "error";
       signals.push({
         type: "exit_code",
@@ -440,7 +381,8 @@ ${toolOutput.stderr || ""}`;
       signals.push({
         type: "stack_trace",
         weight: 0.95,
-        value: stackTrace.frames.slice(0, 5).join("\n"),
+        value: stackTrace.frames.slice(0, 5).join(`
+`),
         description: `${stackTrace.language} stack trace detected`
       });
     }
@@ -450,8 +392,8 @@ ${toolOutput.stderr || ""}`;
     const severity = this.determineSeverity(signals, toolOutput.exitCode);
     const { message, stack } = this.extractErrorDetails(combinedOutput);
     const sanitizedMessage = this.privacyFilter.sanitize(message);
-    const sanitizedStack = stack ? this.privacyFilter.sanitize(stack) : void 0;
-    const sanitizedOutput = this.privacyFilter.sanitize(combinedOutput.substring(0, 5e3));
+    const sanitizedStack = stack ? this.privacyFilter.sanitize(stack) : undefined;
+    const sanitizedOutput = this.privacyFilter.sanitize(combinedOutput.substring(0, 5000));
     return {
       detected,
       confidence,
@@ -463,15 +405,9 @@ ${toolOutput.stderr || ""}`;
       rawOutput: sanitizedOutput.sanitized
     };
   }
-  /**
-   * Check if content contains error keywords
-   */
   containsErrorKeywords(content) {
     return ERROR_PATTERNS.universal.some((p) => p.test(content));
   }
-  /**
-   * Detect error patterns in content
-   */
   detectErrorPatterns(content) {
     const signals = [];
     const weights = {
@@ -483,7 +419,8 @@ ${toolOutput.stderr || ""}`;
       test: 0.7
     };
     for (const [category, patterns] of Object.entries(ERROR_PATTERNS)) {
-      if (category === "universal") continue;
+      if (category === "universal")
+        continue;
       for (const pattern of patterns) {
         const match = content.match(pattern);
         if (match) {
@@ -499,9 +436,6 @@ ${toolOutput.stderr || ""}`;
     }
     return signals;
   }
-  /**
-   * Detect stack traces in content
-   */
   detectStackTrace(content) {
     for (const [language, pattern] of Object.entries(STACK_TRACE_PATTERNS)) {
       const globalPattern = new RegExp(pattern.source, "gm");
@@ -520,49 +454,50 @@ ${toolOutput.stderr || ""}`;
       frames: []
     };
   }
-  /**
-   * Calculate confidence score from signals
-   */
   calculateConfidence(signals) {
-    if (signals.length === 0) return 0;
+    if (signals.length === 0)
+      return 0;
     const totalWeight = signals.reduce((sum, s) => sum + s.weight, 0);
     const avgWeight = totalWeight / signals.length;
     const multiplier = Math.min(1.2, 1 + signals.length * 0.05);
     return Math.min(1, avgWeight * multiplier);
   }
-  /**
-   * Classify error type based on signals and content
-   */
   classifyErrorType(signals, content) {
-    if (ERROR_PATTERNS.build.some((p) => p.test(content))) return "build";
-    if (ERROR_PATTERNS.package.some((p) => p.test(content))) return "dependency";
-    if (ERROR_PATTERNS.permission.some((p) => p.test(content))) return "permission";
-    if (ERROR_PATTERNS.network.some((p) => p.test(content))) return "network";
-    if (ERROR_PATTERNS.test.some((p) => p.test(content))) return "test";
-    if (/TypeError:|type error|Type '[^']+' is not assignable/i.test(content)) return "type_error";
-    if (/SyntaxError:|syntax error|unexpected token/i.test(content)) return "syntax";
-    if (/ReferenceError:|RangeError:|runtime error/i.test(content)) return "runtime";
+    if (ERROR_PATTERNS.build.some((p) => p.test(content)))
+      return "build";
+    if (ERROR_PATTERNS.package.some((p) => p.test(content)))
+      return "dependency";
+    if (ERROR_PATTERNS.permission.some((p) => p.test(content)))
+      return "permission";
+    if (ERROR_PATTERNS.network.some((p) => p.test(content)))
+      return "network";
+    if (ERROR_PATTERNS.test.some((p) => p.test(content)))
+      return "test";
+    if (/TypeError:|type error|Type '[^']+' is not assignable/i.test(content))
+      return "type_error";
+    if (/SyntaxError:|syntax error|unexpected token/i.test(content))
+      return "syntax";
+    if (/ReferenceError:|RangeError:|runtime error/i.test(content))
+      return "runtime";
     const hasStackTrace = signals.some((s) => s.type === "stack_trace");
-    if (hasStackTrace) return "runtime";
+    if (hasStackTrace)
+      return "runtime";
     return "unknown";
   }
-  /**
-   * Determine severity from signals and exit code
-   */
   determineSeverity(signals, exitCode) {
-    if (exitCode !== void 0 && EXIT_CODE_SEVERITY[exitCode]) {
+    if (exitCode !== undefined && EXIT_CODE_SEVERITY[exitCode]) {
       return EXIT_CODE_SEVERITY[exitCode];
     }
     const maxWeight = Math.max(...signals.map((s) => s.weight));
-    if (maxWeight >= 0.9) return "error";
-    if (maxWeight >= 0.7) return "error";
+    if (maxWeight >= 0.9)
+      return "error";
+    if (maxWeight >= 0.7)
+      return "error";
     return "warning";
   }
-  /**
-   * Extract error message and stack from output
-   */
   extractErrorDetails(output) {
-    const lines = output.split("\n");
+    const lines = output.split(`
+`);
     let message = "";
     let stack = "";
     let inStack = false;
@@ -570,11 +505,9 @@ ${toolOutput.stderr || ""}`;
       if (this.isErrorLine(line) && !message) {
         message = line.trim();
         inStack = true;
-      } else if (inStack && (line.match(/^\s+at\s/) || // JS stack
-      line.match(/^\s+File\s/) || // Python stack
-      line.match(/^\s+\d+:\s/) || // Rust stack
-      line.match(/^\s+from\s/))) {
-        stack += line + "\n";
+      } else if (inStack && (line.match(/^\s+at\s/) || line.match(/^\s+File\s/) || line.match(/^\s+\d+:\s/) || line.match(/^\s+from\s/))) {
+        stack += line + `
+`;
       }
     }
     if (!message) {
@@ -587,18 +520,15 @@ ${toolOutput.stderr || ""}`;
     }
     return {
       message: message || output.substring(0, 500),
-      stack: stack || void 0
+      stack: stack || undefined
     };
   }
-  /**
-   * Check if a line looks like an error message
-   */
   isErrorLine(line) {
     const trimmed = line.trim();
     return /^(Error|TypeError|ReferenceError|SyntaxError|RangeError):/i.test(trimmed) || /^(error|FAIL|fatal|panic)\b/i.test(trimmed) || /^error\[E\d+\]:/.test(trimmed) || /^error TS\d+:/.test(trimmed);
   }
-};
-var defaultErrorDetector = new ErrorDetector();
+}
+var defaultErrorDetector = new ErrorDetector;
 
 // src/storage/local-store.ts
 import Database from "better-sqlite3";
@@ -642,8 +572,9 @@ function calculateStringSimilarity(str1, str2) {
   const words1 = new Set(str1.toLowerCase().split(/\s+/));
   const words2 = new Set(str2.toLowerCase().split(/\s+/));
   const intersection = new Set([...words1].filter((x) => words2.has(x)));
-  const union = /* @__PURE__ */ new Set([...words1, ...words2]);
-  if (union.size === 0) return 0;
+  const union = new Set([...words1, ...words2]);
+  if (union.size === 0)
+    return 0;
   return intersection.size / union.size;
 }
 
@@ -656,9 +587,7 @@ function runMigrations(db) {
       applied_at TEXT DEFAULT CURRENT_TIMESTAMP
     )
   `);
-  const appliedMigrations = new Set(
-    db.prepare("SELECT name FROM migrations").all().map((r) => r.name)
-  );
+  const appliedMigrations = new Set(db.prepare("SELECT name FROM migrations").all().map((r) => r.name));
   for (const migration of MIGRATIONS) {
     if (!appliedMigrations.has(migration.name)) {
       db.exec(migration.sql);
@@ -740,7 +669,7 @@ var MIGRATIONS = [
 ];
 
 // src/storage/local-store.ts
-var LocalStore = class _LocalStore {
+class LocalStore {
   db;
   constructor(projectDirectory) {
     const dbPath = `${projectDirectory}/.fixhive/fixhive.db`;
@@ -753,10 +682,6 @@ var LocalStore = class _LocalStore {
     this.db.pragma("foreign_keys = ON");
     runMigrations(this.db);
   }
-  // ============ Error Records ============
-  /**
-   * Create a new error record
-   */
   createErrorRecord(data) {
     const id = uuidv4();
     const errorHash = generateErrorFingerprint(data.errorMessage, data.errorStack);
@@ -784,17 +709,11 @@ var LocalStore = class _LocalStore {
     this.incrementStat("total_errors");
     return this.getErrorById(id);
   }
-  /**
-   * Get error record by ID
-   */
   getErrorById(id) {
     const stmt = this.db.prepare("SELECT * FROM error_records WHERE id = ?");
     const row = stmt.get(id);
     return row ? this.rowToRecord(row) : null;
   }
-  /**
-   * Get errors by session
-   */
   getSessionErrors(sessionId, options) {
     let query = "SELECT * FROM error_records WHERE session_id = ?";
     const params = [sessionId];
@@ -810,24 +729,13 @@ var LocalStore = class _LocalStore {
     const stmt = this.db.prepare(query);
     return stmt.all(...params).map((row) => this.rowToRecord(row));
   }
-  /**
-   * Get unresolved errors for a session
-   */
   getUnresolvedErrors(sessionId) {
     return this.getSessionErrors(sessionId, { status: "unresolved" });
   }
-  /**
-   * Get recent errors across all sessions
-   */
   getRecentErrors(limit = 10) {
-    const stmt = this.db.prepare(
-      "SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?"
-    );
+    const stmt = this.db.prepare("SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?");
     return stmt.all(limit).map((row) => this.rowToRecord(row));
   }
-  /**
-   * Mark error as resolved
-   */
   markResolved(id, data) {
     const stmt = this.db.prepare(`
       UPDATE error_records
@@ -844,9 +752,6 @@ var LocalStore = class _LocalStore {
     }
     return null;
   }
-  /**
-   * Mark error as uploaded to cloud
-   */
   markUploaded(id, cloudKnowledgeId) {
     const stmt = this.db.prepare(`
       UPDATE error_records
@@ -860,19 +765,10 @@ var LocalStore = class _LocalStore {
       this.incrementStat("uploaded_errors");
     }
   }
-  /**
-   * Find similar errors by hash
-   */
   findSimilarErrors(errorHash) {
-    const stmt = this.db.prepare(
-      "SELECT * FROM error_records WHERE error_hash = ? ORDER BY created_at DESC"
-    );
+    const stmt = this.db.prepare("SELECT * FROM error_records WHERE error_hash = ? ORDER BY created_at DESC");
     return stmt.all(errorHash).map((row) => this.rowToRecord(row));
   }
-  // ============ Query Cache ============
-  /**
-   * Get cached query results
-   */
   getCachedResults(errorHash) {
     const stmt = this.db.prepare(`
       SELECT results FROM query_cache
@@ -885,10 +781,7 @@ var LocalStore = class _LocalStore {
     }
     return null;
   }
-  /**
-   * Cache query results
-   */
-  cacheResults(errorHash, results, expirationMs = 36e5) {
+  cacheResults(errorHash, results, expirationMs = 3600000) {
     const id = uuidv4();
     const expiresAt = new Date(Date.now() + expirationMs).toISOString();
     const stmt = this.db.prepare(`
@@ -898,22 +791,13 @@ var LocalStore = class _LocalStore {
     stmt.run(id, errorHash, JSON.stringify(results), expiresAt);
     this.incrementStat("queries_made");
   }
-  /**
-   * Clear expired cache entries
-   */
   clearExpiredCache() {
     const stmt = this.db.prepare("DELETE FROM query_cache WHERE expires_at <= datetime('now')");
     const result = stmt.run();
     return result.changes;
   }
-  // ============ Statistics ============
-  /**
-   * Get usage statistics
-   */
   getStats() {
-    const stmt = this.db.prepare(
-      "SELECT total_errors, resolved_errors, uploaded_errors FROM usage_stats WHERE id = 1"
-    );
+    const stmt = this.db.prepare("SELECT total_errors, resolved_errors, uploaded_errors FROM usage_stats WHERE id = 1");
     const row = stmt.get();
     return {
       totalErrors: row.total_errors,
@@ -921,89 +805,66 @@ var LocalStore = class _LocalStore {
       uploadedErrors: row.uploaded_errors
     };
   }
-  /**
-   * Allowed stat column names for incrementStat (whitelist to prevent SQL injection)
-   */
   static ALLOWED_STATS = [
     "total_errors",
     "resolved_errors",
     "uploaded_errors",
     "queries_made"
   ];
-  /**
-   * Increment a stat counter
-   * @throws Error if stat name is not in the allowed whitelist
-   */
   incrementStat(stat) {
-    if (!_LocalStore.ALLOWED_STATS.includes(stat)) {
-      throw new Error(`Invalid stat name: ${stat}. Allowed: ${_LocalStore.ALLOWED_STATS.join(", ")}`);
+    if (!LocalStore.ALLOWED_STATS.includes(stat)) {
+      throw new Error(`Invalid stat name: ${stat}. Allowed: ${LocalStore.ALLOWED_STATS.join(", ")}`);
     }
     const stmt = this.db.prepare(`UPDATE usage_stats SET ${stat} = ${stat} + 1 WHERE id = 1`);
     stmt.run();
   }
-  // ============ Preferences ============
-  /**
-   * Get preference value
-   */
   getPreference(key) {
     const stmt = this.db.prepare("SELECT value FROM user_preferences WHERE key = ?");
     const row = stmt.get(key);
     return row?.value || null;
   }
-  /**
-   * Set preference value
-   */
   setPreference(key, value) {
     const stmt = this.db.prepare(`
       INSERT OR REPLACE INTO user_preferences (key, value) VALUES (?, ?)
     `);
     stmt.run(key, value);
   }
-  // ============ Utilities ============
-  /**
-   * Convert database row to LocalErrorRecord
-   */
   rowToRecord(row) {
     return {
       id: row.id,
       errorHash: row.error_hash,
       errorType: row.error_type,
       errorMessage: row.error_message,
-      errorStack: row.error_stack || void 0,
-      language: row.language || void 0,
-      framework: row.framework || void 0,
+      errorStack: row.error_stack || undefined,
+      language: row.language || undefined,
+      framework: row.framework || undefined,
       toolName: row.tool_name,
       toolInput: JSON.parse(row.tool_input || "{}"),
       sessionId: row.session_id,
       status: row.status,
-      resolution: row.resolution || void 0,
-      resolutionCode: row.resolution_code || void 0,
+      resolution: row.resolution || undefined,
+      resolutionCode: row.resolution_code || undefined,
       createdAt: row.created_at,
-      resolvedAt: row.resolved_at || void 0,
-      uploadedAt: row.uploaded_at || void 0,
-      cloudKnowledgeId: row.cloud_knowledge_id || void 0
+      resolvedAt: row.resolved_at || undefined,
+      uploadedAt: row.uploaded_at || undefined,
+      cloudKnowledgeId: row.cloud_knowledge_id || undefined
     };
   }
-  /**
-   * Close database connection
-   */
   close() {
     this.db.close();
   }
-  /**
-   * Get database for advanced queries
-   */
   getDatabase() {
     return this.db;
   }
-};
+}
 
 // src/cloud/embedding.ts
 import OpenAI from "openai";
 var DEFAULT_MODEL = "text-embedding-3-small";
 var DEFAULT_DIMENSIONS = 1536;
-var MAX_INPUT_LENGTH = 3e4;
-var EmbeddingService = class {
+var MAX_INPUT_LENGTH = 30000;
+
+class EmbeddingService {
   client;
   model;
   dimensions;
@@ -1012,9 +873,6 @@ var EmbeddingService = class {
     this.model = model || DEFAULT_MODEL;
     this.dimensions = dimensions || DEFAULT_DIMENSIONS;
   }
-  /**
-   * Generate embedding for a single text
-   */
   async generate(text) {
     const truncated = this.truncateText(text);
     const response = await this.client.embeddings.create({
@@ -1024,9 +882,6 @@ var EmbeddingService = class {
     });
     return response.data[0].embedding;
   }
-  /**
-   * Generate embeddings for multiple texts
-   */
   async generateBatch(texts) {
     const truncated = texts.map((t) => this.truncateText(t));
     const response = await this.client.embeddings.create({
@@ -1036,10 +891,6 @@ var EmbeddingService = class {
     });
     return response.data.map((d) => d.embedding);
   }
-  /**
-   * Generate embedding for error context
-   * Combines error message, stack trace, and context
-   */
   async generateErrorEmbedding(errorMessage, errorStack, context) {
     const parts = [];
     if (context?.language) {
@@ -1053,26 +904,22 @@ var EmbeddingService = class {
       parts.push(`Stack Trace:
 ${errorStack}`);
     }
-    const text = parts.join("\n");
+    const text = parts.join(`
+`);
     return this.generate(text);
   }
-  /**
-   * Truncate text to fit within model limits
-   */
   truncateText(text) {
     if (text.length <= MAX_INPUT_LENGTH) {
       return text;
     }
     const truncated = text.substring(0, MAX_INPUT_LENGTH);
-    const lastNewline = truncated.lastIndexOf("\n");
+    const lastNewline = truncated.lastIndexOf(`
+`);
     if (lastNewline > MAX_INPUT_LENGTH * 0.8) {
       return truncated.substring(0, lastNewline);
     }
     return truncated;
   }
-  /**
-   * Calculate cosine similarity between two embeddings
-   */
   static cosineSimilarity(a, b) {
     if (a.length !== b.length) {
       throw new Error("Embeddings must have same dimensions");
@@ -1080,28 +927,23 @@ ${errorStack}`);
     let dotProduct = 0;
     let normA = 0;
     let normB = 0;
-    for (let i = 0; i < a.length; i++) {
+    for (let i = 0;i < a.length; i++) {
       dotProduct += a[i] * b[i];
       normA += a[i] * a[i];
       normB += b[i] * b[i];
     }
     const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-    if (magnitude === 0) return 0;
+    if (magnitude === 0)
+      return 0;
     return dotProduct / magnitude;
   }
-  /**
-   * Get embedding dimensions
-   */
   getDimensions() {
     return this.dimensions;
   }
-  /**
-   * Get model name
-   */
   getModel() {
     return this.model;
   }
-};
+}
 function createEmbeddingService(config) {
   return new EmbeddingService(config.apiKey, config.model, config.dimensions);
 }
@@ -1115,69 +957,69 @@ async function getCreateClient() {
   }
   return createClient;
 }
-var CloudClient = class _CloudClient {
-  supabase;
-  embedding;
-  contributorId;
-  similarityThreshold;
-  constructor(supabase, embedding, contributorId, similarityThreshold) {
-    this.supabase = supabase;
-    this.embedding = embedding;
-    this.contributorId = contributorId;
-    this.similarityThreshold = similarityThreshold;
-  }
-  /**
-   * Create a CloudClient instance (async factory for Bun compatibility)
-   */
-  static async create(config) {
-    const createClientFn = await getCreateClient();
-    const supabase = createClientFn(config.supabaseUrl, config.supabaseAnonKey);
-    let embedding = null;
-    if (config.openaiApiKey) {
-      try {
-        embedding = new EmbeddingService(config.openaiApiKey);
-      } catch (err) {
-        console.warn("[FixHive] Failed to initialize embedding service:", err);
-      }
+function mapToKnowledgeEntry(row) {
+  return {
+    id: row.id,
+    errorHash: row.error_hash,
+    errorType: row.error_type,
+    errorMessage: row.error_message,
+    errorStack: row.error_stack || undefined,
+    language: row.language,
+    framework: row.framework || undefined,
+    dependencies: row.dependencies || undefined,
+    resolutionDescription: row.resolution_description,
+    resolutionCode: row.resolution_code || undefined,
+    resolutionSteps: row.resolution_steps || undefined,
+    contributorId: row.contributor_id,
+    upvotes: row.upvotes || 0,
+    downvotes: row.downvotes || 0,
+    usageCount: row.usage_count || 0,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    isVerified: row.is_verified || false,
+    similarity: row.similarity || undefined
+  };
+}
+async function createCloudClient(config) {
+  const createClientFn = await getCreateClient();
+  const supabase = createClientFn(config.supabaseUrl, config.supabaseAnonKey);
+  let embedding = null;
+  if (config.openaiApiKey) {
+    try {
+      embedding = new EmbeddingService(config.openaiApiKey);
+    } catch (err) {
+      console.warn("[FixHive] Failed to initialize embedding service:", err);
     }
-    const contributorId = config.contributorId || generateContributorId();
-    const similarityThreshold = config.similarityThreshold || 0.7;
-    return new _CloudClient(supabase, embedding, contributorId, similarityThreshold);
   }
-  /**
-   * Search for similar errors in cloud knowledge base
-   */
-  async searchSimilar(request) {
-    const startTime = Date.now();
-    if (!this.embedding) {
-      return this.searchByText(request);
+  const contributorId = config.contributorId || generateContributorId();
+  const similarityThreshold = config.similarityThreshold || 0.7;
+  async function checkDuplicateInternal(errorHash, embeddingData) {
+    const { data: hashMatch } = await supabase.from("knowledge_entries").select("id").eq("error_hash", errorHash).limit(1).single();
+    if (hashMatch) {
+      return {
+        isDuplicate: true,
+        existingId: hashMatch.id,
+        similarityScore: 1
+      };
     }
-    const queryText = `${request.errorMessage}
-${request.errorStack || ""}`;
-    const embedding = await this.embedding.generate(queryText);
-    const { data, error } = await this.supabase.rpc("search_similar_errors", {
-      query_embedding: embedding,
-      match_threshold: request.threshold || this.similarityThreshold,
-      match_count: request.limit || 10,
-      filter_language: request.language || null,
-      filter_framework: request.framework || null
+    const { data, error } = await supabase.rpc("check_duplicate_entry", {
+      new_hash: errorHash,
+      new_embedding: embeddingData,
+      similarity_threshold: 0.95
     });
-    if (error) {
-      console.error("Search error:", error);
-      return { results: [], queryTime: Date.now() - startTime, cached: false };
+    if (error || !data || data.length === 0) {
+      return { isDuplicate: false, similarityScore: 0 };
     }
+    const result = data[0];
     return {
-      results: (data || []).map(this.mapToKnowledgeEntry),
-      queryTime: Date.now() - startTime,
-      cached: false
+      isDuplicate: result.is_duplicate,
+      existingId: result.existing_id,
+      similarityScore: result.similarity_score
     };
   }
-  /**
-   * Fallback text-based search
-   */
-  async searchByText(request) {
+  async function searchByText(request) {
     const startTime = Date.now();
-    let query = this.supabase.from("knowledge_entries").select("*").ilike("error_message", `%${request.errorMessage.substring(0, 100)}%`).order("upvotes", { ascending: false }).limit(request.limit || 10);
+    let query = supabase.from("knowledge_entries").select("*").ilike("error_message", `%${request.errorMessage.substring(0, 100)}%`).order("upvotes", { ascending: false }).limit(request.limit || 10);
     if (request.language) {
       query = query.eq("language", request.language);
     }
@@ -1190,214 +1032,164 @@ ${request.errorStack || ""}`;
       return { results: [], queryTime: Date.now() - startTime, cached: false };
     }
     return {
-      results: (data || []).map(this.mapToKnowledgeEntry),
+      results: (data || []).map(mapToKnowledgeEntry),
       queryTime: Date.now() - startTime,
       cached: false
     };
   }
-  /**
-   * Upload a resolution to cloud knowledge base
-   */
-  async uploadResolution(request) {
-    const { errorRecord, resolution, resolutionCode, resolutionSteps } = request;
-    let embedding = null;
-    if (this.embedding) {
-      const embeddingText = `${errorRecord.errorMessage}
+  return {
+    async searchSimilar(request) {
+      const startTime = Date.now();
+      if (!embedding) {
+        return searchByText(request);
+      }
+      const queryText = `${request.errorMessage}
+${request.errorStack || ""}`;
+      const queryEmbedding = await embedding.generate(queryText);
+      const { data, error } = await supabase.rpc("search_similar_errors", {
+        query_embedding: queryEmbedding,
+        match_threshold: request.threshold || similarityThreshold,
+        match_count: request.limit || 10,
+        filter_language: request.language || null,
+        filter_framework: request.framework || null
+      });
+      if (error) {
+        console.error("Search error:", error);
+        return { results: [], queryTime: Date.now() - startTime, cached: false };
+      }
+      return {
+        results: (data || []).map(mapToKnowledgeEntry),
+        queryTime: Date.now() - startTime,
+        cached: false
+      };
+    },
+    async uploadResolution(request) {
+      const { errorRecord, resolution, resolutionCode, resolutionSteps } = request;
+      let embeddingData = null;
+      if (embedding) {
+        const embeddingText = `${errorRecord.errorMessage}
 ${errorRecord.errorStack || ""}`;
-      embedding = await this.embedding.generate(embeddingText);
-    }
-    if (embedding) {
-      const duplicateCheck = await this.checkDuplicate(errorRecord.errorHash, embedding);
-      if (duplicateCheck.isDuplicate && duplicateCheck.similarityScore > 0.95) {
-        await this.supabase.rpc("increment_usage_count", {
-          entry_id: duplicateCheck.existingId
-        });
+        embeddingData = await embedding.generate(embeddingText);
+      }
+      if (embeddingData) {
+        const duplicateCheck = await checkDuplicateInternal(errorRecord.errorHash, embeddingData);
+        if (duplicateCheck.isDuplicate && duplicateCheck.similarityScore > 0.95) {
+          await supabase.rpc("increment_usage_count", {
+            entry_id: duplicateCheck.existingId
+          });
+          return {
+            success: true,
+            isDuplicate: true,
+            existingId: duplicateCheck.existingId,
+            message: "Similar solution already exists. Usage count incremented."
+          };
+        }
+      }
+      const { data, error } = await supabase.from("knowledge_entries").insert({
+        error_hash: errorRecord.errorHash,
+        error_type: errorRecord.errorType,
+        error_message: errorRecord.errorMessage,
+        error_stack: errorRecord.errorStack,
+        language: errorRecord.language || "other",
+        framework: errorRecord.framework,
+        embedding: embeddingData,
+        resolution_description: resolution,
+        resolution_code: resolutionCode,
+        resolution_steps: resolutionSteps,
+        contributor_id: contributorId
+      }).select("id").single();
+      if (error) {
         return {
-          success: true,
-          isDuplicate: true,
-          existingId: duplicateCheck.existingId,
-          message: "Similar solution already exists. Usage count incremented."
+          success: false,
+          isDuplicate: false,
+          message: `Upload failed: ${error.message}`
         };
       }
-    }
-    const { data, error } = await this.supabase.from("knowledge_entries").insert({
-      error_hash: errorRecord.errorHash,
-      error_type: errorRecord.errorType,
-      error_message: errorRecord.errorMessage,
-      error_stack: errorRecord.errorStack,
-      language: errorRecord.language || "other",
-      framework: errorRecord.framework,
-      embedding,
-      resolution_description: resolution,
-      resolution_code: resolutionCode,
-      resolution_steps: resolutionSteps,
-      contributor_id: this.contributorId
-    }).select("id").single();
-    if (error) {
       return {
-        success: false,
+        success: true,
+        knowledgeId: data.id,
         isDuplicate: false,
-        message: `Upload failed: ${error.message}`
-      };
-    }
-    return {
-      success: true,
-      knowledgeId: data.id,
-      isDuplicate: false,
-      message: "Solution uploaded successfully!"
-    };
-  }
-  /**
-   * Check for duplicate entries
-   */
-  async checkDuplicate(errorHash, embedding) {
-    const { data: hashMatch } = await this.supabase.from("knowledge_entries").select("id").eq("error_hash", errorHash).limit(1).single();
-    if (hashMatch) {
-      return {
-        isDuplicate: true,
-        existingId: hashMatch.id,
-        similarityScore: 1
+        message: "Solution uploaded successfully!"
       };
-    }
-    const { data, error } = await this.supabase.rpc("check_duplicate_entry", {
-      new_hash: errorHash,
-      new_embedding: embedding,
-      similarity_threshold: 0.95
-    });
-    if (error || !data || data.length === 0) {
-      return { isDuplicate: false, similarityScore: 0 };
-    }
-    const result = data[0];
-    return {
-      isDuplicate: result.is_duplicate,
-      existingId: result.existing_id,
-      similarityScore: result.similarity_score
-    };
-  }
-  /**
-   * Vote on a knowledge entry (with duplicate vote prevention)
-   */
-  async vote(knowledgeId, helpful) {
-    const voteType = helpful ? "up" : "down";
-    const { data, error } = await this.supabase.rpc("safe_vote", {
-      p_entry_id: knowledgeId,
-      p_user_hash: this.contributorId,
-      p_vote_type: voteType
-    });
-    if (error) {
-      return { success: false, error: error.message };
-    }
-    const result = data;
-    if (result.success) {
-      await this.supabase.from("usage_logs").insert({
+    },
+    async checkDuplicate(errorHash, embeddingData) {
+      return checkDuplicateInternal(errorHash, embeddingData);
+    },
+    async vote(knowledgeId, helpful) {
+      const voteType = helpful ? "up" : "down";
+      const { data, error } = await supabase.rpc("safe_vote", {
+        p_entry_id: knowledgeId,
+        p_user_hash: contributorId,
+        p_vote_type: voteType
+      });
+      if (error) {
+        return { success: false, error: error.message };
+      }
+      const result = data;
+      if (result.success) {
+        await supabase.from("usage_logs").insert({
+          knowledge_id: knowledgeId,
+          action: helpful ? "upvote" : "downvote",
+          user_hash: contributorId
+        });
+      }
+      return result;
+    },
+    async reportEntry(knowledgeId, reason) {
+      const { data, error } = await supabase.rpc("report_entry", {
+        p_entry_id: knowledgeId,
+        p_user_hash: contributorId,
+        p_reason: reason || null
+      });
+      if (error) {
+        return { success: false };
+      }
+      return data;
+    },
+    async reportHelpful(knowledgeId) {
+      await supabase.rpc("increment_usage_count", {
+        entry_id: knowledgeId
+      });
+      await supabase.from("usage_logs").insert({
         knowledge_id: knowledgeId,
-        action: helpful ? "upvote" : "downvote",
-        user_hash: this.contributorId
+        action: "apply",
+        user_hash: contributorId
       });
+    },
+    async getContributorStats() {
+      const { data } = await supabase.from("knowledge_entries").select("upvotes, usage_count").eq("contributor_id", contributorId);
+      if (!data || data.length === 0) {
+        return { contributionCount: 0, helpedCount: 0, totalUpvotes: 0 };
+      }
+      return {
+        contributionCount: data.length,
+        helpedCount: data.reduce((sum, e) => sum + (e.usage_count || 0), 0),
+        totalUpvotes: data.reduce((sum, e) => sum + (e.upvotes || 0), 0)
+      };
+    },
+    async getEntry(id) {
+      const { data, error } = await supabase.from("knowledge_entries").select("*").eq("id", id).single();
+      if (error || !data) {
+        return null;
+      }
+      return mapToKnowledgeEntry(data);
+    },
+    getContributorId() {
+      return contributorId;
+    },
+    hasEmbeddingService() {
+      return embedding !== null;
     }
-    return result;
-  }
-  /**
-   * Report an entry for review
-   */
-  async reportEntry(knowledgeId, reason) {
-    const { data, error } = await this.supabase.rpc("report_entry", {
-      p_entry_id: knowledgeId,
-      p_user_hash: this.contributorId,
-      p_reason: reason || null
-    });
-    if (error) {
-      return { success: false };
-    }
-    return data;
-  }
-  /**
-   * Report helpful usage
-   */
-  async reportHelpful(knowledgeId) {
-    await this.supabase.rpc("increment_usage_count", {
-      entry_id: knowledgeId
-    });
-    await this.supabase.from("usage_logs").insert({
-      knowledge_id: knowledgeId,
-      action: "apply",
-      user_hash: this.contributorId
-    });
-  }
-  /**
-   * Get contributor statistics
-   */
-  async getContributorStats() {
-    const { data } = await this.supabase.from("knowledge_entries").select("upvotes, usage_count").eq("contributor_id", this.contributorId);
-    if (!data || data.length === 0) {
-      return { contributionCount: 0, helpedCount: 0, totalUpvotes: 0 };
-    }
-    return {
-      contributionCount: data.length,
-      helpedCount: data.reduce((sum, e) => sum + (e.usage_count || 0), 0),
-      totalUpvotes: data.reduce((sum, e) => sum + (e.upvotes || 0), 0)
-    };
-  }
-  /**
-   * Get entry by ID
-   */
-  async getEntry(id) {
-    const { data, error } = await this.supabase.from("knowledge_entries").select("*").eq("id", id).single();
-    if (error || !data) {
-      return null;
-    }
-    return this.mapToKnowledgeEntry(data);
-  }
-  /**
-   * Map database row to CloudKnowledgeEntry
-   */
-  mapToKnowledgeEntry(row) {
-    return {
-      id: row.id,
-      errorHash: row.error_hash,
-      errorType: row.error_type,
-      errorMessage: row.error_message,
-      errorStack: row.error_stack || void 0,
-      language: row.language,
-      framework: row.framework || void 0,
-      dependencies: row.dependencies || void 0,
-      resolutionDescription: row.resolution_description,
-      resolutionCode: row.resolution_code || void 0,
-      resolutionSteps: row.resolution_steps || void 0,
-      contributorId: row.contributor_id,
-      upvotes: row.upvotes || 0,
-      downvotes: row.downvotes || 0,
-      usageCount: row.usage_count || 0,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      isVerified: row.is_verified || false,
-      similarity: row.similarity || void 0
-    };
-  }
-  /**
-   * Get contributor ID
-   */
-  getContributorId() {
-    return this.contributorId;
-  }
-  /**
-   * Check if embedding service is available
-   */
-  hasEmbeddingService() {
-    return this.embedding !== null;
-  }
-};
-async function createCloudClient(config) {
-  return CloudClient.create(config);
+  };
 }
+var CloudClient = {
+  create: createCloudClient
+};
 
 // src/plugin/tools.ts
 import { tool } from "@opencode-ai/plugin";
 function createTools(localStore, cloudClient, privacyFilter, context) {
   return {
-    /**
-     * Search cloud knowledge base for error solutions
-     */
     fixhive_search: tool({
       description: "Search FixHive knowledge base for error solutions. Use when encountering errors to find community solutions.",
       args: {
@@ -1426,9 +1218,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
         return formatSearchResults(results.results, false);
       }
     }),
-    /**
-     * Mark error as resolved and optionally upload solution
-     */
     fixhive_resolve: tool({
       description: "Mark an error as resolved and optionally share the solution with the community.",
       args: {
@@ -1464,9 +1253,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
         return "Error marked as resolved locally.";
       }
     }),
-    /**
-     * List errors in current session
-     */
     fixhive_list: tool({
       description: "List errors detected in the current session.",
       args: {
@@ -1485,9 +1271,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
         return formatErrorList(errors);
       }
     }),
-    /**
-     * Vote on a solution
-     */
     fixhive_vote: tool({
       description: "Upvote or downvote a FixHive solution based on whether it helped.",
       args: {
@@ -1505,9 +1288,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
         return args.helpful ? "Thanks for the feedback! Solution upvoted." : "Thanks for the feedback! Solution downvoted.";
       }
     }),
-    /**
-     * Report inappropriate content
-     */
     fixhive_report: tool({
       description: "Report a FixHive solution for inappropriate content, spam, or incorrect information.",
       args: {
@@ -1522,9 +1302,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
         return "Report submitted. Thank you for helping keep FixHive clean!";
       }
     }),
-    /**
-     * Get usage statistics
-     */
     fixhive_stats: tool({
       description: "Get FixHive usage statistics.",
       args: {},
@@ -1546,9 +1323,6 @@ function createTools(localStore, cloudClient, privacyFilter, context) {
 `;
       }
     }),
-    /**
-     * Report that a solution was helpful
-     */
     fixhive_helpful: tool({
       description: "Report that a FixHive solution was helpful and resolved your issue.",
       args: {
@@ -1583,7 +1357,8 @@ ${r.resolutionCode}
     if (r.resolutionSteps?.length) {
       entry += `
 **Steps:**
-${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join("\n")}
+${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join(`
+`)}
 `;
     }
     entry += `
@@ -1591,7 +1366,8 @@ ${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join("\n")}
 
 ---`;
     return entry;
-  }).join("\n");
+  }).join(`
+`);
   return `${header}
 ${entries}
 
@@ -1602,9 +1378,8 @@ function formatErrorList(errors) {
   const table = `
 | ID | Type | Status | Message |
 |----|------|--------|---------|
-${errors.map(
-    (e) => `| ${e.id.slice(0, 8)} | ${e.errorType} | ${e.status} | ${e.errorMessage.slice(0, 50)}... |`
-  ).join("\n")}
+${errors.map((e) => `| ${e.id.slice(0, 8)} | ${e.errorType} | ${e.status} | ${e.errorMessage.slice(0, 50)}... |`).join(`
+`)}
 `;
   return `${header}
 ${table}
@@ -1614,8 +1389,7 @@ Use \`fixhive_resolve <id>\` to mark as resolved and share solutions.`;
 
 // src/plugin/index.ts
 var DEFAULT_CONFIG = {
-  cacheExpirationMs: 36e5,
-  // 1 hour
+  cacheExpirationMs: 3600000,
   embeddingModel: "text-embedding-3-small",
   embeddingDimensions: 1536,
   similarityThreshold: 0.7,
@@ -1626,14 +1400,14 @@ var FixHivePlugin = async (ctx) => {
   console.log("[FixHive] Plugin loaded");
   console.log(`[FixHive] Project: ${ctx.directory}`);
   console.log(`[FixHive] Cloud: ${config.supabaseUrl ? "enabled" : "disabled"}`);
-  const privacyFilter = new PrivacyFilter();
+  const privacyFilter = new PrivacyFilter;
   const filterContext = createFilterContext(ctx.directory);
   const errorDetector = new ErrorDetector(privacyFilter);
   const localStore = new LocalStore(ctx.directory);
   let cloudClient = null;
   if (config.supabaseUrl && config.supabaseAnonKey) {
     try {
-      cloudClient = await CloudClient.create({
+      cloudClient = await createCloudClient({
         supabaseUrl: config.supabaseUrl,
         supabaseAnonKey: config.supabaseAnonKey,
         openaiApiKey: config.openaiApiKey,
@@ -1657,9 +1431,9 @@ var FixHivePlugin = async (ctx) => {
   console.log("[FixHive] Ready - use fixhive_stats to verify");
   const errorProducingTools = ["bash", "edit", "write", "read", "terminal"];
   return {
-    // ============ Tool Execution Hook ============
     "tool.execute.after": async (input, output) => {
-      if (!errorProducingTools.includes(input.tool)) return;
+      if (!errorProducingTools.includes(input.tool))
+        return;
       const detection = errorDetector.detect({
         tool: input.tool,
         output: output.output,
@@ -1669,7 +1443,7 @@ var FixHivePlugin = async (ctx) => {
       });
       if (detection.detected && detection.confidence >= 0.5) {
         const sanitizedErrorMessage = privacyFilter.sanitize(detection.errorMessage, filterContext).sanitized;
-        const sanitizedErrorStack = detection.errorStack ? privacyFilter.sanitize(detection.errorStack, filterContext).sanitized : void 0;
+        const sanitizedErrorStack = detection.errorStack ? privacyFilter.sanitize(detection.errorStack, filterContext).sanitized : undefined;
         localStore.createErrorRecord({
           errorType: detection.errorType,
           errorMessage: sanitizedErrorMessage,
@@ -1678,7 +1452,6 @@ var FixHivePlugin = async (ctx) => {
           framework: pluginContext.framework,
           toolName: input.tool,
           toolInput: {},
-          // Tool input is intentionally omitted to avoid storing sensitive data
           sessionId: pluginContext.sessionId || input.sessionID
         });
         if (cloudClient) {
@@ -1691,10 +1464,7 @@ var FixHivePlugin = async (ctx) => {
               limit: 3
             });
             if (solutions.results.length > 0) {
-              localStore.cacheResults(
-                generateErrorFingerprint(sanitizedErrorMessage, sanitizedErrorStack),
-                solutions.results
-              );
+              localStore.cacheResults(generateErrorFingerprint(sanitizedErrorMessage, sanitizedErrorStack), solutions.results);
               output.title = `${output.title} [FixHive: ${solutions.results.length} solution(s) found]`;
             }
           } catch (e) {
@@ -1704,24 +1474,22 @@ var FixHivePlugin = async (ctx) => {
         }
       }
     },
-    // ============ Session Compaction Hook ============
     "experimental.session.compacting": async (_input, output) => {
       const unresolvedErrors = localStore.getUnresolvedErrors(pluginContext.sessionId);
       if (unresolvedErrors.length > 0) {
         output.context.push(`
 ## FixHive: Unresolved Errors in Session
 
-${unresolvedErrors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 100)}...`).join("\n")}
+${unresolvedErrors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 100)}...`).join(`
+`)}
 
 Use \`fixhive_mark_resolved\` when errors are fixed to contribute solutions.
 `);
       }
     },
-    // ============ Chat Message Hook ============
     "chat.message": async (input, _output) => {
       pluginContext.sessionId = input.sessionID;
     },
-    // ============ Custom Tools ============
     tool: cloudClient ? createTools(localStore, cloudClient, privacyFilter, pluginContext) : createOfflineTools(localStore, privacyFilter, pluginContext)
   };
 };
@@ -1744,7 +1512,8 @@ function createOfflineTools(localStore, _privacyFilter, context) {
         }
         return `## Session Errors (${errors.length})
 
-${errors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 80)}...`).join("\n")}
+${errors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 80)}...`).join(`
+`)}
 
 *Cloud features disabled. Set FIXHIVE_SUPABASE_URL and FIXHIVE_SUPABASE_KEY to enable.*`;
       }
@@ -1803,7 +1572,7 @@ function detectLanguage(directory) {
       return lang;
     }
   }
-  return void 0;
+  return;
 }
 function detectFramework(directory) {
   const pkgPath = join(directory, "package.json");
@@ -1811,49 +1580,57 @@ function detectFramework(directory) {
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps["next"]) return "nextjs";
-      if (deps["react"]) return "react";
-      if (deps["vue"]) return "vue";
-      if (deps["@angular/core"]) return "angular";
-      if (deps["express"]) return "express";
-      if (deps["fastify"]) return "fastify";
-      if (deps["hono"]) return "hono";
-    } catch {
-    }
+      if (deps["next"])
+        return "nextjs";
+      if (deps["react"])
+        return "react";
+      if (deps["vue"])
+        return "vue";
+      if (deps["@angular/core"])
+        return "angular";
+      if (deps["express"])
+        return "express";
+      if (deps["fastify"])
+        return "fastify";
+      if (deps["hono"])
+        return "hono";
+    } catch {}
   }
   const reqPath = join(directory, "requirements.txt");
   if (existsSync2(reqPath)) {
     try {
       const content = readFileSync(reqPath, "utf-8");
-      if (content.includes("django")) return "django";
-      if (content.includes("flask")) return "flask";
-      if (content.includes("fastapi")) return "fastapi";
-    } catch {
-    }
-  }
-  return void 0;
+      if (content.includes("django"))
+        return "django";
+      if (content.includes("flask"))
+        return "flask";
+      if (content.includes("fastapi"))
+        return "fastapi";
+    } catch {}
+  }
+  return;
 }
 var plugin_default = FixHivePlugin;
 export {
-  CloudClient,
-  EmbeddingService,
-  ErrorDetector,
-  FixHivePlugin,
-  LocalStore,
-  PrivacyFilter,
-  calculateStringSimilarity,
-  createCloudClient,
-  createEmbeddingService,
-  createFilterContext,
-  plugin_default as default,
-  defaultErrorDetector,
-  defaultPrivacyFilter,
-  fingerprintsMatch,
-  generateContributorId,
-  generateErrorFingerprint,
-  generateSessionHash,
-  normalizeErrorContent,
-  runMigrations,
+  shortHash,
   sha256,
-  shortHash
+  runMigrations,
+  normalizeErrorContent,
+  generateSessionHash,
+  generateErrorFingerprint,
+  generateContributorId,
+  fingerprintsMatch,
+  defaultPrivacyFilter,
+  defaultErrorDetector,
+  plugin_default as default,
+  createFilterContext,
+  createEmbeddingService,
+  createCloudClient,
+  calculateStringSimilarity,
+  PrivacyFilter,
+  LocalStore,
+  FixHivePlugin,
+  ErrorDetector,
+  EmbeddingService,
+  CloudClient
 };