create-walle 0.1.0

package/template/wall-e/loops/tasks.js

@@ -0,0 +1,487 @@
+'use strict';
+const brain = require('../brain');
+const { spawn } = require('child_process');
+const path = require('path');
+const { findSkill } = require('../skills/skill-loader');
+
+const WALL_E_DIR = path.join(__dirname, '..');
+
+// ── Live log buffer — in-memory, keyed by task ID ──
+const taskLogs = new Map(); // task_id → { lines: string[], startedAt, status }
+const taskProcesses = new Map(); // task_id → child process (for stopping)
+
+function stopTask(taskId) {
+  const child = taskProcesses.get(taskId);
+  if (child) {
+    child.kill('SIGTERM');
+    taskProcesses.delete(taskId);
+    return true;
+  }
+  return false;
+}
+
+function getTaskLogs(taskId) {
+  return taskLogs.get(taskId) || null;
+}
+
+function clearTaskLogs(taskId) {
+  taskLogs.delete(taskId);
+}
+
+function appendLog(taskId, line) {
+  let entry = taskLogs.get(taskId);
+  if (!entry) {
+    entry = { lines: [], startedAt: new Date().toISOString(), status: 'running' };
+    taskLogs.set(taskId, entry);
+  }
+  entry.lines.push(line);
+  // Cap at 500 lines to prevent memory bloat
+  if (entry.lines.length > 500) entry.lines.shift();
+}
+
+/**
+ * On daemon startup, recover tasks that were interrupted (stuck in 'running').
+ * Resets them to 'pending' so they get re-picked up.
+ */
+function recoverInterruptedTasks() {
+  const db = brain.getDb();
+  const stuck = db.prepare("SELECT * FROM tasks WHERE status = 'running'").all();
+  if (stuck.length === 0) return 0;
+
+  for (const t of stuck) {
+    const hasCheckpoint = t.checkpoint ? ' (has checkpoint — will resume)' : '';
+    console.log(`[tasks] Recovering interrupted task: ${t.title}${hasCheckpoint}`);
+    brain.updateTask(t.id, {
+      status: 'pending',
+      started_at: null,
+      next_run_at: new Date().toISOString(), // run immediately on recovery
+    });
+  }
+  return stuck.length;
+}
+
+/**
+ * Task executor loop — picks up due tasks and runs them.
+ */
+async function runDueTasks() {
+  const tasks = brain.getDueTasks();
+  if (tasks.length === 0) return { processed: 0 };
+
+  let processed = 0;
+  for (const task of tasks) {
+    if (task.status === 'running') continue;
+
+    const now = new Date().toISOString();
+    const hasCheckpoint = task.checkpoint ? ' (resuming from checkpoint)' : '';
+    brain.updateTask(task.id, { status: 'running', started_at: now });
+    appendLog(task.id, `[${now.slice(11, 19)}] Starting: ${task.title}${hasCheckpoint}`);
+
+    try {
+      let resultText;
+
+      if (task.skill) {
+        resultText = await executeSkill(task.id, task);
+      } else if (task.execution === 'script' && task.script) {
+        resultText = await executeScript(task.id, task.script, task.checkpoint);
+      } else {
+        resultText = await executeChat(task.id, task);
+      }
+
+      const completedAt = new Date().toISOString();
+      appendLog(task.id, `[${completedAt.slice(11, 19)}] Completed`);
+
+      const logEntry = taskLogs.get(task.id);
+      if (logEntry) logEntry.status = 'completed';
+
+      // Strip BRIEFING_ITEMS block from displayed result, store items separately
+      const cleanResult = resultText.replace(/<!--\s*BRIEFING_ITEMS[\s\S]*?-->/, '').trim();
+
+      brain.updateTask(task.id, {
+        status: task.type === 'recurring' ? 'pending' : 'completed',
+        completed_at: completedAt,
+        last_run_at: completedAt,
+        run_count: (task.run_count || 0) + 1,
+        result: cleanResult.slice(0, 10000),
+        error: null,
+        checkpoint: null, // clear checkpoint on success
+        next_run_at: task.type === 'recurring' ? computeNextDue(task.schedule) : null,
+        // Keep started_at so duration can be computed as completed_at - started_at
+      });
+
+      // Consolidate briefing items if present
+      try {
+        consolidateBriefingItems(task, resultText, completedAt);
+      } catch (e) {
+        console.error('[tasks] Briefing item consolidation failed:', e.message);
+      }
+
+      // Notify (skip frequent recurring)
+      if (task.type !== 'recurring' || !task.schedule?.match(/every\s+\d+\s*m/i)) {
+        try {
+          const { sendNotification } = require('../tools/local-tools');
+          await sendNotification('WALL-E Task', task.title + ' — done');
+        } catch {}
+      }
+
+      processed++;
+      console.log(`[tasks] Completed: ${task.title} (${task.execution || 'chat'})`);
+    } catch (err) {
+      console.error('[tasks] Failed:', task.title, err.message);
+      appendLog(task.id, `[ERROR] ${err.message}`);
+
+      const logEntry = taskLogs.get(task.id);
+      if (logEntry) logEntry.status = 'failed';
+
+      // Detect actionable errors and create pending questions
+      const errMsg = err.message || '';
+      const isSlackAuth = errMsg.includes('Slack token expired') || errMsg.includes('invalid_auth') || errMsg.includes('401') || errMsg.includes('not authenticated');
+      if (isSlackAuth) {
+        try {
+          // Pause all Slack-related tasks to prevent repeated failures
+          const allTasks = brain.listTasks({});
+          for (const t of allTasks) {
+            if (t.script && t.script.includes('slack') && (t.status === 'pending' || t.status === 'running')) {
+              brain.updateTask(t.id, { status: 'paused' });
+              console.log(`[tasks] Auto-paused: ${t.title} (Slack auth expired)`);
+            }
+          }
+          // Create a pending question for the user (dedup: skip if one already exists)
+          const existingQ = brain.listQuestions({ status: 'pending', question_type: 'action_required' })
+            .find(q => q.question.includes('Slack token expired'));
+          if (existingQ) {
+            console.log('[tasks] Slack re-auth question already pending, skipping duplicate');
+          } else {
+            brain.insertQuestion({
+              question_type: 'action_required',
+              question: 'Slack token expired — WALL-E cannot access Slack until you re-authenticate.',
+              context: JSON.stringify({
+                action: 'slack_reauth',
+                failed_task: task.title,
+                error: errMsg,
+                instructions: 'Click "Reconnect Slack" in the Tasks tab, or run: node tools/slack-mcp.js auth',
+              }),
+              priority: 'high',
+            });
+            console.log('[tasks] Created pending question for Slack re-auth');
+            try {
+              const { sendNotification } = require('../tools/local-tools');
+              await sendNotification('WALL-E: Slack Disconnected', 'Re-authenticate to resume Slack tasks');
+            } catch {}
+          }
+        } catch (e) {
+          console.error('[tasks] Failed to create auth question:', e.message);
+        }
+      }
+
+      brain.updateTask(task.id, {
+        status: task.type === 'recurring' ? 'pending' : 'failed',
+        error: isSlackAuth ? 'Slack token expired. Reconnect Slack to retry.' : err.message,
+        completed_at: new Date().toISOString(),
+        last_run_at: new Date().toISOString(),
+        run_count: (task.run_count || 0) + 1,
+        next_run_at: task.type === 'recurring' ? computeNextDue(task.schedule) : null,
+        // Keep started_at so duration can be computed
+      });
+
+      // For Slack auth errors, override recurring status to paused
+      if (isSlackAuth && task.type === 'recurring') {
+        brain.updateTask(task.id, { status: 'paused' });
+      }
+    }
+  }
+
+  return { processed };
+}
+
+// ── Skill execution ──
+
+async function executeSkill(taskId, task) {
+  const skill = findSkill(task.skill);
+  if (!skill) throw new Error(`Skill "${task.skill}" not found`);
+
+  appendLog(taskId, `Skill: ${skill.name} v${skill.version} (${skill.execution})`);
+
+  if (skill.execution === 'script') {
+    // Resolve entry point relative to the skill directory
+    const entryPath = path.resolve(skill.dir, skill.entry || 'run.js');
+    if (!require('fs').existsSync(entryPath)) {
+      throw new Error(`Skill entry point not found: ${entryPath}`);
+    }
+
+    // Build the shell command: node <entry> <args...>
+    const args = [...(skill.args || [])];
+
+    // Merge task-level skill_config with skill defaults
+    const skillConfig = {};
+    if (skill.config) {
+      for (const [k, v] of Object.entries(skill.config)) {
+        if (v && typeof v === 'object' && v.default !== undefined) {
+          skillConfig[k] = v.default;
+        }
+      }
+    }
+    // Task overrides
+    let taskConfig = {};
+    if (task.skill_config) {
+      try {
+        taskConfig = typeof task.skill_config === 'string'
+          ? JSON.parse(task.skill_config)
+          : task.skill_config;
+      } catch {}
+    }
+    Object.assign(skillConfig, taskConfig);
+
+    // For slack-backfill: pass mode/month as CLI args if configured
+    if (skillConfig.mode && !args.includes(skillConfig.mode)) {
+      // Only add mode as arg if the script expects it as argv[2]
+      // (slack-backfill uses process.argv[2] as mode)
+      if (skill.name === 'slack-backfill') {
+        args.push(skillConfig.mode);
+        if (skillConfig.month) args.push(skillConfig.month);
+      }
+    }
+
+    const scriptCmd = `node ${entryPath} ${args.join(' ')}`.trim();
+    appendLog(taskId, `Running: ${scriptCmd}`);
+
+    // Pass config as env var + checkpoint support
+    return executeScript(taskId, scriptCmd, task.checkpoint, {
+      WALL_E_SKILL_CONFIG: JSON.stringify(skillConfig),
+      WALL_E_SKILL_DIR: skill.dir,
+      WALL_E_SRC_DIR: WALL_E_DIR,
+    });
+  }
+
+  if (skill.execution === 'agent') {
+    // Build a task-like object with skill instructions as the description
+    const agentTask = {
+      ...task,
+      title: task.title || skill.name,
+      description: skill.instructions || skill.description,
+    };
+    appendLog(taskId, `Agent skill: sending instructions to Claude...`);
+    return executeChat(taskId, agentTask);
+  }
+
+  throw new Error(`Unknown skill execution mode: ${skill.execution}`);
+}
+
+// ── Script execution with live log streaming ──
+
+function executeScript(taskId, script, checkpoint, extraEnv) {
+  return new Promise((resolve, reject) => {
+    // Pass checkpoint as env var so scripts can resume from where they left off
+    const env = { ...process.env, HOME: process.env.HOME };
+    if (checkpoint) env.WALL_E_CHECKPOINT = checkpoint;
+    if (extraEnv) Object.assign(env, extraEnv);
+
+    const child = spawn('bash', ['-c', script], {
+      cwd: WALL_E_DIR,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    taskProcesses.set(taskId, child);
+
+    let stdout = '';
+    let stderr = '';
+    // No timeout — tasks run until completion. User can stop via UI.
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      text.split('\n').filter(Boolean).forEach(line => {
+        appendLog(taskId, line);
+        // Lines starting with CHECKPOINT: are saved as resume points
+        if (line.startsWith('CHECKPOINT:')) {
+          brain.updateTask(taskId, { checkpoint: line.slice(11).trim() });
+        }
+      });
+    });
+
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      text.split('\n').filter(Boolean).forEach(line => {
+        appendLog(taskId, `[stderr] ${line}`);
+      });
+    });
+
+    child.on('close', (code) => {
+      taskProcesses.delete(taskId);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Exit code ${code}: ${stderr.slice(0, 500)}`));
+      } else {
+        let output = stdout.trim();
+        if (stderr.trim()) output += '\n[stderr] ' + stderr.trim();
+        resolve(output);
+      }
+    });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+// ── Chat execution with log streaming ──
+
+async function executeChat(taskId, task) {
+  const chatModule = require('../chat');
+  const prompt = buildTaskPrompt(task);
+
+  appendLog(taskId, 'Sending to Claude...');
+
+  const result = await chatModule.chat(prompt, {
+    channel: 'task',
+    session_id: `task-${task.id}`,
+    onProgress: (event) => {
+      if (event.type === 'tool_call') appendLog(taskId, event.summary);
+      else if (event.type === 'tool_done') appendLog(taskId, `Done: ${event.summary}`);
+      else if (event.type === 'thinking') appendLog(taskId, `Turn ${(event.turn || 0) + 1}...`);
+    },
+  });
+
+  return result.reply || '';
+}
+
+function buildTaskPrompt(task) {
+  let prompt = `[TASK] ${task.title}`;
+  if (task.description) prompt += `\n\n${task.description}`;
+  prompt += `\n\nThis is a background task. Complete it thoroughly using your tools. Provide a clear, actionable result.`;
+  if (task.priority === 'urgent' || task.priority === 'high') {
+    prompt += ` This is ${task.priority} priority.`;
+  }
+  return prompt;
+}
+
+function computeNextDue(schedule) {
+  if (!schedule) return null;
+  const now = new Date();
+
+  const dailyAtMatch = schedule.match(/^daily\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
+  if (dailyAtMatch) {
+    let hour = parseInt(dailyAtMatch[1]);
+    const min = parseInt(dailyAtMatch[2] || '0');
+    const ampm = dailyAtMatch[3]?.toLowerCase();
+    if (ampm === 'pm' && hour < 12) hour += 12;
+    if (ampm === 'am' && hour === 12) hour = 0;
+    const next = new Date(now);
+    next.setHours(hour, min, 0, 0);
+    if (next <= now) next.setDate(next.getDate() + 1);
+    return next.toISOString();
+  }
+
+  const weeklyMatch = schedule.match(/^weekly\s+(?:on\s+)?(\w+)(?:\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?)?$/i);
+  if (weeklyMatch) {
+    const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+    const dayAbbrevs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+    const dayInput = weeklyMatch[1].toLowerCase();
+    let targetDay = dayNames.indexOf(dayInput);
+    if (targetDay === -1) targetDay = dayAbbrevs.indexOf(dayInput.slice(0, 3));
+    if (targetDay === -1) targetDay = 1;
+    let hour = parseInt(weeklyMatch[2] || '9');
+    const min = parseInt(weeklyMatch[3] || '0');
+    const ampm = weeklyMatch[4]?.toLowerCase();
+    if (ampm === 'pm' && hour < 12) hour += 12;
+    const next = new Date(now);
+    next.setHours(hour, min, 0, 0);
+    const daysUntil = (targetDay - now.getDay() + 7) % 7 || 7;
+    next.setDate(next.getDate() + daysUntil);
+    return next.toISOString();
+  }
+
+  if (schedule === 'hourly') return new Date(now.getTime() + 3600000).toISOString();
+  if (schedule === 'daily') return new Date(now.getTime() + 86400000).toISOString();
+  if (schedule === 'weekly') return new Date(now.getTime() + 604800000).toISOString();
+
+  const everyMatch = schedule.match(/^every\s+(\d+)\s*(m|h|d)$/i);
+  if (everyMatch) {
+    const n = parseInt(everyMatch[1]);
+    const unit = everyMatch[2].toLowerCase();
+    const ms = unit === 'h' ? n * 3600000 : unit === 'm' ? n * 60000 : n * 86400000;
+    return new Date(now.getTime() + ms).toISOString();
+  }
+
+  return null;
+}
+
+/**
+ * Immediately run a task by ID — bypasses the daemon loop timer.
+ * Sets the task to pending with immediate next_run_at, then executes runDueTasks().
+ */
+async function runTaskById(taskId) {
+  const task = brain.getTask(taskId);
+  if (!task) throw new Error('Task not found');
+  if (task.status === 'running') throw new Error('Task is already running');
+  brain.updateTask(taskId, { status: 'pending', next_run_at: new Date().toISOString(), error: null, result: null });
+  return runDueTasks();
+}
+
+// ── Briefing Item Consolidation ──
+
+/**
+ * Parse BRIEFING_ITEMS from task result and upsert into briefing_items table.
+ * New items are inserted; existing items (matched by skill + title) get updated.
+ * Items from previous runs that don't appear in the new result are left as-is
+ * (user may have modified their status).
+ */
+function consolidateBriefingItems(task, resultText, timestamp) {
+  const match = resultText.match(/<!--\s*BRIEFING_ITEMS\s*\n([\s\S]*?)-->/);
+  if (!match) return;
+
+  let items;
+  try {
+    items = JSON.parse(match[1].trim());
+  } catch (e) {
+    console.error('[tasks] Failed to parse BRIEFING_ITEMS JSON:', e.message);
+    return;
+  }
+
+  if (!Array.isArray(items) || items.length === 0) return;
+
+  const skill = task.skill || 'unknown';
+  const now = timestamp || new Date().toISOString();
+  let inserted = 0, updated = 0;
+
+  for (const item of items) {
+    if (!item.title) continue;
+
+    // Try exact title match first
+    const existing = brain.findBriefingItemByTitle(skill, item.title);
+
+    if (existing) {
+      // Update existing item — bump times_seen, update last_seen, and refresh metadata
+      const updates = {
+        last_seen: now,
+        times_seen: (existing.times_seen || 1) + 1,
+      };
+      // Update urgency/owner/category if they changed (but don't downgrade user edits)
+      if (item.urgency) updates.urgency = item.urgency;
+      if (item.owner) updates.owner = item.owner;
+      if (item.category) updates.category = item.category;
+      if (item.context) updates.context = typeof item.context === 'string' ? item.context : JSON.stringify(item.context);
+      brain.updateBriefingItem(existing.id, updates);
+      updated++;
+    } else {
+      // Insert new item
+      brain.insertBriefingItem({
+        task_id: task.id,
+        skill,
+        title: item.title,
+        category: item.category || null,
+        owner: item.owner || null,
+        urgency: item.urgency || 'async',
+        context: item.context ? (typeof item.context === 'string' ? item.context : JSON.stringify(item.context)) : null,
+        first_seen: now,
+        last_seen: now,
+      });
+      inserted++;
+    }
+  }
+
+  if (inserted || updated) {
+    console.log(`[tasks] Briefing items consolidated: ${inserted} new, ${updated} updated (skill: ${skill})`);
+  }
+}
+
+module.exports = { runDueTasks, runTaskById, recoverInterruptedTasks, buildTaskPrompt, computeNextDue, getTaskLogs, clearTaskLogs, stopTask, executeSkill, consolidateBriefingItems, taskLogs };

package/template/wall-e/loops/think.js

@@ -0,0 +1,125 @@
+const brain = require('../brain');
+const { extractKnowledge } = require('../extraction/knowledge-extractor');
+const { detectContradictions } = require('../extraction/contradiction');
+
+const BATCH_SIZE = 20;
+
+async function runOnce(opts = {}) {
+  const extractFn = opts.extractFn || extractKnowledge;
+  const ownerName = brain.getOwnerName();
+
+  const pending = brain.listMemories({ extractionStatus: 'pending', limit: BATCH_SIZE });
+  if (pending.length === 0) {
+    // Still run self-resolution even with no new memories
+    await selfResolveQuestions(ownerName, opts);
+    return { memoriesProcessed: 0, knowledgeExtracted: 0 };
+  }
+
+  let knowledgeExtracted = 0;
+
+  try {
+    // Step 1: Extract knowledge (async API call)
+    const entries = await extractFn(pending, ownerName, { model: opts.model });
+
+    // Step 2: Detect contradictions (async API call, outside transaction)
+    const contradictions = await detectContradictions(entries, ownerName, { detectFn: opts.detectFn });
+
+    // Step 3: DB transaction: insert knowledge + handle contradictions + mark done
+    const db = brain.getDb();
+    const writeResults = db.transaction(() => {
+      // Insert all new knowledge entries, tracking their IDs
+      const insertedIds = [];
+      for (const entry of entries) {
+        const result = brain.insertKnowledge({
+          category: entry.category,
+          subject: entry.subject,
+          predicate: entry.predicate,
+          object: entry.object,
+          confidence: entry.confidence || 0.5,
+          source_memory_ids: JSON.stringify(entry.source_memory_ids || []),
+        });
+        insertedIds.push({ ...entry, _id: result.id });
+        knowledgeExtracted++;
+      }
+
+      // Handle contradictions
+      for (const contradiction of contradictions) {
+        // Find the ID of the newly inserted entry that matches this contradiction
+        const newInserted = insertedIds.find(e =>
+          e.subject === contradiction.new_entry.subject &&
+          e.predicate === contradiction.new_entry.predicate &&
+          e.object === contradiction.new_entry.object
+        );
+
+        // Insert pending question
+        brain.insertQuestion({
+          question_type: 'contradiction',
+          question: contradiction.explanation,
+          context: JSON.stringify({
+            old_id: contradiction.old_id,
+            new_entry: contradiction.new_entry,
+          }),
+        });
+
+        // Supersede old knowledge
+        if (newInserted) {
+          brain.supersedeKnowledge(contradiction.old_id, newInserted._id);
+        }
+      }
+
+      for (const mem of pending) {
+        brain.updateMemoryExtraction(mem.id, 'done');
+      }
+    });
+    writeResults();
+  } catch (err) {
+    console.error('[think] Extraction failed:', err.message);
+    for (const mem of pending) {
+      try {
+        brain.updateMemoryExtraction(mem.id, 'failed');
+      } catch (updateErr) {
+        console.error('[think] Failed to mark memory as failed:', updateErr.message);
+      }
+    }
+  }
+
+  brain.upsertCheckpoint('think', {
+    last_memory_at: pending[pending.length - 1].timestamp,
+    metadata: JSON.stringify({ memories_processed: pending.length, knowledge_extracted: knowledgeExtracted }),
+  });
+
+  // Task 4: Self-resolve pending questions
+  await selfResolveQuestions(ownerName, opts);
+
+  return { memoriesProcessed: pending.length, knowledgeExtracted };
+}
+
+async function selfResolveQuestions(ownerName, opts = {}) {
+  const pendingQuestions = brain.listQuestions({ status: 'pending', limit: 10 });
+
+  for (const question of pendingQuestions) {
+    // Get memories created after the question was created
+    const newMemories = brain.listMemories({ since: question.created_at });
+
+    // Need more than 3 new relevant memories to attempt resolution
+    if (newMemories.length <= 3) continue;
+
+    const selfResolveFn = opts.selfResolveFn;
+    if (!selfResolveFn) continue;
+
+    try {
+      const result = await selfResolveFn(question, newMemories, ownerName);
+      if (result && result.resolved) {
+        brain.answerQuestion(question.id, {
+          answer: result.answer,
+          resolution_type: 'inferred',
+          resolution_evidence: JSON.stringify(result.evidence),
+        });
+      }
+    } catch (err) {
+      console.error('[think] Self-resolution failed for question', question.id, ':', err.message);
+    }
+  }
+}
+
+module.exports = { runOnce };