@the-magic-tower/fixhive-opencode-plugin 0.1.22 → 0.1.24

package/dist/index.js

@@ -1,10 +1,14 @@
 // src/plugin/index.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+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",
@@ -12,6 +16,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[AWS_KEY_REDACTED]",
     priority: 100
   },
+  // OpenAI API Keys
   {
     name: "openai_key",
     category: "secret",
@@ -19,6 +24,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[OPENAI_KEY_REDACTED]",
     priority: 100
   },
+  // GitHub Tokens
   {
     name: "github_token",
     category: "secret",
@@ -26,6 +32,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[GITHUB_TOKEN_REDACTED]",
     priority: 100
   },
+  // Google API Keys
   {
     name: "google_api_key",
     category: "secret",
@@ -33,6 +40,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[GOOGLE_API_KEY_REDACTED]",
     priority: 100
   },
+  // Stripe Keys
   {
     name: "stripe_key",
     category: "secret",
@@ -40,6 +48,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[STRIPE_KEY_REDACTED]",
     priority: 100
   },
+  // JWT Tokens (limited length to prevent ReDoS)
   {
     name: "jwt_token",
     category: "secret",
@@ -47,6 +56,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[JWT_REDACTED]",
     priority: 100
   },
+  // Bearer Tokens
   {
     name: "bearer_token",
     category: "secret",
@@ -54,6 +64,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1 [TOKEN_REDACTED]",
     priority: 100
   },
+  // Private Keys
   {
     name: "private_key",
     category: "secret",
@@ -61,6 +72,7 @@ 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",
@@ -68,6 +80,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1=[KEY_REDACTED]",
     priority: 95
   },
+  // Secret/Password assignments (limited length to prevent ReDoS)
   {
     name: "secret_assignment",
     category: "secret",
@@ -75,6 +88,10 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1=[REDACTED]",
     priority: 90
   },
+  // =====================================
+  // IDENTITY (High Risk)
+  // =====================================
+  // Email Addresses
   {
     name: "email",
     category: "identity",
@@ -82,6 +99,10 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[EMAIL_REDACTED]",
     priority: 80
   },
+  // =====================================
+  // INFRASTRUCTURE (Medium Risk)
+  // =====================================
+  // Database Connection Strings
   {
     name: "db_connection",
     category: "infrastructure",
@@ -89,6 +110,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "$1://[CONNECTION_REDACTED]",
     priority: 85
   },
+  // Internal URLs
   {
     name: "internal_url",
     category: "infrastructure",
@@ -96,6 +118,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "[INTERNAL_URL_REDACTED]",
     priority: 75
   },
+  // IP Addresses (except localhost and common dev IPs)
   {
     name: "ipv4",
     category: "infrastructure",
@@ -108,6 +131,10 @@ var DEFAULT_FILTER_RULES = [
     },
     priority: 70
   },
