twinclaw 1.1.1 → 1.1.2

package/dist/services/learning-system.js

@@ -0,0 +1,226 @@
+import { logThought } from '../utils/logger.js';
+import { writeFile, readFile, mkdir, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { getWorkspaceDir } from '../config/workspace.js';
+class LearningSystem {
+    #memoryDir;
+    #memories = new Map();
+    #maxMemories = 1000;
+    constructor() {
+        this.#memoryDir = '';
+    }
+    async initialize() {
+        this.#memoryDir = path.join(getWorkspaceDir(), 'memory');
+        if (!existsSync(this.#memoryDir)) {
+            await mkdir(this.#memoryDir, { recursive: true });
+        }
+        await this.#loadMemories();
+        void logThought(`[Learning] Initialized with ${this.#memories.size} memories`);
+    }
+    async #loadMemories() {
+        try {
+            const files = await readdir(this.#memoryDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const content = await readFile(path.join(this.#memoryDir, file), 'utf-8');
+                    const memory = JSON.parse(content);
+                    this.#memories.set(memory.id, memory);
+                }
+            }
+        }
+        catch (err) {
+            void logThought(`[Learning] No existing memories found`);
+        }
+    }
+    async learn(type, description, context, solution, outcome) {
+        const existing = this.#findSimilar(description);
+        let entry;
+        if (existing && existing.description === description) {
+            existing.timesApplied++;
+            if (outcome) {
+                const newRate = (existing.successRate * (existing.timesApplied - 1) + (outcome === 'success' ? 1 : 0)) / existing.timesApplied;
+                existing.successRate = newRate;
+            }
+            existing.outcome = outcome;
+            existing.timestamp = new Date();
+            entry = existing;
+        }
+        else {
+            entry = {
+                id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                type,
+                description,
+                context,
+                solution,
+                outcome,
+                timestamp: new Date(),
+                relevance: this.#calculateRelevance(context),
+                timesApplied: 1,
+                successRate: outcome === 'success' ? 1 : 0
+            };
+            this.#memories.set(entry.id, entry);
+        }
+        await this.#saveMemory(entry);
+        void logThought(`[Learning] Learned: ${type} - ${description} (success rate: ${entry.successRate.toFixed(1)})`);
+        if (this.#memories.size > this.#maxMemories) {
+            await this.#pruneMemories();
+        }
+        return entry;
+    }
+    #findSimilar(description) {
+        const searchTerms = description.toLowerCase().split(/\s+/);
+        let bestMatch;
+        let bestScore = 0;
+        for (const memory of this.#memories.values()) {
+            const memTerms = memory.description.toLowerCase().split(/\s+/);
+            let score = 0;
+            for (const term of searchTerms) {
+                if (memTerms.includes(term)) {
+                    score++;
+                }
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatch = memory;
+            }
+        }
+        return bestScore > 2 ? bestMatch : undefined;
+    }
+    #calculateRelevance(context) {
+        let score = 0;
+        if (context.component)
+            score += 2;
+        if (context.action)
+            score += 1;
+        if (context.result)
+            score += 1;
+        return Math.min(score / 4, 1);
+    }
+    async #saveMemory(memory) {
+        const filePath = path.join(this.#memoryDir, `${memory.id}.json`);
+        await writeFile(filePath, JSON.stringify(memory, null, 2), 'utf-8');
+    }
+    async #pruneMemories() {
+        const sorted = Array.from(this.#memories.values())
+            .sort((a, b) => {
+            const aScore = a.relevance * (a.successRate + 0.5);
+            const bScore = b.relevance * (b.successRate + 0.5);
+            return bScore - aScore;
+        });
+        const toKeep = sorted.slice(0, this.#maxMemories / 2);
+        const toRemove = sorted.slice(this.#maxMemories / 2);
+        for (const memory of toRemove) {
+            this.#memories.delete(memory.id);
+            try {
+                const { unlink } = await import('fs/promises');
+                await unlink(path.join(this.#memoryDir, `${memory.id}.json`));
+            }
+            catch { }
+        }
+        void logThought(`[Learning] Pruned memories, kept ${toKeep.length} most relevant`);
+    }
+    query(query, context) {
+        const searchTerms = query.toLowerCase().split(/\s+/);
+        const scored = Array.from(this.#memories.values())
+            .map(memory => {
+            let score = 0;
+            const descTerms = memory.description.toLowerCase().split(/\s+/);
+            for (const term of searchTerms) {
+                if (descTerms.includes(term))
+                    score += 3;
+            }
+            if (memory.type === 'fix')
+                score *= 1.5;
+            if (memory.successRate > 0.7)
+                score *= 1.2;
+            if (context?.component) {
+                if (memory.context.component === context.component) {
+                    score *= 1.5;
+                }
+            }
+            return { memory, score };
+        })
+            .filter(r => r.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 10);
+        const entries = scored.map(r => r.memory);
+        const suggestions = this.#generateSuggestions(entries, context);
+        return { entries, suggestions };
+    }
+    #generateSuggestions(entries, context) {
+        const suggestions = [];
+        const successfulFixes = entries.filter(e => e.type === 'fix' && e.successRate > 0.5);
+        if (successfulFixes.length > 0) {
+            suggestions.push(`Try: ${successfulFixes[0].solution || 'review previous solution'}`);
+        }
+        const patterns = entries.filter(e => e.type === 'pattern');
+        if (patterns.length > 0) {
+            suggestions.push(`Pattern detected: ${patterns[0].description}`);
+        }
+        if (entries.length === 0) {
+            suggestions.push('No similar experiences found. Consider:');
+            suggestions.push('  - Breaking down the problem into smaller parts');
+            suggestions.push('  - Checking service documentation');
+            suggestions.push('  - Starting with a simpler configuration');
+        }
+        return suggestions.slice(0, 5);
+    }
+    getStats() {
+        const byType = {};
+        let totalSuccess = 0;
+        let totalCount = 0;
+        for (const memory of this.#memories.values()) {
+            byType[memory.type] = (byType[memory.type] || 0) + 1;
+            totalSuccess += memory.successRate;
+            totalCount++;
+        }
+        const topPatterns = Array.from(this.#memories.values())
+            .filter(m => m.type === 'pattern')
+            .sort((a, b) => b.timesApplied - a.timesApplied)
+            .slice(0, 5)
+            .map(m => m.description);
+        return {
+            total: this.#memories.size,
+            byType,
+            successRate: totalCount > 0 ? totalSuccess / totalCount : 0,
+            topPatterns
+        };
+    }
+    getMemoriesByType(type) {
+        return Array.from(this.#memories.values())
+            .filter(m => m.type === type)
+            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+    async clear(type) {
+        let count = 0;
+        const toDelete = [];
+        for (const [id, memory] of this.#memories.entries()) {
+            if (!type || memory.type === type) {
+                toDelete.push(id);
+            }
+        }
+        for (const id of toDelete) {
+            this.#memories.delete(id);
+            try {
+                const { unlink } = await import('fs/promises');
+                await unlink(path.join(this.#memoryDir, `${id}.json`));
+                count++;
+            }
+            catch { }
+        }
+        void logThought(`[Learning] Cleared ${count} memories`);
+        return count;
+    }
+}
+let learningSystem = null;
+export function getLearningSystem() {
+    if (!learningSystem) {
+        learningSystem = new LearningSystem();
+    }
+    return learningSystem;
+}
+export async function initializeLearning() {
+    const system = getLearningSystem();
+    await system.initialize();
+}

package/dist/services/self-healing.js

@@ -0,0 +1,267 @@
+import { logThought } from '../utils/logger.js';
+import { readConfig } from '../config/config-loader.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+import { getLearningSystem } from './learning-system.js';
+const execAsync = promisify(exec);
+class SelfHealingService {
+    #healthMetrics = new Map();
+    #healingActions = [];
+    #learningHistory = [];
+    #healthCheckInterval = null;
+    #autoHealEnabled = true;
+    async initialize() {
+        void logThought('[SelfHealer] Initializing self-healing system...');
+        this.#startHealthChecks();
+        void logThought('[SelfHealer] Self-healing system initialized');
+    }
+    #startHealthChecks() {
+        this.#healthCheckInterval = setInterval(async () => {
+            await this.performHealthCheck();
+        }, 60000);
+    }
+    async performHealthCheck() {
+        const metrics = [];
+        metrics.push(await this.#checkSystemResources());
+        metrics.push(await this.#checkSkills());
+        metrics.push(await this.#checkConfig());
+        metrics.push(await this.#checkChannels());
+        for (const metric of metrics) {
+            this.#healthMetrics.set(metric.component, metric);
+            if (metric.status === 'failed' && this.#autoHealEnabled) {
+                await this.#attemptHealing(metric);
+            }
+        }
+        return metrics;
+    }
+    async #checkSystemResources() {
+        const start = Date.now();
+        try {
+            const cpuLoad = os.loadavg()[0];
+            const freeMem = os.freemem();
+            const totalMem = os.totalmem();
+            const memPercent = ((totalMem - freeMem) / totalMem) * 100;
+            let status = 'healthy';
+            if (cpuLoad > 8 || memPercent > 90)
+                status = 'degraded';
+            if (cpuLoad > 16 || memPercent > 95)
+                status = 'failed';
+            return {
+                component: 'system.resources',
+                status,
+                lastCheck: new Date(),
+                responseTime: Date.now() - start,
+                details: { cpuLoad, memPercent, freeMem, totalMem }
+            };
+        }
+        catch (err) {
+            return {
+                component: 'system.resources',
+                status: 'failed',
+                lastCheck: new Date(),
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    async #checkSkills() {
+        try {
+            const learning = getLearningSystem();
+            const stats = learning.getStats();
+            return {
+                component: 'skills',
+                status: 'healthy',
+                lastCheck: new Date(),
+                details: {
+                    memories: stats.total,
+                    successRate: stats.successRate
+                }
+            };
+        }
+        catch (err) {
+            return {
+                component: 'skills',
+                status: 'failed',
+                lastCheck: new Date(),
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    async #checkConfig() {
+        try {
+            const config = await readConfig();
+            const hasApiSecret = !!config.runtime?.apiSecret;
+            const hasModelKey = !!(config.models?.openRouterApiKey || config.models?.modalApiKey || config.models?.geminiApiKey);
+            const hasChannels = !!(config.messaging?.telegram?.botToken || config.messaging?.whatsapp?.phoneNumber);
+            let status = 'healthy';
+            if (!hasApiSecret)
+                status = 'failed';
+            else if (!hasModelKey || !hasChannels)
+                status = 'degraded';
+            return {
+                component: 'config',
+                status,
+                lastCheck: new Date(),
+                details: { hasApiSecret, hasModelKey, hasChannels }
+            };
+        }
+        catch (err) {
+            return {
+                component: 'config',
+                status: 'failed',
+                lastCheck: new Date(),
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    async #checkChannels() {
+        try {
+            const config = await readConfig();
+            const hasTelegram = !!(config.messaging?.telegram?.botToken);
+            const hasWhatsApp = !!(config.messaging?.whatsapp?.phoneNumber);
+            const hasAnyChannel = hasTelegram || hasWhatsApp;
+            return {
+                component: 'channels',
+                status: hasAnyChannel ? 'healthy' : 'degraded',
+                lastCheck: new Date(),
+                details: {
+                    telegram: hasTelegram,
+                    whatsapp: hasWhatsApp
+                }
+            };
+        }
+        catch (err) {
+            return {
+                component: 'channels',
+                status: 'failed',
+                lastCheck: new Date(),
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    async #attemptHealing(metric) {
+        void logThought(`[SelfHealer] Attempting to heal: ${metric.component}`);
+        const action = {
+            id: `${metric.component}_${Date.now()}`,
+            description: `Auto-heal ${metric.component}`,
+            executed: false,
+            success: false,
+            timestamp: new Date()
+        };
+        try {
+            switch (metric.component) {
+                case 'system.resources':
+                    await this.#healSystemResources(metric);
+                    break;
+                case 'skills':
+                    await this.#healSkills(metric);
+                    break;
+                case 'config':
+                    await this.#healConfig(metric);
+                    break;
+                default:
+                    void logThought(`[SelfHealer] No healing action for: ${metric.component}`);
+            }
+            action.executed = true;
+            action.success = true;
+            action.result = 'Healing attempted';
+        }
+        catch (err) {
+            action.success = false;
+            action.result = err instanceof Error ? err.message : String(err);
+            void logThought(`[SelfHealer] Healing failed: ${action.result}`);
+        }
+        this.#healingActions.push(action);
+    }
+    async #healSystemResources(metric) {
+        const details = metric.details;
+        if (details?.memPercent && details.memPercent > 90) {
+            void logThought('[SelfHealer] High memory detected, attempting cleanup...');
+            try {
+                await execAsync('powershell -Command "Get-Process | Sort-Object WorkingSet64 -Descending | Select-Object -First 10 | Stop-Process -Force"');
+                void logThought('[SelfHealer] Cleaned up top memory consumers');
+            }
+            catch { }
+        }
+    }
+    async #healSkills(metric) {
+        void logThought('[SelfHealer] Checking learning system for skill issues...');
+        const learning = getLearningSystem();
+        const stats = learning.getStats();
+        if (stats.total > 0 && stats.successRate < 0.7) {
+            void logThought(`[SelfHealer] Low success rate detected: ${(stats.successRate * 100).toFixed(1)}%`);
+            const query = learning.query('skill failure');
+            if (query.suggestions.length > 0) {
+                void logThought(`[SelfHealer] Suggested fix: ${query.suggestions[0]}`);
+            }
+        }
+    }
+    async #healConfig(metric) {
+        const details = metric.details;
+        if (!details?.hasApiSecret) {
+            void logThought('[SelfHealer] Missing API secret, user needs to configure');
+        }
+        const learning = getLearningSystem();
+        const fixes = this.suggestFixes('config');
+        if (fixes.length > 0) {
+            void logThought(`[SelfHealer] Known fixes: ${fixes[0]}`);
+        }
+    }
+    learn(pattern, success, context, solution) {
+        this.#learningHistory.push({
+            pattern,
+            success,
+            timestamp: new Date(),
+            context,
+            solution
+        });
+        if (this.#learningHistory.length > 1000) {
+            this.#learningHistory = this.#learningHistory.slice(-500);
+        }
+        void logThought(`[SelfHealer] Learned: ${pattern} (success: ${success})`);
+    }
+    getSimilarPastIssues(currentIssue) {
+        return this.#learningHistory
+            .filter(l => l.pattern.toLowerCase().includes(currentIssue.toLowerCase()))
+            .slice(-5);
+    }
+    suggestFixes(issue) {
+        const similar = this.getSimilarPastIssues(issue);
+        const fixes = similar
+            .filter(l => l.success && l.solution)
+            .map(l => l.solution);
+        return [...new Set(fixes)];
+    }
+    getHealthMetrics() {
+        return Array.from(this.#healthMetrics.values());
+    }
+    getHealingHistory() {
+        return this.#healingActions.slice(-50);
+    }
+    enableAutoHeal(enabled) {
+        this.#autoHealEnabled = enabled;
+        void logThought(`[SelfHealer] Auto-heal ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    shutdown() {
+        if (this.#healthCheckInterval) {
+            clearInterval(this.#healthCheckInterval);
+        }
+        void logThought('[SelfHealer] Shutdown complete');
+    }
+}
+let selfHealingService = null;
+export function getSelfHealingService() {
+    if (!selfHealingService) {
+        selfHealingService = new SelfHealingService();
+    }
+    return selfHealingService;
+}
+export async function initializeSelfHealer() {
+    const service = getSelfHealingService();
+    await service.initialize();
+}
+export async function shutdownSelfHealer() {
+    if (selfHealingService) {
+        selfHealingService.shutdown();
+    }
+}

package/dist/services/skill-acquisition/intent-parser.js

@@ -0,0 +1,115 @@
+/**
+ * Intent Parser Service
+ * Converts natural language skill requests into structured requirements
+ * Simplified version without direct LLM dependency
+ */
+import { logThought } from '../../utils/logger.js';
+// Known provider -> credentials mapping
+const PROVIDER_CREDENTIALS = {
+    'sendgrid': [{ name: 'SENDGRID_API_KEY', type: 'api_key', description: 'SendGrid API Key', envVarHint: 'SENDGRID_API_KEY', isRequired: true }],
+    'twilio': [{ name: 'TWILIO_ACCOUNT_SID', type: 'api_key', description: 'Twilio Account SID', envVarHint: 'TWILIO_ACCOUNT_SID', isRequired: true }],
+    'slack': [{ name: 'SLACK_BOT_TOKEN', type: 'bearer_token', description: 'Slack Bot Token', envVarHint: 'SLACK_BOT_TOKEN', isRequired: true }],
+    'github': [{ name: 'GITHUB_PERSONAL_ACCESS_TOKEN', type: 'bearer_token', description: 'GitHub PAT', envVarHint: 'GITHUB_PERSONAL_ACCESS_TOKEN', isRequired: true }],
+    'notion': [{ name: 'NOTION_API_KEY', type: 'api_key', description: 'Notion API Key', envVarHint: 'NOTION_API_KEY', isRequired: true }],
+    'discord': [{ name: 'DISCORD_BOT_TOKEN', type: 'bearer_token', description: 'Discord Bot Token', envVarHint: 'DISCORD_BOT_TOKEN', isRequired: true }],
+    'openai': [{ name: 'OPENAI_API_KEY', type: 'api_key', description: 'OpenAI API Key', envVarHint: 'OPENAI_API_KEY', isRequired: true }],
+    'aws': [{ name: 'AWS_ACCESS_KEY_ID', type: 'api_key', description: 'AWS Access Key', envVarHint: 'AWS_ACCESS_KEY_ID', isRequired: true }],
+};
+// Capability keywords -> suggested approach
+const CAPABILITY_APPROACHES = {
+    'file': [{ approach: 'mcp-bridge', confidence: 0.9, estimatedEffort: 'low' }],
+    'filesystem': [{ approach: 'mcp-bridge', confidence: 0.9, estimatedEffort: 'low' }],
+    'memory': [{ approach: 'mcp-bridge', confidence: 0.9, estimatedEffort: 'low' }],
+    'search': [{ approach: 'mcp-bridge', confidence: 0.8, estimatedEffort: 'low' }],
+    'database': [{ approach: 'mcp-bridge', confidence: 0.8, estimatedEffort: 'low' }],
+    'sql': [{ approach: 'mcp-bridge', confidence: 0.8, estimatedEffort: 'low' }],
+};
+export class IntentParser {
+    async parseIntent(userRequest) {
+        void logThought(`[IntentParser] Parsing: "${userRequest}"`);
+        const lower = userRequest.toLowerCase();
+        // Extract capability
+        const capability = this.#extractCapability(lower);
+        // Extract provider
+        const provider = this.#extractProvider(lower);
+        // Get required credentials
+        const requiredCredentials = provider ? (PROVIDER_CREDENTIALS[provider] || []) : [];
+        // Get suggested approaches
+        const suggestedApproaches = this.#getSuggestedApproaches(lower);
+        // Estimate complexity
+        const estimatedComplexity = this.#estimateComplexity(lower);
+        void logThought(`[IntentParser] Parsed: capability=${capability}, provider=${provider || 'none'}, complexity=${estimatedComplexity}`);
+        return {
+            capability,
+            provider,
+            description: userRequest,
+            requiredCredentials,
+            requiredScopes: [],
+            estimatedComplexity,
+            similarSkills: [],
+            suggestedApproaches,
+        };
+    }
+    #extractCapability(request) {
+        // Common capability keywords
+        const keywords = {
+            'email-send': ['email', 'mail', 'sendgrid', 'smtp'],
+            'sms-send': ['sms', 'text message', 'twilio'],
+            'file-management': ['file', 'upload', 'download', 'read file', 'write file'],
+            'api-call': ['api', 'http', 'fetch', 'rest'],
+            'database-query': ['database', 'db', 'sql', 'query'],
+            'search': ['search', 'find', 'lookup'],
+            'calendar': ['calendar', 'schedule', 'event'],
+            'note-taking': ['note', 'notion', 'obsidian', 'notes'],
+            'messaging': ['message', 'slack', 'discord', 'telegram'],
+            'github': ['github', 'repo', 'git'],
+            'browser': ['browser', 'scrape', 'web'],
+            'ai': ['ai', 'openai', 'gpt', 'llm'],
+        };
+        for (const [cap, words] of Object.entries(keywords)) {
+            if (words.some(w => request.includes(w))) {
+                return cap;
+            }
+        }
+        // Default: extract from words
+        const words = request.split(/\s+/).filter(w => w.length > 3).slice(0, 3);
+        return words.join('-') || 'custom';
+    }
+    #extractProvider(request) {
+        const providers = Object.keys(PROVIDER_CREDENTIALS);
+        for (const p of providers) {
+            if (request.includes(p)) {
+                return p;
+            }
+        }
+        return undefined;
+    }
+    #estimateComplexity(request) {
+        const complexIndicators = ['workflow', 'multiple', 'chain', 'complex', 'orchestrate', 'parallel', 'multi-step'];
+        const mediumIndicators = ['api', 'fetch', 'database', 'transform', 'convert'];
+        if (complexIndicators.some(w => request.includes(w)))
+            return 'complex';
+        if (mediumIndicators.some(w => request.includes(w)))
+            return 'medium';
+        return 'simple';
+    }
+    #getSuggestedApproaches(request) {
+        for (const [keyword, approaches] of Object.entries(CAPABILITY_APPROACHES)) {
+            if (request.includes(keyword)) {
+                return approaches;
+            }
+        }
+        // Default approach: function-based
+        return [
+            { approach: 'function', confidence: 0.7, estimatedEffort: 'medium' },
+        ];
+    }
+}
+// Singleton
+let intentParser = null;
+export function getIntentParser() {
+    if (!intentParser) {
+        intentParser = new IntentParser();
+    }
+    return intentParser;
+}