create-walle 0.9.3 → 0.9.4

package/template/wall-e/skills/skill-validator.js

@@ -0,0 +1,73 @@
+'use strict';
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Validate a skill's `requires` field before execution.
+ * Checks: bins (command availability), env (environment variables), mcp (MCP server configs).
+ * Returns { valid: boolean, missing: [{ type, name, suggestion }] }
+ */
+function validateSkillRequirements(skill) {
+  const requires = skill.requires || {};
+  const missing = [];
+
+  // Check required binaries
+  if (requires.bins) {
+    const bins = Array.isArray(requires.bins) ? requires.bins : [requires.bins];
+    for (const bin of bins) {
+      try {
+        execFileSync('which', [bin], { encoding: 'utf8', stdio: 'pipe' });
+      } catch {
+        missing.push({ type: 'bin', name: bin, suggestion: `Install ${bin} or add it to PATH` });
+      }
+    }
+  }
+
+  // Check required environment variables
+  if (requires.env) {
+    const envVars = Array.isArray(requires.env) ? requires.env : [requires.env];
+    for (const envVar of envVars) {
+      if (!process.env[envVar]) {
+        missing.push({ type: 'env', name: envVar, suggestion: `Set ${envVar} in .env or environment` });
+      }
+    }
+  }
+
+  // Check required MCP servers
+  if (requires.mcp) {
+    const mcpServers = Array.isArray(requires.mcp) ? requires.mcp : [requires.mcp];
+    const availableMcp = getAvailableMcpServers();
+    for (const server of mcpServers) {
+      if (!availableMcp.has(server)) {
+        missing.push({ type: 'mcp', name: server, suggestion: `Configure MCP server "${server}" in Claude Code settings` });
+      }
+    }
+  }
+
+  return { valid: missing.length === 0, missing };
+}
+
+/**
+ * Get set of available MCP server names from Claude Code config.
+ */
+function getAvailableMcpServers() {
+  const servers = new Set();
+  try {
+    const fs = require('fs');
+    const configPaths = [
+      path.join(process.env.HOME || '', '.claude', 'claude_desktop_config.json'),
+      path.join(process.env.HOME || '', '.config', 'claude', 'claude_desktop_config.json'),
+    ];
+    for (const cp of configPaths) {
+      try {
+        const config = JSON.parse(fs.readFileSync(cp, 'utf8'));
+        if (config.mcpServers) {
+          Object.keys(config.mcpServers).forEach(k => servers.add(k));
+        }
+      } catch {}
+    }
+  } catch {}
+  return servers;
+}
+
+module.exports = { validateSkillRequirements };

package/template/wall-e/tests/brain.test.js

@@ -40,17 +40,17 @@ describe('Brain DB Schema and Init', () => {
     assert.equal(row, 1);
   });
 
