maskweaver 0.9.4 → 0.9.6

package/dist/memory/store/sqlite.js

@@ -1,47 +1,24 @@
-/**
- * SQLite Storage - Persistent chunk and embedding storage
- *
- * Uses better-sqlite3 for Node.js compatibility.
- * WAL mode for concurrent access.
- *
- * NOTE: better-sqlite3 is an optional dependency.
- * This module uses dynamic import to avoid errors when not installed.
- */
 import { existsSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { cosineSimilarityFloat32, embeddingToBlob, blobToEmbedding, toFloat32Array, } from '../core.js';
-// Dynamic import for better-sqlite3 or bun:sqlite
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let DatabaseConstructor = null;
 let isBun = false;
 let sqliteUnavailable = false;
 let sqliteUnavailableReason = '';
-// Check if running in Bun at module level
-// @ts-ignore
 const IS_BUN = typeof Bun !== 'undefined';
-/**
- * Check if SQLite is available without throwing.
- * Returns true if SQLite can be loaded, false otherwise.
- */
 export function isSqliteAvailable() {
     return !sqliteUnavailable;
 }
-/**
- * Get the reason SQLite is unavailable.
- */
 export function getSqliteUnavailableReason() {
     return sqliteUnavailableReason;
 }
 async function loadDatabase() {
     if (DatabaseConstructor)
         return DatabaseConstructor;
-    // If we already know SQLite is unavailable, return null immediately
     if (sqliteUnavailable)
         return null;
-    // In Bun environment, use bun:sqlite exclusively
     if (IS_BUN) {
         try {
-            // @ts-ignore
             const { Database } = await import('bun:sqlite');
             DatabaseConstructor = Database;
             isBun = true;
@@ -54,8 +31,6 @@ async function loadDatabase() {
             return null;
         }
     }
-    // In Node.js environment, use better-sqlite3
-    // Use Function constructor to avoid Bun's static analysis of import()
     try {
         const dynamicImport = new Function('specifier', 'return import(specifier)');
         const module = await dynamicImport('better-sqlite3');
@@ -72,35 +47,23 @@ async function loadDatabase() {
         return null;
     }
 }
-// ============================================================================
-// Database Class
-// ============================================================================
 export class MemoryDatabase {
-    db; // Database.Database type
+    db;
     statements = new Map();
     ftsAvailable = false;
     constructor(db) {
         this.db = db;
     }
-    /**
-     * Create a new MemoryDatabase instance.
-     * Uses async factory pattern because better-sqlite3 is dynamically imported.
-     * Returns null if SQLite is not available (graceful degradation).
-     */
     static async create(dbPath) {
         const DatabaseClass = await loadDatabase();
-        // SQLite not available - graceful degradation
         if (!DatabaseClass) {
             return null;
         }
-        // Ensure directory exists
         const dir = dirname(dbPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
-        // Open database
         const db = new DatabaseClass(dbPath);
-        // Enable WAL mode for concurrency
         if (isBun) {
             db.exec('PRAGMA journal_mode = WAL');
             db.exec('PRAGMA synchronous = NORMAL');
@@ -108,19 +71,14 @@ export class MemoryDatabase {
         else {
             db.pragma('journal_mode = WAL');
             db.pragma('synchronous = NORMAL');
-            db.pragma('cache_size = -64000'); // 64MB
+            db.pragma('cache_size = -64000');
             db.pragma('temp_store = MEMORY');
         }
         const instance = new MemoryDatabase(db);
-        // Initialize schema
         instance.initSchema();
-        // Prepare statements
         instance.prepareStatements();
         return instance;
     }
-    /**
-     * Initialize database schema.
-     */
     initSchema() {
         this.db.exec(`
       -- Chunks table
@@ -158,7 +116,6 @@ export class MemoryDatabase {
       CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks(hash);
       CREATE INDEX IF NOT EXISTS idx_mask_usage_name ON mask_usage(mask_name);
     `);
-        // FTS5 virtual table
         this.ftsAvailable = false;
         try {
             this.db.exec(`
@@ -172,10 +129,8 @@ export class MemoryDatabase {
             this.ftsAvailable = true;
         }
         catch (error) {
-            // FTS5 not supported by this SQLite build
             console.warn('[Memory DB] FTS5 not available. Text search will be disabled:', error);
         }
-        // FTS triggers — only if FTS table was created successfully
         if (this.ftsAvailable) {
             try {
                 this.db.exec(`
@@ -202,9 +157,6 @@ export class MemoryDatabase {
             }
         }
     }
-    /**
-     * Prepare SQL statements for reuse.
-     */
     prepareStatements() {
         this.statements.set('upsertChunk', this.db.prepare(`
       INSERT INTO chunks (path, start_line, end_line, text, hash, source)
@@ -236,7 +188,6 @@ export class MemoryDatabase {
       FROM chunks c
       JOIN embeddings e ON c.id = e.chunk_id
     `));
-        // FTS statement — only prepare if FTS table exists
         if (this.ftsAvailable) {
             this.statements.set('searchFts', this.db.prepare(`
         SELECT rowid, text, rank
@@ -264,23 +215,12 @@ export class MemoryDatabase {
       ORDER BY usage_count DESC
     `));
     }
-    // ==========================================================================
-    // CRUD Operations
-    // ==========================================================================
-    /**
-     * Insert or update chunk.
-     *
-     * If embedding is empty (e.g., text-only mode), the chunk is stored
-     * but the embedding row is skipped. This allows text search to work
-     * while vector search gracefully returns no results for these chunks.
-     */
     upsertChunk(chunk, embedding) {
         const stmt = this.statements.get('upsertChunk');
         const result = stmt.get(chunk.path, chunk.startLine, chunk.endLine, chunk.text, chunk.hash, chunk.source);
         if (!result?.id) {
             throw new Error('[Memory DB] Failed to upsert chunk');
         }
-        // Only save embedding if it has actual content
         if (embedding && embedding.length > 0) {
             const embStmt = this.statements.get('upsertEmbedding');
             const embeddingBlob = embeddingToBlob(embedding);
@@ -288,9 +228,6 @@ export class MemoryDatabase {
         }
         return result.id;
     }
-    /**
-     * Bulk insert chunks in transaction.
-     */
     upsertChunks(chunks) {
         const ids = [];
         const transaction = this.db.transaction(() => {
@@ -302,25 +239,16 @@ export class MemoryDatabase {
         transaction();
         return ids;
     }
-    /**
-     * Delete chunks by path.
-     */
     deleteChunksByPath(path) {
         const stmt = this.statements.get('deleteChunksByPath');
         const result = stmt.run(path);
         return result.changes;
     }
-    /**
-     * Check if chunk changed.
-     */
     isChunkChanged(path, hash) {
         const stmt = this.statements.get('checkChunkByHash');
         const result = stmt.get(path, hash);
         return result === undefined;
     }
-    /**
-     * Get chunks by path.
-     */
     getChunksByPath(path) {
         const stmt = this.statements.get('getChunksByPath');
         const rows = stmt.all(path);
@@ -335,34 +263,19 @@ export class MemoryDatabase {
             createdAt: row.created_at,
         }));
     }
-    // ==========================================================================
-    // Search Operations
-    // ==========================================================================
-    /**
-     * Vector similarity search.
-     *
-     * Returns empty results if queryEmbedding is empty (e.g., text-only mode).
-     * Skips stored embeddings with dimension mismatches instead of crashing.
-     */
     searchByVector(queryEmbedding, limit = 6, sourceFilter) {
-        // Empty embedding = text-only mode. Skip vector search entirely.
         if (!queryEmbedding || queryEmbedding.length === 0) {
             return [];
         }
         const queryVec = toFloat32Array(queryEmbedding);
-        // Get all embeddings
         const stmt = this.statements.get('getAllEmbeddings');
         let rows = stmt.all();
-        // Filter by source if specified
         if (sourceFilter && sourceFilter.length > 0) {
             rows = rows.filter(row => sourceFilter.includes(row.source));
         }
-        // Calculate similarities and sort
-        // cosineSimilarityFloat32 returns 0 on dimension mismatch (no throw)
         const scored = [];
         for (const row of rows) {
             const embeddingVec = blobToEmbedding(row.embedding);
-            // Skip rows with empty or invalid embeddings
             if (embeddingVec.length === 0) {
                 continue;
             }
@@ -386,10 +299,6 @@ export class MemoryDatabase {
             .sort((a, b) => b.score - a.score)
             .slice(0, limit);
     }
-    /**
-     * Full-text search using FTS5.
-     * Returns empty results if FTS is not available.
-     */
     searchByText(query, limit = 6) {
         if (!this.ftsAvailable) {
             return [];
@@ -408,7 +317,6 @@ export class MemoryDatabase {
                 const chunk = chunkStmt.get(fts.rowid);
                 if (!chunk)
                     continue;
-                // Normalize BM25 score to 0-1 range
                 const normalizedScore = Math.min(1, Math.max(0, -fts.rank / 10));
                 results.push({
                     chunk: {
@@ -432,9 +340,6 @@ export class MemoryDatabase {
             return [];
         }
     }
-    /**
-     * Normalize FTS query.
-     */
     normalizeFtsQuery(query) {
         const tokens = query
             .replace(/[^\w\s가-힣]/g, ' ')
@@ -444,9 +349,6 @@ export class MemoryDatabase {
             return '';
         return tokens.map(t => `${t}*`).join(' OR ');
     }
-    // ==========================================================================
-    // Mask Usage
-    // ==========================================================================
     recordMaskUsage(maskName, taskDescription, effectivenessScore) {
         const stmt = this.statements.get('insertMaskUsage');
         stmt.run(maskName, taskDescription ?? null, effectivenessScore ?? null);
@@ -455,9 +357,6 @@ export class MemoryDatabase {
         const stmt = this.statements.get('getMaskStats');
         return stmt.all();
     }
-    // ==========================================================================
-    // Utilities
-    // ==========================================================================
     getStats() {
         const chunkCount = this.db.prepare('SELECT COUNT(*) as count FROM chunks').get().count;
         const embeddingCount = this.db.prepare('SELECT COUNT(*) as count FROM embeddings').get().count;
@@ -491,14 +390,7 @@ export class MemoryDatabase {
         this.db.close();
     }
 }
-// ============================================================================
-// Singleton Instance
-// ============================================================================
 let defaultInstance = null;
-/**
- * Initialize the database.
- * Returns null if SQLite is not available (graceful degradation).
- */
 export async function initDatabase(dbPath) {
     if (defaultInstance) {
         defaultInstance.close();
@@ -506,30 +398,15 @@ export async function initDatabase(dbPath) {
     defaultInstance = await MemoryDatabase.create(dbPath);
     return defaultInstance;
 }
-/**
- * Get the database instance.
- * Returns null if SQLite is not available or not initialized.
- * Use this for optional memory features.
- */
 export function getDatabase() {
     if (!defaultInstance && !isSqliteAvailable()) {
-        // SQLite not available - return null instead of throwing
         return null;
     }
     return defaultInstance;
 }
-/**
- * Try to get the database instance, returning null if not initialized.
- * Use this when database access is optional (e.g., in intake stage).
- */
 export function tryGetDatabase() {
     return defaultInstance;
 }
-// ============================================================================
-// Convenience Functions
-// These throw errors if SQLite is not available. Use getDatabase() directly
-// for optional access with null checks.
-// ============================================================================
 export function upsertChunk(chunk, embedding) {
     const db = getDatabase();
     if (!db)
@@ -539,13 +416,13 @@ export function upsertChunk(chunk, embedding) {
 export function searchByVector(embedding, limit) {
     const db = getDatabase();
     if (!db)
-        return []; // Graceful degradation - return empty results
+        return [];
     return db.searchByVector(embedding, limit);
 }
 export function searchByText(query, limit) {
     const db = getDatabase();
     if (!db)
-        return []; // Graceful degradation - return empty results
+        return [];
     return db.searchByText(query, limit);
 }
 export function deleteChunksByPath(path) {

package/dist/plugin/config/index.d.ts

@@ -1,153 +1,41 @@
-/**
- * Maskweaver Plugin Configuration Loader
- *
- * Loads maskweaver.json(c) configuration files with support for:
- * - Project-level configuration (.opencode/maskweaver.json)
- * - Global configuration (~/.config/opencode/maskweaver.json)
- * - JSONC format (comments, trailing commas)
- *
- * Based on oh-my-opencode pattern for plugin configuration management.
- */
-/**
- * Logger interface for config loading.
- * Accepts the SDK client (or any compatible object).
- */
 interface ConfigLoaderContext {
     client: unknown;
     verbose?: boolean;
 }
-/**
- * Agent override configuration
- */
 export interface AgentOverride {
     model?: string;
     systemPrompt?: string;
 }
-/**
- * Mask-specific configuration
- */
 export interface MaskConfig {
-    /** Default mask ID to activate on session start */
     default?: string;
-    /** Automatically activate default mask on session start */
     autoActivate?: boolean;
 }
-/**
- * Logging configuration
- */
 export interface LoggingConfig {
-    /** Enable verbose logging */
     verbose?: boolean;
 }
-/**
- * Completion sound notification configuration
- */
 export interface CompletionSoundConfig {
-    /** Play sound when the active session becomes idle */
     enabled?: boolean;
 }
-/**
- * Notification configuration
- */
 export interface NotificationsConfig {
     completionSound?: CompletionSoundConfig;
 }
-/**
- * Maskweaver Plugin Configuration
- */
 export interface MaskweaverPluginConfig {
-    /** JSON Schema reference (for IDE support) */
     $schema?: string;
-    /** List of disabled mask IDs */
     disabled_masks?: string[];
-    /** List of disabled tool names */
     disabled_tools?: string[];
-    /** Agent overrides (model, system prompt) */
     agents?: Record<string, AgentOverride>;
-    /** Mask configuration */
     masks?: MaskConfig;
-    /** Logging configuration */
     logging?: LoggingConfig;
-    /** Notifications configuration */
     notifications?: NotificationsConfig;
 }
-/**
- * Load plugin configuration from directory
- *
- * Searches for configuration files in priority order and returns
- * the first found configuration. Returns empty object if no config found.
- *
- * @param directory - Project directory to search for config
- * @param ctx - Optional plugin context (for logging)
- * @returns Parsed configuration object
- */
 export declare function loadPluginConfig(directory: string, ctx?: ConfigLoaderContext): MaskweaverPluginConfig;
-/**
- * Check if a tool is enabled in the configuration
- *
- * A tool is considered enabled if:
- * - No disabled_tools list exists, OR
- * - disabled_tools list exists but doesn't include the tool name
- *
- * @param config - Plugin configuration
- * @param toolName - Name of the tool to check
- * @returns true if tool is enabled, false otherwise
- */
 export declare function isToolEnabled(config: MaskweaverPluginConfig, toolName: string): boolean;
-/**
- * Check if a mask is enabled in the configuration
- *
- * A mask is considered enabled if:
- * - No disabled_masks list exists, OR
- * - disabled_masks list exists but doesn't include the mask ID
- *
- * @param config - Plugin configuration
- * @param maskId - ID of the mask to check
- * @returns true if mask is enabled, false otherwise
- */
 export declare function isMaskEnabled(config: MaskweaverPluginConfig, maskId: string): boolean;
-/**
- * Get the default mask ID from configuration
- *
- * @param config - Plugin configuration
- * @returns Default mask ID if configured, undefined otherwise
- */
 export declare function getDefaultMask(config: MaskweaverPluginConfig): string | undefined;
-/**
- * Check if auto-activation is enabled for the default mask
- *
- * @param config - Plugin configuration
- * @returns true if auto-activation is enabled, false otherwise
- */
 export declare function isAutoActivateEnabled(config: MaskweaverPluginConfig): boolean;
-/**
- * Get agent override for a specific agent
- *
- * @param config - Plugin configuration
- * @param agentName - Name of the agent
- * @returns Agent override config if exists, undefined otherwise
- */
 export declare function getAgentOverride(config: MaskweaverPluginConfig, agentName: string): AgentOverride | undefined;
-/**
- * Check if verbose logging is enabled
- *
- * @param config - Plugin configuration
- * @returns true if verbose logging is enabled, false otherwise
- */
 export declare function isVerboseLoggingEnabled(config: MaskweaverPluginConfig): boolean;
-/**
- * Check if completion sound notification is enabled
- *
- * @param config - Plugin configuration
- * @returns true if completion sound is enabled, false otherwise
- */
 export declare function isCompletionSoundEnabled(config: MaskweaverPluginConfig): boolean;
-/**
- * Validate configuration structure
- *
- * @param config - Configuration to validate
- * @returns Array of validation error messages (empty if valid)
- */
 export declare function validateConfig(config: MaskweaverPluginConfig): string[];
 declare const _default: {
     loadPluginConfig: typeof loadPluginConfig;