create-walle 0.9.8 → 0.9.9

package/README.md

@@ -23,7 +23,7 @@ An always-on AI agent that learns from your Slack, email, calendar, and coding s
 - **Second Brain** — Automatically ingests your digital life into a searchable memory store with full-text search, knowledge extraction, and pattern detection
 - **Proactive Intelligence** — Surfaces time-sensitive items, suggests actions, and delivers morning briefings and weekly reflections without being asked
 - **Chat with Tools** — Talk to Wall-E in the browser — it can search your memories, look up people, run skills, and call external tools via MCP (Slack, Glean, etc.)
-- **16 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model training, and more
+- **17 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model evaluation, and more
 - **Multi-Model** — Works with Claude, GPT, Gemini, and local models via Ollama with smart routing
 - **Skill Management GUI** — Search, filter, create, edit, and monitor skills from the browser with rich cards, config forms, execution history, export/import, and pre-flight validation
 - **Multi-Device** — Share your brain across machines via Dropbox or iCloud

package/bin/create-walle.js

@@ -13,6 +13,7 @@ const RED = '\x1b[31m';
 const CYAN = '\x1b[36m';
 const RESET = '\x1b[0m';
 
+const { injectMcpConfigs } = require('./mcp-inject');
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
 const LABEL = 'com.walle.server';
 const INSTALL_PATH_FILE = path.join(process.env.HOME, '.walle', 'install-path');
@@ -70,6 +71,29 @@ ${BOLD}${CYAN}  Wall-E${RESET} — Your personal digital twin
 `);
 }
 
+function printMcpResults(wallePort) {
+  try {
+    const results = injectMcpConfigs(wallePort);
+    const hasAny = results.some(r => r.action !== 'not_installed');
+    if (!hasAny) return;
+
+    console.log(`  ${BOLD}MCP Integrations:${RESET}`);
+    for (const r of results) {
+      if (r.action === 'not_installed') {
+        console.log(`     ${DIM}-  ${r.tool} -- not installed${RESET}`);
+      } else if (r.action === 'already_configured') {
+        console.log(`     ${DIM}=  ${r.tool} -- already configured${RESET}`);
+      } else if (r.action === 'updated') {
+        console.log(`     ${GREEN}~  ${r.tool}${RESET} -- updated port in ${DIM}${r.configPath}${RESET}`);
+      } else {
+        console.log(`     ${GREEN}+  ${r.tool}${RESET} -- added Wall-E to ${DIM}${r.configPath}${RESET}`);
+      }
+    }
+    console.log(`\n  ${DIM}Your AI coding tools can now access Wall-E's memory and knowledge.`);
+    console.log(`  To undo: remove the "wall-e" entry from the config files above.${RESET}\n`);
+  } catch {}
+}
+
 function install(targetDir) {
   // If no target dir given, check for existing install
   if (!targetDir) {
@@ -128,6 +152,10 @@ function install(targetDir) {
     `WALLE_OWNER_NAME=${ownerName}`,
     '# ANTHROPIC_API_KEY=',
     '',
+    '# AI Provider: anthropic, openai, google, ollama',
+    '# WALLE_PROVIDER=anthropic',
+    '# WALLE_MODEL=',
+    '',
     `CTM_PORT=${port}`,
     `WALL_E_PORT=${wallePort}`,
     '',
@@ -172,6 +200,7 @@ function install(targetDir) {
     npx create-walle status      ${DIM}Check status${RESET}
     npx create-walle logs        ${DIM}View logs${RESET}
 `);
+  printMcpResults(parseInt(wallePort));
 }
 
 function update() {
@@ -218,7 +247,7 @@ function update() {
   console.log(`  Installing dependencies...\n`);
   npmInstall(dir);
 
-  // 6. Start again
+  // 7. Start again
   console.log(`\n  Starting Wall-E...`);
   startForegroundOrService(dir, port);
 
@@ -227,6 +256,7 @@ function update() {
 
   ${DIM}Your .env and config were preserved.${RESET}
 `);
+  printMcpResults(parseInt(readWallePort(dir)));
 }
 
 function start() {
@@ -235,6 +265,7 @@ function start() {
   console.log(`\n  Starting Wall-E from ${DIM}${dir}${RESET} on port ${port}...`);
   installService(dir, port);
   console.log(`  ${GREEN}Running!${RESET}  http://localhost:${port}\n`);
+  printMcpResults(parseInt(readWallePort(dir)));
 }
 
 function stop() {

package/bin/mcp-inject.js

@@ -0,0 +1,60 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const MCP_TARGETS = [
+  { tool: 'Claude Code', configPath: '.claude/mcp.json', detectDir: '.claude' },
+  { tool: 'Cursor', configPath: '.cursor/mcp.json', detectDir: '.cursor' },
+  { tool: 'Windsurf', configPath: '.codeium/windsurf/mcp_config.json', detectDir: '.codeium/windsurf' },
+  { tool: 'Claude Desktop', configPath: 'Library/Application Support/Claude/claude_desktop_config.json', detectDir: 'Library/Application Support/Claude' },
+];
+
+/**
+ * Inject Wall-E MCP server config into detected AI tool config files.
+ * @param {number} wallePort - The Wall-E HTTP port
+ * @param {string} [homeDir] - Home directory override for testing
+ * @returns {Array<{tool: string, action: string, configPath?: string}>}
+ */
+function injectMcpConfigs(wallePort, homeDir) {
+  const home = homeDir || process.env.HOME;
+  const walleUrl = `http://localhost:${wallePort}/mcp`;
+  const results = [];
+
+  for (const target of MCP_TARGETS) {
+    const detectPath = path.join(home, target.detectDir);
+    const configPath = path.join(home, target.configPath);
+
+    if (!fs.existsSync(detectPath)) {
+      results.push({ tool: target.tool, action: 'not_installed' });
+      continue;
+    }
+
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      } catch {
+        config = {};
+      }
+    }
+
+    if (!config.mcpServers) config.mcpServers = {};
+
+    const existing = config.mcpServers['wall-e'];
+    if (existing && existing.url === walleUrl) {
+      results.push({ tool: target.tool, action: 'already_configured', configPath });
+      continue;
+    }
+
+    const action = existing ? 'updated' : 'added';
+    config.mcpServers['wall-e'] = { type: 'http', url: walleUrl };
+
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    results.push({ tool: target.tool, action, configPath });
+  }
+
+  return results;
+}
+
+module.exports = { injectMcpConfigs, MCP_TARGETS };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-walle",
-  "version": "0.9.8",
-  "description": "CTM + Wall-E — AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini & Aider, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
+  "version": "0.9.9",
+  "description": "CTM + Wall-E \u2014 AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini & Aider, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"
   },
@@ -15,5 +15,13 @@
     "prepublishOnly": "bash build.sh"
   },
   "license": "MIT",
