@the-magic-tower/fixhive-opencode-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,1782 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/privacy-filter.ts
+var DEFAULT_FILTER_RULES = [
+  // =====================================
+  // SECRETS (Critical - Always Filter)
+  // =====================================
+  // AWS Keys
+  {
+    name: "aws_access_key",
+    category: "secret",
+    pattern: /\b(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}\b/g,
+    replacement: "[AWS_KEY_REDACTED]",
+    priority: 100
+  },
+  // OpenAI API Keys
+  {
+    name: "openai_key",
+    category: "secret",
+    pattern: /\b(sk-[a-zA-Z0-9]{20,})\b/g,
+    replacement: "[OPENAI_KEY_REDACTED]",
+    priority: 100
+  },
+  // GitHub Tokens
+  {
+    name: "github_token",
+    category: "secret",
+    pattern: /\b(gh[pousr]_[A-Za-z0-9_]{36,}|github_pat_[A-Za-z0-9_]{22,})\b/g,
+    replacement: "[GITHUB_TOKEN_REDACTED]",
+    priority: 100
+  },
+  // Google API Keys
+  {
+    name: "google_api_key",
+    category: "secret",
+    pattern: /\bAIza[0-9A-Za-z\-_]{35}\b/g,
+    replacement: "[GOOGLE_API_KEY_REDACTED]",
+    priority: 100
+  },
+  // Stripe Keys
+  {
+    name: "stripe_key",
+    category: "secret",
+    pattern: /\b(sk|pk|rk)_(live|test)_[0-9a-zA-Z]{24,}\b/g,
+    replacement: "[STRIPE_KEY_REDACTED]",
+    priority: 100
+  },
+  // JWT Tokens (limited length to prevent ReDoS)
+  {
+    name: "jwt_token",
+    category: "secret",
+    pattern: /\beyJ[A-Za-z0-9_-]{10,500}\.eyJ[A-Za-z0-9_-]{10,1000}\.[A-Za-z0-9_-]{10,500}/g,
+    replacement: "[JWT_REDACTED]",
+    priority: 100
+  },
+  // Bearer Tokens
+  {
+    name: "bearer_token",
+    category: "secret",
+    pattern: /\b(Bearer|Authorization:?\s*Bearer)\s+[\w\-._~+\/]+=*/gi,
+    replacement: "$1 [TOKEN_REDACTED]",
+    priority: 100
+  },
+  // Private Keys
+  {
+    name: "private_key",
+    category: "secret",
+    pattern: /-----BEGIN\s+(RSA|DSA|EC|OPENSSH|PGP)?\s*PRIVATE KEY-----[\s\S]*?-----END\s+(RSA|DSA|EC|OPENSSH|PGP)?\s*PRIVATE KEY-----/g,
+    replacement: "[PRIVATE_KEY_REDACTED]",
+    priority: 100
+  },
+  // Generic API Keys (context-based, limited length to prevent ReDoS)
+  {
+    name: "generic_api_key",
+    category: "secret",
+    pattern: /\b(api[_-]?key|apikey|api[_-]?secret)\s{0,5}[=:]\s{0,5}["']?[\w-]{20,200}["']?/gi,
+    replacement: "$1=[KEY_REDACTED]",
+    priority: 95
+  },
+  // Secret/Password assignments (limited length to prevent ReDoS)
+  {
+    name: "secret_assignment",
+    category: "secret",
+    pattern: /\b(password|passwd|pwd|secret|token|credential)\s{0,5}[=:]\s{0,5}["']?[^\s"']{8,200}["']?/gi,
+    replacement: "$1=[REDACTED]",
+    priority: 90
+  },
+  // =====================================
+  // IDENTITY (High Risk)
+  // =====================================
+  // Email Addresses
+  {
+    name: "email",
+    category: "identity",
+    pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+    replacement: "[EMAIL_REDACTED]",
+    priority: 80
+  },
+  // =====================================
+  // INFRASTRUCTURE (Medium Risk)
+  // =====================================
+  // Database Connection Strings
+  {
+    name: "db_connection",
+    category: "infrastructure",
+    pattern: /\b(mongodb|postgres|postgresql|mysql|redis|amqp):\/\/[^\s]+/gi,
+    replacement: "$1://[CONNECTION_REDACTED]",
+    priority: 85
+  },
+  // Internal URLs
+  {
+    name: "internal_url",
+    category: "infrastructure",
+    pattern: /\bhttps?:\/\/(?:[\w-]+\.)*(?:internal|corp|local|intranet|private)[\w.-]*(?::\d+)?(?:\/[^\s]*)?/gi,
+    replacement: "[INTERNAL_URL_REDACTED]",
+    priority: 75
+  },
+  // IP Addresses (except localhost and common dev IPs)
+  {
+    name: "ipv4",
+    category: "infrastructure",
+    pattern: /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g,
+    replacement: (match) => {
+      if (match === "127.0.0.1" || match === "0.0.0.0" || match.startsWith("192.168.")) {
+        return match;
+      }
+      return "[IP_REDACTED]";
+    },
+    priority: 70
+  },
+  // =====================================
+  // FILE PATHS (Context-dependent)
+  // =====================================
+  // Home Directory Paths (macOS)
+  {
+    name: "macos_home_path",
+    category: "path",
+    pattern: /\/Users\/[\w.-]+/g,
+    replacement: "~",
+    priority: 60
+  },
+  // Home Directory Paths (Linux)
+  {
+    name: "linux_home_path",
+    category: "path",
+    pattern: /\/home\/[\w.-]+/g,
+    replacement: "~",
+    priority: 60
+  },
+  // Home Directory Paths (Windows)
+  {
+    name: "windows_home_path",
+    category: "path",
+    pattern: /C:\\Users\\[\w.-]+/gi,
+    replacement: "~",
+    priority: 60
+  },
+  // =====================================
+  // ENVIRONMENT (Medium Risk)
+  // =====================================
+  // Sensitive Environment Variables
+  {
+    name: "env_var_value",
+    category: "environment",
+    pattern: /\b([A-Z_][A-Z0-9_]*)\s*=\s*["']?([^\s"']+)["']?/g,
+    replacement: (match, name, _value) => {
+      const sensitivePatterns = [
+        "API_KEY",
+        "SECRET",
+        "PASSWORD",
+        "TOKEN",
+        "CREDENTIAL",
+        "PRIVATE",
+        "AUTH",
+        "DATABASE_URL",
+        "REDIS_URL",
+        "OPENAI",
+        "STRIPE",
+        "AWS"
+      ];
+      if (sensitivePatterns.some((s) => name.toUpperCase().includes(s))) {
+        return `${name}=[REDACTED]`;
+      }
+      return match;
+    },
+    priority: 65
+  }
+];
+var PrivacyFilter = class {
+  rules;
+  constructor(customRules) {
+    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 = [];
+    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)]
+    };
+  }
+  /**
+   * Generalize file paths while keeping meaningful structure
+   */
+  generalizePaths(content, context) {
+    let result = content;
+    if (context.projectRoot) {
+      const escapedRoot = context.projectRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      result = result.replace(new RegExp(escapedRoot, "g"), "<PROJECT>");
+    }
+    for (const [fullPath, alias] of context.commonPaths) {
+      const escapedPath = fullPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      result = result.replace(new RegExp(escapedPath, "g"), alias);
+    }
+    result = result.replace(/node_modules\/(?:@[\w.-]+\/)?[\w.-]+\//g, "node_modules/<PKG>/");
+    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) {
+      this.rules.splice(index, 1);
+      return true;
+    }
+    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") {
+        rule.pattern.lastIndex = 0;
+        const hasSensitiveData = rule.pattern.test(content);
+        rule.pattern.lastIndex = 0;
+        if (hasSensitiveData) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+};
+function createFilterContext(projectDirectory) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
+  return {
+    projectRoot: projectDirectory,
+    homeDir,
+    commonPaths: /* @__PURE__ */ new Map([
+      ["/usr/local/lib/", "<LIB>/"],
+      ["/usr/lib/", "<LIB>/"],
+      ["/var/log/", "<LOG>/"],
+      ["/tmp/", "<TMP>/"],
+      ["/etc/", "<ETC>/"]
+    ])
+  };
+}
+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,
+    /\b(denied|rejected|refused|forbidden)\b/i,
+    /\b(not found|missing|undefined|null pointer)\b/i,
+    /\b(invalid|illegal|malformed|corrupt)\b/i,
+    /\b(timeout|timed out|connection refused)\b/i,
+    /\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,
+    /yarn error/m,
+    /pnpm error/m,
+    /pip error/m,
+    /cargo error/m,
+    /ModuleNotFoundError:/m,
+    /ImportError:/m,
+    /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,
+    /ENOTFOUND/m,
+    /getaddrinfo ENOTFOUND/m,
+    /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 = {
+  javascript: /^\s+at\s+(?:(?:async\s+)?[\w.<>]+\s+\()?(?:[\w/\\.:-]+:\d+:\d+|native|<anonymous>)\)?$/m,
+  python: /^\s+File\s+"[^"]+",\s+line\s+\d+/m,
+  java: /^\s+at\s+[\w.$]+\([\w.]+:\d+\)$/m,
+  golang: /^goroutine\s+\d+\s+\[.+\]:/m,
+  rust: /^\s+\d+:\s+0x[\da-f]+\s+-\s+.+$/m,
+  ruby: /^\s+from\s+[\w/\\.]+:\d+:in\s+`.+'$/m,
+  php: /^#\d+\s+[\w/\\.]+\(\d+\):\s+[\w\\]+/m,
+  csharp: /^\s+at\s+[\w.<>]+\s+in\s+[\w/\\.]+:line\s+\d+$/m
+};
+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 {
+  privacyFilter;
+  constructor(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) {
+      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("\n"),
+        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) : void 0;
+    const sanitizedOutput = this.privacyFilter.sanitize(combinedOutput.substring(0, 5e3));
+    return {
+      detected,
+      confidence,
+      errorType,
+      severity,
+      signals,
+      errorMessage: sanitizedMessage.sanitized,
+      errorStack: sanitizedStack?.sanitized,
+      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 = {
+      prefixed: 0.85,
+      build: 0.8,
+      package: 0.75,
+      permission: 0.8,
+      network: 0.75,
+      test: 0.7
+    };
+    for (const [category, patterns] of Object.entries(ERROR_PATTERNS)) {
+      if (category === "universal") continue;
+      for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+          signals.push({
+            type: "pattern",
+            weight: weights[category] || 0.7,
+            value: match[0].substring(0, 200),
+            description: `Matched ${category} pattern: ${pattern.source.substring(0, 50)}`
+          });
+          break;
+        }
+      }
+    }
+    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");
+      const matches = content.match(globalPattern);
+      if (matches && matches.length >= 2) {
+        return {
+          hasStackTrace: true,
+          language,
+          frames: matches
+        };
+      }
+    }
+    return {
+      hasStackTrace: false,
+      language: null,
+      frames: []
+    };
+  }
+  /**
+   * Calculate confidence score from signals
+   */
+  calculateConfidence(signals) {
+    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";
+    const hasStackTrace = signals.some((s) => s.type === "stack_trace");
+    if (hasStackTrace) return "runtime";
+    return "unknown";
+  }
+  /**
+   * Determine severity from signals and exit code
+   */
+  determineSeverity(signals, 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";
+    return "warning";
+  }
+  /**
+   * Extract error message and stack from output
+   */
+  extractErrorDetails(output) {
+    const lines = output.split("\n");
+    let message = "";
+    let stack = "";
+    let inStack = false;
+    for (const line of lines) {
+      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";
+      }
+    }
+    if (!message) {
+      for (const line of lines) {
+        if (line.trim()) {
+          message = line.trim();
+          break;
+        }
+      }
+    }
+    return {
+      message: message || output.substring(0, 500),
+      stack: stack || void 0
+    };
+  }
+  /**
+   * 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();
+
+// src/storage/local-store.ts
+import Database from "better-sqlite3";
+import { v4 as uuidv4 } from "uuid";
+import { mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+
+// src/core/hash.ts
+import { createHash } from "crypto";
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function shortHash(content) {
+  return sha256(content).substring(0, 16);
+}
+function generateErrorFingerprint(errorMessage, errorStack) {
+  const combined = `${errorMessage}
+${errorStack || ""}`;
+  const normalized = normalizeErrorContent(combined);
+  return shortHash(normalized);
+}
+function normalizeErrorContent(content) {
+  return content.replace(/['"`][^'"`\n]{0,100}['"`]/g, "<STR>").replace(/(?:\/[\w.-]+)+/g, "<PATH>").replace(/(?:[A-Z]:\\[\w.-]+)+/gi, "<PATH>").replace(/:\d+:\d+/g, ":<LINE>:<COL>").replace(/line\s+\d+/gi, "line <LINE>").replace(/0x[a-f0-9]+/gi, "<ADDR>").replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi, "<UUID>").replace(/\b[a-f0-9]{8,}\b/gi, "<HASH>").replace(/\b\d{5,}\b/g, "<NUM>").replace(/\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/g, "<TIMESTAMP>").replace(/\s+/g, " ").trim();
+}
+function generateContributorId() {
+  const machineInfo = [
+    process.env.USER || process.env.USERNAME || "",
+    process.env.HOME || process.env.USERPROFILE || "",
+    process.platform,
+    process.arch
+  ].join(":");
+  return `anon_${shortHash(machineInfo)}`;
+}
+function generateSessionHash(sessionId) {
+  return shortHash(`session:${sessionId}:${Date.now()}`);
+}
+function fingerprintsMatch(fp1, fp2) {
+  return fp1 === fp2;
+}
+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;
+  return intersection.size / union.size;
+}
+
+// src/storage/migrations.ts
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      applied_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+  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);
+      db.prepare("INSERT INTO migrations (name) VALUES (?)").run(migration.name);
+    }
+  }
+}
+var MIGRATIONS = [
+  {
+    name: "001_initial_schema",
+    sql: `
+      -- Error records table
+      CREATE TABLE IF NOT EXISTS error_records (
+        id TEXT PRIMARY KEY,
+        error_hash TEXT NOT NULL,
+        error_type TEXT NOT NULL,
+        error_message TEXT NOT NULL,
+        error_stack TEXT,
+        language TEXT,
+        framework TEXT,
+        tool_name TEXT NOT NULL,
+        tool_input TEXT NOT NULL DEFAULT '{}',
+        session_id TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'unresolved',
+        resolution TEXT,
+        resolution_code TEXT,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        resolved_at TEXT,
+        uploaded_at TEXT,
+        cloud_knowledge_id TEXT
+      );
+
+      -- Indexes for error_records
+      CREATE INDEX IF NOT EXISTS idx_error_records_hash ON error_records(error_hash);
+      CREATE INDEX IF NOT EXISTS idx_error_records_status ON error_records(status);
+      CREATE INDEX IF NOT EXISTS idx_error_records_session ON error_records(session_id);
+      CREATE INDEX IF NOT EXISTS idx_error_records_created ON error_records(created_at);
+
+      -- Query cache table
+      CREATE TABLE IF NOT EXISTS query_cache (
+        id TEXT PRIMARY KEY,
+        error_hash TEXT NOT NULL,
+        results TEXT NOT NULL DEFAULT '[]',
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        expires_at TEXT NOT NULL
+      );
+
+      -- Indexes for query_cache
+      CREATE INDEX IF NOT EXISTS idx_query_cache_hash ON query_cache(error_hash);
+      CREATE INDEX IF NOT EXISTS idx_query_cache_expires ON query_cache(expires_at);
+
+      -- User preferences table
+      CREATE TABLE IF NOT EXISTS user_preferences (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      -- Usage statistics table
+      CREATE TABLE IF NOT EXISTS usage_stats (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        total_errors INTEGER NOT NULL DEFAULT 0,
+        resolved_errors INTEGER NOT NULL DEFAULT 0,
+        uploaded_errors INTEGER NOT NULL DEFAULT 0,
+        queries_made INTEGER NOT NULL DEFAULT 0,
+        last_sync TEXT
+      );
+
+      -- Initialize usage stats
+      INSERT OR IGNORE INTO usage_stats (id) VALUES (1);
+    `
+  },
+  {
+    name: "002_add_confidence_score",
+    sql: `
+      ALTER TABLE error_records ADD COLUMN confidence REAL DEFAULT 0;
+      ALTER TABLE error_records ADD COLUMN severity TEXT DEFAULT 'error';
+    `
+  }
+];
+
+// src/storage/local-store.ts
+var LocalStore = 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);
+  }
+  // ============ Error Records ============
+  /**
+   * Create a new error record
+   */
+  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);
+  }
+  /**
+   * 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];
+    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 = 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 ?"
+    );
+    return stmt.all(limit).map((row) => this.rowToRecord(row));
+  }
+  /**
+   * Mark error as resolved
+   */
+  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 this.getErrorById(id);
+    }
+    return null;
+  }
+  /**
+   * Mark error as uploaded to cloud
+   */
+  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");
+    }
+  }
+  /**
+   * Find similar errors by hash
+   */
+  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));
+  }
+  // ============ Query Cache ============
+  /**
+   * Get cached query results
+   */
+  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;
+  }
+  /**
+   * Cache query results
+   */
+  cacheResults(errorHash, results, expirationMs = 36e5) {
+    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");
+  }
+  /**
+   * 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 row = stmt.get();
+    return {
+      totalErrors: row.total_errors,
+      resolvedErrors: row.resolved_errors,
+      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(", ")}`);
+    }
+    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,
+      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,
+      createdAt: row.created_at,
+      resolvedAt: row.resolved_at || void 0,
+      uploadedAt: row.uploaded_at || void 0,
+      cloudKnowledgeId: row.cloud_knowledge_id || void 0
+    };
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Get database for advanced queries
+   */
+  getDatabase() {
+    return this.db;
+  }
+};
+
+// 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 = 3e4;
+var EmbeddingService = class {
+  client;
+  model;
+  dimensions;
+  constructor(apiKey, model, dimensions) {
+    this.client = new OpenAI({ apiKey });
+    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({
+      model: this.model,
+      input: truncated,
+      dimensions: this.dimensions
+    });
+    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({
+      model: this.model,
+      input: truncated,
+      dimensions: this.dimensions
+    });
+    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) {
+      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("\n");
+    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");
+    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");
+    }
+    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];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    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);
+}
+
+// src/cloud/client.ts
+var CloudClient = class {
+  supabase;
+  embedding;
+  contributorId;
+  similarityThreshold;
+  constructor(config) {
+    this.supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
+    this.embedding = config.openaiApiKey ? new EmbeddingService(config.openaiApiKey) : null;
+    this.contributorId = config.contributorId || generateContributorId();
+    this.similarityThreshold = config.similarityThreshold || 0.7;
+  }
+  /**
+   * Search for similar errors in cloud knowledge base
+   */
+  async searchSimilar(request) {
+    const startTime = Date.now();
+    if (!this.embedding) {
+      return this.searchByText(request);
+    }
+    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
+    });
+    if (error) {
+      console.error("Search error:", error);
+      return { results: [], queryTime: Date.now() - startTime, cached: false };
+    }
+    return {
+      results: (data || []).map(this.mapToKnowledgeEntry),
+      queryTime: Date.now() - startTime,
+      cached: false
+    };
+  }
+  /**
+   * Fallback text-based search
+   */
+  async 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);
+    if (request.language) {
+      query = query.eq("language", request.language);
+    }
+    if (request.framework) {
+      query = query.eq("framework", request.framework);
+    }
+    const { data, error } = await query;
+    if (error) {
+      console.error("Text search error:", error);
+      return { results: [], queryTime: Date.now() - startTime, cached: false };
+    }
+    return {
+      results: (data || []).map(this.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}
+${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
+        });
+        return {
+          success: true,
+          isDuplicate: true,
+          existingId: duplicateCheck.existingId,
+          message: "Similar solution already exists. Usage count incremented."
+        };
+      }
+    }
+    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,
+        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
+      };
+    }
+    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
+   */
+  async vote(knowledgeId, helpful) {
+    const column = helpful ? "upvotes" : "downvotes";
+    await this.supabase.rpc("increment_vote", {
+      entry_id: knowledgeId,
+      vote_type: column
+    });
+    await this.supabase.from("usage_logs").insert({
+      knowledge_id: knowledgeId,
+      action: helpful ? "upvote" : "downvote",
+      user_hash: this.contributorId
+    });
+  }
+  /**
+   * 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;
+  }
+};
+function createCloudClient(config) {
+  return new CloudClient(config);
+}
+
+// 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: {
+        errorMessage: tool.schema.string().describe("The error message to search for"),
+        language: tool.schema.string().optional().describe("Programming language (typescript, python, etc.)"),
+        framework: tool.schema.string().optional().describe("Framework (react, nextjs, express, etc.)"),
+        limit: tool.schema.number().optional().describe("Maximum results (default: 5)")
+      },
+      async execute(args, ctx) {
+        context.sessionId = ctx.sessionID;
+        const sanitized = privacyFilter.sanitize(args.errorMessage);
+        const cachedResults = localStore.getCachedResults(sanitized.sanitized);
+        if (cachedResults && cachedResults.length > 0) {
+          return formatSearchResults(cachedResults, true);
+        }
+        const results = await cloudClient.searchSimilar({
+          errorMessage: sanitized.sanitized,
+          language: args.language,
+          framework: args.framework,
+          limit: args.limit || 5
+        });
+        if (results.results.length === 0) {
+          return "No matching solutions found in FixHive knowledge base.";
+        }
+        localStore.cacheResults(sanitized.sanitized, results.results);
+        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: {
+        errorId: tool.schema.string().describe("Error ID from fixhive_list"),
+        resolution: tool.schema.string().describe("Description of how the error was resolved"),
+        resolutionCode: tool.schema.string().optional().describe("Code fix or diff that resolved the error"),
+        upload: tool.schema.boolean().optional().describe("Upload solution to community (default: true)")
+      },
+      async execute(args, ctx) {
+        context.sessionId = ctx.sessionID;
+        const record = localStore.markResolved(args.errorId, {
+          resolution: args.resolution,
+          resolutionCode: args.resolutionCode
+        });
+        if (!record) {
+          return `Error with ID ${args.errorId} not found.`;
+        }
+        if (args.upload !== false) {
+          const uploadResult = await cloudClient.uploadResolution({
+            errorRecord: record,
+            resolution: args.resolution,
+            resolutionCode: args.resolutionCode
+          });
+          if (uploadResult.isDuplicate) {
+            return `Error resolved locally. Similar solution already exists in FixHive (ID: ${uploadResult.existingId}).`;
+          }
+          if (uploadResult.success && uploadResult.knowledgeId) {
+            localStore.markUploaded(args.errorId, uploadResult.knowledgeId);
+            return `Error resolved and shared with FixHive community! Knowledge ID: ${uploadResult.knowledgeId}`;
+          }
+          return `Error resolved locally. Upload failed: ${uploadResult.message}`;
+        }
+        return "Error marked as resolved locally.";
+      }
+    }),
+    /**
+     * List errors in current session
+     */
+    fixhive_list: tool({
+      description: "List errors detected in the current session.",
+      args: {
+        status: tool.schema.enum(["unresolved", "resolved", "uploaded"]).optional().describe("Filter by status"),
+        limit: tool.schema.number().optional().describe("Maximum results (default: 10)")
+      },
+      async execute(args, ctx) {
+        context.sessionId = ctx.sessionID;
+        const errors = localStore.getSessionErrors(ctx.sessionID, {
+          status: args.status,
+          limit: args.limit || 10
+        });
+        if (errors.length === 0) {
+          return "No errors recorded in this session.";
+        }
+        return formatErrorList(errors);
+      }
+    }),
+    /**
+     * Vote on a solution
+     */
+    fixhive_vote: tool({
+      description: "Upvote or downvote a FixHive solution based on whether it helped.",
+      args: {
+        knowledgeId: tool.schema.string().describe("Knowledge entry ID"),
+        helpful: tool.schema.boolean().describe("True for upvote, false for downvote")
+      },
+      async execute(args) {
+        await cloudClient.vote(args.knowledgeId, args.helpful);
+        return args.helpful ? "Thanks for the feedback! Solution upvoted." : "Thanks for the feedback! Solution downvoted.";
+      }
+    }),
+    /**
+     * Get usage statistics
+     */
+    fixhive_stats: tool({
+      description: "Get FixHive usage statistics.",
+      args: {},
+      async execute() {
+        const localStats = localStore.getStats();
+        const cloudStats = await cloudClient.getContributorStats();
+        return `
+## FixHive Statistics
+
+### Local
+- Errors recorded: ${localStats.totalErrors}
+- Resolved: ${localStats.resolvedErrors}
+- Uploaded: ${localStats.uploadedErrors}
+
+### Community Contributions
+- Solutions shared: ${cloudStats.contributionCount}
+- Times your solutions helped: ${cloudStats.helpedCount}
+- Total upvotes received: ${cloudStats.totalUpvotes}
+`;
+      }
+    }),
+    /**
+     * Report that a solution was helpful
+     */
+    fixhive_helpful: tool({
+      description: "Report that a FixHive solution was helpful and resolved your issue.",
+      args: {
+        knowledgeId: tool.schema.string().describe("Knowledge entry ID that helped")
+      },
+      async execute(args) {
+        await cloudClient.reportHelpful(args.knowledgeId);
+        return "Thanks! Your feedback helps improve solution rankings.";
+      }
+    })
+  };
+}
+function formatSearchResults(results, cached) {
+  const header = cached ? `## FixHive Solutions Found (${results.length}) [Cached]` : `## FixHive Solutions Found (${results.length})`;
+  const entries = results.map((r, i) => {
+    const similarity = r.similarity ? ` (${Math.round(r.similarity * 100)}% match)` : "";
+    let entry = `
+### ${i + 1}. ${r.errorMessage.slice(0, 80)}...${similarity}
+**Language:** ${r.language} | **Framework:** ${r.framework || "N/A"} | **Upvotes:** ${r.upvotes}
+
+**Resolution:**
+${r.resolutionDescription}
+`;
+    if (r.resolutionCode) {
+      entry += `
+**Code Fix:**
+\`\`\`
+${r.resolutionCode}
+\`\`\`
+`;
+    }
+    if (r.resolutionSteps?.length) {
+      entry += `
+**Steps:**
+${r.resolutionSteps.map((s, j) => `${j + 1}. ${s}`).join("\n")}
+`;
+    }
+    entry += `
+*ID: ${r.id}*
+
+---`;
+    return entry;
+  }).join("\n");
+  return `${header}
+${entries}
+
+Use \`fixhive_vote\` to rate solutions or \`fixhive_helpful\` if a solution resolved your issue.`;
+}
+function formatErrorList(errors) {
+  const header = `## Session Errors (${errors.length})`;
+  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")}
+`;
+  return `${header}
+${table}
+
+Use \`fixhive_resolve <id>\` to mark as resolved and share solutions.`;
+}
+
+// src/plugin/index.ts
+var DEFAULT_CONFIG = {
+  cacheExpirationMs: 36e5,
+  // 1 hour
+  embeddingModel: "text-embedding-3-small",
+  embeddingDimensions: 1536,
+  similarityThreshold: 0.7,
+  maxSearchResults: 10
+};
+var FixHivePlugin = async (ctx) => {
+  const config = loadConfig();
+  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) {
+    cloudClient = new CloudClient({
+      supabaseUrl: config.supabaseUrl,
+      supabaseAnonKey: config.supabaseAnonKey,
+      openaiApiKey: config.openaiApiKey,
+      contributorId: config.contributorId,
+      similarityThreshold: config.similarityThreshold
+    });
+  }
+  const pluginContext = {
+    sessionId: "",
+    projectDirectory: ctx.directory,
+    language: detectLanguage(ctx.directory),
+    framework: detectFramework(ctx.directory)
+  };
+  const errorProducingTools = ["bash", "edit", "write", "read", "terminal"];
+  return {
+    // ============ Tool Execution Hook ============
+    "tool.execute.after": async (input, output) => {
+      if (!errorProducingTools.includes(input.tool)) return;
+      const detection = errorDetector.detect({
+        tool: input.tool,
+        output: output.output,
+        exitCode: output.metadata?.exitCode,
+        stderr: output.metadata?.stderr,
+        metadata: output.metadata
+      });
+      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;
+        localStore.createErrorRecord({
+          errorType: detection.errorType,
+          errorMessage: sanitizedErrorMessage,
+          errorStack: sanitizedErrorStack,
+          language: pluginContext.language,
+          framework: pluginContext.framework,
+          toolName: input.tool,
+          toolInput: {},
+          // Tool input is intentionally omitted to avoid storing sensitive data
+          sessionId: pluginContext.sessionId || input.sessionID
+        });
+        if (cloudClient) {
+          try {
+            const solutions = await cloudClient.searchSimilar({
+              errorMessage: sanitizedErrorMessage,
+              errorStack: sanitizedErrorStack,
+              language: pluginContext.language,
+              framework: pluginContext.framework,
+              limit: 3
+            });
+            if (solutions.results.length > 0) {
+              localStore.cacheResults(
+                generateErrorFingerprint(sanitizedErrorMessage, sanitizedErrorStack),
+                solutions.results
+              );
+              output.title = `${output.title} [FixHive: ${solutions.results.length} solution(s) found]`;
+            }
+          } catch (e) {
+            const errorMessage = e instanceof Error ? e.message : "Unknown error";
+            console.error(`[FixHive] Cloud query failed: ${errorMessage}`);
+          }
+        }
+      }
+    },
+    // ============ 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")}
+
+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)
+  };
+};
+function createOfflineTools(localStore, _privacyFilter, context) {
+  const { tool: tool2 } = __require("@opencode-ai/plugin");
+  return {
+    fixhive_list: tool2({
+      description: "List errors detected in the current session.",
+      args: {
+        status: tool2.schema.enum(["unresolved", "resolved", "uploaded"]).optional().describe("Filter by status"),
+        limit: tool2.schema.number().optional().describe("Maximum results (default: 10)")
+      },
+      async execute(args, ctx) {
+        context.sessionId = ctx.sessionID;
+        const errors = localStore.getSessionErrors(ctx.sessionID, {
+          status: args.status,
+          limit: args.limit || 10
+        });
+        if (errors.length === 0) {
+          return "No errors recorded in this session.";
+        }
+        return `## Session Errors (${errors.length})
+
+${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.*`;
+      }
+    }),
+    fixhive_stats: tool2({
+      description: "Get FixHive usage statistics.",
+      args: {},
+      async execute() {
+        const stats = localStore.getStats();
+        return `
+## FixHive Statistics (Offline Mode)
+
+### Local
+- Errors recorded: ${stats.totalErrors}
+- Resolved: ${stats.resolvedErrors}
+- Uploaded: ${stats.uploadedErrors}
+
+*Cloud features disabled. Set FIXHIVE_SUPABASE_URL and FIXHIVE_SUPABASE_KEY to enable community sharing.*
+`;
+      }
+    })
+  };
+}
+function loadConfig() {
+  return {
+    supabaseUrl: process.env.FIXHIVE_SUPABASE_URL || "",
+    supabaseAnonKey: process.env.FIXHIVE_SUPABASE_KEY || "",
+    openaiApiKey: process.env.OPENAI_API_KEY || process.env.FIXHIVE_OPENAI_KEY || "",
+    contributorId: process.env.FIXHIVE_CONTRIBUTOR_ID || "",
+    cacheExpirationMs: DEFAULT_CONFIG.cacheExpirationMs,
+    embeddingModel: DEFAULT_CONFIG.embeddingModel,
+    embeddingDimensions: DEFAULT_CONFIG.embeddingDimensions,
+    similarityThreshold: DEFAULT_CONFIG.similarityThreshold,
+    maxSearchResults: DEFAULT_CONFIG.maxSearchResults
+  };
+}
+function detectLanguage(directory) {
+  const fs = __require("fs");
+  const path = __require("path");
+  const indicators = [
+    ["package.json", "typescript"],
+    ["tsconfig.json", "typescript"],
+    ["pyproject.toml", "python"],
+    ["requirements.txt", "python"],
+    ["Cargo.toml", "rust"],
+    ["go.mod", "go"],
+    ["pom.xml", "java"],
+    ["build.gradle", "java"],
+    ["Gemfile", "ruby"],
+    ["composer.json", "php"]
+  ];
+  for (const [file, lang] of indicators) {
+    if (fs.existsSync(path.join(directory, file))) {
+      return lang;
+    }
+  }
+  return void 0;
+}
+function detectFramework(directory) {
+  const fs = __require("fs");
+  const path = __require("path");
+  const pkgPath = path.join(directory, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.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 {
+    }
+  }
+  const reqPath = path.join(directory, "requirements.txt");
+  if (fs.existsSync(reqPath)) {
+    try {
+      const content = fs.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;
+}
+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,
+  sha256,
+  shortHash
+};