create-walle 0.1.0

package/bin/create-walle.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+// Template directory bundled inside this npm package
+const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
+
+function detectName() {
+  try { return execFileSync('git', ['config', 'user.name'], { encoding: 'utf8' }).trim(); } catch {}
+  try { return execFileSync('id', ['-F'], { encoding: 'utf8' }).trim(); } catch {} // macOS full name
+  return process.env.USER || 'Owner';
+}
+
+function detectTimezone() {
+  try { return Intl.DateTimeFormat().resolvedOptions().timeZone; } catch {}
+  return 'UTC';
+}
+
+function copyRecursive(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      if (entry === 'node_modules' || entry === '.git') continue;
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+async function main() {
+  const targetDir = process.argv[2] || 'walle';
+
+  console.log(`\n${BOLD}${CYAN}  Wall-E${RESET} — Your personal digital twin\n`);
+
+  if (fs.existsSync(targetDir)) {
+    console.log(`  Directory "${targetDir}" already exists. Choose a different name:\n    npx create-walle my-agent\n`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(TEMPLATE_DIR)) {
+    console.error('  Template directory not found. Try: npm cache clean --force && npx create-walle@latest');
+    process.exit(1);
+  }
+
+  // Auto-detect owner info (strip chars that would break .env)
+  const ownerName = detectName().replace(/[\r\n=]/g, '').trim().slice(0, 200);
+  const timezone = detectTimezone();
+  const nameParts = ownerName.split(/\s+/);
+
+  console.log(`  ${DIM}Owner:    ${ownerName}${RESET}`);
+  console.log(`  ${DIM}Timezone: ${timezone}${RESET}`);
+
+  // Copy template
+  console.log(`\n  Copying files...`);
+  copyRecursive(TEMPLATE_DIR, targetDir);
+
+  // Install dependencies
+  console.log(`  Installing dependencies...\n`);
+  try {
+    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(targetDir, 'claude-task-manager'), stdio: 'inherit' });
+    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(targetDir, 'wall-e'), stdio: 'inherit' });
+  } catch (e) {
+    console.error(`\n  Failed to install dependencies. Make sure npm is installed and try:\n    cd ${targetDir}/claude-task-manager && npm install\n    cd ${targetDir}/wall-e && npm install\n`);
+    process.exit(1);
+  }
+
+  // Create .env (API key left as placeholder — configured via web UI)
+  const envLines = [
+    `# Wall-E configuration — generated ${new Date().toISOString().split('T')[0]}`,
+    `# Add your API key below, or configure it at http://localhost:3456/setup`,
+    '',
+    `WALLE_OWNER_NAME=${ownerName}`,
+    '# ANTHROPIC_API_KEY=sk-ant-...',
+    '',
+    '# Slack (connect via http://localhost:3456/#walle → Settings)',
+    '# SLACK_TOKEN=',
+    '# SLACK_OWNER_USER_ID=',
+    '# SLACK_OWNER_HANDLE=',
+  ];
+  fs.writeFileSync(path.join(targetDir, '.env'), envLines.join('\n') + '\n', { mode: 0o600 });
+
+  // Create wall-e-config.json
+  const walleConfig = {
+    owner: {
+      name: ownerName,
+      first_name: nameParts[0],
+      last_name: nameParts.slice(1).join(' '),
+      timezone,
+    },
+    adapters: { ctm: { enabled: true }, slack: { enabled: false } },
+    intervals: { ingest_ms: 60000, think_ms: 120000 },
+  };
+  fs.writeFileSync(
+    path.join(targetDir, 'wall-e', 'wall-e-config.json'),
+    JSON.stringify(walleConfig, null, 2) + '\n',
+    { mode: 0o600 }
+  );
+
+  // Create data directory
+  const dataDir = path.join(process.env.HOME, '.walle', 'data');
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  // Init git repo
+  execFileSync('git', ['init', '-q'], { cwd: targetDir, stdio: 'ignore' });
+
+  console.log(`
+  ${GREEN}${BOLD}Done!${RESET}
+
+  ${BOLD}1. Start:${RESET}
+     cd ${targetDir} && node claude-task-manager/server.js
+
+  ${BOLD}2. Open:${RESET}
+     http://localhost:3456
+
+  ${BOLD}3. Finish setup in the browser:${RESET}
+     Add your Anthropic API key and connect integrations.
+`);
+}
+
+main().catch(err => {
+  console.error(`  Error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "create-walle",
+  "version": "0.1.0",
+  "description": "Set up Wall-E — your personal digital twin",
+  "bin": {
+    "create-walle": "bin/create-walle.js"
+  },
+  "files": [
+    "bin/",
+    "template/"
+  ],
+  "scripts": {
+    "build": "bash build.sh",
+    "prepublishOnly": "bash build.sh"
+  },
+  "license": "MIT",
+  "keywords": ["wall-e", "ai", "digital-twin", "claude", "personal-assistant"]
+}

package/template/.env.example

@@ -0,0 +1,40 @@
+# Wall-E & CTM Configuration
+# Copy this to .env and fill in your values
+
+# === Required ===
+
+# Anthropic API key (for Wall-E chat, skills, and agent loops)
+ANTHROPIC_API_KEY=sk-ant-...
+
+# Owner name (used in system prompts, memory attribution)
+WALLE_OWNER_NAME=Your Name
+
+# === Data Storage ===
+
+# Where to store databases and backups (default: ~/.walle/data)
+# CTM_DATA_DIR=~/.walle/data
+# WALL_E_DATA_DIR=~/.walle/data
+
+# === Optional: Slack Integration ===
+
+# Slack bot/user token (for Slack sync skills)
+# SLACK_TOKEN=xoxb-...
+# SLACK_BOT_TOKEN=xoxb-...
+
+# Your Slack user ID (for filtering your own messages)
+# SLACK_OWNER_USER_ID=U0XXXXXXXX
+
+# Your Slack handle/username (for search queries)
+# SLACK_OWNER_HANDLE=your.name
+
+# === Optional: API Gateway ===
+
+# If using Portkey or another gateway instead of direct Anthropic API
+# ANTHROPIC_BASE_URL=https://api.portkey.ai/v1
+# ANTHROPIC_CUSTOM_HEADERS_B64=<base64-encoded JSON headers>
+
+# === Optional: Server Config ===
+
+# CTM_PORT=3456
+# CTM_HOST=127.0.0.1
+# WALL_E_PORT=3457

package/template/CLAUDE.md

@@ -0,0 +1,12 @@
+# Project: Tools (CTM + Wall-E)
+
+## Service Management
+
+NEVER kill CTM or Wall-E processes directly (e.g. `kill`, `lsof | xargs kill`, `pkill`).
+Always use the restart API or helper script — they handle graceful shutdown and auto-respawn.
+
+- **Restart CTM**: `bash claude-task-manager/bin/restart-ctm.sh` or `curl -sX POST http://localhost:3456/api/restart/ctm`
+- **Restart Wall-E**: `curl -sX POST http://localhost:3456/api/restart/walle`
+- **Stop Wall-E**: `curl -sX POST http://localhost:3456/api/stop/walle`
+- **Start Wall-E**: `curl -sX POST http://localhost:3456/api/start/walle`
+- **Check status**: `curl -s http://localhost:3456/api/services/status`

package/template/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juncao Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/template/README.md

@@ -0,0 +1,167 @@
+# Wall-E
+
+**Your personal digital twin** — an AI agent that learns from your Slack, email, and calendar to build a searchable second brain, answer questions in your voice, and automate daily workflows.
+
+Wall-E runs locally alongside **CTM** (Claude Task Manager), a terminal multiplexer and task dashboard for Claude Code sessions.
+
+## What It Does
+
+- **Ingests** your Slack messages, calendar events, and sent emails into a local SQLite brain
+- **Learns** your preferences, relationships, communication style, and knowledge over time
+- **Answers** questions about your work, meetings, and conversations — with citations
+- **Runs skills** on a schedule: morning briefings, Slack sync, calendar sync, and more
+- **Manages tasks** and Claude Code sessions through a web dashboard
+
+## Architecture
+
+```
+CTM (port 3456)                    Wall-E
++-----------------------+          +------------------------+
+| Web Dashboard         |          | Agent Daemon           |
+|  - Sessions (pty)     |  <--->   |  - Ingest loop (60s)   |
+|  - Prompts editor     |          |  - Think loop (120s)   |
+|  - Task manager       |          |  - Reflect loop (1hr)  |
+|  - Code review        |          |  - Skills loop (5min)  |
+|  - Wall-E chat tab    |          |  - Tasks loop (30s)    |
++-----------------------+          +------------------------+
+         |                                    |
+         v                                    v
+   task-manager.db                    wall-e-brain.db
+   (sessions, prompts,               (memories, knowledge,
+    tasks, reviews)                   people, skills, tasks)
+```
+
+## Quickstart
+
+```bash
+npx create-walle my-agent
+cd my-agent
+node claude-task-manager/server.js
+```
+
+Open **http://localhost:3456** — the browser setup page walks you through adding your API key and connecting integrations. Your name and timezone are auto-detected.
+
+Or clone manually:
+
+```bash
+git clone <repo-url> walle && cd walle
+cd claude-task-manager && npm install && cd ..
+cd wall-e && npm install && cd ..
+node claude-task-manager/server.js
+```
+
+The first run auto-creates `.env`, `wall-e-config.json`, and `~/.walle/data/`. Finish setup at http://localhost:3456/setup.html.
+
+## Configuration
+
+All configuration lives in `.env` (auto-generated on first run). Edit directly or use the browser setup page.
+
+| Variable | Required | Description |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | Yes | Your Anthropic API key (set via browser setup) |
+| `WALLE_OWNER_NAME` | Auto | Your name (auto-detected from `git config`) |
+| `WALL_E_DATA_DIR` | No | Data directory (default: `~/.walle/data`) |
+| `CTM_DATA_DIR` | No | CTM data directory (default: `~/.walle/data`) |
+| `SLACK_TOKEN` | No | Slack token (set via OAuth — click "Connect" in setup) |
+| `SLACK_OWNER_USER_ID` | No | Your Slack user ID |
+| `SLACK_OWNER_HANDLE` | No | Your Slack handle |
+
+## Bundled Skills
+
+Wall-E ships with skills that run on a schedule to keep your brain up to date:
+
+| Skill | Schedule | Description |
+|---|---|---|
+| `google-calendar` | every 30m | Syncs macOS Calendar events (Google, iCloud, Outlook) via EventKit |
+| `slack-sync` | every 15m | Incremental Slack message sync via MCP |
+| `slack-backfill` | manual | Full Slack history backfill (2022-present) |
+| `email-sync` | every 30m | Syncs sent emails from macOS Mail via JXA |
+| `email-digest` | daily 7am | Summarizes recent email activity |
+| `morning-briefing` | daily 7am | AI-generated daily briefing from all sources |
+| `memory-search` | on-demand | Full-text search across all memories |
+
+### Creating Custom Skills
+
+Skills are defined as `SKILL.md` files with YAML frontmatter:
+
+```yaml
+---
+name: my-skill
+description: What this skill does
+version: 1.0.0
+execution: script        # or "agent" for LLM-driven skills
+entry: run.js
+trigger:
+  type: interval
+  schedule: "every 30m"
+tags: [sync, data]
+---
+```
+
+Place skills in `wall-e/skills/_bundled/your-skill/SKILL.md` or load from a custom directory.
+
+## Dashboard Features
+
+### Sessions Tab
+Terminal multiplexer for Claude Code — create, monitor, and manage multiple sessions from a single browser tab.
+
+### Prompts Tab
+Rich-text prompt editor with versioning, tagging, folders, and one-click send to any active Claude session. Supports composite prompts (parent + sub-prompts).
+
+### Tasks Tab
+Task dashboard with recurring task support, skill execution, checkpoint/resume, and live logs.
+
+### Wall-E Tab
+Chat directly with Wall-E — ask about your schedule, search your memories, run skills, and get AI-powered answers grounded in your actual data.
+
+### Code Review Tab
+Review code changes across projects with inline diffs and AI-assisted review.
+
+## API
+
+CTM runs on port 3456. Key endpoints:
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/services/status` | CTM and Wall-E process status |
+| POST | `/api/restart/walle` | Restart Wall-E daemon |
+| POST | `/api/start/walle` | Start Wall-E daemon |
+| POST | `/api/stop/walle` | Stop Wall-E daemon |
+| GET | `/api/wall-e/status` | Wall-E brain stats and owner info |
+| GET | `/api/wall-e/memories` | List memories (filterable by source, since, limit) |
+| GET | `/api/wall-e/knowledge` | List knowledge entries |
+| GET | `/api/wall-e/people` | List known people |
+| GET | `/api/wall-e/timeline` | Memory timeline |
+| POST | `/api/wall-e/chat` | Chat with Wall-E |
+| GET | `/api/prompts` | List prompts |
+| GET | `/api/sessions` | List active terminal sessions |
+
+## Tech Stack
+
+- **Runtime**: Node.js (no framework — raw `http.createServer`)
+- **Database**: SQLite via better-sqlite3 (WAL mode, FTS5 full-text search)
+- **AI**: Claude API via Anthropic SDK (supports Portkey gateway)
+- **Frontend**: Vanilla HTML/CSS/JS (no build step, no React)
+- **macOS integration**: EventKit (calendar), JXA (email/AppleScript), Spotlight (file search)
+- **Terminal**: node-pty for session management
+
+## Development
+
+```bash
+# Run Wall-E tests
+cd wall-e && npm test
+
+# Run a single test file
+node --test tests/brain.test.js
+
+# Run Slack backfill manually
+node scripts/slack-backfill.js 2024-01  # single month
+node scripts/slack-backfill.js incremental  # new messages only
+
+# Run calendar sync manually
+node skills/_bundled/google-calendar/run.js
+```
+
+## License
+
+MIT

package/template/bin/setup.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+// First-run setup — auto-detects owner info and creates .env + config.
+// No interactive prompts. API key and integrations are configured via the web UI.
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const ENV_PATH = path.join(ROOT, '.env');
+const WALLE_CONFIG = path.join(ROOT, 'wall-e', 'wall-e-config.json');
+
+function detectName() {
+  try { return execFileSync('git', ['config', 'user.name'], { encoding: 'utf8' }).trim(); } catch {}
+  try { return execFileSync('id', ['-F'], { encoding: 'utf8' }).trim(); } catch {}
+  return process.env.USER || 'Owner';
+}
+
+function detectTimezone() {
+  try { return Intl.DateTimeFormat().resolvedOptions().timeZone; } catch {}
+  return 'UTC';
+}
+
+/**
+ * Returns true if setup was performed, false if already configured.
+ */
+function runIfNeeded() {
+  if (fs.existsSync(ENV_PATH)) return false;
+
+  const ownerName = detectName().replace(/[\r\n=]/g, '').trim().slice(0, 200);
+  const timezone = detectTimezone();
+  const nameParts = ownerName.split(/\s+/);
+
+  // Write .env
+  const envLines = [
+    `# Wall-E configuration — generated ${new Date().toISOString().split('T')[0]}`,
+    `# Configure API key and integrations at http://localhost:3456/setup`,
+    '',
+    `WALLE_OWNER_NAME=${ownerName}`,
+    '# ANTHROPIC_API_KEY=sk-ant-...',
+  ];
+  fs.writeFileSync(ENV_PATH, envLines.join('\n') + '\n', { mode: 0o600 });
+
+  // Set in current process
+  process.env.WALLE_OWNER_NAME = ownerName;
+
+  // Write wall-e-config.json if missing
+  if (!fs.existsSync(WALLE_CONFIG)) {
+    const config = {
+      owner: {
+        name: ownerName,
+        first_name: nameParts[0],
+        last_name: nameParts.slice(1).join(' '),
+        timezone,
+      },
+      adapters: { ctm: { enabled: true }, slack: { enabled: false } },
+      intervals: { ingest_ms: 60000, think_ms: 120000 },
+    };
+    fs.mkdirSync(path.dirname(WALLE_CONFIG), { recursive: true });
+    fs.writeFileSync(WALLE_CONFIG, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+  }
+
+  // Create data directory
+  const dataDir = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  console.log(`[setup] First-run setup complete. Owner: ${ownerName}`);
+  console.log(`[setup] Finish setup at http://localhost:3456/setup`);
+  return true;
+}
+
+/** Returns true if setup is needed (no API key configured anywhere). Cached after first check. */
+let _needsSetupCache = undefined;
+function needsSetup() {
+  if (_needsSetupCache !== undefined) return _needsSetupCache;
+  // Check process.env first (may be set via Portkey, environment, etc.)
+  if (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_BASE_URL) {
+    _needsSetupCache = false;
+    return false;
+  }
+  if (!fs.existsSync(ENV_PATH)) {
+    _needsSetupCache = true;
+    return true;
+  }
+  const content = fs.readFileSync(ENV_PATH, 'utf8');
+  _needsSetupCache = !content.match(/^ANTHROPIC_API_KEY=\S+/m);
+  return _needsSetupCache;
+}
+
+/** Call after saving API key to clear the needsSetup cache. */
+function clearSetupCache() { _needsSetupCache = undefined; }
+
+module.exports = { runIfNeeded, needsSetup, clearSetupCache };
+
+if (require.main === module) {
+  const ran = runIfNeeded();
+  if (!ran) console.log('Already configured.');
+}

package/template/claude-code-skill.md

@@ -0,0 +1,60 @@
+# Wall-E — Claude Code Skill
+
+Wall-E can be used as an MCP server from Claude Code, giving Claude access to your personal knowledge base, calendar, and memory search.
+
+## Install as MCP Server
+
+Add to your Claude Code MCP config (`~/.claude/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "wall-e": {
+      "type": "http",
+      "url": "http://localhost:3457/mcp"
+    }
+  }
+}
+```
+
+Then start Wall-E's standalone HTTP server:
+
+```bash
+cd wall-e
+WALL_E_PORT=3457 node agent.js
+```
+
+## Available Tools
+
+Once connected, Claude Code gains access to:
+
+| Tool | Description |
+|---|---|
+| `search_memories` | Full-text search across all ingested memories (Slack, email, calendar) |
+| `calendar_events` | Get upcoming calendar events with attendees, location, notes |
+| `remember_fact` | Store new knowledge in the brain |
+| `run_skill` | Execute any bundled or custom skill |
+| `list_mcp_tools` | Discover tools from Wall-E's own MCP connections |
+
+## Use Cases in Claude Code
+
+Once Wall-E is connected as an MCP server, you can ask Claude Code:
+
+- "What meetings do I have tomorrow?" — searches calendar memories
+- "What did I discuss with Alice last week?" — searches Slack memories
+- "Remember that I prefer Tailwind over Bootstrap" — stores knowledge
+- "Run the morning briefing skill" — generates a daily summary
+- "Search my memories for the database migration discussion" — full-text search
+
+## CLAUDE.md Integration
+
+Add to your project's `CLAUDE.md` to give Claude Code context about Wall-E:
+
+```markdown
+## Wall-E (Personal Digital Twin)
+
+This project has Wall-E connected as an MCP server. Use it to:
+- Search the owner's memories and knowledge base
+- Check calendar events and meeting schedules
+- Look up past Slack conversations for context
+```