-  "keywords": ["ctm", "task-manager", "wall-e", "ai", "digital-twin", "claude", "personal-assistant"]
+  "keywords": [
+    "ctm",
+    "task-manager",
+    "wall-e",
+    "ai",
+    "digital-twin",
+    "claude",
+    "personal-assistant"
+  ]
 }

package/template/bin/setup.js

@@ -7,6 +7,7 @@
 const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteFileSync } = require('../claude-task-manager/atomic-write');
 
 const ROOT = path.resolve(__dirname, '..');
 const ENV_PATH = path.join(ROOT, '.env');
@@ -41,7 +42,7 @@ function runIfNeeded() {
     `WALLE_OWNER_NAME=${ownerName}`,
     '# ANTHROPIC_API_KEY=sk-ant-...',
   ];
-  fs.writeFileSync(ENV_PATH, envLines.join('\n') + '\n', { mode: 0o600 });
+  atomicWriteFileSync(ENV_PATH, envLines.join('\n') + '\n', { mode: 0o600 });
 
   // Set in current process
   process.env.WALLE_OWNER_NAME = ownerName;

package/template/claude-code-skill.md

@@ -1,10 +1,22 @@
-# Wall-E — Claude Code Skill
+# Wall-E -- Claude Code MCP Server
 
-Wall-E can be used as an MCP server from Claude Code, giving Claude access to your personal knowledge base, calendar, and memory search.
+Wall-E automatically registers as an MCP server in Claude Code, Cursor, Windsurf, and Claude Desktop during installation.
 
-## Install as MCP Server
+## Automatic Setup
 
