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

package/dist/index.js

@@ -1,22 +1,4 @@
 // @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";
@@ -175,42 +157,9 @@ var DEFAULT_FILTER_RULES = [
     priority: 65
   }
 ];
-
-class PrivacyFilter {
-  rules;
-  constructor(customRules) {
-    this.rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort((a, b) => b.priority - a.priority);
-  }
-  sanitize(content, context) {
-    let result = content;
-    const appliedFilters = [];
-    let totalRedacted = 0;
-    for (const rule of this.rules) {
-      const before = result;
-      if (typeof rule.replacement === "function") {
-        result = result.replace(rule.pattern, rule.replacement);
-      } else {
-        result = result.replace(rule.pattern, rule.replacement);
-      }
-      if (result !== before) {
-        const matches = before.match(rule.pattern);
-        if (matches) {
-          totalRedacted += matches.length;
-          appliedFilters.push(rule.name);
-        }
-      }
-    }
-    if (context) {
-      result = this.generalizePaths(result, context);
-    }
-    return {
-      original: content,
-      sanitized: result,
-      redactedCount: totalRedacted,
-      appliedFilters: [...new Set(appliedFilters)]
-    };
-  }
-  generalizePaths(content, context) {
+function createPrivacyFilter(customRules) {
+  const rules = [...DEFAULT_FILTER_RULES, ...customRules || []].sort((a, b) => b.priority - a.priority);
+  function generalizePaths(content, context) {
     let result = content;
     if (context.projectRoot) {
       const escapedRoot = context.projectRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -224,35 +173,69 @@ class PrivacyFilter {
     result = result.replace(/site-packages\/[\w.-]+\//g, "site-packages/<PKG>/");
     return result;
   }
-  addRule(rule) {
-    this.rules.push(rule);
-    this.rules.sort((a, b) => b.priority - a.priority);
-  }
-  removeRule(name) {
-    const index = this.rules.findIndex((r) => r.name === name);
-    if (index !== -1) {
-      this.rules.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-  getRules() {
-    return this.rules;
-  }
-  containsSensitiveData(content) {
-    for (const rule of this.rules) {
-      if (rule.category === "secret") {
-        rule.pattern.lastIndex = 0;
-        const hasSensitiveData = rule.pattern.test(content);
-        rule.pattern.lastIndex = 0;
-        if (hasSensitiveData) {
-          return true;
+  return {
+    sanitize(content, context) {
+      let result = content;
+      const appliedFilters = [];
+      let totalRedacted = 0;
+      for (const rule of rules) {
+        const before = result;
+        if (typeof rule.replacement === "function") {
+          result = result.replace(rule.pattern, rule.replacement);
+        } else {
+          result = result.replace(rule.pattern, rule.replacement);
+        }
+        if (result !== before) {
+          const matches = before.match(rule.pattern);
+          if (matches) {
+            totalRedacted += matches.length;
+            appliedFilters.push(rule.name);
+          }
+        }
+      }
+      if (context) {
+        result = generalizePaths(result, context);
+      }
+      return {
+        original: content,
+        sanitized: result,
+        redactedCount: totalRedacted,
+        appliedFilters: [...new Set(appliedFilters)]
+      };
+    },
+    addRule(rule) {
+      rules.push(rule);
+      rules.sort((a, b) => b.priority - a.priority);
+    },
+    removeRule(name) {
+      const index = rules.findIndex((r) => r.name === name);
+      if (index !== -1) {
+        rules.splice(index, 1);
+        return true;
+      }
+      return false;
+    },
+    getRules() {
+      return rules;
+    },
+    containsSensitiveData(content) {
+      for (const rule of rules) {
+        if (rule.category === "secret") {
+          rule.pattern.lastIndex = 0;
+          const hasSensitiveData = rule.pattern.test(content);
+          rule.pattern.lastIndex = 0;
+          if (hasSensitiveData) {
+            return true;
+          }
         }
       }
+      return false;
     }
-    return false;
-  }
+  };
 }
+var PrivacyFilter = {
+  create: createPrivacyFilter
+};
 function createFilterContext(projectDirectory) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
   return {
@@ -267,7 +250,7 @@ function createFilterContext(projectDirectory) {
     ])
   };
 }
-var defaultPrivacyFilter = new PrivacyFilter;
+var defaultPrivacyFilter = createPrivacyFilter();
 
 // src/core/error-detector.ts
 var ERROR_PATTERNS = {
@@ -345,70 +328,12 @@ var EXIT_CODE_SEVERITY = {
   139: "critical",
   143: "warning"
 };
-
-class ErrorDetector {
-  privacyFilter;
-  constructor(privacyFilter) {
-    this.privacyFilter = privacyFilter || new PrivacyFilter;
-  }
-  detect(toolOutput) {
-    const signals = [];
-    const combinedOutput = `${toolOutput.output || ""}
-${toolOutput.stderr || ""}`;
-    if (toolOutput.exitCode !== undefined && toolOutput.exitCode !== 0) {
-      const severity2 = EXIT_CODE_SEVERITY[toolOutput.exitCode] || "error";
-      signals.push({
-        type: "exit_code",
-        weight: 0.9,
-        value: toolOutput.exitCode,
-        description: `Non-zero exit code: ${toolOutput.exitCode} (${severity2})`
-      });
-    }
-    if (toolOutput.stderr && toolOutput.stderr.trim().length > 0) {
-      const hasErrorKeywords = this.containsErrorKeywords(toolOutput.stderr);
-      const stderrWeight = hasErrorKeywords ? 0.85 : 0.4;
-      signals.push({
-        type: "stderr",
-        weight: stderrWeight,
-        value: toolOutput.stderr.substring(0, 500),
-        description: hasErrorKeywords ? "Stderr with error keywords" : "Stderr output present"
-      });
-    }
-    const patternMatches = this.detectErrorPatterns(combinedOutput);
-    signals.push(...patternMatches);
-    const stackTrace = this.detectStackTrace(combinedOutput);
-    if (stackTrace.hasStackTrace) {
-      signals.push({
-        type: "stack_trace",
-        weight: 0.95,
-        value: stackTrace.frames.slice(0, 5).join(`
-`),
-        description: `${stackTrace.language} stack trace detected`
-      });
-    }
-    const confidence = this.calculateConfidence(signals);
-    const detected = confidence >= 0.5;
-    const errorType = this.classifyErrorType(signals, combinedOutput);
-    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) : undefined;
-    const sanitizedOutput = this.privacyFilter.sanitize(combinedOutput.substring(0, 5000));
-    return {
-      detected,
-      confidence,
-      errorType,
-      severity,
-      signals,
-      errorMessage: sanitizedMessage.sanitized,
-      errorStack: sanitizedStack?.sanitized,
-      rawOutput: sanitizedOutput.sanitized
-    };
-  }
-  containsErrorKeywords(content) {
+function createErrorDetector(privacyFilter) {
+  const filter = privacyFilter || createPrivacyFilter();
+  function containsErrorKeywords(content) {
     return ERROR_PATTERNS.universal.some((p) => p.test(content));
   }
-  detectErrorPatterns(content) {
+  function detectErrorPatterns(content) {
     const signals = [];
     const weights = {
       prefixed: 0.85,
@@ -436,7 +361,7 @@ ${toolOutput.stderr || ""}`;
     }
     return signals;
   }
-  detectStackTrace(content) {
+  function detectStackTrace(content) {
     for (const [language, pattern] of Object.entries(STACK_TRACE_PATTERNS)) {
       const globalPattern = new RegExp(pattern.source, "gm");
       const matches = content.match(globalPattern);
@@ -454,7 +379,7 @@ ${toolOutput.stderr || ""}`;
       frames: []
     };
   }
-  calculateConfidence(signals) {
+  function calculateConfidence(signals) {
     if (signals.length === 0)
       return 0;
     const totalWeight = signals.reduce((sum, s) => sum + s.weight, 0);
@@ -462,7 +387,7 @@ ${toolOutput.stderr || ""}`;
     const multiplier = Math.min(1.2, 1 + signals.length * 0.05);
     return Math.min(1, avgWeight * multiplier);
   }
-  classifyErrorType(signals, content) {
+  function classifyErrorType(signals, content) {
     if (ERROR_PATTERNS.build.some((p) => p.test(content)))
       return "build";
     if (ERROR_PATTERNS.package.some((p) => p.test(content)))
@@ -484,7 +409,7 @@ ${toolOutput.stderr || ""}`;
       return "runtime";
     return "unknown";
   }
-  determineSeverity(signals, exitCode) {
+  function determineSeverity(signals, exitCode) {
     if (exitCode !== undefined && EXIT_CODE_SEVERITY[exitCode]) {
       return EXIT_CODE_SEVERITY[exitCode];
     }
@@ -495,14 +420,18 @@ ${toolOutput.stderr || ""}`;
       return "error";
     return "warning";
   }
-  extractErrorDetails(output) {
+  function 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);
+  }
+  function extractErrorDetails(output) {
     const lines = output.split(`
 `);
     let message = "";
     let stack = "";
     let inStack = false;
     for (const line of lines) {
-      if (this.isErrorLine(line) && !message) {
+      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/))) {
@@ -523,12 +452,67 @@ ${toolOutput.stderr || ""}`;
       stack: stack || undefined
     };
   }
-  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);
-  }
+  return {
+    detect(toolOutput) {
+      const signals = [];
+      const combinedOutput = `${toolOutput.output || ""}
+${toolOutput.stderr || ""}`;
+      if (toolOutput.exitCode !== undefined && toolOutput.exitCode !== 0) {
+        const severity2 = EXIT_CODE_SEVERITY[toolOutput.exitCode] || "error";
+        signals.push({
+          type: "exit_code",
+          weight: 0.9,
+          value: toolOutput.exitCode,
+          description: `Non-zero exit code: ${toolOutput.exitCode} (${severity2})`
+        });
+      }
+      if (toolOutput.stderr && toolOutput.stderr.trim().length > 0) {
+        const hasErrorKeywords = containsErrorKeywords(toolOutput.stderr);
+        const stderrWeight = hasErrorKeywords ? 0.85 : 0.4;
+        signals.push({
+          type: "stderr",
+          weight: stderrWeight,
+          value: toolOutput.stderr.substring(0, 500),
+          description: hasErrorKeywords ? "Stderr with error keywords" : "Stderr output present"
+        });
+      }
+      const patternMatches = detectErrorPatterns(combinedOutput);
+      signals.push(...patternMatches);
+      const stackTrace = detectStackTrace(combinedOutput);
+      if (stackTrace.hasStackTrace) {
+        signals.push({
+          type: "stack_trace",
+          weight: 0.95,
+          value: stackTrace.frames.slice(0, 5).join(`
+`),
+          description: `${stackTrace.language} stack trace detected`
+        });
+      }
+      const confidence = calculateConfidence(signals);
+      const detected = confidence >= 0.5;
+      const errorType = classifyErrorType(signals, combinedOutput);
+      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));
+      return {
+        detected,
+        confidence,
+        errorType,
+        severity,
+        signals,
+        errorMessage: sanitizedMessage.sanitized,
+        errorStack: sanitizedStack?.sanitized,
+        rawOutput: sanitizedOutput.sanitized
+      };
+    }
+  };
 }
-var defaultErrorDetector = new ErrorDetector;
+var ErrorDetector = {
+  create: createErrorDetector
+};
+var defaultErrorDetector = createErrorDetector();
 
 // src/storage/local-store.ts
 import Database from "better-sqlite3";
@@ -669,246 +653,227 @@ var MIGRATIONS = [
 ];
 
 // src/storage/local-store.ts
-class LocalStore {
-  db;
-  constructor(projectDirectory) {
-    const dbPath = `${projectDirectory}/.fixhive/fixhive.db`;
-    const dir = dirname(dbPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    runMigrations(this.db);
-  }
-  createErrorRecord(data) {
-    const id = uuidv4();
-    const errorHash = generateErrorFingerprint(data.errorMessage, data.errorStack);
-    const stmt = this.db.prepare(`
-      INSERT INTO error_records (
-        id, error_hash, error_type, error_message, error_stack,
-        language, framework, tool_name, tool_input, session_id, status
-      ) VALUES (
-        @id, @errorHash, @errorType, @errorMessage, @errorStack,
-        @language, @framework, @toolName, @toolInput, @sessionId, 'unresolved'
-      )
-    `);
-    stmt.run({
-      id,
-      errorHash,
-      errorType: data.errorType,
-      errorMessage: data.errorMessage,
-      errorStack: data.errorStack || null,
-      language: data.language || null,
-      framework: data.framework || null,
-      toolName: data.toolName,
-      toolInput: JSON.stringify(data.toolInput),
-      sessionId: data.sessionId
-    });
-    this.incrementStat("total_errors");
-    return this.getErrorById(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;
+var ALLOWED_STATS = [
+  "total_errors",
+  "resolved_errors",
+  "uploaded_errors",
+  "queries_made"
+];
+function rowToRecord(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 || 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 || undefined,
+    resolutionCode: row.resolution_code || undefined,
+    createdAt: row.created_at,
+    resolvedAt: row.resolved_at || undefined,
+    uploadedAt: row.uploaded_at || undefined,
+    cloudKnowledgeId: row.cloud_knowledge_id || undefined
+  };
+}
+function createLocalStore(projectDirectory) {
+  const dbPath = `${projectDirectory}/.fixhive/fixhive.db`;
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  getSessionErrors(sessionId, options) {
-    let query = "SELECT * FROM error_records WHERE session_id = ?";
-    const params = [sessionId];
-    if (options?.status) {
-      query += " AND status = ?";
-      params.push(options.status);
-    }
-    query += " ORDER BY created_at DESC";
-    if (options?.limit) {
-      query += " LIMIT ?";
-      params.push(options.limit);
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  function incrementStat(stat) {
+    if (!ALLOWED_STATS.includes(stat)) {
+      throw new Error(`Invalid stat name: ${stat}. Allowed: ${ALLOWED_STATS.join(", ")}`);
     }
-    const stmt = this.db.prepare(query);
-    return stmt.all(...params).map((row) => this.rowToRecord(row));
-  }
-  getUnresolvedErrors(sessionId) {
-    return this.getSessionErrors(sessionId, { status: "unresolved" });
-  }
-  getRecentErrors(limit = 10) {
-    const stmt = this.db.prepare("SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?");
-    return stmt.all(limit).map((row) => this.rowToRecord(row));
+    const stmt = db.prepare(`UPDATE usage_stats SET ${stat} = ${stat} + 1 WHERE id = 1`);
+    stmt.run();
   }
-  markResolved(id, data) {
-    const stmt = this.db.prepare(`
-      UPDATE error_records
-      SET status = 'resolved',
-          resolution = ?,
-          resolution_code = ?,
-          resolved_at = datetime('now')
-      WHERE id = ?
-    `);
-    const result = stmt.run(data.resolution, data.resolutionCode || null, id);
-    if (result.changes > 0) {
-      this.incrementStat("resolved_errors");
+  return {
+    createErrorRecord(data) {
+      const id = uuidv4();
+      const errorHash = generateErrorFingerprint(data.errorMessage, data.errorStack);
+      const stmt = db.prepare(`
+        INSERT INTO error_records (
+          id, error_hash, error_type, error_message, error_stack,
+          language, framework, tool_name, tool_input, session_id, status
+        ) VALUES (
+          @id, @errorHash, @errorType, @errorMessage, @errorStack,
+          @language, @framework, @toolName, @toolInput, @sessionId, 'unresolved'
+        )
+      `);
+      stmt.run({
+        id,
+        errorHash,
+        errorType: data.errorType,
+        errorMessage: data.errorMessage,
+        errorStack: data.errorStack || null,
+        language: data.language || null,
+        framework: data.framework || null,
+        toolName: data.toolName,
+        toolInput: JSON.stringify(data.toolInput),
+        sessionId: data.sessionId
+      });
+      incrementStat("total_errors");
       return this.getErrorById(id);
+    },
+    getErrorById(id) {
+      const stmt = db.prepare("SELECT * FROM error_records WHERE id = ?");
+      const row = stmt.get(id);
+      return row ? rowToRecord(row) : null;
+    },
+    getSessionErrors(sessionId, options) {
+      let query = "SELECT * FROM error_records WHERE session_id = ?";
+      const params = [sessionId];
+      if (options?.status) {
+        query += " AND status = ?";
+        params.push(options.status);
+      }
+      query += " ORDER BY created_at DESC";
+      if (options?.limit) {
+        query += " LIMIT ?";
+        params.push(options.limit);
+      }
+      const stmt = db.prepare(query);
+      return stmt.all(...params).map((row) => rowToRecord(row));
+    },
+    getUnresolvedErrors(sessionId) {
+      return this.getSessionErrors(sessionId, { status: "unresolved" });
+    },
+    getRecentErrors(limit = 10) {
+      const stmt = db.prepare("SELECT * FROM error_records ORDER BY created_at DESC LIMIT ?");
+      return stmt.all(limit).map((row) => rowToRecord(row));
+    },
+    markResolved(id, data) {
+      const stmt = db.prepare(`
+        UPDATE error_records
+        SET status = 'resolved',
+            resolution = ?,
+            resolution_code = ?,
+            resolved_at = datetime('now')
+        WHERE id = ?
+      `);
+      const result = stmt.run(data.resolution, data.resolutionCode || null, id);
+      if (result.changes > 0) {
+        incrementStat("resolved_errors");
+        return this.getErrorById(id);
+      }
+      return null;
+    },
+    markUploaded(id, cloudKnowledgeId) {
+      const stmt = db.prepare(`
+        UPDATE error_records
+        SET status = 'uploaded',
+            cloud_knowledge_id = ?,
+            uploaded_at = datetime('now')
+        WHERE id = ?
+      `);
+      const result = stmt.run(cloudKnowledgeId, id);
+      if (result.changes > 0) {
+        incrementStat("uploaded_errors");
+      }
+    },
+    findSimilarErrors(errorHash) {
+      const stmt = db.prepare("SELECT * FROM error_records WHERE error_hash = ? ORDER BY created_at DESC");
+      return stmt.all(errorHash).map((row) => rowToRecord(row));
+    },
+    getCachedResults(errorHash) {
+      const stmt = db.prepare(`
+        SELECT results FROM query_cache
+        WHERE error_hash = ? AND expires_at > datetime('now')
+        ORDER BY created_at DESC LIMIT 1
+      `);
+      const row = stmt.get(errorHash);
+      if (row) {
+        return JSON.parse(row.results);
+      }
+      return null;
+    },
+    cacheResults(errorHash, results, expirationMs = 3600000) {
+      const id = uuidv4();
+      const expiresAt = new Date(Date.now() + expirationMs).toISOString();
+      const stmt = db.prepare(`
+        INSERT INTO query_cache (id, error_hash, results, expires_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      stmt.run(id, errorHash, JSON.stringify(results), expiresAt);
+      incrementStat("queries_made");
+    },
+    clearExpiredCache() {
+      const stmt = db.prepare("DELETE FROM query_cache WHERE expires_at <= datetime('now')");
+      const result = stmt.run();
+      return result.changes;
+    },
+    getStats() {
+      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,
+        resolvedErrors: row.resolved_errors,
+        uploadedErrors: row.uploaded_errors
+      };
+    },
+    getPreference(key) {
+      const stmt = db.prepare("SELECT value FROM user_preferences WHERE key = ?");
+      const row = stmt.get(key);
+      return row?.value || null;
+    },
+    setPreference(key, value) {
+      const stmt = db.prepare(`
+        INSERT OR REPLACE INTO user_preferences (key, value) VALUES (?, ?)
+      `);
+      stmt.run(key, value);
+    },
+    close() {
+      db.close();
+    },
+    getDatabase() {
+      return db;
     }
-    return null;
-  }
-  markUploaded(id, cloudKnowledgeId) {
-    const stmt = this.db.prepare(`
-      UPDATE error_records
-      SET status = 'uploaded',
-          cloud_knowledge_id = ?,
-          uploaded_at = datetime('now')
-      WHERE id = ?
-    `);
-    const result = stmt.run(cloudKnowledgeId, id);
-    if (result.changes > 0) {
-      this.incrementStat("uploaded_errors");
-    }
-  }
-  findSimilarErrors(errorHash) {
-    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));
-  }
-  getCachedResults(errorHash) {
-    const stmt = this.db.prepare(`
-      SELECT results FROM query_cache
-      WHERE error_hash = ? AND expires_at > datetime('now')
-      ORDER BY created_at DESC LIMIT 1
-    `);
-    const row = stmt.get(errorHash);
-    if (row) {
-      return JSON.parse(row.results);
-    }
-    return null;
-  }
-  cacheResults(errorHash, results, expirationMs = 3600000) {
-    const id = uuidv4();
-    const expiresAt = new Date(Date.now() + expirationMs).toISOString();
-    const stmt = this.db.prepare(`
-      INSERT INTO query_cache (id, error_hash, results, expires_at)
-      VALUES (?, ?, ?, ?)
-    `);
-    stmt.run(id, errorHash, JSON.stringify(results), expiresAt);
-    this.incrementStat("queries_made");
-  }
-  clearExpiredCache() {
-    const stmt = this.db.prepare("DELETE FROM query_cache WHERE expires_at <= datetime('now')");
-    const result = stmt.run();
-    return result.changes;
-  }
-  getStats() {
-    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,
-      resolvedErrors: row.resolved_errors,
-      uploadedErrors: row.uploaded_errors
-    };
-  }
-  static ALLOWED_STATS = [
-    "total_errors",
-    "resolved_errors",
-    "uploaded_errors",
-    "queries_made"
-  ];
-  incrementStat(stat) {
-    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();
-  }
-  getPreference(key) {
-    const stmt = this.db.prepare("SELECT value FROM user_preferences WHERE key = ?");
-    const row = stmt.get(key);
-    return row?.value || null;
-  }
-  setPreference(key, value) {
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO user_preferences (key, value) VALUES (?, ?)
-    `);
-    stmt.run(key, value);
-  }
-  rowToRecord(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 || 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 || undefined,
-      resolutionCode: row.resolution_code || undefined,
-      createdAt: row.created_at,
-      resolvedAt: row.resolved_at || undefined,
-      uploadedAt: row.uploaded_at || undefined,
-      cloudKnowledgeId: row.cloud_knowledge_id || undefined
-    };
-  }
-  close() {
-    this.db.close();
-  }
-  getDatabase() {
-    return this.db;
-  }
+  };
 }
+var LocalStore = {
+  create: createLocalStore
+};
+
+// src/cloud/client.ts
+import { createClient } from "@supabase/supabase-js";
 
 // src/cloud/embedding.ts
 import OpenAI from "openai";
 var DEFAULT_MODEL = "text-embedding-3-small";
 var DEFAULT_DIMENSIONS = 1536;
 var MAX_INPUT_LENGTH = 30000;
-
-class EmbeddingService {
-  client;
-  model;
-  dimensions;
-  constructor(apiKey, model, dimensions) {
-    this.client = new OpenAI({ apiKey });
-    this.model = model || DEFAULT_MODEL;
-    this.dimensions = dimensions || DEFAULT_DIMENSIONS;
-  }
-  async generate(text) {
-    const truncated = this.truncateText(text);
-    const response = await this.client.embeddings.create({
-      model: this.model,
-      input: truncated,
-      dimensions: this.dimensions
-    });
-    return response.data[0].embedding;
-  }
-  async generateBatch(texts) {
-    const truncated = texts.map((t) => this.truncateText(t));
-    const response = await this.client.embeddings.create({
-      model: this.model,
-      input: truncated,
-      dimensions: this.dimensions
-    });
-    return response.data.map((d) => d.embedding);
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Embeddings must have same dimensions");
   }
-  async generateErrorEmbedding(errorMessage, errorStack, context) {
-    const parts = [];
-    if (context?.language) {
-      parts.push(`Language: ${context.language}`);
-    }
-    if (context?.framework) {
-      parts.push(`Framework: ${context.framework}`);
-    }
-    parts.push(`Error: ${errorMessage}`);
-    if (errorStack) {
-      parts.push(`Stack Trace:
-${errorStack}`);
-    }
-    const text = parts.join(`
-`);
-    return this.generate(text);
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
   }
-  truncateText(text) {
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0)
+    return 0;
+  return dotProduct / magnitude;
+}
+function createEmbeddingService(config) {
+  const client = new OpenAI({ apiKey: config.apiKey });
+  const model = config.model || DEFAULT_MODEL;
+  const dimensions = config.dimensions || DEFAULT_DIMENSIONS;
+  function truncateText(text) {
     if (text.length <= MAX_INPUT_LENGTH) {
       return text;
     }
@@ -920,43 +885,56 @@ ${errorStack}`);
     }
     return truncated;
   }
-  static cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-      throw new Error("Embeddings must have same dimensions");
-    }
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0;i < a.length; i++) {
-      dotProduct += a[i] * b[i];
-      normA += a[i] * a[i];
-      normB += b[i] * b[i];
+  return {
+    async generate(text) {
+      const truncated = truncateText(text);
+      const response = await client.embeddings.create({
+        model,
+        input: truncated,
+        dimensions
+      });
+      return response.data[0].embedding;
+    },
+    async generateBatch(texts) {
+      const truncated = texts.map((t) => truncateText(t));
+      const response = await client.embeddings.create({
+        model,
+        input: truncated,
+        dimensions
+      });
+      return response.data.map((d) => d.embedding);
+    },
+    async generateErrorEmbedding(errorMessage, errorStack, context) {
+      const parts = [];
+      if (context?.language) {
+        parts.push(`Language: ${context.language}`);
+      }
+      if (context?.framework) {
+        parts.push(`Framework: ${context.framework}`);
+      }
+      parts.push(`Error: ${errorMessage}`);
+      if (errorStack) {
+        parts.push(`Stack Trace:
+${errorStack}`);
+      }
+      const text = parts.join(`
+`);
+      return this.generate(text);
+    },
+    getDimensions() {
+      return dimensions;
+    },
+    getModel() {
+      return model;
     }
-    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-    if (magnitude === 0)
-      return 0;
-    return dotProduct / magnitude;
-  }
-  getDimensions() {
-    return this.dimensions;
-  }
-  getModel() {
-    return this.model;
-  }
-}
-function createEmbeddingService(config) {
-  return new EmbeddingService(config.apiKey, config.model, config.dimensions);
+  };
 }
+var EmbeddingService = {
+  create: createEmbeddingService,
+  cosineSimilarity
+};
 
 // src/cloud/client.ts
-var createClient;
-async function getCreateClient() {
-  if (!createClient) {
-    const supabase = await import("@supabase/supabase-js");
-    createClient = supabase.createClient;
-  }
-  return createClient;
-}
 function mapToKnowledgeEntry(row) {
   return {
     id: row.id,
@@ -981,12 +959,11 @@ function mapToKnowledgeEntry(row) {
   };
 }
 async function createCloudClient(config) {
-  const createClientFn = await getCreateClient();
-  const supabase = createClientFn(config.supabaseUrl, config.supabaseAnonKey);
+  const supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
   let embedding = null;
   if (config.openaiApiKey) {
     try {
-      embedding = new EmbeddingService(config.openaiApiKey);
+      embedding = createEmbeddingService({ apiKey: config.openaiApiKey });
     } catch (err) {
       console.warn("[FixHive] Failed to initialize embedding service:", err);
     }
@@ -1400,10 +1377,10 @@ 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 = createPrivacyFilter();
   const filterContext = createFilterContext(ctx.directory);
-  const errorDetector = new ErrorDetector(privacyFilter);
-  const localStore = new LocalStore(ctx.directory);
+  const errorDetector = createErrorDetector(privacyFilter);
+  const localStore = createLocalStore(ctx.directory);
   let cloudClient = null;
   if (config.supabaseUrl && config.supabaseAnonKey) {
     try {
@@ -1623,9 +1600,13 @@ export {
   defaultPrivacyFilter,
   defaultErrorDetector,
   plugin_default as default,
+  createPrivacyFilter,
+  createLocalStore,
   createFilterContext,
+  createErrorDetector,
   createEmbeddingService,
   createCloudClient,
+  cosineSimilarity,
   calculateStringSimilarity,
   PrivacyFilter,
   LocalStore,