create-walle 0.9.3 → 0.9.4

package/template/wall-e/coding-review.js

@@ -0,0 +1,189 @@
+'use strict';
+const { spawn } = require('node:child_process');
+
+/**
+ * Build a prompt for reviewing a single subtask's diff against its intent.
+ * @param {{ title: string, prompt: string }} subtask
+ * @param {string} diff
+ * @returns {string}
+ */
+function buildSubtaskReviewPrompt(subtask, diff) {
+  return `You are a code reviewer. Review the following diff for a subtask and check whether it correctly implements the stated intent. Look for bugs, security issues, and missing pieces.
+
+## Subtask Title
+${subtask.title}
+
+## Subtask Intent
+${subtask.prompt}
+
+## Diff
+\`\`\`
+${diff}
+\`\`\`
+
+Reply with JSON in exactly this format (no other text outside the JSON):
+{"pass": true/false, "issues": ["description of each issue"], "severity": "minor|major|blocker"}
+
+- "pass": true if the diff correctly implements the intent with no significant issues
+- "issues": array of strings describing any problems found (empty array if none)
+- "severity": "minor" for style/nitpicks, "major" for bugs or missing functionality, "blocker" for security issues or fundamentally broken logic`;
+}
+
+/**
+ * Build a prompt for final review of the entire diff against the original request.
+ * @param {string} request - The original user request
+ * @param {string} fullDiff - Combined diff of all changes
+ * @returns {string}
+ */
+function buildFinalReviewPrompt(request, fullDiff) {
+  return `You are a senior code reviewer performing a final review of an entire changeset. Check that the diff fully implements the original request. Evaluate:
+
+1. Cross-file consistency - do imports, exports, and interfaces line up?
+2. Missing pieces - is anything from the request left unimplemented?
+3. Architectural issues - are there design problems that span multiple files?
+4. Bugs and security issues
+
+## Original Request
+${request}
+
+## Full Diff
+\`\`\`
+${fullDiff}
+\`\`\`
+
+Reply with JSON in exactly this format (no other text outside the JSON):
+{"pass": true/false, "issues": ["description of each issue"], "severity": "minor|major|blocker", "summary": "one-line summary of the review"}
+
+- "pass": true if the changeset correctly and completely implements the request
+- "issues": array of strings describing any problems found (empty array if none)
+- "severity": "minor" for style/nitpicks, "major" for bugs or missing functionality, "blocker" for security issues or fundamentally broken logic
+- "summary": a brief one-line summary of the overall review`;
+}
+
+/**
+ * Extract a JSON verdict from Claude's response text.
+ * Finds the first JSON object containing a "pass" field.
+ * @param {string} text
+ * @returns {{ pass: boolean, issues: string[], severity: string, summary: string }}
+ */
+function parseVerdict(text) {
+  const failResult = {
+    pass: false,
+    issues: ['Failed to parse review verdict'],
+    severity: 'blocker',
+    summary: '',
+  };
+
+  if (!text) return failResult;
+
+  // Match all JSON-like objects in the text
+  const jsonPattern = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
+  let match;
+  while ((match = jsonPattern.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(match[0]);
+      if ('pass' in parsed) {
+        return {
+          pass: Boolean(parsed.pass),
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+          severity: parsed.severity || 'minor',
+          summary: parsed.summary || '',
+        };
+      }
+    } catch {
+      // Not valid JSON, try next match
+    }
+  }
+
+  return failResult;
+}
+
+/**
+ * Spawn `claude` CLI to run a review prompt and return the parsed verdict.
+ * Uses spawn with argument array (no shell injection risk).
+ * @param {string} prompt
+ * @param {{ cwd?: string, timeoutMs?: number, budgetUsd?: number }} opts
+ * @returns {Promise<{ pass: boolean, issues: string[], severity: string, summary: string }>}
+ */
+function runReview(prompt, opts = {}) {
+  const { cwd, timeoutMs = 120_000 } = opts;
+
+  return new Promise((resolve) => {
+    const blockerVerdict = {
+      pass: false,
+      issues: ['Review process failed'],
+      severity: 'blocker',
+      summary: '',
+    };
+
+    let proc;
+    try {
+      const args = ['-p', prompt, '--output-format', 'text', '--max-turns', '1'];
+      proc = spawn('claude', args, {
+        cwd: cwd || process.cwd(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutMs,
+      });
+    } catch (err) {
+      blockerVerdict.issues = [`Spawn error: ${err.message}`];
+      return resolve(blockerVerdict);
+    }
+
+    const MAX_OUTPUT = 256 * 1024; // 256KB cap
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (chunk) => {
+      if (stdout.length < MAX_OUTPUT) stdout += chunk;
+    });
+    proc.stderr.on('data', (chunk) => {
+      if (stderr.length < MAX_OUTPUT) stderr += chunk;
+    });
+
+    proc.on('error', (err) => {
+      blockerVerdict.issues = [`Spawn error: ${err.message}`];
+      resolve(blockerVerdict);
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0 && !stdout.trim()) {
+        blockerVerdict.issues = [`claude exited with code ${code}: ${stderr.trim() || 'no output'}`];
+        return resolve(blockerVerdict);
+      }
+      resolve(parseVerdict(stdout));
+    });
+  });
+}
+
+/**
+ * Review a single subtask's diff.
+ * @param {{ title: string, prompt: string }} subtask
+ * @param {string} diff
+ * @param {{ cwd?: string, timeoutMs?: number, budgetUsd?: number }} opts
+ * @returns {Promise<{ pass: boolean, issues: string[], severity: string, summary: string }>}
+ */
+function reviewSubtask(subtask, diff, opts = {}) {
+  const prompt = buildSubtaskReviewPrompt(subtask, diff);
+  return runReview(prompt, opts);
+}
+
+/**
+ * Final review of the entire diff against the original request.
+ * @param {string} request
+ * @param {string} fullDiff
+ * @param {{ cwd?: string, timeoutMs?: number, budgetUsd?: number }} opts
+ * @returns {Promise<{ pass: boolean, issues: string[], severity: string, summary: string }>}
+ */
+function reviewFinal(request, fullDiff, opts = {}) {
+  const prompt = buildFinalReviewPrompt(request, fullDiff);
+  return runReview(prompt, opts);
+}
+
+module.exports = {
+  buildSubtaskReviewPrompt,
+  buildFinalReviewPrompt,
+  parseVerdict,
+  runReview,
+  reviewSubtask,
+  reviewFinal,
+};

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