-Add to your Claude Code MCP config (`~/.claude/mcp.json`):
+When you install or start Wall-E (`npx create-walle install ./my-agent`), it detects installed AI coding tools and adds itself to their MCP config. You'll see output like:
+
+```
+  MCP Integrations:
+     + Claude Code  -- added Wall-E to ~/.claude/mcp.json
+     + Cursor       -- added Wall-E to ~/.cursor/mcp.json
+```
+
+No manual configuration needed.
+
+## Manual Setup
+
+If auto-detection missed your tool, add this to your MCP config:
 
 ```json
 {
@@ -17,44 +29,33 @@ Add to your Claude Code MCP config (`~/.claude/mcp.json`):
 }
 ```
 
-Then start Wall-E's standalone HTTP server:
-
-```bash
-cd wall-e
-WALL_E_PORT=3457 node agent.js
-```
+Config file locations:
+- Claude Code: `~/.claude/mcp.json`
+- Cursor: `~/.cursor/mcp.json`
+- Windsurf: `~/.codeium/windsurf/mcp_config.json`
+- Claude Desktop: `~/Library/Application Support/Claude/claude_desktop_config.json`
 
 ## Available Tools
 
-Once connected, Claude Code gains access to:
+Once connected, your AI coding tool 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
+| `remember` | Store new knowledge in the brain |
+| `list_knowledge` | Browse stored knowledge |
+| `list_people` | List known people with relationships |
+| `get_brief` | Get today's daily briefing |
+| `ask_walle` | Ask Wall-E a question (uses full chat pipeline with memory context) |
 
-Once Wall-E is connected as an MCP server, you can ask Claude Code:
+## Use Cases
 
-- "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
+- "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
+- "Who do I know at Acme Corp?" -- searches people
+- "Give me my daily brief" -- generates a summary
 
-## CLAUDE.md Integration
+## To Undo
 
