@the-magic-tower/fixhive-opencode-plugin 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,616 @@
+import { Plugin } from '@opencode-ai/plugin';
+import Database from 'better-sqlite3';
+
+/**
+ * FixHive OpenCode Plugin
+ * Community-based error knowledge sharing plugin for OpenCode
+ */
+
+/**
+ * FixHive Plugin Factory
+ */
+declare const FixHivePlugin: Plugin;
+
+/**
+ * FixHive Type Definitions
+ * Community-based error knowledge sharing for OpenCode
+ */
+type ErrorType = 'runtime' | 'build' | 'lint' | 'test' | 'network' | 'permission' | 'dependency' | 'syntax' | 'type_error' | 'unknown';
+type ErrorStatus = 'unresolved' | 'resolved' | 'uploaded';
+type Language = 'typescript' | 'javascript' | 'python' | 'rust' | 'go' | 'java' | 'ruby' | 'php' | 'csharp' | 'cpp' | 'other';
+type Severity = 'critical' | 'error' | 'warning';
+interface LocalErrorRecord {
+    id: string;
+    errorHash: string;
+    errorType: ErrorType;
+    errorMessage: string;
+    errorStack?: string;
+    language?: Language;
+    framework?: string;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    sessionId: string;
+    status: ErrorStatus;
+    resolution?: string;
+    resolutionCode?: string;
+    createdAt: string;
+    resolvedAt?: string;
+    uploadedAt?: string;
+    cloudKnowledgeId?: string;
+}
+interface QueryCacheEntry {
+    id: string;
+    errorHash: string;
+    results: CloudKnowledgeEntry[];
+    createdAt: string;
+    expiresAt: string;
+}
+interface LocalStats {
+    totalErrors: number;
+    resolvedErrors: number;
+    uploadedErrors: number;
+}
+interface CloudKnowledgeEntry {
+    id: string;
+    errorHash: string;
+    errorType: ErrorType;
+    errorMessage: string;
+    errorStack?: string;
+    language: Language;
+    framework?: string;
+    dependencies?: Record<string, string>;
+    embedding?: number[];
+    resolutionDescription: string;
+    resolutionCode?: string;
+    resolutionSteps?: string[];
+    contributorId: string;
+    upvotes: number;
+    downvotes: number;
+    usageCount: number;
+    createdAt: string;
+    updatedAt: string;
+    isVerified: boolean;
+    similarity?: number;
+}
+interface DuplicateCheckResult {
+    isDuplicate: boolean;
+    existingId?: string;
+    similarityScore: number;
+}
+interface ContributorStats {
+    contributionCount: number;
+    helpedCount: number;
+    totalUpvotes: number;
+}
+interface DetectedSignal {
+    type: 'exit_code' | 'stderr' | 'pattern' | 'stack_trace';
+    weight: number;
+    value: string | number;
+    description: string;
+}
+interface ErrorDetectionResult {
+    detected: boolean;
+    confidence: number;
+    errorType: ErrorType;
+    severity: Severity;
+    signals: DetectedSignal[];
+    errorMessage: string;
+    errorStack?: string;
+    rawOutput: string;
+}
+interface StackFrame {
+    function: string;
+    file: string;
+    line: number;
+    column?: number;
+    isProjectCode: boolean;
+}
+interface StackTraceInfo {
+    hasStackTrace: boolean;
+    language: string | null;
+    frames: string[];
+}
+interface FixHiveContext {
+    sessionId: string;
+    projectDirectory: string;
+    language?: Language;
+    framework?: string;
+}
+interface ToolOutput {
+    tool: string;
+    output: string;
+    exitCode?: number;
+    stderr?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PrivacyFilterRule {
+    name: string;
+    category: 'secret' | 'identity' | 'infrastructure' | 'path' | 'environment';
+    pattern: RegExp;
+    replacement: string | ((match: string, ...groups: string[]) => string);
+    priority: number;
+}
+interface SanitizedContent {
+    original: string;
+    sanitized: string;
+    redactedCount: number;
+    appliedFilters: string[];
+}
+interface FilterContext {
+    projectRoot: string;
+    homeDir: string;
+    commonPaths: Map<string, string>;
+}
+interface SearchRequest {
+    errorMessage: string;
+    errorStack?: string;
+    language?: Language;
+    framework?: string;
+    limit?: number;
+    threshold?: number;
+}
+interface SearchResponse {
+    results: CloudKnowledgeEntry[];
+    queryTime: number;
+    cached: boolean;
+}
+interface UploadRequest {
+    errorRecord: LocalErrorRecord;
+    resolution: string;
+    resolutionCode?: string;
+    resolutionSteps?: string[];
+}
+interface UploadResponse {
+    success: boolean;
+    knowledgeId?: string;
+    isDuplicate: boolean;
+    existingId?: string;
+    message: string;
+}
+interface QueryKnowledgeArgs {
+    errorMessage: string;
+    language?: string;
+    framework?: string;
+    limit?: number;
+}
+interface SubmitResolutionArgs {
+    errorId: string;
+    resolution: string;
+    resolutionCode?: string;
+}
+interface ListErrorsArgs {
+    status?: ErrorStatus;
+    limit?: number;
+}
+interface MarkResolvedArgs {
+    errorId: string;
+    resolution: string;
+    resolutionCode?: string;
+    upload?: boolean;
+}
+interface VoteArgs {
+    knowledgeId: string;
+    helpful: boolean;
+}
+interface FixHiveConfig {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    openaiApiKey?: string;
+    contributorId: string;
+    cacheExpirationMs: number;
+    embeddingModel: string;
+    embeddingDimensions: number;
+    similarityThreshold: number;
+    maxSearchResults: number;
+}
+interface PartialConfig {
+    supabaseUrl?: string;
+    supabaseAnonKey?: string;
+    openaiApiKey?: string;
+    contributorId?: string;
+    cacheExpirationMs?: number;
+}
+type FixHiveEvent = {
+    type: 'error:detected';
+    payload: LocalErrorRecord;
+} | {
+    type: 'error:resolved';
+    payload: {
+        errorId: string;
+        resolution: string;
+    };
+} | {
+    type: 'solution:uploaded';
+    payload: {
+        knowledgeId: string;
+    };
+} | {
+    type: 'solution:found';
+    payload: CloudKnowledgeEntry[];
+};
+
+/**
+ * FixHive Privacy Filter
+ * Sanitizes sensitive information from error messages before sharing
+ */
+
+/**
+ * Privacy Filter Pipeline
+ * Applies multiple filtering rules to sanitize sensitive content
+ */
+declare class PrivacyFilter {
+    private rules;
+    constructor(customRules?: PrivacyFilterRule[]);
+    /**
+     * Sanitize content by applying all filter rules
+     */
+    sanitize(content: string, context?: FilterContext): SanitizedContent;
+    /**
+     * Generalize file paths while keeping meaningful structure
+     */
+    private generalizePaths;
+    /**
+     * Add a custom filter rule
+     */
+    addRule(rule: PrivacyFilterRule): void;
+    /**
+     * Remove a filter rule by name
+     */
+    removeRule(name: string): boolean;
+    /**
+     * Get all current rules
+     */
+    getRules(): ReadonlyArray<PrivacyFilterRule>;
+    /**
+     * Check if content contains sensitive data
+     * Note: Always reset regex lastIndex BEFORE testing to prevent state pollution
+     */
+    containsSensitiveData(content: string): boolean;
+}
+/**
+ * Create default filter context from project directory
+ */
+declare function createFilterContext(projectDirectory: string): FilterContext;
+declare const defaultPrivacyFilter: PrivacyFilter;
+
+/**
+ * FixHive Error Detector
+ * Detects errors from tool outputs using multi-signal analysis
+ */
+
+/**
+ * Error Detector Class
+ * Analyzes tool outputs to detect errors
+ */
+declare class ErrorDetector {
+    private privacyFilter;
+    constructor(privacyFilter?: PrivacyFilter);
+    /**
+     * Detect if output contains an error
+     */
+    detect(toolOutput: ToolOutput): ErrorDetectionResult;
+    /**
+     * Check if content contains error keywords
+     */
+    private containsErrorKeywords;
+    /**
+     * Detect error patterns in content
+     */
+    private detectErrorPatterns;
+    /**
+     * Detect stack traces in content
+     */
+    private detectStackTrace;
+    /**
+     * Calculate confidence score from signals
+     */
+    private calculateConfidence;
+    /**
+     * Classify error type based on signals and content
+     */
+    private classifyErrorType;
+    /**
+     * Determine severity from signals and exit code
+     */
+    private determineSeverity;
+    /**
+     * Extract error message and stack from output
+     */
+    private extractErrorDetails;
+    /**
+     * Check if a line looks like an error message
+     */
+    private isErrorLine;
+}
+declare const defaultErrorDetector: ErrorDetector;
+
+/**
+ * FixHive Hash Utilities
+ * Generates fingerprints and hashes for error deduplication
+ */
+/**
+ * Generate SHA-256 hash of content
+ */
+declare function sha256(content: string): string;
+/**
+ * Generate a shortened hash (first 16 characters)
+ */
+declare function shortHash(content: string): string;
+/**
+ * Generate error fingerprint for matching similar errors
+ * Normalizes variable parts (paths, numbers, hashes) before hashing
+ */
+declare function generateErrorFingerprint(errorMessage: string, errorStack?: string): string;
+/**
+ * Normalize error content by replacing variable parts
+ */
+declare function normalizeErrorContent(content: string): string;
+/**
+ * Generate contributor ID (anonymous hash)
+ * Uses machine-specific information to create a stable anonymous ID
+ */
+declare function generateContributorId(): string;
+/**
+ * Generate session-specific hash
+ */
+declare function generateSessionHash(sessionId: string): string;
+/**
+ * Compare two fingerprints for similarity
+ * Returns true if they're identical (exact match)
+ */
+declare function fingerprintsMatch(fp1: string, fp2: string): boolean;
+/**
+ * Calculate simple string similarity (Jaccard index)
+ * Used as a fallback when embeddings aren't available
+ */
+declare function calculateStringSimilarity(str1: string, str2: string): number;
+
+/**
+ * FixHive Local Store
+ * SQLite-based local storage for error records and caching
+ */
+
+/**
+ * Local Store Class
+ * Manages SQLite database for error records and caching
+ */
+declare class LocalStore {
+    private db;
+    constructor(projectDirectory: string);
+    /**
+     * Create a new error record
+     */
+    createErrorRecord(data: Omit<LocalErrorRecord, 'id' | 'errorHash' | 'status' | 'createdAt'>): LocalErrorRecord;
+    /**
+     * Get error record by ID
+     */
+    getErrorById(id: string): LocalErrorRecord | null;
+    /**
+     * Get errors by session
+     */
+    getSessionErrors(sessionId: string, options?: {
+        status?: ErrorStatus;
+        limit?: number;
+    }): LocalErrorRecord[];
+    /**
+     * Get unresolved errors for a session
+     */
+    getUnresolvedErrors(sessionId: string): LocalErrorRecord[];
+    /**
+     * Get recent errors across all sessions
+     */
+    getRecentErrors(limit?: number): LocalErrorRecord[];
+    /**
+     * Mark error as resolved
+     */
+    markResolved(id: string, data: {
+        resolution: string;
+        resolutionCode?: string;
+    }): LocalErrorRecord | null;
+    /**
+     * Mark error as uploaded to cloud
+     */
+    markUploaded(id: string, cloudKnowledgeId: string): void;
+    /**
+     * Find similar errors by hash
+     */
+    findSimilarErrors(errorHash: string): LocalErrorRecord[];
+    /**
+     * Get cached query results
+     */
+    getCachedResults(errorHash: string): CloudKnowledgeEntry[] | null;
+    /**
+     * Cache query results
+     */
+    cacheResults(errorHash: string, results: CloudKnowledgeEntry[], expirationMs?: number): void;
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache(): number;
+    /**
+     * Get usage statistics
+     */
+    getStats(): LocalStats;
+    /**
+     * Allowed stat column names for incrementStat (whitelist to prevent SQL injection)
+     */
+    private static readonly ALLOWED_STATS;
+    /**
+     * Increment a stat counter
+     * @throws Error if stat name is not in the allowed whitelist
+     */
+    private incrementStat;
+    /**
+     * Get preference value
+     */
+    getPreference(key: string): string | null;
+    /**
+     * Set preference value
+     */
+    setPreference(key: string, value: string): void;
+    /**
+     * Convert database row to LocalErrorRecord
+     */
+    private rowToRecord;
+    /**
+     * Close database connection
+     */
+    close(): void;
+    /**
+     * Get database for advanced queries
+     */
+    getDatabase(): Database.Database;
+}
+
+/**
+ * FixHive Database Migrations
+ * SQLite schema setup and migrations
+ */
+
+/**
+ * Run all migrations on the database
+ */
+declare function runMigrations(db: Database.Database): void;
+
+/**
+ * FixHive Cloud Client
+ * Supabase client for cloud knowledge base operations
+ */
+
+/**
+ * Cloud Client Class
+ * Manages communication with Supabase cloud database
+ */
+declare class CloudClient {
+    private supabase;
+    private embedding;
+    private contributorId;
+    private similarityThreshold;
+    constructor(config: {
+        supabaseUrl: string;
+        supabaseAnonKey: string;
+        openaiApiKey?: string;
+        contributorId?: string;
+        similarityThreshold?: number;
+    });
+    /**
+     * Search for similar errors in cloud knowledge base
+     */
+    searchSimilar(request: SearchRequest): Promise<SearchResponse>;
+    /**
+     * Fallback text-based search
+     */
+    private searchByText;
+    /**
+     * Upload a resolution to cloud knowledge base
+     */
+    uploadResolution(request: UploadRequest): Promise<UploadResponse>;
+    /**
+     * Check for duplicate entries
+     */
+    checkDuplicate(errorHash: string, embedding: number[]): Promise<DuplicateCheckResult>;
+    /**
+     * Vote on a knowledge entry (with duplicate vote prevention)
+     */
+    vote(knowledgeId: string, helpful: boolean): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Report an entry for review
+     */
+    reportEntry(knowledgeId: string, reason?: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Report helpful usage
+     */
+    reportHelpful(knowledgeId: string): Promise<void>;
+    /**
+     * Get contributor statistics
+     */
+    getContributorStats(): Promise<ContributorStats>;
+    /**
+     * Get entry by ID
+     */
+    getEntry(id: string): Promise<CloudKnowledgeEntry | null>;
+    /**
+     * Map database row to CloudKnowledgeEntry
+     */
+    private mapToKnowledgeEntry;
+    /**
+     * Get contributor ID
+     */
+    getContributorId(): string;
+    /**
+     * Check if embedding service is available
+     */
+    hasEmbeddingService(): boolean;
+}
+/**
+ * Create cloud client with config
+ */
+declare function createCloudClient(config: {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    openaiApiKey?: string;
+    contributorId?: string;
+    similarityThreshold?: number;
+}): CloudClient;
+
+/**
+ * FixHive Embedding Service
+ * Generates text embeddings for semantic search using OpenAI
+ */
+/**
+ * Embedding Service Class
+ * Generates embeddings for error messages and solutions
+ */
+declare class EmbeddingService {
+    private client;
+    private model;
+    private dimensions;
+    constructor(apiKey: string, model?: string, dimensions?: number);
+    /**
+     * Generate embedding for a single text
+     */
+    generate(text: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts
+     */
+    generateBatch(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embedding for error context
+     * Combines error message, stack trace, and context
+     */
+    generateErrorEmbedding(errorMessage: string, errorStack?: string, context?: {
+        language?: string;
+        framework?: string;
+    }): Promise<number[]>;
+    /**
+     * Truncate text to fit within model limits
+     */
+    private truncateText;
+    /**
+     * Calculate cosine similarity between two embeddings
+     */
+    static cosineSimilarity(a: number[], b: number[]): number;
+    /**
+     * Get embedding dimensions
+     */
+    getDimensions(): number;
+    /**
+     * Get model name
+     */
+    getModel(): string;
+}
+/**
+ * Create embedding service with config
+ */
+declare function createEmbeddingService(config: {
+    apiKey: string;
+    model?: string;
+    dimensions?: number;
+}): EmbeddingService;
+
+export { CloudClient, type CloudKnowledgeEntry, type ContributorStats, type DetectedSignal, type DuplicateCheckResult, EmbeddingService, type ErrorDetectionResult, ErrorDetector, type ErrorStatus, type ErrorType, type FilterContext, type FixHiveConfig, type FixHiveContext, type FixHiveEvent, FixHivePlugin, type Language, type ListErrorsArgs, type LocalErrorRecord, type LocalStats, LocalStore, type MarkResolvedArgs, type PartialConfig, PrivacyFilter, type PrivacyFilterRule, type QueryCacheEntry, type QueryKnowledgeArgs, type SanitizedContent, type SearchRequest, type SearchResponse, type Severity, type StackFrame, type StackTraceInfo, type SubmitResolutionArgs, type ToolOutput, type UploadRequest, type UploadResponse, type VoteArgs, calculateStringSimilarity, createCloudClient, createEmbeddingService, createFilterContext, FixHivePlugin as default, defaultErrorDetector, defaultPrivacyFilter, fingerprintsMatch, generateContributorId, generateErrorFingerprint, generateSessionHash, normalizeErrorContent, runMigrations, sha256, shortHash };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-magic-tower/fixhive-opencode-plugin",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Community-based error knowledge sharing for OpenCode",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --clean",
+    "build": "tsup src/index.ts --format esm --dts --clean",
     "build:dts": "tsup src/index.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts --format esm --watch",
     "typecheck": "tsc --noEmit",
@@ -47,7 +47,8 @@
     "@supabase/supabase-js": "^2.45.0",
     "better-sqlite3": "^11.3.0",
     "openai": "^4.60.0",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.1.1",
@@ -60,8 +61,7 @@
     "eslint": "^9.0.0",
     "tsup": "^8.2.0",
     "typescript": "^5.5.0",
-    "vitest": "^2.0.0",
-    "zod": "^4.3.5"
+    "vitest": "^2.0.0"
   },
   "engines": {
     "node": ">=20.0.0"