@@ -44,10 +44,11 @@ module.exports = [
   },
   {
     title: 'Email: Full Send History Pull',
-    description: 'One-time full sync of sent email history from macOS Mail. Run manually to backfill.',
-    type: 'once',
+    description: 'Full sync of sent email history from macOS Mail. First run pulls 10 years; subsequent runs sync incrementally from last email.',
+    type: 'recurring',
+    schedule: 'every 12h',
     skill: 'email-sync',
-    skill_config: JSON.stringify({ days_back: 3650, sync_inbox: true }),
+    skill_config: JSON.stringify({ days_back: 3650, sync_inbox: true, incremental: true }),
     priority: 'normal',
   },
   {
@@ -66,6 +67,14 @@ module.exports = [
     skill: 'slack-mentions',
     priority: 'normal',
   },
+  {
+    title: 'Glean: Team Structure Sync',
+    description: 'Sync team structure and contacts from Glean people directory into Wall-E brain.',
+    type: 'recurring',
+    schedule: 'weekly Monday at 6am',
+    skill: 'glean-team-sync',
+    priority: 'normal',
+  },
   {
     title: 'Weekly Reflection',
     description: 'Generate a weekly reflection analyzing patterns, decisions, and insights from the past 7 days.',

package/template/wall-e/deploy.sh

@@ -11,9 +11,9 @@ if ! command -v fly &> /dev/null; then
 fi
 
 # Check if app exists
-if ! fly apps list 2>/dev/null | grep -q wall-e-agent; then
+if ! fly apps list 2>/dev/null | grep -q my-wall-e; then
   echo "Creating Fly.io app..."
-  fly apps create wall-e-agent
+  fly apps create my-wall-e
   fly volumes create wall_e_data --region sjc --size 1
 fi
 
@@ -31,5 +31,5 @@ fly deploy
 
 echo ""
 echo "=== Deployment complete ==="
-echo "WALL-E is running at: https://wall-e-agent.fly.dev"
-echo "Health check: https://wall-e-agent.fly.dev/api/wall-e/health"
+echo "WALL-E is running at: https://my-wall-e.fly.dev"
+echo "Health check: https://my-wall-e.fly.dev/api/wall-e/health"

package/template/wall-e/fly.toml

@@ -1,5 +1,5 @@
-app = "wall-e-agent"
-primary_region = "sjc"
+app = "my-wall-e"
+primary_region = "sjc"  # Change to your nearest region: https://fly.io/docs/reference/regions/
 
 [build]
 

package/template/wall-e/package.json

@@ -9,10 +9,13 @@
     "test": "node --test tests/*.test.js",
     "deploy": "./deploy.sh"
   },
-  "engines": { "node": ">=18" },
+  "engines": {
+    "node": ">=18"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
     "better-sqlite3": "^12.8.0",
+    "grammy": "^1.42.0",
     "uuid": "^11.1.0"
   }
 }

