@hyperfixi/patterns-reference 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,403 @@
+import { C as ConnectionOptions, a as Command, E as Expression, K as Keyword, F as Feature, S as SpecialSymbol, L as LanguageElementType, b as LanguageElement, c as LanguageDocsStats, d as LLMExample, P as PatternsReference } from './index-CBoczxz7.mjs';
+export { f as ClassifiedPattern, g as ComplexityLevel, D as DiscoveryResult, h as EngineCompat, j as ExpressionOperator, e as Pattern, m as PatternStats, k as SearchOptions, n as SyncOptions, o as SyncResult, l as TestOptions, T as Translation, i as TranslationMethod, p as ValidationOptions, q as ValidationResult, V as VerificationResult, W as WordOrder } from './index-CBoczxz7.mjs';
+import Database from 'better-sqlite3';
+export { r as addLLMExample, q as buildFewShotContext, c as getAllPatterns, f as getAllTranslations, n as getExamplesByCommand, j as getHighConfidenceTranslations, o as getHighQualityExamples, m as getLLMExamples, t as getLLMStats, p as getMostUsedExamples, g as getPatternById, d as getPatternStats, a as getPatternsByCategory, b as getPatternsByCommand, e as getTranslation, k as getTranslationStats, h as getTranslationsByLanguage, i as getVerifiedTranslations, l as getWordOrder, s as searchPatterns, u as updateQualityScore, v as verifyTranslation } from './llm-UOOBXwj3.mjs';
+export { discoverPatterns, seedLLMExamples, syncTranslations, validateAllTranslations } from './sync/index.mjs';
+import '@lokascript/semantic';
+
+/**
+ * Database Connection Management
+ *
+ * Provides singleton connection to the patterns-reference SQLite database.
+ */
+
+/**
+ * Get database connection (lazy singleton).
+ */
+declare function getDatabase(options?: ConnectionOptions): InstanceType<typeof Database>;
+/**
+ * Close database connection.
+ */
+declare function closeDatabase(): void;
+/**
+ * For testing: reset the database connection.
+ */
+declare function resetConnection(): void;
+/**
+ * Check if database is connected.
+ */
+declare function isConnected(): boolean;
+/**
+ * Get the current database path.
+ */
+declare function getCurrentDbPath(): string | null;
+
+/**
+ * Language Documentation API
+ *
+ * Provides functions to query hyperscript language documentation:
+ * commands, expressions, keywords, features, and special symbols.
+ */
+
+/**
+ * Get a command by name.
+ */
+declare function getCommandByName(name: string, options?: ConnectionOptions): Promise<Command | null>;
+/**
+ * Get all commands.
+ */
+declare function getAllCommands(options?: ConnectionOptions): Promise<Command[]>;
+/**
+ * Search commands by name or description.
+ */
+declare function searchCommands(query: string, options?: ConnectionOptions): Promise<Command[]>;
+/**
+ * Get an expression by name.
+ */
+declare function getExpressionByName(name: string, options?: ConnectionOptions): Promise<Expression | null>;
+/**
+ * Get all expressions.
+ */
+declare function getAllExpressions(options?: ConnectionOptions): Promise<Expression[]>;
+/**
+ * Get expressions by category.
+ */
+declare function getExpressionsByCategory(category: string, options?: ConnectionOptions): Promise<Expression[]>;
+/**
+ * Get a keyword by name.
+ */
+declare function getKeywordByName(name: string, options?: ConnectionOptions): Promise<Keyword | null>;
+/**
+ * Get all keywords.
+ */
+declare function getAllKeywords(options?: ConnectionOptions): Promise<Keyword[]>;
+/**
+ * Get a feature by name.
+ */
+declare function getFeatureByName(name: string, options?: ConnectionOptions): Promise<Feature | null>;
+/**
+ * Get all features.
+ */
+declare function getAllFeatures(options?: ConnectionOptions): Promise<Feature[]>;
+/**
+ * Get a special symbol by name.
+ */
+declare function getSpecialSymbolByName(name: string, options?: ConnectionOptions): Promise<SpecialSymbol | null>;
+/**
+ * Get all special symbols.
+ */
+declare function getAllSpecialSymbols(options?: ConnectionOptions): Promise<SpecialSymbol[]>;
+/**
+ * Search across all language elements.
+ */
+declare function searchLanguageElements(query: string, types?: LanguageElementType[], options?: ConnectionOptions): Promise<LanguageElement[]>;
+/**
+ * Get language documentation statistics.
+ */
+declare function getLanguageDocsStats(options?: ConnectionOptions): Promise<LanguageDocsStats>;
+
+/**
+ * Unified LLM Adapter
+ *
+ * This adapter provides a unified interface for LLM example operations,
+ * supporting both sync and async access patterns for backward compatibility
+ * with packages/core/src/context/llm-examples-query.ts.
+ *
+ * @module @hyperfixi/patterns-reference/adapters/llm-adapter
+ */
+
+/**
+ * Legacy record type matching packages/core/src/context/llm-examples-query.ts
+ */
+interface LLMExampleRecord {
+    id: number;
+    prompt: string;
+    completion: string;
+    language: string;
+    qualityScore: number;
+}
+/**
+ * Check if the database is available for sync operations.
+ */
+declare function isDatabaseAvailable(): boolean;
+/**
+ * Find relevant examples (sync interface - matches llm-examples-query.ts).
+ *
+ * This is the synchronous version for backward compatibility.
+ * Prefer async getLLMExamples() for new code.
+ *
+ * @param prompt - The user's request/prompt
+ * @param language - Target language code (default: 'en')
+ * @param limit - Maximum number of examples to return (default: 5)
+ */
+declare function findRelevantExamples(prompt: string, language?: string, limit?: number): LLMExampleRecord[];
+/**
+ * Find examples by command type (sync interface).
+ */
+declare function findExamplesByCommand(command: string, language?: string, limit?: number): LLMExampleRecord[];
+/**
+ * Build few-shot context (sync interface).
+ */
+declare function buildFewShotContextSync(prompt: string, language?: string, numExamples?: number): string;
+/**
+ * Track example usage (sync interface).
+ */
+declare function trackExampleUsage(ids: number[]): void;
+/**
+ * Get LLM example statistics (sync interface).
+ */
+declare function getLLMExampleStats(): {
+    total: number;
+    byLanguage: Record<string, number>;
+    avgQuality: number;
+} | null;
+
+/**
+ * Create a unified LLM adapter with both sync and async methods.
+ *
+ * @example
+ * ```typescript
+ * import { createLLMAdapter } from '@hyperfixi/patterns-reference/adapters/llm-adapter';
+ *
+ * const adapter = createLLMAdapter();
+ *
+ * // Sync (backward compat)
+ * const examples = adapter.findRelevantExamples('toggle a class');
+ *
+ * // Async (preferred)
+ * const asyncExamples = await adapter.getLLMExamples('toggle a class');
+ *
+ * adapter.close();
+ * ```
+ */
+declare function createLLMAdapter(options?: ConnectionOptions): {
+    findRelevantExamples: typeof findRelevantExamples;
+    findExamplesByCommand: typeof findExamplesByCommand;
+    buildFewShotContextSync: typeof buildFewShotContextSync;
+    trackExampleUsage: typeof trackExampleUsage;
+    getLLMExampleStats: typeof getLLMExampleStats;
+    isDatabaseAvailable: typeof isDatabaseAvailable;
+    getLLMExamples: (prompt: string, language?: string, limit?: number) => Promise<LLMExample[]>;
+    getExamplesByCommand: (command: string, language?: string, limit?: number) => Promise<LLMExample[]>;
+    getHighQualityExamples: (language?: string, minQuality?: number, limit?: number) => Promise<LLMExample[]>;
+    getMostUsedExamples: (language?: string, limit?: number) => Promise<LLMExample[]>;
+    buildFewShotContext: (prompt: string, language?: string, numExamples?: number) => Promise<string>;
+    getLLMStats: () => Promise<{
+        total: number;
+        byLanguage: Record<string, number>;
+        avgQuality: number;
+        totalUsage: number;
+    }>;
+    close: typeof closeDatabase;
+};
+
+/**
+ * Patterns Provider
+ *
+ * Provides patterns from the patterns-reference database to the semantic registry.
+ * This enables runtime pattern matching using database-backed patterns.
+ *
+ * @module @hyperfixi/patterns-reference/registry
+ */
+
+/**
+ * Pattern source interface for external pattern providers.
+ */
+interface PatternsSource {
+    /** Unique identifier for the source */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Get patterns for a specific language */
+    getPatternsForLanguage(language: string): Promise<PatternEntry[]>;
+    /** Get patterns for a specific command */
+    getPatternsForCommand(command: string, language?: string): Promise<PatternEntry[]>;
+    /** Check if source has patterns for a language */
+    hasPatterns(language: string): Promise<boolean>;
+    /** Get all supported languages */
+    getSupportedLanguages(): Promise<string[]>;
+}
+/**
+ * Pattern entry from the database.
+ */
+interface PatternEntry {
+    /** Pattern ID */
+    id: string;
+    /** The hyperscript code */
+    code: string;
+    /** Primary command (toggle, add, remove, etc.) */
+    command: string | null;
+    /** Language code */
+    language: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Whether the pattern has been verified to parse correctly */
+    verified: boolean;
+    /** Pattern title/description */
+    title?: string;
+    /** Pattern category */
+    category?: string;
+}
+/**
+ * Database-backed patterns provider.
+ */
+declare class DatabasePatternsProvider implements PatternsSource {
+    readonly id = "patterns-reference-db";
+    readonly name = "Patterns Reference Database";
+    private options;
+    private languageCache;
+    private supportedLanguagesCache;
+    constructor(options?: ConnectionOptions);
+    /**
+     * Get patterns for a specific language.
+     */
+    getPatternsForLanguage(language: string): Promise<PatternEntry[]>;
+    /**
+     * Get patterns for a specific command.
+     */
+    getPatternsForCommand(command: string, language?: string): Promise<PatternEntry[]>;
+    /**
+     * Check if source has patterns for a language.
+     */
+    hasPatterns(language: string): Promise<boolean>;
+    /**
+     * Get all supported languages.
+     */
+    getSupportedLanguages(): Promise<string[]>;
+    /**
+     * Clear the pattern cache.
+     */
+    clearCache(): void;
+    /**
+     * Extract primary command from hyperscript code.
+     */
+    private extractCommand;
+}
+/**
+ * Get the default patterns provider instance.
+ */
+declare function getDefaultProvider(options?: ConnectionOptions): DatabasePatternsProvider;
+/**
+ * Create a new patterns provider instance.
+ */
+declare function createPatternsProvider(options?: ConnectionOptions): DatabasePatternsProvider;
+/**
+ * Reset the default provider (for testing).
+ */
+declare function resetDefaultProvider(): void;
+
+/**
+ * Options for semantic integration initialization.
+ */
+interface SemanticIntegrationOptions extends ConnectionOptions {
+    /** Whether to register as the default provider */
+    registerAsDefault?: boolean;
+    /** Custom provider instance to use */
+    provider?: DatabasePatternsProvider;
+}
+/**
+ * Result of initialization.
+ */
+interface IntegrationResult {
+    success: boolean;
+    provider: DatabasePatternsProvider;
+    registeredWith: 'semantic' | 'standalone';
+    error?: string;
+}
+/**
+ * Initialize semantic integration.
+ *
+ * This registers the patterns-reference database as an external pattern source
+ * with the @lokascript/semantic registry, enabling runtime pattern matching.
+ *
+ * @param options - Integration options
+ * @returns Integration result
+ *
+ * @example
+ * ```typescript
+ * const result = await initializeSemanticIntegration();
+ * if (result.success) {
+ *   console.log('Patterns available in semantic parser');
+ * }
+ * ```
+ */
+declare function initializeSemanticIntegration(options?: SemanticIntegrationOptions): Promise<IntegrationResult>;
+/**
+ * Check if semantic integration is initialized.
+ */
+declare function isSemanticIntegrationInitialized(): boolean;
+/**
+ * Get the bridge provider instance.
+ */
+declare function getBridgeProvider(): DatabasePatternsProvider | null;
+/**
+ * Uninitialize semantic integration.
+ * Useful for testing or cleanup.
+ */
+declare function uninitializeSemanticIntegration(): Promise<void>;
+/**
+ * Query patterns from the database for a specific language.
+ * Works regardless of whether semantic integration is initialized.
+ *
+ * @param language - Language code
+ * @returns Array of pattern entries
+ */
+declare function queryPatterns(language: string): Promise<PatternEntry[]>;
+/**
+ * Query patterns from the database for a specific command.
+ *
+ * @param command - Command name (e.g., 'toggle', 'add')
+ * @param language - Optional language filter
+ * @returns Array of pattern entries
+ */
+declare function queryPatternsForCommand(command: string, language?: string): Promise<PatternEntry[]>;
+/**
+ * Get supported languages from the database.
+ *
+ * @returns Array of language codes
+ */
+declare function getSupportedLanguages(): Promise<string[]>;
+
+/**
+ * @hyperfixi/patterns-reference
+ *
+ * Queryable patterns database for hyperscript with multilingual translations
+ * and LLM support for few-shot learning.
+ *
+ * @example
+ * ```typescript
+ * import { createPatternsReference } from '@hyperfixi/patterns-reference';
+ *
+ * const ref = createPatternsReference();
+ *
+ * // Query patterns
+ * const pattern = await ref.getPatternById('toggle-class-basic');
+ * const patterns = await ref.searchPatterns('toggle');
+ *
+ * // Get translations
+ * const translation = await ref.getTranslation('toggle-class-basic', 'ja');
+ *
+ * // Get LLM examples
+ * const examples = await ref.getLLMExamples('toggle a class on click');
+ *
+ * // Clean up
+ * ref.close();
+ * ```
+ */
+
+/**
+ * Create a PatternsReference instance.
+ *
+ * This provides a unified API for querying patterns, translations,
+ * and LLM examples from the hyperscript-lsp database.
+ *
+ * @param options - Connection options (dbPath, readonly)
+ * @returns PatternsReference instance
+ */
+declare function createPatternsReference(options?: ConnectionOptions): PatternsReference;
+/**
+ * Version of the package.
+ */
+declare const VERSION = "0.1.0";
+
+export { Command, ConnectionOptions, DatabasePatternsProvider, Expression, Feature, type IntegrationResult, Keyword, LLMExample, type LLMExampleRecord, LanguageDocsStats, LanguageElement, LanguageElementType, type PatternEntry, PatternsReference, type PatternsSource, type SemanticIntegrationOptions, SpecialSymbol, VERSION, buildFewShotContextSync, closeDatabase, createLLMAdapter, createPatternsProvider, createPatternsReference, findExamplesByCommand, findRelevantExamples, getAllCommands, getAllExpressions, getAllFeatures, getAllKeywords, getAllSpecialSymbols, getBridgeProvider, getCommandByName, getCurrentDbPath, getDatabase, getDefaultProvider, getExpressionByName, getExpressionsByCategory, getFeatureByName, getKeywordByName, getLLMExampleStats, getLanguageDocsStats, getSpecialSymbolByName, getSupportedLanguages, initializeSemanticIntegration, isConnected, isDatabaseAvailable, isSemanticIntegrationInitialized, queryPatterns, queryPatternsForCommand, resetConnection, resetDefaultProvider, searchCommands, searchLanguageElements, trackExampleUsage, uninitializeSemanticIntegration };