create-walle 0.1.0

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

@@ -0,0 +1,65 @@
+---
+name: email-sync
+description: >
+  Sync sent emails from macOS Mail into WALL-E's brain so it can learn
+  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
+author: juncao
+execution: script
+entry: run.js
+args: ["--days-back", "3"]
+trigger:
+  type: manual
+config:
+  days_back:
+    type: number
+    default: 3
+    description: "How many days back to sync"
+  sync_inbox:
+    type: boolean
+    default: false
+    description: "Also sync inbox emails addressed directly to owner"
+tags: [email, gmail, mail, sent, sync, learning]
+permissions:
+  - mail:read
+  - brain:write
+---
+# Email Sync
+
+## What This Skill Does
+
+Syncs sent emails from macOS Mail into WALL-E's brain so it can learn the
+owner's writing style, communication patterns, and topics of interest.
+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>`
+
+## Memory Format
+
+Each email is stored as a memory:
+- **source**: `email`
+- **source_channel**: account name (e.g., `owner@example.com`)
+- **memory_type**: `email_sent` or `email_received`
+- **subject**: email subject
+- **content**: human-readable summary with recipients + body for sent mail
+- **metadata**: JSON with messageId, sender, recipients, dates
+- **timestamp**: date sent/received (ISO8601)
+- **importance**: 0.6 for sent (learning), 0.4 for received
+
+## Prerequisites
+
+macOS Mail.app must be configured with your email accounts and running.
+The terminal must have Automation access for Mail.app:
+**System Settings > Privacy & Security > Automation > [terminal] > Mail**
+
+## Output
+
+Returns: `{ inserted, updated, skipped, filtered, errors, total }`

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

@@ -0,0 +1,104 @@
+// mail-reader.jxa — Read emails from macOS Mail via JXA
+// Usage: osascript -l JavaScript mail-reader.jxa [--days-back N] [--inbox]
+//
+// Always reads Sent with content. Inbox is opt-in via --inbox flag.
+// Outputs JSON: { accounts: [...], inbox: [...], sent: [...] }
+
+function run(argv) {
+  var daysBack = 3;
+  var readInbox = false;
+
+  for (var i = 0; i < argv.length; i++) {
+    if (argv[i] === '--days-back' && argv[i + 1]) daysBack = parseInt(argv[i + 1], 10);
+    if (argv[i] === '--inbox') readInbox = true;
+  }
+
+  var mail = Application('Mail');
+  var cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+
+  var results = { accounts: [], inbox: [], sent: [] };
+  var accounts = mail.accounts();
+
+  for (var a = 0; a < accounts.length; a++) {
+    var acct = accounts[a];
+    var acctName = acct.name();
+
+    // Collect account email addresses for inbox filtering
+    var acctEmails = [];
+    try { acctEmails = acct.emailAddresses(); } catch(e) {}
+    results.accounts.push({ name: acctName, emails: acctEmails });
+
+    // Read inbox (opt-in only)
+    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++) {
+          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 */ }
+        }
+      } catch(e) { /* account may not have INBOX */ }
+    }
+
+    // Always read sent — try common mailbox names
+    var sentNames = ['[Gmail]/Sent Mail', 'Sent Messages', 'Sent', 'Sent Items'];
+    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++) {
+          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
+            };
+
+            // 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 */ }
+        }
+        break; // found the sent mailbox for this account
+      } catch(e) { /* try next sent mailbox name */ }
+    }
+  }
+
+  return JSON.stringify(results);
+}

package/template/wall-e/skills/_bundled/email-sync/run.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * email-sync skill — reads sent emails from macOS Mail (which syncs with
+ * Gmail/Google Workspace) via JXA, then stores them as memories in
+ * WALL-E's brain so it can learn the owner's communication style.
+ *
+ * By default, only SENT emails are synced (with body content).
+ * Inbox sync is opt-in via --sync-inbox, and when enabled only emails
+ * where the owner is on the To/Cc line are included.
+ *
+ * Usage:  node run.js [--days-back N] [--sync-inbox]
+ *
+ * Requires: Mail.app running with accounts configured. Terminal needs
+ *   Automation access for Mail in System Settings > Privacy & Security.
+ */
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const SKILL_DIR = __dirname;
+const JXA_SCRIPT = path.join(SKILL_DIR, 'mail-reader.jxa');
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let daysBack = 3;
+let syncInbox = false;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--days-back' && args[i + 1]) daysBack = parseInt(args[i + 1], 10);
+  if (args[i] === '--sync-inbox') syncInbox = true;
+}
+
+// Task-level config overrides (passed via WALL_E_SKILL_CONFIG env var)
+try {
+  const envConfig = process.env.WALL_E_SKILL_CONFIG
+    ? JSON.parse(process.env.WALL_E_SKILL_CONFIG) : {};
+  if (envConfig.days_back != null) daysBack = envConfig.days_back;
+  if (envConfig.sync_inbox != null) syncInbox = !!envConfig.sync_inbox;
+} catch { /* ignore parse errors */ }
+
+// ── Step 1: Read emails via JXA ──────────────────────────────────────
+
+function readEmails() {
+  const jxaArgs = ['-l', 'JavaScript', JXA_SCRIPT, '--days-back', String(daysBack)];
+  if (syncInbox) jxaArgs.push('--inbox');
+
+  const result = execFileSync('osascript', jxaArgs, {
+    timeout: 300_000, // 5 min for content fetching
+    maxBuffer: 50 * 1024 * 1024,
+  });
+
+  const data = JSON.parse(result.toString('utf8'));
+  console.error(`[email-sync] Read ${data.inbox.length} inbox + ${data.sent.length} sent (${daysBack}d back)`);
+  return data;
+}
+
+// ── Step 2: Open Automation privacy settings on permission error ─────
+
+function openAutomationSettings() {
+  try {
+    execFileSync('open', ['x-apple.systempreferences:com.apple.preference.security?Privacy_Automation'], {
+      timeout: 5_000,
+    });
+    console.error('[email-sync] Opened System Settings > Privacy & Security > Automation');
+  } catch {
+    console.error('[email-sync] Please open: System Settings > Privacy & Security > Automation');
+    console.error('[email-sync] Enable Mail access for your terminal app.');
+  }
+}
+
+// ── Step 3: Store in brain ───────────────────────────────────────────
+
+function storeToBrain(data) {
+  const brainPath = path.resolve(SKILL_DIR, '..', '..', '..', 'brain.js');
+  if (!fs.existsSync(brainPath)) {
+    console.error(`[email-sync] brain.js not found at ${brainPath}`);
+    process.exit(1);
+  }
+  const brain = require(brainPath);
+  brain.initDb();
+
+  let inserted = 0;
+  let skipped = 0;
+  let updated = 0;
+  let filtered = 0;
+  let errors = 0;
+
+  // Collect owner's email addresses from all accounts
+  const ownerEmails = new Set();
+  for (const acct of (data.accounts || [])) {
+    for (const email of (acct.emails || [])) {
+      ownerEmails.add(email.toLowerCase());
+    }
+  }
+  console.error(`[email-sync] Owner emails: ${[...ownerEmails].join(', ')}`);
+
+  // Filter inbox: only emails where owner is on To or Cc line
+  const inboxFiltered = data.inbox.filter(msg => {
+    const allRecips = [...(msg.to || []), ...(msg.cc || [])];
+    return allRecips.some(r => r.email && ownerEmails.has(r.email.toLowerCase()));
+  });
+  filtered = data.inbox.length - inboxFiltered.length;
+  if (data.inbox.length > 0) {
+    console.error(`[email-sync] Inbox: ${inboxFiltered.length} addressed to owner, ${filtered} filtered out (mailing lists, BCC, etc.)`);
+  }
+
+  const allMessages = [
+    ...inboxFiltered.map(m => ({ ...m, type: 'email_received' })),
+    ...data.sent.map(m => ({ ...m, type: 'email_sent' })),
+  ];
+
+  for (const msg of allMessages) {
+    try {
+      // Build readable content
+      const parts = [msg.subject];
+      parts.push(`From: ${msg.sender}`);
+      if (msg.to && msg.to.length > 0) {
+        const names = msg.to.map(r => r.name || r.email).filter(Boolean);
+        if (names.length > 0) parts.push(`To: ${names.join(', ')}`);
+      }
+      if (msg.cc && msg.cc.length > 0) {
+        const names = msg.cc.map(r => r.name || r.email).filter(Boolean);
+        if (names.length > 0) parts.push(`Cc: ${names.join(', ')}`);
+      }
+      if (msg.content) {
+        parts.push(`\n${msg.content}`);
+      }
+      const content = parts.join('\n');
+
+      const sourceId = `mail:${msg.messageId}`;
+
+      // Check if exists
+      const existing = brain.getDb().prepare(
+        'SELECT id, content FROM memories WHERE source = ? AND source_id = ?'
+      ).get('email', sourceId);
+
+      if (existing) {
+        if (existing.content !== content) {
+          brain.getDb().prepare(
+            'UPDATE memories SET content = ?, metadata = ?, timestamp = ? WHERE id = ?'
+          ).run(content, JSON.stringify(msg), msg.date, existing.id);
+          updated++;
+        } else {
+          skipped++;
+        }
+        continue;
+      }
+
+      // Insert new
+      const mem = {
+        source: 'email',
+        source_id: sourceId,
+        source_channel: msg.account,
+        memory_type: msg.type,
+        subject: msg.subject,
+        content,
+        metadata: JSON.stringify(msg),
+        importance: msg.type === 'email_sent' ? 0.6 : 0.4,
+        timestamp: msg.date,
+      };
+
+      const result = brain.insertMemory(mem);
+      if (result) inserted++;
+      else skipped++;
+    } catch (err) {
+      errors++;
+      console.error(`[email-sync] Error processing message: ${err.message}`);
+    }
+  }
+
+  brain.closeDb();
+  return { inserted, updated, skipped, filtered, errors, total: allMessages.length };
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function main() {
+  const MAX_RETRIES = 2;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const data = readEmails();
+      const stats = storeToBrain(data);
+      console.log(JSON.stringify(stats));
+      console.error(`[email-sync] Done: ${stats.inserted} new, ${stats.updated} updated, ${stats.skipped} unchanged, ${stats.filtered} filtered, ${stats.errors} errors`);
+      return;
+    } catch (err) {
+      const errMsg = (err.stderr || err.message || '').toString();
+      const isPermDenied = errMsg.includes('not allowed') || errMsg.includes('assistive access')
+        || errMsg.includes('-1743') || errMsg.includes('-1744') || errMsg.includes('AppleEvent');
+
+      if (isPermDenied && attempt < MAX_RETRIES) {
+        console.error(`[email-sync] Mail access denied (attempt ${attempt + 1}/${MAX_RETRIES + 1}).`);
+        console.error('[email-sync] Opening System Settings — please grant Automation access for Mail to your terminal app...');
+        openAutomationSettings();
+        await sleep(15_000);
+        continue;
+      }
+      if (isPermDenied) {
+        console.error('[email-sync] Mail access still denied after retries.');
+        console.error('[email-sync] Grant Automation > Mail access to your terminal in System Settings > Privacy & Security.');
+        process.exit(1);
+      }
+      console.error(`[email-sync] Error: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+main();