-  it('has all 22 tables', () => {
+  it('has all 24 tables', () => {
     const db = brain.getDb();
     const tables = db.prepare(
       "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
     ).all().map(r => r.name);
 
     const expected = [
-      'agent_actions', 'agent_exchanges', 'brain_metadata', 'briefing_items', 'chat_messages', 'code_identity', 'current_state',
+      'agent_actions', 'agent_exchanges', 'brain_metadata', 'briefing_items', 'chat_branches', 'chat_messages', 'code_identity', 'current_state',
       'daily_summaries', 'domain_confidence', 'initiative_log', 'knowledge', 'loop_checkpoints', 'memories',
       'owner', 'patterns', 'pending_questions', 'people', 'personas',
-      'sessions', 'skill_executions', 'skills', 'tasks'
+      'sessions', 'skill_executions', 'skills', 'slack_threads', 'tasks'
     ].sort();
 
     assert.deepEqual(tables, expected);

package/template/wall-e/tests/coding-agent-integration.test.js

@@ -0,0 +1,240 @@
+'use strict';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
+
+const { assembleContext } = require('../coding-context');
+const {
+  buildPlanningPrompt,
+  parsePlan,
+  writeCheckpoint,
+  readCheckpoint,
+  formatReport,
+  runHeadless,
+} = require('../coding-orchestrator');
+
+describe('coding-agent integration', () => {
+  let tmpDir;
+  let originalPath;
+
+  const MOCK_CLAUDE_SCRIPT = `#!/bin/bash
+if echo "$@" | grep -q "senior engineer"; then
+  cat << 'PLAN'
+{"subtasks":[{"id":"1","title":"Add hello endpoint","prompt":"Add a /hello endpoint to server.js that returns Hello World","depends_on":[],"verify":{"test":false,"review":false},"files_hint":["server.js"]}],"branch_name":"feat/hello","estimated_scope":"small"}
+PLAN
+else
+  echo '// Added by coding agent' >> "$PWD/server.js"
+  echo '{"result":"done","is_error":false}'
+fi
+`;
+
+  const SERVER_JS = `const http = require('http');
+const server = http.createServer((req, res) => {
+  res.writeHead(200);
+  res.end('ok');
+});
+server.listen(0);
+`;
+
+  const PACKAGE_JSON = JSON.stringify({
+    name: 'test-project',
+    version: '1.0.0',
+    scripts: { test: 'echo "tests passed"' },
+  }, null, 2);
+
+  const CLAUDE_MD = '# Test\nUse node:test';
+
+  before(() => {
+    // Create temp directory with project files
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'coding-agent-integ-'));
+
+    fs.writeFileSync(path.join(tmpDir, 'CLAUDE.md'), CLAUDE_MD);
+    fs.writeFileSync(path.join(tmpDir, 'server.js'), SERVER_JS);
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), PACKAGE_JSON);
+
+    // Initialize git repo
+    execFileSync('git', ['init'], { cwd: tmpDir });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: tmpDir });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: tmpDir });
+    execFileSync('git', ['add', '.'], { cwd: tmpDir });
+    execFileSync('git', ['commit', '-m', 'init'], { cwd: tmpDir });
+
+    // Create mock claude binary
+    const mockClaudePath = path.join(tmpDir, 'claude');
+    fs.writeFileSync(mockClaudePath, MOCK_CLAUDE_SCRIPT);
+    fs.chmodSync(mockClaudePath, 0o755);
+
+    // Save original PATH
+    originalPath = process.env.PATH;
+  });
+
+  after(() => {
+    // Restore PATH
+    process.env.PATH = originalPath;
+
+    // Remove temp directory
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('assembleContext', () => {
+    it('gathers file tree, CLAUDE.md, and relevant files from temp dir', async () => {
+      const ctx = await assembleContext('server http', tmpDir);
+
+      // File tree should contain our files
+      assert.ok(ctx.fileTree.includes('server.js'), 'file tree should include server.js');
+      assert.ok(ctx.fileTree.includes('package.json'), 'file tree should include package.json');
+      assert.ok(ctx.fileTree.includes('CLAUDE.md'), 'file tree should include CLAUDE.md');
+
+      // CLAUDE.md content
+      assert.equal(ctx.claudeMd, CLAUDE_MD);
+
+      // Git log should have our init commit
+      assert.ok(ctx.gitLog.includes('init'), 'git log should include init commit');
+
+      // Test command detected from package.json
+      assert.equal(ctx.testCommand, 'npm test');
+
+      // Relevant files should match keyword "server"
+      assert.ok('server.js' in ctx.relevantFiles, 'relevant files should include server.js');
+    });
+  });
+
+  describe('buildPlanningPrompt', () => {
+    it('includes request, context sections, and JSON instruction', async () => {
+      const ctx = await assembleContext('add hello endpoint', tmpDir);
+      const prompt = buildPlanningPrompt('add hello endpoint', ctx);
+
+      assert.ok(prompt.includes('senior software engineer'), 'should mention senior engineer role');
+      assert.ok(prompt.includes('add hello endpoint'), 'should include the request');
+      assert.ok(prompt.includes('# Test'), 'should include CLAUDE.md content');
+      assert.ok(prompt.includes('server.js'), 'should include file tree');
+      assert.ok(prompt.includes('"subtasks"'), 'should include JSON schema instruction');
+      assert.ok(prompt.includes('branch_name'), 'should include branch_name in schema');
+    });
+  });
+
+  describe('parsePlan', () => {
+    it('parses valid plan JSON from text', () => {
+      const text = '{"subtasks":[{"id":"1","title":"Do thing","prompt":"Do the thing","depends_on":[],"verify":{"test":false,"review":false},"files_hint":["foo.js"]}],"branch_name":"feat/thing","estimated_scope":"small"}';
+      const plan = parsePlan(text);
+
+      assert.ok(Array.isArray(plan.subtasks));
+      assert.equal(plan.subtasks.length, 1);
+      assert.equal(plan.subtasks[0].title, 'Do thing');
+      assert.equal(plan.branch_name, 'feat/thing');
+      assert.equal(plan.estimated_scope, 'small');
+    });
+
+    it('parses plan from fenced code block', () => {
+      const text = 'Here is the plan:\n```json\n{"subtasks":[{"title":"Step 1","prompt":"Do step 1"}],"branch_name":"feat/steps","estimated_scope":"small"}\n```';
+      const plan = parsePlan(text);
+
+      assert.equal(plan.subtasks.length, 1);
+      assert.equal(plan.branch_name, 'feat/steps');
+    });
+
+    it('throws on empty output', () => {
+      assert.throws(() => parsePlan(''), /empty output/);
+    });
+
+    it('throws on output with no valid subtasks', () => {
+      assert.throws(() => parsePlan('no json here'), /no valid JSON/);
+    });
+  });
+
+  describe('writeCheckpoint / readCheckpoint', () => {
+    it('round-trips state correctly', () => {
+      const state = {
+        plan: { subtasks: [{ title: 'A' }], branch_name: 'feat/test' },
+        completed: 1,
+        session_ids: ['abc-123'],
+        budget_used: 0.5,
+        cumulative_context: 'Step 1 done',
+      };
+      const filePath = path.join(tmpDir, 'checkpoint-test.json');
+
+      writeCheckpoint(filePath, state);
+      const loaded = readCheckpoint(filePath);
+
+      assert.deepStrictEqual(loaded, state);
+
+      // Cleanup
+      fs.unlinkSync(filePath);
+    });
+  });
+
+  describe('formatReport', () => {
+    it('formats a successful report with all fields', () => {
+      const report = {
+        success: true,
+        branch: 'feat/hello',
+        commit: 'abc1234',
+        concerns: ['Minor style issue'],
+        summary: 'Added hello endpoint',
+      };
+      const formatted = formatReport(report);
+
+      assert.ok(formatted.includes('Status: SUCCESS'));
+      assert.ok(formatted.includes('Branch: feat/hello'));
+      assert.ok(formatted.includes('Commit: abc1234'));
+      assert.ok(formatted.includes('Minor style issue'));
+      assert.ok(formatted.includes('Summary: Added hello endpoint'));
+    });
+
+    it('formats a failed report with error', () => {
+      const report = {
+        success: false,
+        error: 'Budget exceeded',
+      };
+      const formatted = formatReport(report);
+
+      assert.ok(formatted.includes('Status: FAILED'));
+      assert.ok(formatted.includes('Error: Budget exceeded'));
+    });
+  });
+
+  describe('runHeadless with mock claude', () => {
+    it('runs mock claude and returns success with output', async () => {
+      // Prepend tmpDir to PATH so mock claude is found first
+      process.env.PATH = tmpDir + ':' + originalPath;
+
+      try {
+        const result = await runHeadless('implement the feature', { cwd: tmpDir, timeoutMs: 10000 });
+
+        assert.equal(result.success, true, `expected success but got exitCode=${result.exitCode}, stderr=${result.stderr}`);
+        assert.ok(result.output.includes('"result":"done"'), 'output should contain result JSON');
+        assert.ok(result.sessionId, 'should have a sessionId');
+        assert.equal(result.exitCode, 0);
+
+        // Verify the mock actually wrote to server.js
+        const serverContent = fs.readFileSync(path.join(tmpDir, 'server.js'), 'utf8');
+        assert.ok(serverContent.includes('// Added by coding agent'), 'mock should have appended comment to server.js');
+      } finally {
+        // Restore PATH
+        process.env.PATH = originalPath;
+      }
+    });
+
+    it('runs mock claude planning mode when prompt contains "senior engineer"', async () => {
+      process.env.PATH = tmpDir + ':' + originalPath;
+
+      try {
+        const result = await runHeadless('You are a senior engineer planning a task', { cwd: tmpDir, timeoutMs: 10000 });
+
+        assert.equal(result.success, true, `expected success but got exitCode=${result.exitCode}, stderr=${result.stderr}`);
+        assert.ok(result.output.includes('"subtasks"'), 'output should contain plan JSON with subtasks');
+        assert.ok(result.output.includes('feat/hello'), 'output should contain branch name');
+
+        // Verify the plan can be parsed
+        const plan = parsePlan(result.output);
+        assert.equal(plan.subtasks.length, 1);
+        assert.equal(plan.subtasks[0].title, 'Add hello endpoint');
+      } finally {
+        process.env.PATH = originalPath;
+      }
+    });
+  });
+});

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