+  // =====================================
+  // FILE PATHS (Context-dependent)
+  // =====================================
+  // Home Directory Paths (macOS)
   {
     name: "macos_home_path",
     category: "path",
@@ -115,6 +142,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
+  // Home Directory Paths (Linux)
   {
     name: "linux_home_path",
     category: "path",
@@ -122,6 +150,7 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
+  // Home Directory Paths (Windows)
   {
     name: "windows_home_path",
     category: "path",
@@ -129,6 +158,10 @@ var DEFAULT_FILTER_RULES = [
     replacement: "~",
     priority: 60
   },
+  // =====================================
+  // ENVIRONMENT (Medium Risk)
+  // =====================================
+  // Sensitive Environment Variables
   {
     name: "env_var_value",
     category: "environment",
@@ -157,7 +190,9 @@ var DEFAULT_FILTER_RULES = [
   }
 ];
 function createPrivacyFilter(customRules) {
-  const rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort((a, b) => b.priority - a.priority);
+  const rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort(
+    (a, b) => b.priority - a.priority
+  );
   function generalizePaths(content, context) {
     let result = content;
     if (context.projectRoot) {
@@ -173,6 +208,9 @@ function createPrivacyFilter(customRules) {
     return result;
   }
   return {
+    /**
+     * Sanitize content by applying all filter rules
+     */
     sanitize(content, context) {
       let result = content;
       const appliedFilters = [];
@@ -202,10 +240,16 @@ function createPrivacyFilter(customRules) {
         appliedFilters: [...new Set(appliedFilters)]
       };
     },
+    /**
+     * Add a custom filter rule
+     */
     addRule(rule) {
       rules.push(rule);
       rules.sort((a, b) => b.priority - a.priority);
     },
+    /**
+     * Remove a filter rule by name
+     */
     removeRule(name) {
       const index = rules.findIndex((r) => r.name === name);
       if (index !== -1) {
@@ -214,9 +258,16 @@ function createPrivacyFilter(customRules) {
       }
       return false;
     },
+    /**
+     * Get all current rules
+     */
     getRules() {
       return rules;
     },
+    /**
+     * Check if content contains sensitive data
+     * Note: Always reset regex lastIndex BEFORE testing to prevent state pollution
+     */
     containsSensitiveData(content) {
       for (const rule of rules) {
         if (rule.category === "secret") {
@@ -240,7 +291,7 @@ function createFilterContext(projectDirectory) {
   return {
     projectRoot: projectDirectory,
     homeDir,
-    commonPaths: new Map([
+    commonPaths: /* @__PURE__ */ new Map([
       ["/usr/local/lib/", "<LIB>/"],
       ["/usr/lib/", "<LIB>/"],
       ["/var/log/", "<LOG>/"],
@@ -253,6 +304,7 @@ var defaultPrivacyFilter = createPrivacyFilter();
 
 // 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,
@@ -263,26 +315,36 @@ 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,
@@ -295,7 +357,9 @@ 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,
@@ -304,6 +368,7 @@ 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 = {
@@ -318,14 +383,23 @@ 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
 };
 function createErrorDetector(privacyFilter) {
   const filter = privacyFilter || createPrivacyFilter();
@@ -343,8 +417,7 @@ function createErrorDetector(privacyFilter) {
       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) {
@@ -379,44 +452,32 @@ function createErrorDetector(privacyFilter) {
     };
   }
   function 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);
   }
   function 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";
   }
   function determineSeverity(signals, exitCode) {
-    if (exitCode !== undefined && EXIT_CODE_SEVERITY[exitCode]) {
+    if (exitCode !== void 0 && 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";
   }
   function isErrorLine(line) {
@@ -424,8 +485,7 @@ function createErrorDetector(privacyFilter) {
     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);
   }
   function extractErrorDetails(output) {
-    const lines = output.split(`
-`);
+    const lines = output.split("\n");
     let message = "";
     let stack = "";
     let inStack = false;
@@ -433,9 +493,11 @@ function createErrorDetector(privacyFilter) {
       if (isErrorLine(line) && !message) {
         message = line.trim();
         inStack = true;
-      } 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 + `
-`;
+      } 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";
       }
     }
     if (!message) {
@@ -448,15 +510,18 @@ function createErrorDetector(privacyFilter) {
     }
     return {
       message: message || output.substring(0, 500),
-      stack: stack || undefined
+      stack: stack || void 0
     };
   }
   return {
+    /**
+     * Detect if output contains an error
+     */
     detect(toolOutput) {
       const signals = [];
       const combinedOutput = `${toolOutput.output || ""}
 ${toolOutput.stderr || ""}`;
-      if (toolOutput.exitCode !== undefined && toolOutput.exitCode !== 0) {
+      if (toolOutput.exitCode !== void 0 && toolOutput.exitCode !== 0) {
         const severity2 = EXIT_CODE_SEVERITY[toolOutput.exitCode] || "error";
         signals.push({
           type: "exit_code",
@@ -482,8 +547,7 @@ ${toolOutput.stderr || ""}`;
         signals.push({
           type: "stack_trace",
           weight: 0.95,
-          value: stackTrace.frames.slice(0, 5).join(`
-`),
+          value: stackTrace.frames.slice(0, 5).join("\n"),
           description: `${stackTrace.language} stack trace detected`
         });
       }
@@ -493,8 +557,8 @@ ${toolOutput.stderr || ""}`;
       const severity = determineSeverity(signals, toolOutput.exitCode);
       const { message, stack } = extractErrorDetails(combinedOutput);
       const sanitizedMessage = filter.sanitize(message);
-      const sanitizedStack = stack ? filter.sanitize(stack) : undefined;
-      const sanitizedOutput = filter.sanitize(combinedOutput.substring(0, 5000));
+      const sanitizedStack = stack ? filter.sanitize(stack) : void 0;
+      const sanitizedOutput = filter.sanitize(combinedOutput.substring(0, 5e3));
       return {
         detected,
         confidence,
@@ -555,9 +619,8 @@ 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 = new Set([...words1, ...words2]);
-  if (union.size === 0)
-    return 0;
+  const union = /* @__PURE__ */ new Set([...words1, ...words2]);
+  if (union.size === 0) return 0;
   return intersection.size / union.size;
 }
 
@@ -570,7 +633,9 @@ 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);
@@ -664,19 +729,19 @@ function rowToRecord(row) {
     errorHash: row.error_hash,
     errorType: row.error_type,
     errorMessage: row.error_message,
-    errorStack: row.error_stack || undefined,
-    language: row.language || undefined,
-    framework: row.framework || undefined,
+    errorStack: row.error_stack || void 0,
+    language: row.language || void 0,
+    framework: row.framework || void 0,
     toolName: row.tool_name,
     toolInput: JSON.parse(row.tool_input || "{}"),
     sessionId: row.session_id,
     status: row.status,
-    resolution: row.resolution || undefined,
-    resolutionCode: row.resolution_code || undefined,
+    resolution: row.resolution || void 0,
+    resolutionCode: row.resolution_code || void 0,
     createdAt: row.created_at,
-    resolvedAt: row.resolved_at || undefined,
-    uploadedAt: row.uploaded_at || undefined,
-    cloudKnowledgeId: row.cloud_knowledge_id || undefined
+    resolvedAt: row.resolved_at || void 0,
+    uploadedAt: row.uploaded_at || void 0,
+    cloudKnowledgeId: row.cloud_knowledge_id || void 0
   };
 }
 function createLocalStore(projectDirectory) {
@@ -697,6 +762,10 @@ function createLocalStore(projectDirectory) {
     stmt.run();
   }
   return {
+    // ============ Error Records ============
+    /**
+     * Create a new error record
+     */
     createErrorRecord(data) {
       const id = uuidv4();
       const errorHash = generateErrorFingerprint(data.errorMessage, data.errorStack);
@@ -724,11 +793,17 @@ function createLocalStore(projectDirectory) {
       incrementStat("total_errors");
       return this.getErrorById(id);
     },
+    /**
+     * Get error record by ID
+     */
     getErrorById(id) {
       const stmt = db.prepare("SELECT * FROM error_records WHERE id = ?");
       const row = stmt.get(id);
       return row ? rowToRecord(row) : null;
     },
+    /**
+     * Get errors by session
+     */
     getSessionErrors(sessionId, options) {
       let query = "SELECT * FROM error_records WHERE session_id = ?";
       const params = [sessionId];
@@ -744,13 +819,24 @@ function createLocalStore(projectDirectory) {
       const stmt = db.prepare(query);
       return stmt.all(...params).map((row) => 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 = db.prepare("SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?");
+      const stmt = db.prepare(
+        "SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?"
+      );
       return stmt.all(limit).map((row) => rowToRecord(row));
     },
+    /**
+     * Mark error as resolved
+     */
     markResolved(id, data) {
       const stmt = db.prepare(`
         UPDATE error_records
@@ -767,6 +853,9 @@ function createLocalStore(projectDirectory) {
       }
       return null;
     },
+    /**
+     * Mark error as uploaded to cloud
+     */
     markUploaded(id, cloudKnowledgeId) {
       const stmt = db.prepare(`
         UPDATE error_records
@@ -780,10 +869,19 @@ function createLocalStore(projectDirectory) {
         incrementStat("uploaded_errors");
       }
     },
+    /**
+     * Find similar errors by hash
+     */
     findSimilarErrors(errorHash) {
-      const stmt = db.prepare("SELECT * FROM error_records WHERE error_hash = ? ORDER BY created_at DESC");
+      const stmt = db.prepare(
+        "SELECT * FROM error_records WHERE error_hash = ? ORDER BY created_at DESC"
+      );
       return stmt.all(errorHash).map((row) => rowToRecord(row));
     },
+    // ============ Query Cache ============
+    /**
+     * Get cached query results
+     */
     getCachedResults(errorHash) {
       const stmt = db.prepare(`
         SELECT results FROM query_cache
@@ -796,7 +894,10 @@ function createLocalStore(projectDirectory) {
       }
       return null;
     },
-    cacheResults(errorHash, results, expirationMs = 3600000) {
+    /**
+     * Cache query results
+     */
+    cacheResults(errorHash, results, expirationMs = 36e5) {
       const id = uuidv4();
       const expiresAt = new Date(Date.now() + expirationMs).toISOString();
       const stmt = db.prepare(`
@@ -806,13 +907,22 @@ function createLocalStore(projectDirectory) {
       stmt.run(id, errorHash, JSON.stringify(results), expiresAt);
       incrementStat("queries_made");
     },
+    /**
+     * Clear expired cache entries
+     */
     clearExpiredCache() {
       const stmt = 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 = db.prepare("SELECT total_errors, resolved_errors, uploaded_errors FROM usage_stats WHERE id = 1");
+      const stmt = db.prepare(
+        "SELECT total_errors, resolved_errors, uploaded_errors FROM usage_stats WHERE id = 1"
+      );
       const row = stmt.get();
       return {
         totalErrors: row.total_errors,
@@ -820,20 +930,34 @@ function createLocalStore(projectDirectory) {
         uploadedErrors: row.uploaded_errors
       };
     },
+    // ============ Preferences ============
+    /**
+     * Get preference value
+     */
     getPreference(key) {
       const stmt = 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 = db.prepare(`
         INSERT OR REPLACE INTO user_preferences (key, value) VALUES (?, ?)
       `);
       stmt.run(key, value);
     },
+    // ============ Utilities ============
+    /**
+     * Close database connection
+     */
     close() {
       db.close();
     },
+    /**
+     * Get database for advanced queries
+     */
     getDatabase() {
       return db;
     }
@@ -843,14 +967,14 @@ var LocalStore = {
   create: createLocalStore
 };
 
-// src/cloud/client.ts
-import * as supabaseJs from "@supabase/supabase-js";
-
 // src/cloud/embedding.ts
-import * as openaiModule from "openai";
 var DEFAULT_MODEL = "text-embedding-3-small";
 var DEFAULT_DIMENSIONS = 1536;
-var MAX_INPUT_LENGTH = 30000;
+var MAX_INPUT_LENGTH = 3e4;
+async function getOpenAIClass() {
+  const mod = await import("openai");
+  return mod.OpenAI || mod.default;
+}
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
     throw new Error("Embeddings must have same dimensions");
@@ -858,19 +982,18 @@ function cosineSimilarity(a, b) {
   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;
 }
-function createEmbeddingService(config) {
-  const OpenAI2 = openaiModule.OpenAI || openaiModule.default;
-  const client = new OpenAI2({ apiKey: config.apiKey });
+async function createEmbeddingService(config) {
+  const OpenAI = await getOpenAIClass();
+  const client = new OpenAI({ apiKey: config.apiKey });
   const model = config.model || DEFAULT_MODEL;
   const dimensions = config.dimensions || DEFAULT_DIMENSIONS;
   function truncateText(text) {
@@ -878,14 +1001,16 @@ function createEmbeddingService(config) {
       return text;
     }
     const truncated = text.substring(0, MAX_INPUT_LENGTH);
-    const lastNewline = truncated.lastIndexOf(`
-`);
+    const lastNewline = truncated.lastIndexOf("\n");
     if (lastNewline > MAX_INPUT_LENGTH * 0.8) {
       return truncated.substring(0, lastNewline);
     }
     return truncated;
   }
   return {
+    /**
+     * Generate embedding for a single text
+     */
     async generate(text) {
       const truncated = truncateText(text);
       const response = await client.embeddings.create({
@@ -895,6 +1020,9 @@ function createEmbeddingService(config) {
       });
       return response.data[0].embedding;
     },
+    /**
+     * Generate embeddings for multiple texts
+     */
     async generateBatch(texts) {
       const truncated = texts.map((t) => truncateText(t));
       const response = await client.embeddings.create({
@@ -904,6 +1032,10 @@ function createEmbeddingService(config) {
       });
       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) {
@@ -917,13 +1049,24 @@ function createEmbeddingService(config) {
         parts.push(`Stack Trace:
 ${errorStack}`);
       }
-      const text = parts.join(`
-`);
-      return this.generate(text);
+      const text = parts.join("\n");
+      const truncated = truncateText(text);
+      const response = await client.embeddings.create({
+        model,
+        input: truncated,
+        dimensions
+      });
+      return response.data[0].embedding;
     },
+    /**
+     * Get embedding dimensions
+     */
     getDimensions() {
       return dimensions;
     },
+    /**
+     * Get model name
+     */
     getModel() {
       return model;
     }
@@ -935,19 +1078,23 @@ var EmbeddingService = {
 };
 
 // src/cloud/client.ts
+async function getSupabaseCreateClient() {
+  const mod = await import("@supabase/supabase-js");
+  return mod.createClient || mod.default?.createClient;
+}
 function mapToKnowledgeEntry(row) {
   return {
     id: row.id,
     errorHash: row.error_hash,
     errorType: row.error_type,
     errorMessage: row.error_message,
-    errorStack: row.error_stack || undefined,
+    errorStack: row.error_stack || void 0,
     language: row.language,
-    framework: row.framework || undefined,
-    dependencies: row.dependencies || undefined,
+    framework: row.framework || void 0,
+    dependencies: row.dependencies || void 0,
     resolutionDescription: row.resolution_description,
-    resolutionCode: row.resolution_code || undefined,
-    resolutionSteps: row.resolution_steps || undefined,
+    resolutionCode: row.resolution_code || void 0,
+    resolutionSteps: row.resolution_steps || void 0,
     contributorId: row.contributor_id,
     upvotes: row.upvotes || 0,
     downvotes: row.downvotes || 0,
@@ -955,15 +1102,16 @@ function mapToKnowledgeEntry(row) {
     createdAt: row.created_at,
     updatedAt: row.updated_at,
     isVerified: row.is_verified || false,
-    similarity: row.similarity || undefined
+    similarity: row.similarity || void 0
   };
 }
 async function createCloudClient(config) {
-  const supabase = supabaseJs.createClient(config.supabaseUrl, config.supabaseAnonKey);
+  const createClient = await getSupabaseCreateClient();
+  const supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
   let embedding = null;
   if (config.openaiApiKey) {
     try {
-      embedding = createEmbeddingService({ apiKey: config.openaiApiKey });
+      embedding = await createEmbeddingService({ apiKey: config.openaiApiKey });
     } catch (err) {
       console.warn("[FixHive] Failed to initialize embedding service:", err);
     }
@@ -1167,6 +1315,9 @@ var CloudClient = {
 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: {
@@ -1195,6 +1346,9 @@ 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: {
@@ -1230,6 +1384,9 @@ 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: {
@@ -1248,6 +1405,9 @@ 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: {
@@ -1265,6 +1425,9 @@ 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: {
@@ -1279,6 +1442,9 @@ 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: {},
@@ -1300,6 +1466,9 @@ 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: {
@@ -1334,8 +1503,7 @@ ${r.resolutionCode}
     if (r.resolutionSteps?.length) {
       entry += `
 **Steps:**
-${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join(`
-`)}
+${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join("\n")}
 `;
     }
     entry += `
@@ -1343,8 +1511,7 @@ ${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join(`
 
 ---`;
     return entry;
-  }).join(`
-`);
+  }).join("\n");
   return `${header}
 ${entries}
 
@@ -1355,8 +1522,9 @@ 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(`
-`)}
+${errors.map(
+    (e) => `| ${e.id.slice(0, 8)} | ${e.errorType} | ${e.status} | ${e.errorMessage.slice(0, 50)}... |`
+  ).join("\n")}
 `;
   return `${header}
 ${table}
@@ -1366,7 +1534,8 @@ Use \`fixhive_resolve <id>\` to mark as resolved and share solutions.`;
 
 // src/plugin/index.ts
 var DEFAULT_CONFIG = {
-  cacheExpirationMs: 3600000,
+  cacheExpirationMs: 36e5,
+  // 1 hour
   embeddingModel: "text-embedding-3-small",
   embeddingDimensions: 1536,
   similarityThreshold: 0.7,
@@ -1408,9 +1577,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,
@@ -1420,7 +1589,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 : undefined;
+        const sanitizedErrorStack = detection.errorStack ? privacyFilter.sanitize(detection.errorStack, filterContext).sanitized : void 0;
         localStore.createErrorRecord({
           errorType: detection.errorType,
           errorMessage: sanitizedErrorMessage,
@@ -1429,6 +1598,7 @@ 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) {
@@ -1441,7 +1611,10 @@ 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) {
@@ -1451,22 +1624,24 @@ 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(`
-`)}
+${unresolvedErrors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 100)}...`).join("\n")}
 
 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)
   };
 };
@@ -1489,8 +1664,7 @@ 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(`
-`)}
+${errors.map((e) => `- [${e.id.slice(0, 8)}] ${e.errorType}: ${e.errorMessage.slice(0, 80)}...`).join("\n")}
 
 *Cloud features disabled. Set FIXHIVE_SUPABASE_URL and FIXHIVE_SUPABASE_KEY to enable.*`;
       }
@@ -1549,7 +1723,7 @@ function detectLanguage(directory) {
       return lang;
     }
   }
-  return;
+  return void 0;
 }
 function detectFramework(directory) {
   const pkgPath = join(directory, "package.json");
@@ -1557,61 +1731,54 @@ 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 {}
+      if (content.includes("django")) return "django";
+      if (content.includes("flask")) return "flask";
+      if (content.includes("fastapi")) return "fastapi";
+    } catch {
+    }
   }
-  return;
+  return void 0;
 }
 var plugin_default = FixHivePlugin;
 export {
-  shortHash,
-  sha256,
-  runMigrations,
-  normalizeErrorContent,
-  generateSessionHash,
-  generateErrorFingerprint,
-  generateContributorId,
-  fingerprintsMatch,
-  defaultPrivacyFilter,
-  defaultErrorDetector,
-  plugin_default as default,
-  createPrivacyFilter,
-  createLocalStore,
-  createFilterContext,
-  createErrorDetector,
-  createEmbeddingService,
-  createCloudClient,
-  cosineSimilarity,
-  calculateStringSimilarity,
-  PrivacyFilter,
-  LocalStore,
-  FixHivePlugin,
-  ErrorDetector,
+  CloudClient,
   EmbeddingService,
-  CloudClient
+  ErrorDetector,
+  FixHivePlugin,
+  LocalStore,
+  PrivacyFilter,
+  calculateStringSimilarity,
+  cosineSimilarity,
+  createCloudClient,
+  createEmbeddingService,
+  createErrorDetector,
+  createFilterContext,
+  createLocalStore,
+  createPrivacyFilter,
+  plugin_default as default,
+  defaultErrorDetector,
+  defaultPrivacyFilter,
+  fingerprintsMatch,
+  generateContributorId,
+  generateErrorFingerprint,
+  generateSessionHash,
+  normalizeErrorContent,
+  runMigrations,
+  sha256,
+  shortHash
 };
+//# sourceMappingURL=index.js.map