package/template/wall-e/skills/_bundled/google-calendar/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: google-calendar
+description: >
+  Sync Google Calendar events into WALL-E's brain via macOS Calendar.
+  Reads events using EventKit (fast native API), stores as memories
+  with attendees, location, notes. Supports incremental sync with
+  update detection. Use for schedule awareness, meeting prep, calendar context.
+version: 1.1.0
+author: juncao
+execution: script
+entry: run.js
+args: ["--days-back", "1", "--days-ahead", "14"]
+trigger:
+  type: interval
+  schedule: "every 30m"
+config:
+  days_back:
+    type: number
+    default: 1
+    description: "How many days back to sync"
+  days_ahead:
+    type: number
+    default: 14
+    description: "How many days ahead to sync"
+tags: [calendar, google, schedule, meetings, events, sync]
+permissions:
+  - calendar:read
+  - brain:write
+---
+# Google Calendar Sync
+
+## What This Skill Does
+
+Syncs calendar events from macOS Calendar (which mirrors Google Calendar) into
+WALL-E's brain as searchable memories. Uses Apple's EventKit framework via a
+compiled Swift binary for fast, reliable access.
+
+## How It Works
+
+1. Compile `cal-reader.swift` to a native binary (cached, only recompiles on change)
+2. Run binary to read events from ALL calendars (Google, Outlook, iCloud, etc.)
+3. For each event, build a content string with title, attendees, location, notes
+4. Dedup by `source_id` = `cal:{uid}:{start}` -- skip unchanged, update modified
+5. Store as memories with `source: 'calendar'`, `source_channel: <calendar name>`
+
+## Memory Format
+
+Each event is stored as a memory:
+- **source**: `calendar`
+- **source_channel**: calendar name (e.g., `owner@example.com`, `Family`)
+- **memory_type**: `calendar_event` or `calendar_allday`
+- **subject**: event title
+- **content**: human-readable summary with attendees, location, notes
+- **metadata**: full JSON event data (uid, start, end, attendees with RSVP status)
+- **timestamp**: event start time (ISO8601)
+
+## Prerequisites
+
+The terminal running WALL-E must have Calendar access granted:
+**System Settings > Privacy & Security > Calendars > [your terminal app]**
+
+The Swift compiler (`swiftc`) must be available (ships with Xcode or Command Line Tools).
+
+## Output
+
+Returns: `{ inserted, updated, skipped, total }`
+
+## Common Queries After Sync
+
+Once synced, calendar events can be found with brain searches like:
+- `source:calendar` -- all calendar events
+- `source_channel:owner@example.com` -- work calendar only
+- Search by attendee name, meeting title, or location

