@yamo/memory-mesh 2.2.0 → 2.3.0

package/lib/search/pattern-miner.js

@@ -1,160 +0,0 @@
-/**
- * PatternMiner - Analyzes search results for patterns and insights
- */
-
-import crypto from "crypto";
-
-class PatternMiner {
-  constructor(options = {}) {
-    // @ts-ignore
-    this.similarityThreshold = options.similarityThreshold || 0.8;
-    // @ts-ignore
-    this.minClusterSize = options.minClusterSize || 2;
-    // @ts-ignore
-    this.maxThemes = options.maxThemes || 10;
-    // @ts-ignore
-    this.minWordLength = options.minWordLength || 4;
-  }
-
-  async minePatterns(results, options = {}) {
-    // @ts-ignore
-    const { extractEntities = false, deduplicate = true } = options;
-    let workingResults = [...results];
-    if (deduplicate) workingResults = this.deduplicate(workingResults);
-
-    const patterns = {
-      originalCount: results.length,
-      uniqueCount: workingResults.length,
-      duplicatesRemoved: results.length - workingResults.length,
-      clusters: [],
-      themes: [],
-      entities: [],
-      summary: ''
-    };
-
-    // @ts-ignore
-    patterns.clusters = this._clusterResults(workingResults);
-    // @ts-ignore
-    patterns.themes = this._extractThemes(workingResults);
-
-    if (extractEntities) {
-      // @ts-ignore
-      patterns.entities = await this._extractEntities(workingResults);
-    }
-
-    patterns.summary = this._generateSummary(patterns);
-    return patterns;
-  }
-
-  _clusterResults(results) {
-    const clusters = [];
-    const used = new Set();
-    for (let i = 0; i < results.length; i++) {
-      if (used.has(i)) continue;
-      const cluster = { representative: results[i], members: [results[i]], similarityScore: 1.0 };
-      for (let j = i + 1; j < results.length; j++) {
-        if (used.has(j)) continue;
-        const similarity = this._calculateSimilarity(results[i], results[j]);
-        if (similarity >= this.similarityThreshold) {
-          cluster.members.push(results[j]);
-          used.add(j);
-          cluster.similarityScore = Math.min(cluster.similarityScore, similarity);
-        }
-      }
-      if (cluster.members.length >= this.minClusterSize || cluster.members.length === 1) {
-        used.add(i);
-        clusters.push(cluster);
-      }
-    }
-    return clusters;
-  }
-
-  _calculateSimilarity(result1, result2) {
-    let score = 0;
-    let factors = 0;
-    if (result1.score !== undefined && result2.score !== undefined) {
-      const scoreDiff = Math.abs(result1.score - result2.score);
-      const scoreSim = Math.max(0, 1 - scoreDiff);
-      score += scoreSim * 0.5;
-      factors += 0.5;
-    }
-    if (result1.metadata?.type && result2.metadata?.type) {
-      const typeMatch = result1.metadata.type === result2.metadata.type ? 1 : 0;
-      score += typeMatch * 0.25;
-      factors += 0.25;
-    }
-    const contentSim = this._contentOverlap(result1.content, result2.content);
-    score += contentSim * 0.1;
-    factors += 0.1;
-    return factors > 0 ? score / factors : 0;
-  }
-
-  _contentOverlap(content1, content2) {
-    const words1 = new Set(content1.toLowerCase().split(/\s+/).filter(w => w.length > this.minWordLength));
-    const words2 = new Set(content2.toLowerCase().split(/\s+/).filter(w => w.length > this.minWordLength));
-    if (words1.size === 0 || words2.size === 0) return 0;
-    const intersection = new Set([...words1].filter(x => words2.has(x)));
-    const union = new Set([...words1, ...words2]);
-    return intersection.size / union.size;
-  }
-
-  _extractThemes(results) {
-    const themeMap = new Map();
-    const stopWords = new Set(['the', 'this', 'that', 'with', 'from', 'have', 'been', 'were', 'they', 'their', 'what', 'when', 'where', 'which', 'will', 'your', 'about', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'could', 'would', 'should', 'each', 'only', 'being', 'other', 'some', 'such', 'them', 'these', 'those', 'over', 'also']);
-    results.forEach(result => {
-      const words = result.content.toLowerCase().split(/\s+/).map(w => w.replace(/[^a-z]/g, '')).filter(w => w.length >= this.minWordLength && !stopWords.has(w));
-      words.forEach(word => {
-        themeMap.set(word, (themeMap.get(word) || 0) + 1);
-      });
-    });
-    return Array.from(themeMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, this.maxThemes).map(([word, count]) => ({
-      word, count, frequency: count / results.length
-    }));
-  }
-
-  async _extractEntities(results) {
-    const entities = [];
-    results.forEach(result => {
-      const emailMatches = result.content.match(/\b[\w.-]+@[\w.-]+\.\w+\b/g);
-      if (emailMatches) emailMatches.forEach(e => entities.push({ type: 'email', value: e }));
-    });
-    const uniqueEntities = [];
-    const seen = new Set();
-    entities.forEach(e => {
-      const key = `${e.type}:${e.value}`;
-      if (!seen.has(key)) {
-        seen.add(key);
-        uniqueEntities.push(e);
-      }
-    });
-    return uniqueEntities;
-  }
-
-  _generateSummary(patterns) {
-    return `Original results: ${patterns.originalCount}, Unique results: ${patterns.uniqueCount}`;
-  }
-
-  deduplicate(results) {
-    const seen = new Set();
-    const unique = [];
-    results.forEach(result => {
-      const hash = crypto.createHash('md5').update(result.content).digest('hex');
-      if (!seen.has(hash)) {
-        seen.add(hash);
-        unique.push(result);
-      }
-    });
-    return unique;
-  }
-
-  getStats() {
-    return {
-      similarityThreshold: this.similarityThreshold,
-      minClusterSize: this.minClusterSize,
-      maxThemes: this.maxThemes,
-      minWordLength: this.minWordLength
-    };
-  }
-}
-
-export default PatternMiner;