package/template/wall-e/skills/_bundled/coding-agent/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: coding-agent
+description: Autonomous coding agent — decomposes requests into subtasks, executes via Claude Code, verifies, and delivers
+version: 1.0.0
+execution: script
+entry: run.js
+trigger:
+  type: manual
+permissions: [brain:read, brain:write, shell:exec, mcp:call]
+tags: [coding, orchestration, automation]
+---
+
+# Coding Agent
+
+Accepts a coding request, breaks it into subtasks, executes each via headless Claude Code sessions, verifies with tests and code review, then commits and reports back.
+
+Triggered manually via chat, Slack, API, or task UI.

package/template/wall-e/skills/_bundled/coding-agent/run.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+/**
+ * Coding Agent Skill — entry point.
+ *
+ * Receives config via WALL_E_SKILL_CONFIG env var.
+ * Resumes from WALL_E_CHECKPOINT if present.
+ * Outputs CHECKPOINT: lines for crash-safe resumption.
+ * Outputs final report to stdout.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+async function main() {
+  // Parse config
+  const configStr = process.env.WALL_E_SKILL_CONFIG;
+  if (!configStr) {
+    console.error('Missing WALL_E_SKILL_CONFIG');
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(configStr);
+  } catch (e) {
+    console.error('Invalid WALL_E_SKILL_CONFIG:', e.message);
+    process.exit(1);
+  }
+
+  const request = config.request;
+  const cwd = config.cwd || process.cwd();
+  const options = config.options || {};
+
+  if (!request) {
+    console.error('Missing request in config');
+    process.exit(1);
+  }
+
+  // Load orchestrator (resolve relative to wall-e root, not skill dir)
+  const walleRoot = path.resolve(__dirname, '..', '..', '..');
+  const orchestrator = require(path.join(walleRoot, 'coding-orchestrator.js'));
+
+  // Load brain if available
+  let brain;
+  try {
+    brain = require(path.join(walleRoot, 'brain.js'));
+  } catch {}
+
+  // Check for checkpoint (resume case)
+  let resumeState = null;
+  const checkpoint = process.env.WALL_E_CHECKPOINT;
+  if (checkpoint && fs.existsSync(checkpoint)) {
+    try {
+      resumeState = orchestrator.readCheckpoint(checkpoint);
+      console.log(`Resuming from checkpoint: ${resumeState.completed.length} subtasks completed`);
+    } catch (e) {
+      console.error('Failed to read checkpoint:', e.message);
+    }
+  }
+
+  // Progress callback — logs to stdout
+  function onProgress(event) {
+    switch (event.type) {
+      case 'subtask_start':
+        console.log(`\n--- Subtask ${event.subtask.id}: ${event.subtask.title} ---`);
+        break;
+      case 'subtask_done':
+        console.log(`  [OK] Subtask ${event.subtask.id} completed`);
+        break;
+      case 'subtask_retry':
+        console.log(`  [RETRY ${event.attempt}] ${(event.error || '').slice(0, 200)}`);
+        break;
+      case 'review_concern':
+        console.log(`  [CONCERN] ${(event.issues || []).join('; ')}`);
+        break;
+      case 'escalate':
+        console.log(`  [ESCALATE] Stuck on subtask ${event.subtask.id}: ${(event.error || '').slice(0, 200)}`);
+        break;
+      case 'budget_exceeded':
+        console.log(`  [BUDGET] Exceeded: ~$${event.spent.toFixed(2)}`);
+        break;
+    }
+  }
+
+  try {
+    // Plan (skip if resuming with existing plan)
+    let planData;
+    if (resumeState && resumeState.plan) {
+      console.log('Using plan from checkpoint');
+      const mergedConfig = { ...orchestrator.getDefaultConfig(), ...options };
+      const { assembleContext } = require(path.join(walleRoot, 'coding-context.js'));
+      const context = await assembleContext(request, cwd, { brain });
+      planData = { plan: resumeState.plan, context, config: mergedConfig };
+    } else {
+      console.log('Planning...');
+      planData = await orchestrator.plan(request, cwd, { ...options, brain });
+      console.log(`Plan: ${planData.plan.subtasks.length} subtasks, branch: ${planData.plan.branch_name}`);
+
+      // Guardrail check
+      if (planData.plan.subtasks.length > planData.config.guardrail_threshold) {
+        console.log(`\n[GUARDRAIL] Plan has ${planData.plan.subtasks.length} subtasks (threshold: ${planData.config.guardrail_threshold})`);
+        console.log('Subtasks:');
+        planData.plan.subtasks.forEach(s => console.log(`  ${s.id}. ${s.title}`));
+        console.log('\nPausing for approval. Re-run to continue.');
+        const statePath = path.join(cwd, '.wall-e-coding-state.json');
+        orchestrator.writeCheckpoint(statePath, {
+          completed: [], plan: planData.plan,
+          cumulative_context: '', branch: planData.plan.branch_name, session_ids: {},
+        });
+        console.log(`CHECKPOINT: ${statePath}`);
+        return;
+      }
+    }
+
+    // Execute
+    console.log('\nExecuting...');
+    const executeResult = await orchestrator.execute(planData, {
+      cwd,
+      onProgress,
+      startFrom: resumeState,
+    });
+
+    if (!executeResult.success) {
+      console.error(`\nExecution failed: ${executeResult.error}`);
+      process.exit(1);
+    }
+
+    // Complete
+    console.log('\nCompleting...');
+    const report = await orchestrator.complete(request, planData, executeResult, {
+      cwd, brain, onProgress,
+    });
+
+    console.log('\n' + orchestrator.formatReport(report));
+  } catch (e) {
+    console.error(`Coding agent error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/template/wall-e/skills/_bundled/email-sync/SKILL.md

@@ -5,7 +5,7 @@ description: >
   the owner's communication style. Always syncs all sent mail with body
   content. Inbox sync is optional and filters to only emails addressed
   directly to the owner (on To/Cc line). Uses JXA to read Mail.app.
-version: 1.1.0
+version: 1.2.0
 author: wall-e
 execution: script
 entry: run.js
@@ -16,11 +16,15 @@ config:
   days_back:
     type: number
     default: 3
-    description: "How many days back to sync"
+    description: "How many days back to sync (used as fallback when incremental has no prior data)"
   sync_inbox:
     type: boolean
     default: false
     description: "Also sync inbox emails addressed directly to owner"
+  incremental:
+    type: boolean
+    default: false
+    description: "Query brain for latest email and only fetch since then (days_back used as fallback for first run)"
 tags: [email, gmail, mail, sent, sync, learning]
 permissions:
   - mail:read
@@ -36,11 +40,12 @@ Optionally syncs inbox emails that are addressed directly to the owner.
 
 ## How It Works
 
-1. Run JXA script via `osascript` to read sent messages from all accounts
-2. Sent mail always includes body content (first 2000 chars) for learning
-3. Inbox is opt-in (`--sync-inbox`), filtered to emails where owner is on To/Cc
-4. Dedup by `source_id` = `mail:{messageId}` — skip unchanged, update modified
-5. Store as memories with `source: 'email'`, `source_channel: <account name>`
+1. **Incremental mode** (`incremental: true`): queries brain for the latest email timestamp, computes `days_back` dynamically (+1 day overlap). Falls back to configured `days_back` on first run (no prior data).
+2. Run JXA script via `osascript` to read sent messages from all accounts
+3. Sent mail always includes body content (first 2000 chars) for learning
+4. Inbox is opt-in (`--sync-inbox`), filtered to emails where owner is on To/Cc
+5. Dedup by `source_id` = `mail:{messageId}` — skip unchanged, update modified
+6. Store as memories with `source: 'email'`, `source_channel: <account name>`
 
 ## Memory Format
 

package/template/wall-e/skills/_bundled/email-sync/mail-reader.jxa

@@ -17,6 +17,24 @@ function run(argv) {
   var cutoff = new Date();
   cutoff.setDate(cutoff.getDate() - daysBack);
 
+  // For large date ranges, chunk into 90-day windows to avoid AppleEvent timeout (-1712).
+  // The .whose() query is a single Apple Event and Mail can't respond in time for huge ranges.
+  var CHUNK_DAYS = 90;
+  var chunks = [];
+  if (daysBack > CHUNK_DAYS) {
+    var now = new Date();
+    var chunkEnd = new Date(now);
+    while (chunkEnd > cutoff) {
+      var chunkStart = new Date(chunkEnd);
+      chunkStart.setDate(chunkStart.getDate() - CHUNK_DAYS);
+      if (chunkStart < cutoff) chunkStart = cutoff;
+      chunks.push({ start: chunkStart, end: chunkEnd });
+      chunkEnd = new Date(chunkStart);
+    }
+  } else {
+    chunks.push({ start: cutoff, end: new Date() });
+  }
+
   var results = { accounts: [], inbox: [], sent: [] };
   var accounts = mail.accounts();
 
@@ -33,27 +51,33 @@ function run(argv) {
     if (readInbox) {
       try {
         var inbox = acct.mailboxes.byName('INBOX');
-        var inboxMsgs = inbox.messages.whose({ dateReceived: { _greaterThan: cutoff } })();
-        for (var m = 0; m < inboxMsgs.length; m++) {
+        for (var ci = 0; ci < chunks.length; ci++) {
           try {
-            var msg = inboxMsgs[m];
-            var toRecips = [];
-            try { toRecips = msg.toRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
-            var ccRecips = [];
-            try { ccRecips = msg.ccRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
+            var inboxMsgs = inbox.messages.whose({
+              _and: [{ dateReceived: { _greaterThan: chunks[ci].start } }, { dateReceived: { _lessThan: chunks[ci].end } }]
+            })();
+            for (var m = 0; m < inboxMsgs.length; m++) {
+              try {
+                var msg = inboxMsgs[m];
+                var toRecips = [];
+                try { toRecips = msg.toRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
+                var ccRecips = [];
+                try { ccRecips = msg.ccRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
 
-            results.inbox.push({
-              messageId: msg.messageId(),
-              subject: msg.subject() || '(no subject)',
-              sender: msg.sender(),
-              to: toRecips,
-              cc: ccRecips,
-              date: msg.dateReceived().toISOString(),
-              account: acctName,
-              mailbox: 'INBOX',
-              readStatus: msg.readStatus()
-            });
-          } catch(e) { /* skip individual message errors */ }
+                results.inbox.push({
+                  messageId: msg.messageId(),
+                  subject: msg.subject() || '(no subject)',
+                  sender: msg.sender(),
+                  to: toRecips,
+                  cc: ccRecips,
+                  date: msg.dateReceived().toISOString(),
+                  account: acctName,
+                  mailbox: 'INBOX',
+                  readStatus: msg.readStatus()
+                });
+              } catch(e) { /* skip individual message errors */ }
+            }
+          } catch(e) { /* chunk query failed, continue */ }
         }
       } catch(e) { /* account may not have INBOX */ }
     }