package/template/wall-e/skills/_bundled/google-calendar/cal-reader.swift

@@ -0,0 +1,81 @@
+import EventKit
+import Foundation
+
+// Accept CLI args: --days-back N --days-ahead N
+var daysBack = 1
+var daysAhead = 14
+var args = CommandLine.arguments
+for i in 0..<args.count {
+    if args[i] == "--days-back", i + 1 < args.count, let n = Int(args[i + 1]) { daysBack = n }
+    if args[i] == "--days-ahead", i + 1 < args.count, let n = Int(args[i + 1]) { daysAhead = n }
+}
+
+let store = EKEventStore()
+let status = EKEventStore.authorizationStatus(for: .event)
+
+switch status {
+case .fullAccess, .authorized:
+    break
+case .notDetermined:
+    let sem = DispatchSemaphore(value: 0)
+    store.requestFullAccessToEvents(completion: { granted, error in
+        if !granted {
+            fputs("{\"error\":\"access_denied\",\"message\":\"Calendar access was denied. Grant access in System Settings > Privacy & Security > Calendars.\"}\n", stderr)
+            exit(1)
+        }
+        sem.signal()
+    })
+    sem.wait()
+default:
+    fputs("{\"error\":\"access_denied\",\"message\":\"Calendar access denied (status=\(status.rawValue)). Grant access to your terminal in System Settings > Privacy & Security > Calendars.\"}\n", stderr)
+    exit(1)
+}
+
+let cal = Calendar.current
+let start = cal.date(byAdding: .day, value: -daysBack, to: Date())!
+let end = cal.date(byAdding: .day, value: daysAhead, to: Date())!
+let pred = store.predicateForEvents(withStart: start, end: end, calendars: nil)
+let events = store.events(matching: pred)
+
+let fmt = ISO8601DateFormatter()
+var arr: [[String: Any]] = []
+
+for e in events {
+    var d: [String: Any] = [
+        "title": e.title ?? "(no title)",
+        "start": fmt.string(from: e.startDate),
+        "end": fmt.string(from: e.endDate),
+        "allDay": e.isAllDay,
+        "calendar": e.calendar.title,
+        "uid": e.calendarItemIdentifier,
+        "location": e.location ?? ""
+    ]
+    if let notes = e.notes, !notes.isEmpty {
+        d["notes"] = String(notes.prefix(500))
+    }
+    if let attendees = e.attendees, !attendees.isEmpty {
+        d["attendees"] = attendees.compactMap { att -> [String: Any]? in
+            let name = att.name ?? ""
+            let email = att.url.absoluteString.replacingOccurrences(of: "mailto:", with: "")
+            let status: String
+            switch att.participantStatus {
+            case .accepted: status = "accepted"
+            case .declined: status = "declined"
+            case .tentative: status = "tentative"
+            case .pending: status = "pending"
+            default: status = "unknown"
+            }
+            let isOrganizer = att.isCurrentUser ? false : (att.participantRole == .chair)
+            return ["name": name, "email": email, "status": status, "organizer": isOrganizer]
+        }
+    }
+    if let org = e.organizer {
+        d["organizer"] = org.name ?? org.url.absoluteString.replacingOccurrences(of: "mailto:", with: "")
+    }
+    arr.append(d)
+}
+
+if let data = try? JSONSerialization.data(withJSONObject: arr, options: []),
+   let str = String(data: data, encoding: .utf8) {
+    print(str)
+}