create-walle 0.9.3 → 0.9.4

package/template/wall-e/chat.js

@@ -18,6 +18,16 @@ function ensureBrainInit() {
   }
 }
 
+function getCodingDefaultCwd() {
+  try {
+    const cfgPath = require('path').join(__dirname, 'wall-e-config.json');
+    const cfg = JSON.parse(require('fs').readFileSync(cfgPath, 'utf8'));
+    return (cfg.coding_agent && cfg.coding_agent.default_cwd) || process.cwd();
+  } catch {
+    return process.cwd();
+  }
+}
+
 async function chat(message, opts = {}) {
   ensureBrainInit();
   const channel = opts.channel || 'ctm';
@@ -72,7 +82,7 @@ async function chat(message, opts = {}) {
     },
     {
       name: 'run_skill',
-      description: 'Run one of my skills to fetch data or perform an action. Use this when the user asks me to do something actionable.',
+      description: `Run one of my skills to fetch data or perform an action. PREFER skills over raw mcp_call when a matching skill exists — skills parse data correctly and store results in brain. Available skills: ${(() => { try { const { loadAllSkills } = require('./skills/skill-loader'); const bundled = loadAllSkills().map(s => s.name + ': ' + (s.description || '').slice(0, 60)); const db = brain.listSkills({ enabled: 1 }).map(s => s.name + ': ' + (s.description || '').slice(0, 60)); const all = [...new Set([...bundled, ...db])]; return all.join('; ') || 'none'; } catch { return 'unknown'; } })()}`,
       input_schema: { type: 'object', properties: { skill_name: { type: 'string', description: 'Name of the skill to run' } }, required: ['skill_name'] },
     },
     {
@@ -176,6 +186,19 @@ async function chat(message, opts = {}) {
         required: ['title', 'description'],
       },
     },
+    {
+      name: 'start_coding',
+      description: 'Start an autonomous coding task. Wall-E will plan the implementation, execute subtasks via Claude Code, run tests, review code, and commit. Use when the user asks you to build, fix, add, or refactor something in a codebase.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          request: { type: 'string', description: 'What to build, fix, or change — the user\'s request in their own words' },
+          cwd: { type: 'string', description: 'Project directory path. Defaults to the current workspace.' },
+          delivery: { type: 'string', enum: ['commit', 'push', 'pr'], description: 'What to do after completion. Default: commit (local only)' },
+        },
+        required: ['request'],
+      },
+    },
     {
       name: 'list_tasks',
       description: 'List current tasks and their status.',
@@ -199,7 +222,20 @@ async function chat(message, opts = {}) {
       return { acknowledged: true };
     }
     if (name === 'run_skill') {
-      const skill = brain.getSkillByName(input.skill_name);
+      // Check bundled/user skills first (script-based), then DB skills (agent-based)
+      const { findSkill } = require('./skills/skill-loader');
+      const bundledSkill = findSkill(input.skill_name);
+      if (bundledSkill && bundledSkill.execution === 'script') {
+        try {
+          const { executeSkill } = require('./loops/tasks');
+          const fakeTaskId = `chat-${Date.now()}`;
+          const result = await executeSkill(fakeTaskId, { id: fakeTaskId, skill: input.skill_name, title: bundledSkill.name });
+          return { success: true, output: result.slice(0, 5000) };
+        } catch (err) {
+          return { error: err.message };
+        }
+      }
+      const skill = bundledSkill || brain.getSkillByName(input.skill_name);
       if (!skill) return { error: `Skill "${input.skill_name}" not found` };
       try {
         const { runSkill } = require('./skills/skill-executor');
@@ -409,6 +445,29 @@ async function chat(message, opts = {}) {
       });
       return { created: true, id: result.id, title: input.title, status: 'pending', due_at: input.due_at || 'immediate' };
     }
+    if (name === 'start_coding') {
+      ensureBrainInit();
+      const result = brain.insertTask({
+        title: input.request.slice(0, 100),
+        description: `Coding request: ${input.request}`,
+        priority: 'normal',
+        type: 'once',
+        execution: 'skill',
+        skill: 'coding-agent',
+        skill_config: JSON.stringify({
+          request: input.request,
+          cwd: input.cwd || getCodingDefaultCwd(),
+          options: { delivery: input.delivery || 'commit' },
+        }),
+        source: 'chat',
+        source_ref: opts.session_id || '',
+      });
+      return {
+        created: true,
+        task_id: result.id,
+        message: 'Coding task created. Wall-E will plan and execute autonomously. Track progress in the Tasks tab.',
+      };
+    }
     if (name === 'list_tasks') {
       const tasks = brain.listTasks({ status: input.status, limit: 20 });
       return { count: tasks.length, tasks: tasks.map(t => ({ id: t.id, title: t.title, status: t.status, priority: t.priority, due_at: t.due_at, created_at: t.created_at, result: t.result?.slice(0, 200) })) };

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

@@ -0,0 +1,252 @@
+'use strict';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execFileAsync = promisify(execFile);
+
+const IGNORED_DIRS = new Set([
+  'node_modules', '.git', '.next', 'dist', 'build', '.superpowers', '__pycache__',
+]);
+
+const MAX_FILE_CONTENT = 50 * 1024; // 50KB
+
+/**
+ * Returns file tree as newline-separated relative paths.
+ * Directories have trailing `/`. Excludes ignored dirs and dotfiles.
+ */
+async function getFileTree(cwd, maxDepth = 5) {
+  const lines = [];
+
+  async function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    // Sort for deterministic output
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const name = entry.name;
+      // Skip dotfiles and ignored dirs
+      if (name.startsWith('.')) continue;
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(name)) continue;
+        const rel = path.relative(cwd, path.join(dir, name)) + '/';
+        lines.push(rel);
+        await walk(path.join(dir, name), depth + 1);
+      } else {
+        const rel = path.relative(cwd, path.join(dir, name));
+        lines.push(rel);
+      }
+    }
+  }
+
+  await walk(cwd, 1);
+  return lines.join('\n');
+}
+
+/**
+ * Reads CLAUDE.md from project dir. Returns content or empty string.
+ */
+async function readClaudeMd(cwd) {
+  try {
+    return await fsp.readFile(path.join(cwd, 'CLAUDE.md'), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Runs `git log --oneline -N`. Returns string or empty.
+ */
+async function getGitLog(cwd, count = 20) {
+  try {
+    const { stdout } = await execFileAsync('git', ['log', '--oneline', `-${count}`], { cwd });
+    return stdout.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Detects test command from package.json or Makefile.
+ */
+async function detectTestCommand(cwd) {
+  // Check package.json
+  try {
+    const pkgRaw = await fsp.readFile(path.join(cwd, 'package.json'), 'utf8');
+    const pkg = JSON.parse(pkgRaw);
+    if (pkg.scripts && pkg.scripts.test) {
+      return 'npm test';
+    }
+  } catch {
+    // no package.json or invalid
+  }
+
+  // Check Makefile
+  try {
+    const makefile = await fsp.readFile(path.join(cwd, 'Makefile'), 'utf8');
+    if (/^test:/m.test(makefile)) {
+      return 'make test';
+    }
+  } catch {
+    // no Makefile
+  }
+
+  return null;
+}
+
+/**
+ * Splits request into keywords, scores files by keyword matches in filename,
+ * reads top matches. Returns { filename: content } map.
+ */
+async function findRelevantFiles(cwd, request, maxFiles = 10, existingTree = null) {
+  const keywords = request
+    .toLowerCase()
+    .split(/[\s,.\-_/]+/)
+    .filter(w => w.length > 2);
+
+  if (keywords.length === 0) return {};
+
+  // Reuse existing tree if provided, otherwise fetch
+  const tree = existingTree || await getFileTree(cwd);
+  const files = tree.split('\n').filter(f => f && !f.endsWith('/'));
+
+  // Score each file
+  const scored = files.map(f => {
+    const lower = f.toLowerCase();
+    let score = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) score++;
+    }
+    return { file: f, score };
+  });
+
+  // Filter and sort
+  const matches = scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxFiles);
+
+  const result = {};
+  for (const { file } of matches) {
+    try {
+      let content = await fsp.readFile(path.join(cwd, file), 'utf8');
+      if (content.length > MAX_FILE_CONTENT) {
+        content = content.slice(0, MAX_FILE_CONTENT);
+      }
+      result[file] = content;
+    } catch {
+      // skip unreadable files
+    }
+  }
+  return result;
+}
+
+/**
+ * Search brain knowledge base for relevant context.
+ * Uses findKnowledge (SQL LIKE) since there's no FTS on memories.
+ */
+function searchBrain(brain, request, limit = 10) {
+  if (!brain || typeof brain.findKnowledge !== 'function') return [];
+  try {
+    // Extract meaningful keywords from the request
+    const keywords = request
+      .toLowerCase()
+      .split(/[\s,.\-_/]+/)
+      .filter(w => w.length > 3);
+    if (keywords.length === 0) return [];
+
+    // Search knowledge by subject for each keyword, deduplicate
+    const seen = new Set();
+    const results = [];
+    for (const kw of keywords.slice(0, 5)) {
+      const found = brain.findKnowledge({ subject: kw, status: 'active' });
+      for (const item of found) {
+        if (!seen.has(item.id) && results.length < limit) {
+          seen.add(item.id);
+          results.push(item);
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * If mcpClient provided, list tools, find search-type tools, call up to 3.
+ * Return [{ tool, result }]. Otherwise return [].
+ */
+async function queryMcp(mcpClient, request) {
+  if (!mcpClient || typeof mcpClient.listTools !== 'function') return [];
+  try {
+    const tools = await mcpClient.listTools();
+    const searchTools = tools.filter(t => {
+      const name = (t.name || '').toLowerCase();
+      const desc = (t.description || '').toLowerCase();
+      return name.includes('search') || name.includes('query') || name.includes('find')
+        || desc.includes('search') || desc.includes('query') || desc.includes('find');
+    });
+
+    const selected = searchTools.slice(0, 3);
+    const settled = await Promise.allSettled(
+      selected.map(tool =>
+        mcpClient.callTool(tool.name, { query: request })
+          .then(result => ({ tool: tool.name, result }))
+      )
+    );
+    return settled
+      .filter(s => s.status === 'fulfilled')
+      .map(s => s.value);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Calls all context-gathering functions in parallel.
+ * Returns combined context object.
+ */
+async function assembleContext(request, cwd, { brain, mcpClient } = {}) {
+  // Gather independent data in parallel (file tree fetched once, reused for relevantFiles)
+  const [fileTree, claudeMd, gitLog, testCommand, brainMemories, mcpResults] =
+    await Promise.all([
+      getFileTree(cwd),
+      readClaudeMd(cwd),
+      getGitLog(cwd),
+      detectTestCommand(cwd),
+      Promise.resolve(searchBrain(brain, request)),
+      queryMcp(mcpClient, request),
+    ]);
+
+  // Pass fileTree to avoid re-traversal
+  const relevantFiles = await findRelevantFiles(cwd, request, 10, fileTree);
+
+  return {
+    fileTree,
+    claudeMd,
+    gitLog,
+    testCommand,
+    relevantFiles,
+    brainMemories,
+    mcpResults,
+  };
+}
+
+module.exports = {
+  getFileTree,
+  readClaudeMd,
+  getGitLog,
+  detectTestCommand,
+  findRelevantFiles,
+  searchBrain,
+  queryMcp,
+  assembleContext,
+};