@yamo/memory-mesh 2.2.0 → 2.3.0

package/lib/reporting/skill-report-generator.js

@@ -1,283 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-/**
- * Skill Execution Report Generator
- *
- * Generates JSON reports for skill executions, capturing:
- * - Skill metadata (name, version, type)
- * - Execution details (duration, status, provider)
- * - Input/output metrics
- * - Quality indicators
- */
-export class SkillReportGenerator {
-    constructor(options = {}) {
-        this.reportsDir = options.reportsDir || this._getReportsDir();
-        this.version = '1.0.0';
-    }
-
-    _getReportsDir() {
-        // @ts-ignore
-        const home = process.env.HOME || process.env.USERPROFILE || process.cwd();
-        return path.join(home, '.yamo', 'reports');
-    }
-
-    /**
-     * Generate a unique report ID
-     * @param {string} sessionId - Session identifier
-     * @returns {string} Report ID
-     */
-    _generateReportId(sessionId) {
-        const timestamp = Date.now();
-        const shortSession = sessionId ? sessionId.substring(0, 8) : 'unknown';
-        return `skill_execution_${timestamp}_${shortSession}`;
-    }
-
-    /**
-     * Extract skill type from file path or name
-     * @param {string} skillName - Name of the skill
-     * @param {string[]} contextFiles - Context files used
-     * @returns {string} Skill type
-     */
-    _getSkillType(skillName, contextFiles = []) {
-        if (skillName === 'LLMClient') return 'direct';
-
-        const skillFile = contextFiles.find(f => f.endsWith('.yamo'));
-        if (!skillFile) return 'unknown';
-
-        if (skillFile.includes('utility/')) return 'utility';
-        if (skillFile.includes('generator/')) return 'generator';
-        if (skillFile.includes('protocol/')) return 'protocol';
-        if (skillFile.includes('system-skills/')) return 'system';
-
-        return 'custom';
-    }
-
-    /**
-     * Parse skill metadata from .yamo file path
-     * @param {string[]} contextFiles - Context files
-     * @returns {Object} Skill metadata
-     */
-    _parseSkillMetadata(contextFiles = []) {
-        const skillFile = contextFiles.find(f => f.endsWith('.yamo'));
-        if (!skillFile) {
-            return { version: null, description: null };
-        }
-
-        // Return basic info - full parsing would require reading the file
-        return {
-            version: '1.0.0', // Default version
-            file: skillFile
-        };
-    }
-
-    /**
-     * Create a report object from execution data
-     * @param {Object} executionData - Data from skill execution
-     * @returns {Object} Report object
-     */
-    createReport(executionData) {
-        const {
-            skill,
-            sessionId,
-            duration,
-            provider,
-            model,
-            promptLength,
-            responseLength,
-            contextFiles = [],
-            parameters = {},
-            status = 'success',
-            error = null,
-            artifactsCreated = [],
-            memoryCaptured = false
-        } = executionData;
-
-        const reportId = this._generateReportId(sessionId);
-        const skillMeta = this._parseSkillMetadata(contextFiles);
-        const skillType = this._getSkillType(skill, contextFiles);
-
-        return {
-            report_id: reportId,
-            timestamp: new Date().toISOString(),
-            skill: {
-                name: skill,
-                version: skillMeta.version,
-                type: skillType,
-                file: skillMeta.file || null
-            },
-            execution: {
-                session_id: sessionId,
-                duration_ms: Math.round(duration),
-                status,
-                error: error ? String(error) : null,
-                provider,
-                model
-            },
-            input: {
-                prompt_length: promptLength,
-                context_files: contextFiles,
-                parameters
-            },
-            output: {
-                response_length: responseLength,
-                artifacts_created: artifactsCreated,
-                tokens_used: null // Could be populated if provider returns token count
-            },
-            quality: {
-                memory_captured: memoryCaptured,
-                artifacts_saved: artifactsCreated.length > 0
-            },
-            meta: {
-                generator: 'yamo-skills',
-                version: this.version
-            }
-        };
-    }
-
-    /**
-     * Generate filename for a report
-     * @param {Object} report - Report object
-     * @returns {string} Filename
-     */
-    getReportFilename(report) {
-        // Format: skill-{name}_{timestamp}_{ms}.json
-        // Include milliseconds for uniqueness when multiple reports per second
-        const safeName = report.skill.name.toLowerCase().replace(/[^a-z0-9]/g, '-');
-        const timestamp = report.timestamp.replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
-        const ms = report.timestamp.slice(20, 23) || '000';
-        return `skill-${safeName}_${timestamp}-${ms}.json`;
-    }
-
-    /**
-     * Ensure reports directory exists
-     */
-    async _ensureReportsDir() {
-        try {
-            await fs.mkdir(this.reportsDir, { recursive: true });
-        } catch (error) {
-            const e = error instanceof Error ? error : new Error(String(error));
-            // @ts-ignore
-            if (e.code !== 'EEXIST') {
-                throw e;
-            }
-        }
-    }
-
-    /**
-     * Save a report to disk
-     * @param {Object} report - Report object to save
-     * @returns {Promise<string>} Path to saved report
-     */
-    async saveReport(report) {
-        await this._ensureReportsDir();
-
-        const filename = this.getReportFilename(report);
-        const filepath = path.join(this.reportsDir, filename);
-
-        await fs.writeFile(filepath, JSON.stringify(report, null, 2), 'utf8');
-
-        return filepath;
-    }
-
-    /**
-     * Generate and save a report in one call
-     * @param {Object} executionData - Data from skill execution
-     * @returns {Promise<Object>} Report object with filepath
-     */
-    async generateAndSave(executionData) {
-        const report = this.createReport(executionData);
-        const filepath = await this.saveReport(report);
-
-        return {
-            ...report,
-            _filepath: filepath
-        };
-    }
-
-    /**
-     * List recent reports
-     * @param {number} limit - Maximum number of reports to return
-     * @returns {Promise<string[]>} Array of report filenames
-     */
-    async listReports(limit = 10) {
-        try {
-            await this._ensureReportsDir();
-            const files = await fs.readdir(this.reportsDir);
-
-            // Filter JSON files and sort by name (descending = newest first)
-            const reports = files
-                .filter(f => f.endsWith('.json'))
-                .sort((a, b) => b.localeCompare(a))
-                .slice(0, limit);
-
-            return reports;
-        } catch (error) {
-            return [];
-        }
-    }
-
-    /**
-     * Read a specific report
-     * @param {string} filename - Report filename
-     * @returns {Promise<Object|null>} Report object or null
-     */
-    async readReport(filename) {
-        try {
-            const filepath = path.join(this.reportsDir, filename);
-            const content = await fs.readFile(filepath, 'utf8');
-            return JSON.parse(content);
-        } catch (error) {
-            return null;
-        }
-    }
-
-    /**
-     * Get aggregate statistics from recent reports
-     * @param {number} limit - Number of reports to analyze
-     * @returns {Promise<Object>} Statistics object
-     */
-    async getStats(limit = 100) {
-        const reportFiles = await this.listReports(limit);
-        const stats = {
-            total_reports: reportFiles.length,
-            skills_used: {},
-            providers_used: {},
-            success_count: 0,
-            error_count: 0,
-            total_duration_ms: 0,
-            avg_duration_ms: 0
-        };
-
-        for (const filename of reportFiles) {
-            const report = await this.readReport(filename);
-            if (!report) continue;
-
-            // Count skills
-            const skillName = report.skill?.name || 'unknown';
-            stats.skills_used[skillName] = (stats.skills_used[skillName] || 0) + 1;
-
-            // Count providers
-            const provider = report.execution?.provider || 'unknown';
-            stats.providers_used[provider] = (stats.providers_used[provider] || 0) + 1;
-
-            // Count success/error
-            if (report.execution?.status === 'success') {
-                stats.success_count++;
-            } else {
-                stats.error_count++;
-            }
-
-            // Sum duration
-            stats.total_duration_ms += report.execution?.duration_ms || 0;
-        }
-
-        if (stats.total_reports > 0) {
-            stats.avg_duration_ms = Math.round(stats.total_duration_ms / stats.total_reports);
-        }
-
-        return stats;
-    }
-}
-
-export default SkillReportGenerator;

