twinclaw 1.1.1 → 1.1.2

package/dist/core/heartbeat.js

@@ -5,35 +5,331 @@ const DEFAULT_CRON = '0 9 * * *';
 const DEFAULT_MESSAGE = 'TwinClaw heartbeat: daily proactive check-in.';
 const HEARTBEAT_JOB_ID = 'twinclaw-heartbeat';
 /**
- * Proactive heartbeat service.
+ * Proactive heartbeat service with configurable checks.
  *
- * Now delegates to the centralized {@link JobScheduler} so heartbeat intervals
- * are managed alongside other repeating background jobs. The external API
- * remains identical to the original implementation for backward compatibility.
+ * Extends the basic HeartbeatService with:
+ * - Configurable proactive checks (email, calendar, weather, notifications)
+ * - State tracking for each check type
+ * - Proactive notification via dispatcher
+ * - Persistent state across restarts
  */
-export class HeartbeatService {
+export class ProactiveHeartbeatService {
     #scheduler;
     #onHeartbeat;
     #cronExpression;
     #message;
+    // Proactive check configuration
+    #checks = new Map();
+    #customCheckSkills;
+    // Notification targets
+    #notifyPlatforms;
+    #notifyUserIds;
+    // Gateway for proactive messages
+    #gateway;
+    // State management
+    #state = {
+        checkStates: {},
+        totalHeartbeats: 0,
+        totalNotifications: 0,
+    };
+    // State file path
+    #statePath = './memory/heartbeat-state.json';
     /**
      * @param onHeartbeat - callback invoked on every heartbeat tick.
      * @param config      - optional cron and message overrides.
      * @param scheduler   - optional external scheduler instance (for shared management).
-     *                      If omitted, a private scheduler is created internally.
      */
+    constructor(onHeartbeat, options = {}) {
+        this.#onHeartbeat = onHeartbeat;
+        this.#cronExpression = options.cronExpression ?? getConfigValue('HEARTBEAT_CRON') ?? DEFAULT_CRON;
+        this.#message = options.message ?? getConfigValue('HEARTBEAT_MESSAGE') ?? DEFAULT_MESSAGE;
+        this.#scheduler = options.scheduler ?? new JobScheduler();
+        this.#customCheckSkills = options.customCheckSkills ?? {};
+        this.#notifyPlatforms = options.notifyPlatforms ?? ['whatsapp'];
+        this.#notifyUserIds = options.notifyUserIds ?? [];
+        this.#gateway = options.gateway;
+        // Initialize default checks
+        this.#initializeDefaultChecks(options.checks);
+        // Load persisted state
+        this.#loadState();
+    }
+    #initializeDefaultChecks(checkOptions) {
+        const defaultChecks = ['email', 'calendar', 'weather', 'notifications'];
+        for (const checkType of defaultChecks) {
+            const enabled = checkOptions?.[checkType] ?? getConfigValue(`HEARTBEAT_CHECK_${checkType.toUpperCase()}`) === 'true';
+            this.#checks.set(checkType, {
+                type: checkType,
+                enabled,
+                skillId: this.#customCheckSkills[checkType],
+            });
+        }
+    }
+    /** Expose the underlying scheduler so callers can register additional jobs. */
+    get scheduler() {
+        return this.#scheduler;
+    }
+    /** Get current heartbeat state */
+    get state() {
+        return { ...this.#state };
+    }
+    /** Get check configuration */
+    getCheck(type) {
+        return this.#checks.get(type);
+    }
+    /** Enable or disable a specific check */
+    setCheckEnabled(type, enabled) {
+        const check = this.#checks.get(type);
+        if (check) {
+            check.enabled = enabled;
+            this.#saveState();
+        }
+    }
+    /** Add a notification target */
+    addNotificationTarget(platform, userId) {
+        if (!this.#notifyPlatforms.includes(platform)) {
+            this.#notifyPlatforms.push(platform);
+        }
+        if (!this.#notifyUserIds.includes(userId)) {
+            this.#notifyUserIds.push(userId);
+        }
+    }
+    start() {
+        // Guard against double-start
+        if (this.#scheduler.getJob(HEARTBEAT_JOB_ID)) {
+            return;
+        }
+        this.#scheduler.register({
+            id: HEARTBEAT_JOB_ID,
+            cronExpression: this.#cronExpression,
+            description: this.#message,
+            handler: async () => {
+                await this.#executeHeartbeat();
+            },
+            autoStart: true,
+        });
+        logThought('[ProactiveHeartbeat] Service started with checks');
+    }
+    stop() {
+        this.#scheduler.unregister(HEARTBEAT_JOB_ID);
+    }
+    /** Execute a single heartbeat with all enabled checks */
+    async #executeHeartbeat() {
+        await logThought(`[ProactiveHeartbeat] Executing heartbeat...`);
+        this.#state.lastHeartbeatAt = new Date().toISOString();
+        this.#state.totalHeartbeats++;
+        const checkResults = [];
+        // Run all enabled checks
+        for (const [type, check] of this.#checks.entries()) {
+            if (!check.enabled)
+                continue;
+            try {
+                const result = await this.#runCheck(type);
+                check.lastResult = result;
+                check.lastCheckAt = new Date();
+                this.#state.checkStates[type] = {
+                    lastCheckAt: new Date().toISOString(),
+                    lastResult: result,
+                };
+                checkResults.push(result);
+                if (result.shouldNotify) {
+                    await this.#sendNotification(result);
+                }
+            }
+            catch (err) {
+                const errorResult = {
+                    success: false,
+                    summary: `${type} check failed`,
+                    details: err instanceof Error ? err.message : String(err),
+                    shouldNotify: false,
+                };
+                checkResults.push(errorResult);
+            }
+        }
+        // Generate summary
+        const summary = this.#generateSummary(checkResults);
+        // Call the original heartbeat callback
+        await this.#onHeartbeat(summary);
+        // Save state
+        this.#saveState();
+    }
+    /** Run a specific check */
+    async #runCheck(type) {
+        const check = this.#checks.get(type);
+        if (!check) {
+            return {
+                success: false,
+                summary: `Unknown check type: ${type}`,
+                shouldNotify: false,
+            };
+        }
+        // If there's a custom skill for this check, run it
+        if (check.skillId && this.#gateway) {
+            try {
+                // Call the gateway directly with the check type
+                const response = await this.#gateway.processMessage({
+                    platform: 'whatsapp',
+                    senderId: 'heartbeat',
+                    chatId: 'heartbeat',
+                    text: `Run check: ${type}`,
+                    rawPayload: { checkType: type, skillId: check.skillId },
+                });
+                return {
+                    success: true,
+                    summary: `${type} check completed`,
+                    details: response,
+                    shouldNotify: response.length > 0,
+                    notificationMessage: response,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    summary: `${type} check failed`,
+                    details: err instanceof Error ? err.message : String(err),
+                    shouldNotify: true,
+                    notificationMessage: `⚠️ ${type} check failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+        // Default check implementations
+        return this.#defaultCheckImplementation(type);
+    }
+    /** Default check implementations */
+    async #defaultCheckImplementation(type) {
+        // These are placeholder implementations
+        // In a real system, these would connect to actual services
+        switch (type) {
+            case 'email':
+                return {
+                    success: true,
+                    summary: 'Email check: No new important emails',
+                    shouldNotify: false,
+                };
+            case 'calendar':
+                return {
+                    success: true,
+                    summary: 'Calendar check: No upcoming events in the next hour',
+                    shouldNotify: false,
+                };
+            case 'weather':
+                return {
+                    success: true,
+                    summary: 'Weather check: Clear skies, 72°F',
+                    shouldNotify: false,
+                };
+            case 'notifications':
+                return {
+                    success: true,
+                    summary: 'Notifications check: No new notifications',
+                    shouldNotify: false,
+                };
+            default:
+                return {
+                    success: false,
+                    summary: `No implementation for check type: ${type}`,
+                    shouldNotify: false,
+                };
+        }
+    }
+    /** Generate a summary of all check results */
+    #generateSummary(results) {
+        const successful = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        const shouldNotify = results.filter(r => r.shouldNotify).length;
+        let summary = `📊 Heartbeat Summary:\n`;
+        summary += `• Total checks: ${results.length}\n`;
+        summary += `• Successful: ${successful}\n`;
+        summary += `• Failed: ${failed}\n`;
+        summary += `• Notifications sent: ${shouldNotify}\n`;
+        if (failed > 0) {
+            summary += `\n⚠️ Failed checks:\n`;
+            for (const result of results.filter(r => !r.success)) {
+                summary += `• ${result.summary}\n`;
+            }
+        }
+        return summary;
+    }
+    /** Send notification to configured targets */
+    async #sendNotification(result) {
+        if (!result.notificationMessage)
+            return;
+        this.#state.totalNotifications++;
+        // In a real implementation, this would use the dispatcher to send
+        // proactive messages to the configured platforms and users
+        await logThought(`[ProactiveHeartbeat] Would send notification: ${result.notificationMessage}`);
+        // TODO: Integrate with dispatcher for actual notification sending
+        // For now, just log the notification
+    }
+    /** Manually trigger a heartbeat */
+    async triggerManual() {
+        await this.#executeHeartbeat();
+    }
+    /** Manually trigger a specific check */
+    async triggerCheck(type) {
+        const result = await this.#runCheck(type);
+        const check = this.#checks.get(type);
+        if (check) {
+            check.lastResult = result;
+            check.lastCheckAt = new Date();
+            this.#saveState();
+        }
+        return result;
+    }
+    /** Load state from disk */
+    #loadState() {
+        try {
+            const fs = require('fs');
+            if (fs.existsSync(this.#statePath)) {
+                const data = fs.readFileSync(this.#statePath, 'utf8');
+                const loaded = JSON.parse(data);
+                this.#state = { ...this.#state, ...loaded };
+                // Restore check states
+                for (const [type, state] of Object.entries(this.#state.checkStates)) {
+                    const check = this.#checks.get(type);
+                    if (check && state) {
+                        check.lastCheckAt = state.lastCheckAt ? new Date(state.lastCheckAt) : undefined;
+                        check.lastResult = state.lastResult;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn('[ProactiveHeartbeat] Failed to load state:', err);
+        }
+    }
+    /** Save state to disk */
+    #saveState() {
+        try {
+            const fs = require('fs');
+            const dir = require('path').dirname(this.#statePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.#statePath, JSON.stringify(this.#state, null, 2));
+        }
+        catch (err) {
+            console.warn('[ProactiveHeartbeat] Failed to save state:', err);
+        }
+    }
+}
+/**
+ * Simple backward-compatible wrapper for the original HeartbeatService
+ */
+export class HeartbeatService {
+    #scheduler;
+    #onHeartbeat;
+    #cronExpression;
+    #message;
     constructor(onHeartbeat, config = {}, scheduler) {
         this.#onHeartbeat = onHeartbeat;
         this.#cronExpression = config.cronExpression ?? getConfigValue('HEARTBEAT_CRON') ?? DEFAULT_CRON;
         this.#message = config.message ?? getConfigValue('HEARTBEAT_MESSAGE') ?? DEFAULT_MESSAGE;
         this.#scheduler = scheduler ?? new JobScheduler();
     }
-    /** Expose the underlying scheduler so callers can register additional jobs. */
     get scheduler() {
         return this.#scheduler;
     }
     start() {
-        // Guard against double-start
         if (this.#scheduler.getJob(HEARTBEAT_JOB_ID)) {
             return;
         }

package/dist/core/lane-executor.js

@@ -1,4 +1,6 @@
 import { logToolCall, scrubSensitiveText } from '../utils/logger.js';
+import { getLearningSystem } from '../services/learning-system.js';
+import { getSelfHealingService } from '../services/self-healing.js';
 /** Convert a Skill (from the registry) into the internal Tool format used by LaneExecutor. */
 function skillToTool(skill) {
     return {
@@ -112,6 +114,8 @@ export class LaneExecutor {
                         const result = await tool.execute(args);
                         content = typeof result === 'string' ? result : JSON.stringify(result);
                         await logToolCall(toolName, args, content);
+                        const success = !content.startsWith('Error');
+                        await this.#recordSkillExecution(toolName, args, success, content);
                     }
                     catch (error) {
                         const rawMessage = error instanceof Error ? error.message : String(error);
@@ -119,6 +123,7 @@ export class LaneExecutor {
                         console.error(`[LaneExecutor] Tool ${toolName} failed: ${sanitizedMessage}`);
                         content = `Error executing tool: ${sanitizedMessage}`;
                         await logToolCall(toolName, args, content);
+                        await this.#recordSkillExecution(toolName, args, false, sanitizedMessage);
                     }
                 }
             }
@@ -131,4 +136,17 @@ export class LaneExecutor {
         }
         return results;
     }
+    async #recordSkillExecution(toolName, args, success, result) {
+        try {
+            const learning = getLearningSystem();
+            const selfHealer = getSelfHealingService();
+            const isError = result.startsWith('Error');
+            const outcome = isError ? 'failure' : 'success';
+            await learning.learn('success', `skill:${toolName}`, { toolName, args, result: result.slice(0, 100) }, success ? undefined : result.slice(0, 200), outcome);
+            selfHealer.learn(`skill:${toolName}`, success, { toolName, args, result: result.slice(0, 100) }, success ? undefined : result.slice(0, 200));
+        }
+        catch (err) {
+            console.warn('[LaneExecutor] Failed to record skill execution:', err);
+        }
+    }
 }

package/dist/core/onboarding.js

@@ -162,7 +162,7 @@ const ONBOARD_FIELDS = [
     {
         key: 'API_PORT',
         label: 'API Port',
-        hint: 'Workspace default. Integer from 1 to 65535.',
+        hint: 'HTTP port for TwinClaw control plane API (default: 18789). Required to connect external clients.',
         validator: (value) => {
             const parsed = Number(value);
             if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
@@ -218,7 +218,6 @@ class ReadlinePrompter {
         this.#rl = readline.createInterface({
             input: process.stdin,
             output: this.#writer,
-            terminal: true,
         });
         this.#rl.on('SIGINT', () => {
             const reject = this.#pendingReject;
@@ -669,3 +668,4 @@ export async function handleOnboardCli(argv) {
     await runSimplifiedOnboarding();
     return true;
 }
+export { runSimplifiedOnboarding } from './simplified-onboarding.js';

package/dist/core/self-improve-cli.js

@@ -0,0 +1,212 @@
+import { getLearningSystem, initializeLearning } from '../services/learning-system.js';
+import { getSkillBuilder, initializeSkillBuilder } from '../services/skill-builder.js';
+import { getAutoConfigurer, initializeAutoConfigurer } from '../services/auto-configurer.js';
+import { getSelfHealingService, initializeSelfHealer } from '../services/self-healing.js';
+export async function handleSelfImproveCli(argv) {
+    if (argv[0] !== 'self') {
+        return false;
+    }
+    try {
+        await initializeLearning();
+        await initializeSkillBuilder();
+        await initializeAutoConfigurer();
+        await initializeSelfHealer();
+    }
+    catch (err) {
+        console.warn('Note: Some services may not be fully initialized:', err instanceof Error ? err.message : String(err));
+    }
+    const command = argv[1];
+    if (!command) {
+        console.log(`
+ 🤖 TwinClaw Self-Improving Agent Commands
+
+ Usage: twinclaw self <command> [options]
+
+ Commands:
+   learn <pattern> <solution>   - Learn from a success
+   query <question>           - Query past experiences
+   stats                      - Show learning statistics
+   health                     - Run health check
+   configure <service>        - Auto-configure a service
+   services                   - List available services
+   build-skill <description> - Build a new skill
+   
+ Examples:
+   twinclaw self learn "api timeout" "increase timeout to 30s"
+   twinclaw self query "github integration"
+   twinclaw self configure slack
+   twinclaw self services
+         `.trim());
+        return true;
+    }
+    try {
+        switch (command) {
+            case 'learn':
+                return await handleLearn(argv.slice(2));
+            case 'query':
+                return await handleQuery(argv.slice(2));
+            case 'stats':
+                return await handleStats();
+            case 'health':
+                return await handleHealth();
+            case 'configure':
+                return await handleConfigure(argv.slice(2));
+            case 'services':
+                return await handleServices();
+            case 'build-skill':
+                return await handleBuildSkill(argv.slice(2));
+            case 'fix':
+                return await handleGetFix(argv.slice(2));
+            default:
+                console.error(`Unknown command: ${command}`);
+                return false;
+        }
+    }
+    catch (err) {
+        console.error('Error:', err instanceof Error ? err.message : String(err));
+        return false;
+    }
+}
+async function handleLearn(args) {
+    if (args.length < 2) {
+        console.log('Usage: twinclaw self learn <pattern> <solution>');
+        return false;
+    }
+    const pattern = args[0];
+    const solution = args.slice(1).join(' ');
+    const learning = getLearningSystem();
+    await learning.learn('fix', pattern, {}, solution, 'success');
+    console.log(`✅ Learned: "${pattern}" -> "${solution}"`);
+    return true;
+}
+async function handleQuery(args) {
+    if (args.length < 1) {
+        console.log('Usage: twinclaw self query <question>');
+        return false;
+    }
+    const query = args.join(' ');
+    const learning = getLearningSystem();
+    const result = learning.query(query);
+    console.log(`\n🔍 Results for: "${query}"\n`);
+    if (result.entries.length === 0) {
+        console.log('No similar experiences found.');
+    }
+    else {
+        console.log('Past experiences:');
+        for (const entry of result.entries.slice(0, 5)) {
+            console.log(`  - ${entry.description} (${entry.successRate * 100}% success)`);
+            if (entry.solution) {
+                console.log(`    Solution: ${entry.solution}`);
+            }
+        }
+    }
+    if (result.suggestions.length > 0) {
+        console.log('\n💡 Suggestions:');
+        for (const s of result.suggestions) {
+            console.log(`  - ${s}`);
+        }
+    }
+    return true;
+}
+async function handleStats() {
+    const learning = getLearningSystem();
+    const stats = learning.getStats();
+    console.log(`
+📊 Learning Statistics
+────────────────────
+Total memories: ${stats.total}
+Success rate: ${(stats.successRate * 100).toFixed(1)}%
+
+By type:
+${Object.entries(stats.byType).map(([type, count]) => `  ${type}: ${count}`).join('\n')}
+
+Top patterns:
+${stats.topPatterns.map(p => `  - ${p}`).join('\n') || '  (none yet)'}
+    `.trim());
+    return true;
+}
+async function handleHealth() {
+    const healer = getSelfHealingService();
+    const metrics = await healer.performHealthCheck();
+    console.log(`
+ 💚 Self-Healing Health Check
+ ───────────────────────────
+ `);
+    for (const metric of metrics) {
+        const statusIcon = metric.status === 'healthy' ? '✅' : metric.status === 'degraded' ? '⚠️' : '❌';
+        console.log(`${statusIcon} ${metric.component}: ${metric.status}`);
+        if (metric.message) {
+            console.log(`   ${metric.message}`);
+        }
+    }
+    console.log('\nRun "twinclaw doctor" for full diagnostics.');
+    return true;
+}
+async function handleConfigure(args) {
+    if (args.length < 1) {
+        console.log('Usage: twinclaw self configure <service>');
+        console.log('Available services: twinclaw self services');
+        return false;
+    }
+    const serviceName = args[0];
+    const configurer = getAutoConfigurer();
+    console.log(`\n🔧 Configuring ${serviceName}...\n`);
+    const { config, steps } = await configurer.fetchDocsAndConfig(serviceName);
+    console.log('Setup steps:');
+    for (const step of steps) {
+        console.log(`  ${step}`);
+    }
+    console.log('\nTo complete setup, edit your twinclaw.json with:');
+    console.log(JSON.stringify({ [serviceName]: config }, null, 2));
+    return true;
+}
+async function handleServices() {
+    const configurer = getAutoConfigurer();
+    const services = configurer.listKnownServices();
+    console.log(`
+📦 Available Auto-Configure Services
+───────────────────────────────────
+`);
+    for (const service of services) {
+        console.log(`  ${service.name.padEnd(15)} - ${service.description}`);
+    }
+    console.log('\nUsage: twinclaw self configure <service>');
+    return true;
+}
+async function handleBuildSkill(args) {
+    if (args.length < 1) {
+        console.log('Usage: twinclaw self build-skill <description>');
+        return false;
+    }
+    const description = args.join(' ');
+    const builder = getSkillBuilder();
+    console.log(`\n🧱 Building skill: "${description}"`);
+    const skill = await builder.buildFromRequest({
+        description,
+        purpose: 'user requested'
+    });
+    console.log(`\n✅ Created skill: ${skill.name}`);
+    console.log(`   Category: ${skill.category}`);
+    console.log(`   ID: ${skill.id}`);
+    console.log(`\nSkill code saved to: ${builder.getCustomSkillsDir()}/${skill.id}.ts`);
+    return true;
+}
+async function handleGetFix(args) {
+    if (args.length < 1) {
+        console.log('Usage: twinclaw self fix <issue>');
+        return false;
+    }
+    const issue = args.join(' ');
+    const healer = getSelfHealingService();
+    const fixes = healer.suggestFixes(issue);
+    console.log(`\n🔧 Suggested fixes for: "${issue}"\n`);
+    if (fixes.length === 0) {
+        console.log('No known fixes. Try: twinclaw self query <issue>');
+    }
+    else {
+        for (const fix of fixes) {
+            console.log(`  - ${fix}`);
+        }
+    }
+    return true;
+}