@@ -0,0 +1,212 @@
+'use strict';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const {
+  getFileTree,
+  readClaudeMd,
+  getGitLog,
+  detectTestCommand,
+  findRelevantFiles,
+  searchBrain,
+  queryMcp,
+  assembleContext,
+} = require('../coding-context');
+
+describe('coding-context', () => {
+  let tmpDir;
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'coding-ctx-'));
+    // Create a small project structure
+    fs.mkdirSync(path.join(tmpDir, 'src'));
+    fs.mkdirSync(path.join(tmpDir, 'src', 'utils'));
+    fs.mkdirSync(path.join(tmpDir, 'node_modules'));
+    fs.mkdirSync(path.join(tmpDir, '.git'));
+    fs.mkdirSync(path.join(tmpDir, 'dist'));
+    fs.writeFileSync(path.join(tmpDir, 'src', 'index.js'), 'console.log("hello");');
+    fs.writeFileSync(path.join(tmpDir, 'src', 'utils', 'helper.js'), 'module.exports = {};');
+    fs.writeFileSync(path.join(tmpDir, 'src', 'auth-service.js'), 'module.exports = { login() {} };');
+    fs.writeFileSync(path.join(tmpDir, 'node_modules', 'foo.js'), 'ignored');
+    fs.writeFileSync(path.join(tmpDir, '.git', 'config'), 'ignored');
+    fs.writeFileSync(path.join(tmpDir, 'dist', 'bundle.js'), 'ignored');
+    fs.writeFileSync(path.join(tmpDir, 'CLAUDE.md'), '# Project Rules\nUse strict mode.');
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({
+      name: 'test-project',
+      scripts: { test: 'jest', start: 'node src/index.js' },
+    }));
+  });
+
+  after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('getFileTree', () => {
+    it('includes source files with relative paths', async () => {
+      const tree = await getFileTree(tmpDir);
+      assert.ok(tree.includes('src/'), `tree should include src/ directory: ${tree}`);
+      assert.ok(tree.includes('src/index.js'), `tree should include src/index.js: ${tree}`);
+      assert.ok(tree.includes('src/utils/helper.js'), `tree should include nested file: ${tree}`);
+    });
+
+    it('excludes node_modules, .git, and dist', async () => {
+      const tree = await getFileTree(tmpDir);
+      assert.ok(!tree.includes('node_modules'), `tree should exclude node_modules: ${tree}`);
+      assert.ok(!tree.includes('.git'), `tree should exclude .git: ${tree}`);
+      assert.ok(!tree.includes('dist'), `tree should exclude dist: ${tree}`);
+    });
+
+    it('marks directories with trailing slash', async () => {
+      const tree = await getFileTree(tmpDir);
+      const lines = tree.split('\n').filter(Boolean);
+      const srcLine = lines.find(l => l === 'src/');
+      assert.ok(srcLine, `should have src/ with trailing slash: ${tree}`);
+    });
+
+    it('respects maxDepth', async () => {
+      const tree = await getFileTree(tmpDir, 1);
+      assert.ok(tree.includes('src/'), 'should include top-level dir');
+      assert.ok(!tree.includes('src/utils/'), 'should not include deeper dirs at depth 1');
+    });
+  });
+
+  describe('readClaudeMd', () => {
+    it('reads existing CLAUDE.md', async () => {
+      const content = await readClaudeMd(tmpDir);
+      assert.ok(content.includes('# Project Rules'));
+      assert.ok(content.includes('Use strict mode.'));
+    });
+
+    it('returns empty string when CLAUDE.md missing', async () => {
+      const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'no-claude-'));
+      try {
+        const content = await readClaudeMd(emptyDir);
+        assert.equal(content, '');
+      } finally {
+        fs.rmSync(emptyDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('getGitLog', () => {
+    it('returns empty string for non-git directory', async () => {
+      const nonGit = fs.mkdtempSync(path.join(os.tmpdir(), 'no-git-'));
+      try {
+        const log = await getGitLog(nonGit);
+        assert.equal(log, '');
+      } finally {
+        fs.rmSync(nonGit, { recursive: true, force: true });
+      }
+    });
+
+    it('returns git log for a real git repo', async () => {
+      // Use the actual tools repo
+      const log = await getGitLog(process.cwd(), 5);
+      assert.ok(log.length > 0, 'should return some log output');
+      const lines = log.trim().split('\n');
+      assert.ok(lines.length <= 5, 'should respect count limit');
+    });
+  });
+
+  describe('detectTestCommand', () => {
+    it('detects npm test from package.json', async () => {
+      const cmd = await detectTestCommand(tmpDir);
+      assert.equal(cmd, 'npm test');
+    });
+
+    it('detects make test from Makefile', async () => {
+      const makeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'makefile-'));
+      try {
+        fs.writeFileSync(path.join(makeDir, 'Makefile'), 'test:\n\tpytest\n');
+        const cmd = await detectTestCommand(makeDir);
+        assert.equal(cmd, 'make test');
+      } finally {
+        fs.rmSync(makeDir, { recursive: true, force: true });
+      }
+    });
+
+    it('returns null when no test config found', async () => {
+      const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'no-test-'));
+      try {
+        const cmd = await detectTestCommand(emptyDir);
+        assert.equal(cmd, null);
+      } finally {
+        fs.rmSync(emptyDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('findRelevantFiles', () => {
+    it('finds files matching keywords in request', async () => {
+      const result = await findRelevantFiles(tmpDir, 'auth service login');
+      assert.ok('src/auth-service.js' in result, `should find auth-service.js: ${Object.keys(result)}`);
+      assert.ok(result['src/auth-service.js'].includes('login'));
+    });
+
+    it('returns empty map when no matches', async () => {
+      const result = await findRelevantFiles(tmpDir, 'zzzznonexistent');
+      assert.equal(Object.keys(result).length, 0);
+    });
+
+    it('respects maxFiles limit', async () => {
+      const result = await findRelevantFiles(tmpDir, 'js helper index auth', 1);
+      assert.ok(Object.keys(result).length <= 1);
+    });
+  });
+
+  describe('searchBrain', () => {
+    it('returns empty array when brain is null', () => {
+      const result = searchBrain(null, 'test query');
+      assert.deepEqual(result, []);
+    });
+
+    it('calls findKnowledge when brain has it', () => {
+      const fakeBrain = {
+        findKnowledge: ({ subject }) => [{ id: 1, subject, predicate: 'is', object: 'relevant', status: 'active' }],
+      };
+      const result = searchBrain(fakeBrain, 'test query coding', 5);
+      assert.ok(result.length >= 1);
+      assert.equal(result[0].id, 1);
+    });
+  });
+
+  describe('queryMcp', () => {
+    it('returns empty array when mcpClient is null', async () => {
+      const result = await queryMcp(null, 'test');
+      assert.deepEqual(result, []);
+    });
+
+    it('calls search-type tools from mcpClient', async () => {
+      const fakeMcp = {
+        listTools: async () => [
+          { name: 'search_docs', description: 'Search documentation' },
+          { name: 'deploy_app', description: 'Deploy application' },
+        ],
+        callTool: async (name, args) => ({ results: ['found'] }),
+      };
+      const result = await queryMcp(fakeMcp, 'find docs');
+      assert.ok(result.length > 0);
+      assert.equal(result[0].tool, 'search_docs');
+    });
+  });
+
+  describe('assembleContext', () => {
+    it('gathers all context in parallel', async () => {
+      const ctx = await assembleContext('auth login feature', tmpDir, {});
+      assert.ok('fileTree' in ctx);
+      assert.ok('claudeMd' in ctx);
+      assert.ok('gitLog' in ctx);
+      assert.ok('testCommand' in ctx);
+      assert.ok('relevantFiles' in ctx);
+      assert.ok('brainMemories' in ctx);
+      assert.ok('mcpResults' in ctx);
+      assert.ok(ctx.claudeMd.includes('Project Rules'));
+      assert.equal(ctx.testCommand, 'npm test');
+      assert.ok(Array.isArray(ctx.brainMemories));
+      assert.ok(Array.isArray(ctx.mcpResults));
+    });
+  });
+});