create-walle 0.9.3 → 0.9.4

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

@@ -25,9 +25,11 @@ const JXA_SCRIPT = path.join(SKILL_DIR, 'mail-reader.jxa');
 const args = process.argv.slice(2);
 let daysBack = 3;
 let syncInbox = false;
+let incremental = 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;
+  if (args[i] === '--incremental') incremental = true;
 }
 
 // Task-level config overrides (passed via WALL_E_SKILL_CONFIG env var)
@@ -36,8 +38,34 @@ try {
     ? 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;
+  if (envConfig.incremental != null) incremental = !!envConfig.incremental;
 } catch { /* ignore parse errors */ }
 
+// Incremental mode: compute days_back from the latest email already in the brain
+if (incremental) {
+  try {
+    const brainPath = path.resolve(SKILL_DIR, '..', '..', '..', 'brain.js');
+    const brain = require(brainPath);
+    brain.initDb();
+    const row = brain.getDb().prepare(
+      "SELECT max(timestamp) as ts FROM memories WHERE source = 'email'"
+    ).get();
+    brain.closeDb();
+    if (row?.ts) {
+      const latestDate = new Date(row.ts);
+      const now = new Date();
+      // Go back 1 extra day for overlap/safety margin
+      const computedDays = Math.ceil((now - latestDate) / (24 * 60 * 60 * 1000)) + 1;
+      console.error(`[email-sync] Incremental: latest email is ${row.ts}, fetching ${computedDays}d back`);
+      daysBack = computedDays;
+    } else {
+      console.error(`[email-sync] Incremental: no existing emails, falling back to ${daysBack}d`);
+    }
+  } catch (err) {
+    console.error(`[email-sync] Incremental check failed: ${err.message}, using days_back=${daysBack}`);
+  }
+}
+
 // ── Step 1: Read emails via JXA ──────────────────────────────────────
 
 function readEmails() {
@@ -191,8 +219,20 @@ async function main() {
       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');
+      const isTimeout = errMsg.includes('-1712') || errMsg.includes('timed out');
+      const isPermDenied = !isTimeout && (errMsg.includes('not allowed') || errMsg.includes('assistive access')
+        || errMsg.includes('-1743') || errMsg.includes('-1744'));
+
+      if (isTimeout) {
+        console.error(`[email-sync] Mail app timed out (attempt ${attempt + 1}/${MAX_RETRIES + 1}). Mail may be busy, not running, or the query is too large.`);
+        if (attempt < MAX_RETRIES) {
+          console.error('[email-sync] Retrying in 10s — make sure Mail.app is open and responsive...');
+          await sleep(10_000);
+          continue;
+        }
+        console.error('[email-sync] Still timing out. Try: 1) Open Mail.app and wait for it to finish syncing, 2) Run with a smaller days_back value.');
+        process.exit(1);
+      }
 
       if (isPermDenied && attempt < MAX_RETRIES) {
         console.error(`[email-sync] Mail access denied (attempt ${attempt + 1}/${MAX_RETRIES + 1}).`);

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

@@ -0,0 +1,57 @@
+---
+name: glean-team-sync
+description: >
+  Sync team structure from Glean people directory into WALL-E's brain.
+  Reads the owner's profile, their manager, peers, and direct reports,
+  then recursively maps each person's contact info, location, and role.
+version: 1.0.0
+author: wall-e
+execution: script
+entry: run.js
+trigger:
+  type: manual
+config:
+  owner_name:
+    type: string
+    default: ""
+    description: "Name of the person whose team to sync (defaults to WALLE_OWNER_NAME)"
+  depth:
+    type: number
+    default: 2
+    description: "How many levels of org tree to traverse (1=direct team, 2=skip-level reports)"
+tags: [glean, team, people, directory, org, contacts]
+permissions:
+  - glean:read
+  - brain:write
+---
+# Glean Team Sync
+
+## What This Skill Does
+
+Syncs team structure from Glean's people directory into WALL-E's brain.
+Starting from the owner, it discovers the org tree (manager, peers, direct
+reports) and stores each person's profile as a memory.
+
+## How It Works
+
+1. Search Glean for the owner by name via `employee_search` MCP tool
+2. Parse the profile: name, title, department, location, email, manager, reports
+3. Recursively search each team member up to configured depth
+4. Dedup by `source_id` = `glean:person:{email}` — skip unchanged, update modified
+5. Store as memories with `source: 'glean'`, `memory_type: 'team_member'`
+
+## Memory Format
+
+Each person is stored as a memory:
+- **source**: `glean`
+- **source_id**: `glean:person:{email}`
+- **source_channel**: department or team name
+- **memory_type**: `team_member`
+- **subject**: person's full name
+- **content**: human-readable profile with title, location, contact, org relationship
+- **metadata**: JSON with structured fields (email, title, department, location, manager, reports, relationship)
+- **importance**: 0.5 (team context)
+
+## Output
+
+Returns: `{ synced, updated, skipped, errors, people: [...names] }`

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

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * glean-team-sync — reads team structure from Glean people directory
+ * and stores each person's profile in WALL-E's brain.
+ *
+ * Uses the Glean MCP `employee_search` tool to find people, then
+ * recursively traverses the org tree.
+ *
+ * Usage: node run.js [--owner "Name"] [--depth N]
+ */
+const path = require('path');
+
+const SKILL_DIR = __dirname;
+const PAUSE_MS = 600;
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let ownerName = process.env.WALLE_OWNER_NAME || '';
+let maxDepth = 2;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--owner' && args[i + 1]) ownerName = args[i + 1];
+  if (args[i] === '--depth' && args[i + 1]) maxDepth = parseInt(args[i + 1], 10);
+}
+
+// Task-level config overrides
+try {
+  const envConfig = process.env.WALL_E_SKILL_CONFIG
+    ? JSON.parse(process.env.WALL_E_SKILL_CONFIG) : {};
+  if (envConfig.owner_name) ownerName = envConfig.owner_name;
+  if (envConfig.depth != null) maxDepth = envConfig.depth;
+} catch { /* ignore */ }
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// ── Glean MCP ───────────────────────────────────────────────────────
+
+let mcpClient;
+let gleanServerName;
+
+async function initGlean() {
+  mcpClient = require(path.resolve(SKILL_DIR, '..', '..', '..', 'skills', 'mcp-client'));
+  const configs = mcpClient.loadMcpConfigs();
+  gleanServerName = Object.keys(configs).find(k => k.includes('glean'));
+  if (!gleanServerName) throw new Error('Glean MCP not configured');
+}
+
+async function searchPerson(query) {
+  const result = await mcpClient.callMcpTool(gleanServerName, 'employee_search', { query });
+  // Extract raw text from MCP response
+  let raw;
+  if (result && result.content) {
+    raw = result.content.map(c => c.text || JSON.stringify(c)).join('\n');
+  } else {
+    raw = JSON.stringify(result);
+  }
+
+  // Parse JSON response — Glean returns { entities: [{ person: {...} }] }
+  try {
+    const data = JSON.parse(raw);
+    if (data.entities && data.entities.length > 0) {
+      return data.entities.map(e => e.person).filter(Boolean);
+    }
+  } catch { /* not JSON, try text parsing below */ }
+
+  // Fallback: already an array of person objects
+  if (Array.isArray(raw)) return raw;
+
+  return [];
+}
+
+// ── Build readable profile ──────────────────────────────────────────
+
+function buildProfile(person, relationship) {
+  const parts = [person.name];
+  if (person.title) parts.push(`Title: ${person.title}`);
+  if (person.department) parts.push(`Department: ${person.department}`);
+  if (person.type) parts.push(`Type: ${person.type}`);
+  if (person.location) parts.push(`Location: ${person.location}`);
+  if (person.email) parts.push(`Email: ${person.email}`);
+  if (person.startDate) parts.push(`Start Date: ${person.startDate}`);
+  if (person.pronoun && person.pronoun !== 'None') parts.push(`Pronouns: ${person.pronoun}`);
+  if (person.manager) {
+    const mgr = typeof person.manager === 'object' ? person.manager.name : person.manager;
+    parts.push(`Manager: ${mgr}`);
+  }
+  if (person.directReportsCount) parts.push(`Direct Reports: ${person.directReportsCount}`);
+  if (person.totalReportsCount) parts.push(`Total Reports: ${person.totalReportsCount}`);
+  if (person.directReports && person.directReports.length > 0) {
+    const names = person.directReports.map(r => typeof r === 'object' ? r.name : r);
+    parts.push(`Direct Report Names: ${names.join(', ')}`);
+  }
+  if (person.teams && person.teams.length > 0) {
+    parts.push(`Teams: ${person.teams.join(', ')}`);
+  }
+  if (person.datasourceToProfileLink) {
+    const links = person.datasourceToProfileLink;
+    if (links.SLACK) parts.push(`Slack: ${links.SLACK}`);
+  }
+  if (relationship) parts.push(`Relationship: ${relationship}`);
+  return parts.join('\n');
+}
+
+// ── Brain storage ───────────────────────────────────────────────────
+
+function storePerson(brain, person, relationship) {
+  const email = person.email || `unknown-${person.name.replace(/\s+/g, '-').toLowerCase()}`;
+  const sourceId = `glean:person:${email}`;
+  const content = buildProfile(person, relationship);
+
+  // Strip circular/large fields from metadata
+  const meta = { ...person, relationship };
+  // Flatten manager to just name+email
+  if (meta.manager && typeof meta.manager === 'object') {
+    meta.managerName = meta.manager.name;
+    meta.managerEmail = meta.manager.email;
+    delete meta.manager;
+  }
+  // Flatten direct reports to names
+  if (meta.directReports) {
+    meta.directReportNames = meta.directReports.map(r => typeof r === 'object' ? r.name : r);
+    delete meta.directReports;
+  }
+  const metadata = JSON.stringify(meta);
+
+  // Check if exists and needs update
+  const existing = brain.getDb().prepare(
+    'SELECT id, content FROM memories WHERE source = ? AND source_id = ?'
+  ).get('glean', sourceId);
+
+  if (existing) {
+    if (existing.content !== content) {
+      brain.getDb().prepare(
+        'UPDATE memories SET content = ?, metadata = ?, timestamp = ? WHERE id = ?'
+      ).run(content, metadata, new Date().toISOString(), existing.id);
+      return 'updated';
+    }
+    return 'skipped';
+  }
+
+  const result = brain.insertMemory({
+    source: 'glean',
+    source_id: sourceId,
+    source_channel: person.department || 'unknown',
+    memory_type: 'team_member',
+    subject: person.name,
+    content,
+    metadata,
+    importance: 0.5,
+    timestamp: new Date().toISOString(),
+  });
+  return result ? 'inserted' : 'skipped';
+}
+
+// ── Recursive crawl ─────────────────────────────────────────────────
+
+async function main() {
+  await initGlean();
+
+  const brainPath = path.resolve(SKILL_DIR, '..', '..', '..', 'brain.js');
+  const brain = require(brainPath);
+  brain.initDb();
+
+  // Resolve owner name from brain if not set via env/args
+  if (!ownerName) {
+    ownerName = brain.getOwnerName() || '';
+  }
+  if (!ownerName) {
+    console.error('[glean-team-sync] No owner name configured (set WALLE_OWNER_NAME or --owner)');
+    process.exit(1);
+  }
+
+  const stats = { synced: 0, updated: 0, skipped: 0, errors: 0, people: [] };
+  const visited = new Set(); // by email
+
+  async function crawlPerson(name, relationship, depth) {
+    console.error(`[glean-team-sync] Searching: ${name} (${relationship}, depth=${depth})`);
+
+    try {
+      const people = await searchPerson(name);
+      await sleep(PAUSE_MS);
+
+      if (people.length === 0) {
+        console.error(`[glean-team-sync] No results for: ${name}`);
+        stats.errors++;
+        return;
+      }
+
+      // Find best match
+      const normalized = name.trim().toLowerCase();
+      const person = people.find(p => p.name && p.name.toLowerCase() === normalized)
+        || people.find(p => p.name && p.name.toLowerCase().includes(normalized))
+        || people[0];
+
+      if (!person || !person.name) {
+        console.error(`[glean-team-sync] No valid profile for: ${name}`);
+        stats.errors++;
+        return;
+      }
+
+      const email = (person.email || '').toLowerCase();
+      if (visited.has(email || person.name.toLowerCase())) return;
+      visited.add(email || person.name.toLowerCase());
+
+      // Store
+      const result = storePerson(brain, person, relationship);
+      if (result === 'inserted') stats.synced++;
+      else if (result === 'updated') stats.updated++;
+      else stats.skipped++;
+      stats.people.push(person.name);
+
+      console.error(`[glean-team-sync] ${result}: ${person.name} — ${person.title || 'no title'}`);
+
+      // Recurse into org tree
+      if (depth < maxDepth) {
+        // Manager
+        if (person.manager) {
+          const mgrName = typeof person.manager === 'object' ? person.manager.name : person.manager;
+          if (mgrName) {
+            await crawlPerson(mgrName, `manager of ${person.name}`, depth + 1);
+          }
+        }
+
+        // Direct reports
+        if (person.directReports && person.directReports.length > 0) {
+          for (const report of person.directReports) {
+            const reportName = typeof report === 'object' ? report.name : report;
+            if (reportName) {
+              await crawlPerson(reportName, `reports to ${person.name}`, depth + 1);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`[glean-team-sync] Error searching ${name}: ${err.message}`);
+      stats.errors++;
+    }
+  }
+
+  await crawlPerson(ownerName, 'self (owner)', 0);
+
+  brain.closeDb();
+  mcpClient.disconnectAll();
+
+  console.log(JSON.stringify(stats));
+  console.error(`[glean-team-sync] Done: ${stats.synced} new, ${stats.updated} updated, ${stats.skipped} unchanged, ${stats.errors} errors (${stats.people.length} people)`);
+}
+
+main().catch(err => {
+  console.error(`[glean-team-sync] Fatal: ${err.message}`);
+  process.exit(1);
+});

package/template/wall-e/skills/_bundled/slack-mentions/SKILL.md

@@ -22,7 +22,7 @@ permissions:
 
 ## What This Skill Does
 
-Polls Slack for messages mentioning @walle or @wall-e from the owner (Juncao).
+Polls Slack for messages mentioning @walle or @wall-e from the owner.
 Classifies each mention as either a task assignment or a question, then:
 
 - **Task**: Creates a brain task with `source: 'slack'` and `source_ref` linking