-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
-```
+Remove the `"wall-e"` entry from the config files listed above.

package/template/claude-task-manager/api-prompts.js

@@ -638,75 +638,114 @@ function handleListConversations(req, res, url) {
   jsonResponse(res, 200, db.listSessionConversations(opts));
 }
 
+// Core import logic shared by API handler and auto-import
+const { getAllSessionFiles, getAllSessionFilesAsync, parseSessionFile } = require('./session-utils');
+const fsp = require('fs').promises;
+
+function importSessionFile(filePath, projectPath, projectEntry) {
+  const parsed = parseSessionFile(filePath, projectPath, projectEntry);
+  if (parsed.isEmpty) return false;
+
+  const existing = db.getSessionConversation(parsed.sessionId);
+  // Skip re-import if file size unchanged AND model already populated
+  if (existing && existing.file_size === parsed.fileSize && existing.model_provider) return false;
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n').filter(Boolean);
+  const messages = [];
+  let assistantCount = 0;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === 'user' && entry.message?.role === 'user') {
+        const c = entry.message.content;
+        const text = typeof c === 'string' ? c
+          : Array.isArray(c) ? c.filter(b => b.type === 'text').map(b => b.text).join('\n') : '';
+        if (text) messages.push({ role: 'user', text: text.slice(0, 5000), timestamp: entry.timestamp });
+      } else if (entry.type === 'assistant' && entry.message?.role === 'assistant') {
+        const c = entry.message.content;
+        if (!Array.isArray(c)) continue;
+        const parts = [];
+        for (const block of c) {
+          if (block.type === 'text' && block.text) parts.push(block.text);
+          else if (block.type === 'tool_use') parts.push(`[Tool: ${block.name}]`);
+        }
+        if (parts.length > 0) {
+          const lastMsg = messages[messages.length - 1];
+          if (lastMsg && lastMsg.role === 'assistant' && lastMsg._parent === entry.parentUuid) {
+            lastMsg.text = parts.join('\n').slice(0, 5000);
+          } else {
+            messages.push({ role: 'assistant', text: parts.join('\n').slice(0, 5000), timestamp: entry.timestamp, _parent: entry.parentUuid });
+            assistantCount++;
+          }
+        }
+      }
+    } catch {}
+  }
+  messages.forEach(m => delete m._parent);
+
+  db.importSessionConversation({
+    session_id: parsed.sessionId,
+    project_path: parsed.project,
+    messages,
+    user_msg_count: parsed.userMsgCount,
+    assistant_msg_count: assistantCount,
+    title: parsed.title,
+    first_message: parsed.firstMessage,
+    git_branch: parsed.gitBranch,
+    file_size: parsed.fileSize,
+    session_created_at: parsed.timestamp,
+    hostname: parsed.hostname,
+    model_provider: parsed.modelProvider,
+    model_id: parsed.modelId,
+  });
+  return true;
+}
+
 async function handleImportConversations(req, res) {
-  // Import all sessions from ~/.claude/projects/ into the DB
   try {
-    const { getAllSessionFiles, parseSessionFile } = require('./session-utils');
     let imported = 0;
-    const allFiles = getAllSessionFiles();
+    for (const { filePath, projectPath, projectEntry } of getAllSessionFiles()) {
+      try { if (importSessionFile(filePath, projectPath, projectEntry)) imported++; } catch {}
+    }
+    jsonResponse(res, 200, { ok: true, imported });
+  } catch (e) { jsonResponse(res, 500, { error: e.message }); }
+}
+
+// Incremental auto-import: only processes files modified since last scan
+// Uses async filesystem operations to avoid blocking the event loop
+// (critical when ~/.claude/projects is on Dropbox/network-synced FS)
+async function runIncrementalConversationImport() {
+  try {
+    // One-time backfill: force full rescan to populate model_provider for existing sessions
+    if (!db.getSetting('conversation_model_backfill_done', false)) {
+      db.setSetting('conversation_import_last_scan_at', 0);
+      db.setSetting('conversation_model_backfill_done', true);
+      console.log('[auto-import] One-time model backfill: forcing full rescan');
+    }
+    const lastScanAt = db.getSetting('conversation_import_last_scan_at', 0);
+    const scanStart = Date.now();
+    const allFiles = await getAllSessionFilesAsync();
+    let imported = 0;
+    let scanned = 0;
 
     for (const { filePath, projectPath, projectEntry } of allFiles) {
       try {
-        const parsed = parseSessionFile(filePath, projectPath, projectEntry);
-        if (parsed.isEmpty) continue;
-
-        const existing = db.getSessionConversation(parsed.sessionId);
-        if (existing && existing.file_size === parsed.fileSize) continue;
-
-        // Read full messages
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.split('\n').filter(Boolean);
-        const messages = [];
-        let assistantCount = 0;
-
-        for (const line of lines) {
-          try {
-            const entry = JSON.parse(line);
-            if (entry.type === 'user' && entry.message?.role === 'user') {
-              const c = entry.message.content;
-              const text = typeof c === 'string' ? c
-                : Array.isArray(c) ? c.filter(b => b.type === 'text').map(b => b.text).join('\n') : '';
-              if (text) messages.push({ role: 'user', text: text.slice(0, 5000), timestamp: entry.timestamp });
-            } else if (entry.type === 'assistant' && entry.message?.role === 'assistant') {
-              const c = entry.message.content;
-              if (!Array.isArray(c)) continue;
-              const parts = [];
-              for (const block of c) {
-                if (block.type === 'text' && block.text) parts.push(block.text);
-                else if (block.type === 'tool_use') parts.push(`[Tool: ${block.name}]`);
-              }
-              if (parts.length > 0) {
-                const lastMsg = messages[messages.length - 1];
-                if (lastMsg && lastMsg.role === 'assistant' && lastMsg._parent === entry.parentUuid) {
-                  lastMsg.text = parts.join('\n').slice(0, 5000);
-                } else {
-                  messages.push({ role: 'assistant', text: parts.join('\n').slice(0, 5000), timestamp: entry.timestamp, _parent: entry.parentUuid });
-                  assistantCount++;
-                }
-              }
-            }
-          } catch {}
-        }
-        messages.forEach(m => delete m._parent);
-
-        db.importSessionConversation({
-          session_id: parsed.sessionId,
-          project_path: parsed.project,
-          messages,
-          user_msg_count: parsed.userMsgCount,
-          assistant_msg_count: assistantCount,
-          title: parsed.title,
-          first_message: parsed.firstMessage,
-          git_branch: parsed.gitBranch,
-          file_size: parsed.fileSize,
-          session_created_at: parsed.timestamp,
-        });
-        imported++;
+        const stat = await fsp.stat(filePath);
+        if (stat.mtimeMs <= lastScanAt) continue;
+        scanned++;
+        if (importSessionFile(filePath, projectPath, projectEntry)) imported++;
       } catch {}
     }
 
-    jsonResponse(res, 200, { ok: true, imported });
-  } catch (e) { jsonResponse(res, 500, { error: e.message }); }
+    db.setSetting('conversation_import_last_scan_at', scanStart);
+    if (imported > 0) console.log(`[auto-import] Imported ${imported} session conversations (scanned ${scanned}/${allFiles.length})`);
+    return { imported, scanned, total: allFiles.length };
+  } catch (e) {
+    console.error('[auto-import] Error:', e.message);
+    return { imported: 0, scanned: 0, total: 0 };
+  }
 }
 
 function handleGetConversation(req, res, url) {
@@ -1057,7 +1096,7 @@ async function handlePermAISuggest(req, res) {
     }
 
     // Use LLM to interpret the natural language permission request
-    const result = await classifyPermissionIntent(body.query || '');
+    const result = await classifyPermissionIntent(query);
     jsonResponse(res, 200, result);
   } catch (e) {
     jsonResponse(res, 500, { error: e.message });
@@ -1093,10 +1132,11 @@ For allow rules, match the scope the user requests.
 
 IMPORTANT: Output ONLY the JSON object, no markdown fencing.
 
-User request: "${query.replace(/"/g, '\\"')}"`;
+User request: (see below)`;
 
   try {
-    const result = await callClaude([{ role: 'user', content: prompt }], 256);
+    // Pass query as a separate message to avoid prompt injection via string interpolation
+    const result = await callClaude([{ role: 'user', content: prompt + '\n\n' + query }], 256);
     const text = result.content?.[0]?.text || '';
     const parsed = JSON.parse(text);
     return {
@@ -1155,12 +1195,17 @@ function handlePermAIException(res, query, parentRule, body) {
       },
     };
 
-    // Try to match known dangerous patterns
+    // Try to match known dangerous patterns (longest match first to avoid duplicates)
     const binPatterns = dangerousPatterns[parentBin] || {};
-    for (const [key, denyRules] of Object.entries(binPatterns)) {
+    const sortedKeys = Object.keys(binPatterns).sort((a, b) => b.length - a.length);
+    let matched = false;
+    for (const key of sortedKeys) {
       if (query.includes(key)) {
-        rules.push(...denyRules);
-        explanation = `Deny ${key} operations for ${parentBin}.`;
+        for (const r of binPatterns[key]) {
+          if (!rules.includes(r)) rules.push(r);
+        }
+        if (!matched) explanation = `Deny ${key} operations for ${parentBin}.`;
+        matched = true;
       }
     }
 
@@ -1234,7 +1279,6 @@ function handleGetScanCache(req, res) {
 
 function handleScanToolUsage(req, res) {
   // Scan session JSONL files and extract tool usage, then generalize into rules
-  const { getAllSessionFiles } = require('./session-utils');
   const allFiles = getAllSessionFiles();
   const toolUsage = {}; // tool_name -> { count, commands: Map<binary, Set<subcmds>>, projects: Set }
 
@@ -1384,7 +1428,6 @@ function handleDeleteAutoApproval(req, res, id) {
 async function handleScanAutoApprovals(req, res) {
   // Scan session JSONL files and find approval patterns:
   // assistant asks a question -> user responds with short affirmative
-  const { getAllSessionFiles } = require('./session-utils');
   const allFiles = getAllSessionFiles();
   const recentFiles = allFiles
     .map(f => { try { return { ...f, mtime: fs.statSync(f.filePath).mtime }; } catch { return null; } })
@@ -1849,4 +1892,4 @@ function handleLifecycleRefresh(req, res) {
   } catch (e) { jsonResponse(res, 500, { error: e.message }); }
 }
 
-module.exports = { handlePromptApi, queueEngine, importPermissionsToDb };
+module.exports = { handlePromptApi, queueEngine, importPermissionsToDb, runIncrementalConversationImport };