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

package/dist/index.d.ts

@@ -1,45 +1,473 @@
+import { Plugin } from '@opencode-ai/plugin';
+import Database from 'better-sqlite3';
+
 /**
- * FixHive - Community-based Error Knowledge Sharing for OpenCode
- *
- * @module @fixhive/opencode-plugin
- * @description
- * FixHive is an OpenCode plugin that automatically captures errors during
- * development sessions, queries a community knowledge base for solutions,
- * and shares resolved errors with other developers.
- *
- * @example
- * ```typescript
- * // In your OpenCode plugin configuration
- * import FixHivePlugin from '@fixhive/opencode-plugin';
- *
- * export default FixHivePlugin;
- * ```
- *
- * @example
- * ```bash
- * # Environment variables
- * FIXHIVE_SUPABASE_URL=https://your-project.supabase.co
- * FIXHIVE_SUPABASE_KEY=your-anon-key
- * OPENAI_API_KEY=sk-...  # Optional, for embeddings
- * ```
- */
-export { FixHivePlugin, default } from './plugin/index.js';
-export { createErrorDetector, defaultErrorDetector } from './core/error-detector.js';
-export { createPrivacyFilter, defaultPrivacyFilter, createFilterContext } from './core/privacy-filter.js';
-export { sha256, shortHash, generateErrorFingerprint, normalizeErrorContent, generateContributorId, generateSessionHash, fingerprintsMatch, calculateStringSimilarity, } from './core/hash.js';
-export { createLocalStore } from './storage/local-store.js';
-export { runMigrations } from './storage/migrations.js';
-export { createCloudClient } from './cloud/client.js';
-export { createEmbeddingService, cosineSimilarity } from './cloud/embedding.js';
-export { ErrorDetector } from './core/error-detector.js';
-export { PrivacyFilter } from './core/privacy-filter.js';
-export { LocalStore } from './storage/local-store.js';
-export { CloudClient } from './cloud/client.js';
-export { EmbeddingService } from './cloud/embedding.js';
-export type { ErrorType, ErrorStatus, Language, Severity, LocalErrorRecord, QueryCacheEntry, LocalStats, CloudKnowledgeEntry, DuplicateCheckResult, ContributorStats, DetectedSignal, ErrorDetectionResult, StackFrame, StackTraceInfo, FixHiveContext, ToolOutput, PrivacyFilterRule, SanitizedContent, FilterContext, SearchRequest, SearchResponse, UploadRequest, UploadResponse, QueryKnowledgeArgs, SubmitResolutionArgs, ListErrorsArgs, MarkResolvedArgs, VoteArgs, FixHiveConfig, PartialConfig, FixHiveEvent, } from './types/index.js';
-export type { ErrorDetector as ErrorDetectorInterface } from './core/error-detector.js';
-export type { PrivacyFilter as PrivacyFilterInterface } from './core/privacy-filter.js';
-export type { LocalStore as LocalStoreInterface } from './storage/local-store.js';
-export type { CloudClient as CloudClientInterface } from './cloud/client.js';
-export type { EmbeddingService as EmbeddingServiceInterface, EmbeddingServiceConfig } from './cloud/embedding.js';
-//# sourceMappingURL=index.d.ts.map
+ * 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
+ */
+
+/**
+ * Create a PrivacyFilter instance
+ * Factory function pattern to avoid ES6 class issues with Bun
+ */
+declare function createPrivacyFilter(customRules?: PrivacyFilterRule[]): PrivacyFilter;
+/**
+ * PrivacyFilter interface - defines all public methods
+ */
+interface PrivacyFilter {
+    sanitize(content: string, context?: FilterContext): SanitizedContent;
+    addRule(rule: PrivacyFilterRule): void;
+    removeRule(name: string): boolean;
+    getRules(): ReadonlyArray<PrivacyFilterRule>;
+    containsSensitiveData(content: string): boolean;
+}
+/**
+ * Legacy class wrapper for backwards compatibility
+ * @deprecated Use createPrivacyFilter() instead
+ */
+declare const PrivacyFilter: {
+    create: typeof createPrivacyFilter;
+};
+/**
+ * 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
+ */
+
+/**
+ * Create an ErrorDetector instance
+ * Factory function pattern to avoid ES6 class issues with Bun
+ */
+declare function createErrorDetector(privacyFilter?: PrivacyFilter): ErrorDetector;
+/**
+ * ErrorDetector interface - defines all public methods
+ */
+interface ErrorDetector {
+    detect(toolOutput: ToolOutput): ErrorDetectionResult;
+}
+/**
+ * Legacy class wrapper for backwards compatibility
+ * @deprecated Use createErrorDetector() instead
+ */
+declare const ErrorDetector: {
+    create: typeof createErrorDetector;
+};
+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
+ */
+
+/**
+ * Create a LocalStore instance
+ * Factory function pattern to avoid ES6 class issues with Bun
+ */
+declare function createLocalStore(projectDirectory: string): LocalStore;
+/**
+ * LocalStore interface - defines all public methods
+ */
+interface LocalStore {
+    createErrorRecord(data: Omit<LocalErrorRecord, 'id' | 'errorHash' | 'status' | 'createdAt'>): LocalErrorRecord;
+    getErrorById(id: string): LocalErrorRecord | null;
+    getSessionErrors(sessionId: string, options?: {
+        status?: ErrorStatus;
+        limit?: number;
+    }): LocalErrorRecord[];
+    getUnresolvedErrors(sessionId: string): LocalErrorRecord[];
+    getRecentErrors(limit?: number): LocalErrorRecord[];
+    markResolved(id: string, data: {
+        resolution: string;
+        resolutionCode?: string;
+    }): LocalErrorRecord | null;
+    markUploaded(id: string, cloudKnowledgeId: string): void;
+    findSimilarErrors(errorHash: string): LocalErrorRecord[];
+    getCachedResults(errorHash: string): CloudKnowledgeEntry[] | null;
+    cacheResults(errorHash: string, results: CloudKnowledgeEntry[], expirationMs?: number): void;
+    clearExpiredCache(): number;
+    getStats(): LocalStats;
+    getPreference(key: string): string | null;
+    setPreference(key: string, value: string): void;
+    close(): void;
+    getDatabase(): Database.Database;
+}
+/**
+ * Legacy class wrapper for backwards compatibility
+ * @deprecated Use createLocalStore() instead
+ */
+declare const LocalStore: {
+    create: typeof createLocalStore;
+};
+
+/**
+ * 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 Configuration
+ */
+interface CloudClientConfig {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    openaiApiKey?: string;
+    contributorId?: string;
+    similarityThreshold?: number;
+}
+/**
+ * Create a CloudClient instance
+ * Factory function pattern to avoid ES6 class issues with Bun
+ */
+declare function createCloudClient(config: CloudClientConfig): Promise<CloudClient>;
+/**
+ * CloudClient interface - defines all public methods
+ */
+interface CloudClient {
+    searchSimilar(request: SearchRequest): Promise<SearchResponse>;
+    uploadResolution(request: UploadRequest): Promise<UploadResponse>;
+    checkDuplicate(errorHash: string, embedding: number[]): Promise<DuplicateCheckResult>;
+    vote(knowledgeId: string, helpful: boolean): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    reportEntry(knowledgeId: string, reason?: string): Promise<{
+        success: boolean;
+    }>;
+    reportHelpful(knowledgeId: string): Promise<void>;
+    getContributorStats(): Promise<ContributorStats>;
+    getEntry(id: string): Promise<CloudKnowledgeEntry | null>;
+    getContributorId(): string;
+    hasEmbeddingService(): boolean;
+}
+declare const CloudClient: {
+    create: typeof createCloudClient;
+};
+
+/**
+ * EmbeddingService configuration
+ */
+interface EmbeddingServiceConfig {
+    apiKey: string;
+    model?: string;
+    dimensions?: number;
+}
+/**
+ * Calculate cosine similarity between two embeddings
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Create an EmbeddingService instance
+ * Factory function pattern to avoid ES6 class issues with Bun
+ */
+declare function createEmbeddingService(config: EmbeddingServiceConfig): EmbeddingService;
+/**
+ * FixHive Embedding Service
+ * Generates text embeddings for semantic search using OpenAI
+ */
+/**
+ * EmbeddingService interface - defines all public methods
+ */
+interface EmbeddingService {
+    generate(text: string): Promise<number[]>;
+    generateBatch(texts: string[]): Promise<number[][]>;
+    generateErrorEmbedding(errorMessage: string, errorStack?: string, context?: {
+        language?: string;
+        framework?: string;
+    }): Promise<number[]>;
+    getDimensions(): number;
+    getModel(): string;
+}
+/**
+ * Legacy class wrapper for backwards compatibility
+ * @deprecated Use createEmbeddingService() instead
+ */
+declare const EmbeddingService: {
+    create: typeof createEmbeddingService;
+    cosineSimilarity: typeof cosineSimilarity;
+};
+
+export { CloudClient, CloudClient as CloudClientInterface, type CloudKnowledgeEntry, type ContributorStats, type DetectedSignal, type DuplicateCheckResult, EmbeddingService, type EmbeddingServiceConfig, EmbeddingService as EmbeddingServiceInterface, type ErrorDetectionResult, ErrorDetector, ErrorDetector as ErrorDetectorInterface, type ErrorStatus, type ErrorType, type FilterContext, type FixHiveConfig, type FixHiveContext, type FixHiveEvent, FixHivePlugin, type Language, type ListErrorsArgs, type LocalErrorRecord, type LocalStats, LocalStore, LocalStore as LocalStoreInterface, type MarkResolvedArgs, type PartialConfig, PrivacyFilter, PrivacyFilter as PrivacyFilterInterface, 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, cosineSimilarity, createCloudClient, createEmbeddingService, createErrorDetector, createFilterContext, createLocalStore, createPrivacyFilter, FixHivePlugin as default, defaultErrorDetector, defaultPrivacyFilter, fingerprintsMatch, generateContributorId, generateErrorFingerprint, generateSessionHash, normalizeErrorContent, runMigrations, sha256, shortHash };