package/lib/utils/error-sanitizer.js

@@ -1,84 +0,0 @@
-/**
- * Secure Error Handling Utilities
- * Sanitizes error messages to prevent API key leakage
- */
-
-/**
- * Sanitize error messages by redacting sensitive information
- * @param {string} message - Error message to sanitize
- * @returns {string} Sanitized error message
- */
-export function sanitizeErrorMessage(message) {
-  if (typeof message !== 'string') {
-    return '[Non-string error message]';
-  }
-
-  // Redact common sensitive patterns
-  return message
-    // Redact Bearer tokens
-    .replace(/Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, 'Bearer [REDACTED]')
-    // Redact OpenAI API keys (sk- followed by 32+ chars)
-    .replace(/sk-[A-Za-z0-9]{32,}/g, 'sk-[REDACTED]')
-    // Redact generic API keys (20+ alphanumeric chars after api_key)
-    .replace(/api_key["\s:]+[A-Za-z0-9]{20,}/gi, 'api_key: [REDACTED]')
-    // Redact environment variable patterns that might contain secrets
-    .replace(/(OPENAI_API_KEY|ANTHROPIC_API_KEY|GOOGLE_API_KEY)[="'\s]+[A-Za-z0-9\-_]+/gi, '$1=[REDACTED]')
-    // Redact Authorization headers
-    .replace(/Authorization:\s*[^"\r\n]+/gi, 'Authorization: [REDACTED]')
-    // Redact potential JWT tokens (header.payload.signature pattern)
-    .replace(/eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g, '[JWT_REDACTED]');
-}
-
-/**
- * Sanitize error object for logging
- * @param {Error|Object} error - Error object to sanitize
- * @returns {Object} Sanitized error object safe for logging
- */
-export function sanitizeErrorForLogging(error) {
-  if (!error || typeof error !== 'object') {
-    return { message: '[Invalid error object]' };
-  }
-
-  const sanitized = {
-    name: error.name || 'Error',
-    message: sanitizeErrorMessage(error.message || 'Unknown error')
-  };
-
-  // Only include stack in development
-  if (process.env.NODE_ENV === 'development' && error.stack) {
-    sanitized.stack = error.stack;
-  }
-
-  // Include code if present (non-sensitive)
-  if (error.code) {
-    sanitized.code = error.code;
-  }
-
-  // Include timestamp
-  sanitized.timestamp = new Date().toISOString();
-
-  return sanitized;
-}
-
-/**
- * Wrap a function to catch and sanitize errors
- * @param {Function} fn - Function to wrap
- * @param {string} context - Context description for error logging
- * @returns {Function} Wrapped function with error sanitization
- */
-export function withSanitizedErrors(fn, context = 'operation') {
-  return async (...args) => {
-    try {
-      return await fn(...args);
-    } catch (error) {
-      const sanitizedError = sanitizeErrorForLogging(error);
-      throw {
-        success: false,
-        error: {
-          ...sanitizedError,
-          context
-        }
-      };
-    }
-  };
-}

package/lib/utils/handoff-validator.js

@@ -1,85 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-/**
- * Handoff Package Validator
- * Verifies that a handoff package is complete and valid.
- */
-class HandoffValidator {
-    constructor(packagePath) {
-        this.packagePath = packagePath;
-        this.requiredFiles = [
-            'context.md',
-            'memory.json',
-            'metadata.json'
-        ];
-    }
-
-    validate() {
-        /** @type {{valid: boolean, errors: string[], warnings: string[], summary: string}} */
-        const result = {
-            valid: true,
-            errors: [],
-            warnings: [],
-            summary: ''
-        };
-
-        if (!fs.existsSync(this.packagePath)) {
-            result.valid = false;
-            result.errors.push(`Package path not found: ${this.packagePath}`);
-            return result;
-        }
-
-        // Check required files
-        for (const file of this.requiredFiles) {
-            const filePath = path.join(this.packagePath, file);
-            if (!fs.existsSync(filePath)) {
-                result.valid = false;
-                result.errors.push(`Missing required file: ${file}`);
-            }
-        }
-
-        // Validate metadata
-        const metadataPath = path.join(this.packagePath, 'metadata.json');
-        if (fs.existsSync(metadataPath)) {
-            try {
-                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-                if (!metadata.timestamp) result.warnings.push('Metadata missing timestamp');
-                if (!metadata.source) result.warnings.push('Metadata missing source');
-            } catch (e) {
-                result.valid = false;
-                result.errors.push('Invalid metadata.json format');
-            }
-        }
-
-        result.summary = result.valid 
-            ? `✅ Package valid with ${result.warnings.length} warnings` 
-            : `❌ Package invalid with ${result.errors.length} errors`;
-
-        return result;
-    }
-}
-
-// CLI usage
-if (process.argv[1] === import.meta.url) {
-    const pkgPath = process.argv[2] || '.';
-    const validator = new HandoffValidator(pkgPath);
-    const result = validator.validate();
-
-    if (!result.valid) {
-        console.log(result.summary);
-        console.log('\n❌ Errors found:');
-        result.errors.forEach(err => console.log(`   - ${err}`));
-        process.exit(1);
-    } else {
-        console.log(result.summary);
-        console.log('\n✅ Handoff package is valid!');
-        
-        if (result.warnings.length > 0) {
-            console.log('\n⚠️  Warnings:');
-            result.warnings.forEach(warn => console.log(`   - ${warn}`));
-        }
-    }
-}
-
-export default HandoffValidator;

package/lib/utils/spinner.js

@@ -1,190 +0,0 @@
-/**
- * Spinner and Progress Indicators
- */
-
-import { fileURLToPath } from 'url';
-
-class Spinner {
-    constructor(text = 'Loading...', options = {}) {
-        this.text = text;
-        // @ts-ignore
-        this.frames = options.frames || ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        // @ts-ignore
-        this.interval = options.interval || 80;
-        // @ts-ignore
-        this.stream = options.stream || process.stderr;
-        // @ts-ignore
-        this.color = options.color || '\x1b[36m';
-        this.frameIndex = 0;
-        this.timer = null;
-        this.isSpinning = false;
-    }
-
-    start() {
-        if (this.isSpinning) return this;
-        this.isSpinning = true;
-        this.frameIndex = 0;
-        this.stream.write('\x1B[?25l');
-        this.timer = setInterval(() => {
-            const frame = this.frames[this.frameIndex];
-            this.stream.write(`\r${this.color}${frame}\x1b[0m ${this.text}`);
-            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-        }, this.interval);
-        return this;
-    }
-
-    update(text) {
-        this.text = text;
-        return this;
-    }
-
-    succeed(text) {
-        return this.stop('\x1b[32m✔\x1b[0m', text);
-    }
-
-    fail(text) {
-        return this.stop('\x1b[31m✖\x1b[0m', text);
-    }
-
-    warn(text) {
-        return this.stop('\x1b[33m⚠\x1b[0m', text);
-    }
-
-    info(text) {
-        return this.stop('\x1b[36mℹ\x1b[0m', text);
-    }
-
-    /**
-     * @param {string|null} symbol
-     * @param {string|null} text
-     */
-    stop(symbol = null, text = null) {
-        if (!this.isSpinning) return this;
-        if (this.timer) {
-            // @ts-ignore
-            clearInterval(this.timer);
-        }
-        this.isSpinning = false;
-        this.stream.write('\r\x1b[K');
-        this.stream.write('\x1B[?25h');
-        if (symbol && text) {
-            this.stream.write(`${symbol} ${text}\n`);
-        } else if (text) {
-            this.stream.write(`${text}\n`);
-        }
-        return this;
-    }
-
-    clear() {
-        if (!this.isSpinning) return this;
-        if (this.timer) {
-            // @ts-ignore
-            clearInterval(this.timer);
-        }
-        this.isSpinning = false;
-        this.stream.write('\r\x1b[K');
-        this.stream.write('\x1B[?25h');
-        return this;
-    }
-}
-
-class ProgressBar {
-    constructor(total, options = {}) {
-        this.total = total;
-        this.current = 0;
-        // @ts-ignore
-        this.width = options.width || 40;
-        // @ts-ignore
-        this.stream = options.stream || process.stderr;
-        // @ts-ignore
-        this.format = options.format || ':bar :percent :current/:total';
-        // @ts-ignore
-        this.complete = options.complete || '█';
-        // @ts-ignore
-        this.incomplete = options.incomplete || '░';
-        // @ts-ignore
-        this.renderThrottle = options.renderThrottle || 16;
-        this.lastRender = 0;
-    }
-
-    tick(amount = 1) {
-        this.current = Math.min(this.current + amount, this.total);
-        const now = Date.now();
-        if (now - this.lastRender < this.renderThrottle && this.current < this.total) {
-            return this;
-        }
-        this.lastRender = now;
-        this.render();
-        return this;
-    }
-
-    render() {
-        const percent = Math.floor((this.current / this.total) * 100);
-        const completeLength = Math.floor(this.width * (this.current / this.total));
-        const incompleteLength = this.width - completeLength;
-        const bar = this.complete.repeat(completeLength) + this.incomplete.repeat(incompleteLength);
-        // @ts-ignore
-        let output = this.format.replace(':bar', bar).replace(':percent', `${percent}%`).replace(':current', String(this.current)).replace(':total', String(this.total));
-        this.stream.write(`\r${output}`);
-        if (this.current >= this.total) {
-            this.stream.write('\n');
-        }
-        return this;
-    }
-
-    update(current) {
-        this.current = Math.min(current, this.total);
-        this.render();
-        return this;
-    }
-}
-
-class MultiSpinner {
-    constructor() {
-        this.spinners = new Map();
-        this.stream = process.stderr;
-    }
-
-    add(key, text, status = 'pending') {
-        this.spinners.set(key, { text, status, startTime: Date.now() });
-        this.render();
-        return this;
-    }
-
-    update(key, status, text = null) {
-        const spinner = this.spinners.get(key);
-        if (spinner) {
-            spinner.status = status;
-            if (text) spinner.text = text;
-            this.render();
-        }
-        return this;
-    }
-
-    succeed(key, text) { return this.update(key, 'success', text); }
-    fail(key, text) { return this.update(key, 'fail', text); }
-    warn(key, text) { return this.update(key, 'warn', text); }
-
-    render() {
-        this.stream.write('\r\x1b[K');
-        const lines = [];
-        for (const [key, spinner] of this.spinners) {
-            // @ts-ignore
-            const symbol = { pending: '\x1b[36m⋯\x1b[0m', success: '\x1b[32m✔\x1b[0m', fail: '\x1b[31m✖\x1b[0m', warn: '\x1b[33m⚠\x1b[0m' }[spinner.status];
-            const duration = ((Date.now() - spinner.startTime) / 1000).toFixed(1);
-            lines.push(`${symbol} ${spinner.text} (${duration}s)`);
-        }
-        this.stream.write(lines.join('\n'));
-        if (lines.length > 1) {
-            this.stream.write(`\x1b[${lines.length - 1}A`);
-        }
-        return this;
-    }
-
-    done() {
-        this.stream.write('\n'.repeat(this.spinners.size));
-        return this;
-    }
-}
-
-export { Spinner, ProgressBar, MultiSpinner };

package/lib/utils/streaming-client.js

@@ -1,128 +0,0 @@
-import { fileURLToPath } from 'url';
-import https from "https";
-
-/**
- * Streaming LLM Client
- */
-class StreamingClient {
-    constructor(config) {
-        this.config = config;
-        this.buffer = '';
-    }
-
-    stream(payload, onToken, onComplete, onError) {
-        const url = new URL(this.config.endpoint);
-        
-        /** @type {any} */
-        const options = {
-            hostname: url.hostname,
-            path: url.pathname,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.config.apiKey}`,
-                'Accept': 'text/event-stream'
-            },
-            rejectUnauthorized: true,
-            minVersion: 'TLSv1.2'
-        };
-
-        const req = https.request(options, (res) => {
-            let fullResponse = '';
-            res.on('data', (chunk) => {
-                this.buffer += chunk.toString();
-                const lines = this.buffer.split('\n');
-                this.buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.startsWith('data: ')) {
-                        const data = line.slice(6);
-                        if (data === '[DONE]') continue;
-                        try {
-                            const parsed = JSON.parse(data);
-                            const token = this.extractToken(parsed, this.config.schema);
-                            if (token) {
-                                fullResponse += token;
-                                onToken(token, parsed);
-                            }
-                        } catch (e) { /* ignore */ }
-                    }
-                }
-            });
-            res.on('end', () => { if (onComplete) onComplete(fullResponse); });
-            res.on('error', (e) => { if (onError) onError(e); });
-        });
-
-        req.on('error', (e) => { if (onError) onError(e); });
-        req.setTimeout(60000, () => {
-            req.destroy();
-            if (onError) onError(new Error('Timeout'));
-        });
-        req.write(JSON.stringify({ ...payload, stream: true }));
-        req.end();
-        return req;
-    }
-
-    extractToken(data, schema) {
-        switch (schema) {
-            case 'openai': return data.choices?.[0]?.delta?.content || '';
-            default: return data.choices?.[0]?.delta?.content || data.delta?.text || '';
-        }
-    }
-
-    async request(payload) {
-        return new Promise((resolve, reject) => {
-            const url = new URL(this.config.endpoint);
-            
-            /** @type {any} */
-            const options = {
-                hostname: url.hostname,
-                path: url.pathname,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.config.apiKey}`
-                },
-                rejectUnauthorized: true,
-                minVersion: 'TLSv1.2'
-            };
-            const req = https.request(options, (res) => {
-                let data = '';
-                res.on('data', (chunk) => data += chunk);
-                res.on('end', () => {
-                    try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
-                });
-            });
-            req.on('error', reject);
-            req.write(JSON.stringify(payload));
-            req.end();
-        });
-    }
-}
-
-class StreamingLLM {
-    constructor(config) {
-        this.client = new StreamingClient(config);
-        this.config = config;
-    }
-
-    async streamToConsole(payload, options = {}) {
-        // @ts-ignore
-        const prefix = options.prefix || '';
-        return new Promise((resolve, reject) => {
-            let tokens = [];
-            this.client.stream(payload, (token) => {
-                process.stdout.write(token);
-                // @ts-ignore
-                tokens.push(token);
-            }, (full) => {
-                process.stdout.write('\n');
-                resolve({ content: full, tokens: tokens.length });
-            }, (e) => {
-                process.stdout.write('\n');
-                reject(e);
-            });
-        });
-    }
-}
-
-export { StreamingClient, StreamingLLM };

package/skills/skill-scrubber.yamo

@@ -1,41 +0,0 @@
-metadata:
-  name;Scrubber;
-  version;1.0.0;
-  description;A utility skill that sanitizes text or files using S-MORA Layer 0 Scrubber principles (removing PII, boilerplate, and normalizing structure).;
-  author;Soverane Labs;
-  license;MIT;
-  tags;utility;sanitization;cleaning;security;
-  capabilities;scrub_text;scrub_file;
-  parameters:
-    content:
-      type;string;
-      required;false;
-      description;Raw text content to scrub.;
-    file_path:
-      type;string;
-      required;false;
-      description;Path to a file to scrub.;
-  environment:
-    requires_filesystem;true;
-  dependencies:
-    required:
-      - node >=18.0.0;
-      - tools/scrubber.js;
----
-agent: ScrubbingAgent;
-intent: sanitize_input_content;
-context:
-  raw_text;provided_by_user.content;
-  target_file;provided_by_user.file_path;
-  scrubber_tool;tools/scrubber.js;
-constraints:
-  - if_file_provided;use_tool_scrub_file_mode;
-  - if_text_provided;use_tool_scrub_mode;
-  - if_both;prefer_file;
-  - remove_boilerplate_and_pii;
-  - normalize_structure;
-  - return_cleaned_json_result;
-priority: high;
-output: scrubbed_result.json;
-log: content_scrubbed;original_length;cleaned_length;
-handoff: End;