package/lib/search/filter.js

@@ -1,275 +0,0 @@
-/**
- * FilterBuilder - Fluent API for building LanceDB filter expressions
- * Provides type-safe filter construction for metadata queries
- */
-
-class FilterBuilder {
-  /**
-   * Create a new FilterBuilder
-   */
-  constructor() {
-    this.filters = [];
-    this.operator = 'AND';
-  }
-
-  /**
-   * Add equality filter
-   * @param {string} field - Field name
-   * @param {*} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  equals(field, value) {
-    this.filters.push(`${field} = ${this._quote(value)}`);
-    return this;
-  }
-
-  /**
-   * Add inequality filter
-   * @param {string} field - Field name
-   * @param {*} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  notEquals(field, value) {
-    this.filters.push(`${field} != ${this._quote(value)}`);
-    return this;
-  }
-
-  /**
-   * Add greater than filter
-   * @param {string} field - Field name
-   * @param {number} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  gt(field, value) {
-    this.filters.push(`${field} > ${value}`);
-    return this;
-  }
-
-  /**
-   * Add greater than or equal filter
-   * @param {string} field - Field name
-   * @param {number} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  gte(field, value) {
-    this.filters.push(`${field} >= ${value}`);
-    return this;
-  }
-
-  /**
-   * Add less than filter
-   * @param {string} field - Field name
-   * @param {number} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  lt(field, value) {
-    this.filters.push(`${field} < ${value}`);
-    return this;
-  }
-
-  /**
-   * Add less than or equal filter
-   * @param {string} field - Field name
-   * @param {number} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  lte(field, value) {
-    this.filters.push(`${field} <= ${value}`);
-    return this;
-  }
-
-  /**
-   * Add contains filter (LIKE)
-   * @param {string} field - Field name
-   * @param {string} value - Value to search for
-   * @returns {FilterBuilder} this for chaining
-   */
-  contains(field, value) {
-    this.filters.push(`${field} LIKE '%${this._escapeLike(value)}%'`);
-    return this;
-  }
-
-  /**
-   * Add starts with filter
-   * @param {string} field - Field name
-   * @param {string} value - Value to match
-   * @returns {FilterBuilder} this for chaining
-   */
-  startsWith(field, value) {
-    this.filters.push(`${field} LIKE '${this._escapeLike(value)}%'`);
-    return this;
-  }
-
-  /**
-   * Add ends with filter
-   * @param {string} field - Field name
-   * @param {string} value - Value to match
-   * @returns {FilterBuilder} this for chaining
-   */
-  endsWith(field, value) {
-    this.filters.push(`${field} LIKE '%${this._escapeLike(value)}'`);
-    return this;
-  }
-
-  /**
-   * Add IN array filter
-   * @param {string} field - Field name
-   * @param {Array} values - Array of values
-   * @returns {FilterBuilder} this for chaining
-   */
-  in(field, values) {
-    if (!Array.isArray(values) || values.length === 0) {
-      throw new Error('IN filter requires non-empty array');
-    }
-    const quoted = values.map(v => this._quote(v)).join(', ');
-    this.filters.push(`${field} IN [${quoted}]`);
-    return this;
-  }
-
-  /**
-   * Add NOT IN array filter
-   * @param {string} field - Field name
-   * @param {Array} values - Array of values
-   * @returns {FilterBuilder} this for chaining
-   */
-  notIn(field, values) {
-    if (!Array.isArray(values) || values.length === 0) {
-      throw new Error('NOT IN filter requires non-empty array');
-    }
-    const quoted = values.map(v => this._quote(v)).join(', ');
-    this.filters.push(`${field} NOT IN [${quoted}]`);
-    return this;
-  }
-
-  /**
-   * Add range filter (inclusive)
-   * @param {string} field - Field name
-   * @param {number} min - Minimum value
-   * @param {number} max - Maximum value
-   * @returns {FilterBuilder} this for chaining
-   */
-  range(field, min, max) {
-    this.filters.push(`${field} >= ${min} AND ${field} <= ${max}`);
-    return this;
-  }
-
-  /**
-   * Add date range filter
-   * @param {string} field - Field name
-   * @param {string|Date} startDate - Start date
-   * @param {string|Date} endDate - End date
-   * @returns {FilterBuilder} this for chaining
-   */
-  dateRange(field, startDate, endDate) {
-    const start = startDate instanceof Date ? startDate.toISOString() : startDate;
-    const end = endDate instanceof Date ? endDate.toISOString() : endDate;
-    this.filters.push(`${field} >= '${start}' AND ${field} <= '${end}'`);
-    return this;
-  }
-
-  /**
-   * Add nested metadata filter
-   * @param {string} field - Metadata field name
-   * @param {*} value - Value to compare
-   * @returns {FilterBuilder} this for chaining
-   */
-  metadata(field, value) {
-    this.filters.push(`metadata.${field} = ${this._quote(value)}`);
-    return this;
-  }
-
-  /**
-   * Combine filters with AND
-   * @returns {FilterBuilder} this for chaining
-   */
-  and() {
-    this.operator = 'AND';
-    return this;
-  }
-
-  /**
-   * Combine filters with OR
-   * @returns {FilterBuilder} this for chaining
-   */
-  or() {
-    this.operator = 'OR';
-    return this;
-  }
-
-  /**
-   * Build and return the filter string
-   * @returns {string} Filter expression
-   */
-  build() {
-    if (this.filters.length === 0) {
-      return '';
-    }
-
-    return this.filters.join(` ${this.operator} `);
-  }
-
-  /**
-   * Check if builder has any filters
-   * @returns {boolean} True if filters exist
-   */
-  hasFilters() {
-    return this.filters.length > 0;
-  }
-
-  /**
-   * Get filter count
-   * @returns {number} Number of filters
-   */
-  count() {
-    return this.filters.length;
-  }
-
-  /**
-   * Reset all filters
-   * @returns {FilterBuilder} this for chaining
-   */
-  reset() {
-    this.filters = [];
-    this.operator = 'AND';
-    return this;
-  }
-
-  /**
-   * Quote string values for SQL
-   * @private
-   * @param {*} value - Value to quote
-   * @returns {string} Quoted value
-   */
-  _quote(value) {
-    if (typeof value === 'string') {
-      return `'${value.replace(/'/g, "''")}'`;
-    }
-    if (value === null) {
-      return 'NULL';
-    }
-    if (typeof value === 'boolean') {
-      return value ? 'true' : 'false';
-    }
-    return String(value);
-  }
-
-  /**
-   * Escape special LIKE characters
-   * @private
-   * @param {string} value - Value to escape
-   * @returns {string} Escaped value
-   */
-  _escapeLike(value) {
-    return value.replace(/'/g, "''").replace(/%/g, '\\%').replace(/_/g, '\\_');
-  }
-
-  /**
-   * Create a new builder instance
-   * @returns {FilterBuilder} New builder
-   */
-  static create() {
-    return new FilterBuilder();
-  }
-}
-
-export default FilterBuilder;

package/lib/search/hybrid.js

@@ -1,137 +0,0 @@
-/**
- * HybridSearch - Combines vector and keyword search
- */
-
-import { QueryError } from "../lancedb/errors.js";
-
-class HybridSearch {
-  constructor(client, embeddingFactory, options = {}) {
-    this.client = client;
-    this.embeddingFactory = embeddingFactory;
-    this.alpha = options.alpha !== undefined
-      ? options.alpha
-      : parseFloat(process.env.HYBRID_SEARCH_ALPHA || '0.5');
-    this.rrfK = options.rrfK || 60;
-  }
-
-  async search(query, options = {}) {
-    // @ts-ignore
-    const limit = options.limit || 10;
-    // @ts-ignore
-    const alpha = options.alpha !== undefined ? options.alpha : this.alpha;
-
-    try {
-      const [vectorResults, keywordResults] = await Promise.all([
-        // @ts-ignore
-        this._vectorSearch(query, limit * 2, options.filter),
-        // @ts-ignore
-        this._keywordSearch(query, limit * 2, options.filter)
-      ]);
-
-      const mergedResults = this._reciprocalRankFusion(
-        vectorResults,
-        keywordResults,
-        alpha,
-        this.rrfK
-      );
-
-      return mergedResults.slice(0, limit);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new QueryError('Hybrid search failed', {
-        query,
-        alpha,
-        originalError: message
-      });
-    }
-  }
-
-  async _vectorSearch(query, limit, filter = null) {
-    const embedding = await this.embeddingFactory.embed(query);
-    const searchOptions = { limit, metric: 'cosine' };
-    if (filter) searchOptions.filter = filter;
-
-    const result = await this.client.search(embedding, searchOptions);
-    return result.map(r => ({
-      ...r,
-      score: 1 - (r.score || 0),
-      searchType: 'vector'
-    }));
-  }
-
-  async _keywordSearch(query, limit, filter = null) {
-    try {
-      const embedding = await this.embeddingFactory.embed(query);
-      const searchOptions = { limit: limit * 3, metric: 'cosine' };
-      if (filter) searchOptions.filter = filter;
-
-      const result = await this.client.search(embedding, searchOptions);
-      const queryTerms = query.toLowerCase().split(/\s+/);
-
-      return result
-        .filter(r => {
-          const content = r.content.toLowerCase();
-          return queryTerms.some(term => content.includes(term));
-        })
-        .slice(0, limit)
-        .map(r => ({
-          ...r,
-          score: r.score || 0,
-          searchType: 'keyword'
-        }));
-    } catch (error) {
-      return [];
-    }
-  }
-
-  _reciprocalRankFusion(vectorResults, keywordResults, alpha, k = 60) {
-    const scores = new Map();
-    vectorResults.forEach((result, index) => {
-      const rr = 1 / (k + index + 1);
-      scores.set(result.id, {
-        result,
-        vectorScore: rr * (1 - alpha),
-        keywordScore: 0,
-        vectorRank: index + 1,
-        keywordRank: null
-      });
-    });
-
-    keywordResults.forEach((result, index) => {
-      const rr = 1 / (k + index + 1);
-      if (scores.has(result.id)) {
-        const entry = scores.get(result.id);
-        entry.keywordScore = rr * alpha;
-        entry.keywordRank = index + 1;
-      } else {
-        scores.set(result.id, {
-          result,
-          vectorScore: 0,
-          keywordScore: rr * alpha,
-          vectorRank: null,
-          keywordRank: index + 1
-        });
-      }
-    });
-
-    return Array.from(scores.values())
-      .map(({ result, vectorScore, keywordScore, vectorRank, keywordRank }) => ({
-        ...result,
-        combinedScore: vectorScore + keywordScore,
-        vectorScore,
-        keywordScore,
-        vectorRank,
-        keywordRank,
-        searchType: vectorRank !== null && keywordRank !== null
-          ? 'hybrid'
-          : vectorRank !== null ? 'vector' : 'keyword'
-      }))
-      .sort((a, b) => b.combinedScore - a.combinedScore);
-  }
-
-  getStats() {
-    return { alpha: this.alpha, rrfK: this.rrfK, type: 'hybrid' };
-  }
-}
-
-export default HybridSearch;