@@ -63,37 +87,43 @@ function run(argv) {
     for (var s = 0; s < sentNames.length; s++) {
       try {
         var sentBox = acct.mailboxes.byName(sentNames[s]);
-        var sentMsgs = sentBox.messages.whose({ dateSent: { _greaterThan: cutoff } })();
-        for (var m = 0; m < sentMsgs.length; m++) {
+        for (var ci = 0; ci < chunks.length; ci++) {
           try {
-            var msg = sentMsgs[m];
-            var toRecips = [];
-            try { toRecips = msg.toRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
-            var ccRecips = [];
-            try { ccRecips = msg.ccRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
+            var sentMsgs = sentBox.messages.whose({
+              _and: [{ dateSent: { _greaterThan: chunks[ci].start } }, { dateSent: { _lessThan: chunks[ci].end } }]
+            })();
+            for (var m = 0; m < sentMsgs.length; m++) {
+              try {
+                var msg = sentMsgs[m];
+                var toRecips = [];
+                try { toRecips = msg.toRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
+                var ccRecips = [];
+                try { ccRecips = msg.ccRecipients().map(function(r) { return { name: r.name(), email: r.address() }; }); } catch(e) {}
 
-            var entry = {
-              messageId: msg.messageId(),
-              subject: msg.subject() || '(no subject)',
-              sender: msg.sender(),
-              to: toRecips,
-              cc: ccRecips,
-              date: msg.dateSent().toISOString(),
-              account: acctName,
-              mailbox: sentNames[s],
-              readStatus: true
-            };
+                var entry = {
+                  messageId: msg.messageId(),
+                  subject: msg.subject() || '(no subject)',
+                  sender: msg.sender(),
+                  to: toRecips,
+                  cc: ccRecips,
+                  date: msg.dateSent().toISOString(),
+                  account: acctName,
+                  mailbox: sentNames[s],
+                  readStatus: true
+                };
 
-            // Always fetch content for sent messages
-            try {
-              var body = msg.content();
-              if (body && body.length > 0) {
-                entry.content = body.substring(0, 2000);
-              }
-            } catch(e) { /* content extraction failed */ }
+                // Always fetch content for sent messages
+                try {
+                  var body = msg.content();
+                  if (body && body.length > 0) {
+                    entry.content = body.substring(0, 2000);
+                  }
+                } catch(e) { /* content extraction failed */ }
 
-            results.sent.push(entry);
-          } catch(e) { /* skip individual message errors */ }
+                results.sent.push(entry);
+              } catch(e) { /* skip individual message errors */ }
+            }
+          } catch(e) { /* chunk query failed, continue */ }
         }
         break; // found the sent mailbox for this account
       } catch(e) { /* try next sent mailbox name */ }