create-walle 0.9.3 → 0.9.4

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

@@ -0,0 +1,303 @@
+'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 {
+  getDefaultConfig,
+  buildPlanningPrompt,
+  parsePlan,
+  buildSubtaskPrompt,
+  writeCheckpoint,
+  readCheckpoint,
+  formatReport,
+} = require('../coding-orchestrator');
+
+describe('coding-orchestrator', () => {
+  let tmpDir;
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'coding-orch-'));
+  });
+
+  after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('getDefaultConfig', () => {
+    it('returns object with all expected keys and correct defaults', () => {
+      const cfg = getDefaultConfig();
+      assert.equal(cfg.delivery, 'commit');
+      assert.equal(cfg.max_retries, 3);
+      assert.equal(cfg.max_subtasks, 15);
+      assert.equal(cfg.guardrail_threshold, 10);
+      assert.equal(cfg.subtask_timeout_ms, 300000);
+      assert.equal(cfg.subtask_budget_usd, 0.50);
+      assert.equal(cfg.total_budget_usd, 5.00);
+      assert.equal(cfg.test_command, 'auto');
+      assert.equal(cfg.review, true);
+    });
+
+    it('returns a new object each time', () => {
+      const a = getDefaultConfig();
+      const b = getDefaultConfig();
+      assert.notStrictEqual(a, b);
+    });
+  });
+
+  describe('buildPlanningPrompt', () => {
+    it('includes request text', () => {
+      const prompt = buildPlanningPrompt('Add user authentication', {
+        claudeMd: '# Rules',
+        fileTree: 'src/\nsrc/index.js',
+        gitLog: 'abc123 initial commit',
+        relevantFiles: { 'src/index.js': 'console.log("hi")' },
+        brainMemories: [{ content: 'User prefers TypeScript' }],
+        mcpResults: [{ tool: 'search', result: 'spec doc' }],
+        testCommand: 'npm test',
+      });
+      assert.ok(prompt.includes('Add user authentication'));
+    });
+
+    it('includes CLAUDE.md conventions section', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '# My Conventions\nUse strict mode.',
+        fileTree: '',
+        gitLog: '',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: null,
+      });
+      assert.ok(prompt.includes('My Conventions'));
+    });
+
+    it('includes file tree section', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '',
+        fileTree: 'src/\nsrc/app.js',
+        gitLog: '',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: null,
+      });
+      assert.ok(prompt.includes('src/app.js'));
+    });
+
+    it('includes JSON output instruction', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '',
+        fileTree: '',
+        gitLog: '',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: null,
+      });
+      assert.ok(prompt.includes('subtasks'));
+      assert.ok(prompt.includes('JSON'));
+    });
+
+    it('includes recent commits when present', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '',
+        fileTree: '',
+        gitLog: 'abc123 feat: added login\ndef456 fix: typo',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: null,
+      });
+      assert.ok(prompt.includes('abc123 feat: added login'));
+    });
+
+    it('includes test command when present', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '',
+        fileTree: '',
+        gitLog: '',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: 'npm test',
+      });
+      assert.ok(prompt.includes('npm test'));
+    });
+
+    it('respects options for max_subtasks', () => {
+      const prompt = buildPlanningPrompt('Fix bug', {
+        claudeMd: '',
+        fileTree: '',
+        gitLog: '',
+        relevantFiles: {},
+        brainMemories: [],
+        mcpResults: [],
+        testCommand: null,
+      }, { max_subtasks: 5 });
+      assert.ok(prompt.includes('5'));
+    });
+  });
+
+  describe('parsePlan', () => {
+    it('parses valid plan JSON from text', () => {
+      const output = `Here is the plan:
+\`\`\`json
+{
+  "subtasks": [
+    { "title": "Create auth module", "prompt": "Create src/auth.js with login/logout" },
+    { "title": "Add tests", "prompt": "Write tests for auth module" }
+  ],
+  "branch_name": "feat/auth",
+  "estimated_scope": "medium"
+}
+\`\`\`
+That's the plan.`;
+      const plan = parsePlan(output);
+      assert.equal(plan.subtasks.length, 2);
+      assert.equal(plan.subtasks[0].title, 'Create auth module');
+      assert.equal(plan.branch_name, 'feat/auth');
+      assert.equal(plan.estimated_scope, 'medium');
+    });
+
+    it('parses plan without code fences', () => {
+      const output = `{"subtasks": [{"title": "Fix bug", "prompt": "Fix the null check"}], "branch_name": "fix/null", "estimated_scope": "small"}`;
+      const plan = parsePlan(output);
+      assert.equal(plan.subtasks.length, 1);
+      assert.equal(plan.branch_name, 'fix/null');
+    });
+
+    it('throws on output with no JSON', () => {
+      assert.throws(() => parsePlan('No JSON here at all'), /Failed to parse plan/);
+    });
+
+    it('throws on empty subtasks array', () => {
+      assert.throws(
+        () => parsePlan('{"subtasks": [], "branch_name": "x"}'),
+        /Failed to parse plan/,
+      );
+    });
+
+    it('throws on missing subtasks key', () => {
+      assert.throws(
+        () => parsePlan('{"branch_name": "x", "tasks": []}'),
+        /Failed to parse plan/,
+      );
+    });
+
+    it('throws on empty input', () => {
+      assert.throws(() => parsePlan(''), /Failed to parse plan/);
+    });
+  });
+
+  describe('buildSubtaskPrompt', () => {
+    it('includes subtask title and prompt', () => {
+      const prompt = buildSubtaskPrompt(
+        { title: 'Create auth module', prompt: 'Build src/auth.js' },
+        'Previous step created src/utils.js',
+        '# Rules\nUse strict.',
+      );
+      assert.ok(prompt.includes('Create auth module'));
+      assert.ok(prompt.includes('Build src/auth.js'));
+    });
+
+    it('includes cumulative context', () => {
+      const prompt = buildSubtaskPrompt(
+        { title: 'Step 2', prompt: 'Do something' },
+        'Step 1 created foo.js and bar.js',
+        '',
+      );
+      assert.ok(prompt.includes('Step 1 created foo.js and bar.js'));
+    });
+
+    it('includes CLAUDE.md conventions', () => {
+      const prompt = buildSubtaskPrompt(
+        { title: 'Step 1', prompt: 'Do something' },
+        '',
+        '# Conventions\nAlways use ESM imports.',
+      );
+      assert.ok(prompt.includes('Always use ESM imports'));
+    });
+
+    it('handles empty cumulative context', () => {
+      const prompt = buildSubtaskPrompt(
+        { title: 'Step 1', prompt: 'First task' },
+        '',
+        '# Rules',
+      );
+      assert.ok(prompt.includes('First task'));
+    });
+  });
+
+  describe('writeCheckpoint / readCheckpoint', () => {
+    it('round-trips state through file', () => {
+      const filePath = path.join(tmpDir, 'checkpoint.json');
+      const state = {
+        plan: { subtasks: [{ title: 'A' }] },
+        completed: 1,
+        session_ids: ['abc-123'],
+        budget_used: 0.50,
+      };
+      writeCheckpoint(filePath, state);
+      const loaded = readCheckpoint(filePath);
+      assert.deepStrictEqual(loaded, state);
+    });
+
+    it('overwrites existing checkpoint', () => {
+      const filePath = path.join(tmpDir, 'checkpoint2.json');
+      writeCheckpoint(filePath, { step: 1 });
+      writeCheckpoint(filePath, { step: 2 });
+      const loaded = readCheckpoint(filePath);
+      assert.equal(loaded.step, 2);
+    });
+
+    it('readCheckpoint throws on missing file', () => {
+      assert.throws(() => readCheckpoint(path.join(tmpDir, 'nonexistent.json')));
+    });
+  });
+
+  describe('formatReport', () => {
+    it('formats report with status, branch, commit', () => {
+      const text = formatReport({
+        success: true,
+        branch: 'feat/auth',
+        commit: 'abc1234',
+        concerns: [],
+      });
+      assert.ok(text.includes('feat/auth'));
+      assert.ok(text.includes('abc1234'));
+      assert.ok(/success/i.test(text));
+    });
+
+    it('formats report with concerns', () => {
+      const text = formatReport({
+        success: true,
+        branch: 'feat/x',
+        commit: 'def5678',
+        concerns: ['Missing error handling', 'No integration tests'],
+      });
+      assert.ok(text.includes('Missing error handling'));
+      assert.ok(text.includes('No integration tests'));
+    });
+
+    it('formats failed report', () => {
+      const text = formatReport({
+        success: false,
+        branch: 'fix/bug',
+        commit: null,
+        concerns: ['Build failed'],
+        error: 'Tests did not pass after 3 retries',
+      });
+      assert.ok(/fail/i.test(text));
+      assert.ok(text.includes('Tests did not pass'));
+    });
+
+    it('handles missing optional fields', () => {
+      const text = formatReport({ success: true });
+      assert.ok(/success/i.test(text));
+      assert.ok(typeof text === 'string');
+    });
+  });
+});

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

@@ -0,0 +1,141 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  buildSubtaskReviewPrompt,
+  buildFinalReviewPrompt,
+  parseVerdict,
+} = require('../coding-review');
+
+describe('coding-review', () => {
+  describe('buildSubtaskReviewPrompt', () => {
+    it('includes subtask title and prompt in the output', () => {
+      const subtask = { title: 'Add login endpoint', prompt: 'Create POST /login that validates credentials' };
+      const diff = '+ app.post("/login", handler);';
+      const result = buildSubtaskReviewPrompt(subtask, diff);
+
+      assert.ok(result.includes('Add login endpoint'), 'should include subtask title');
+      assert.ok(result.includes('Create POST /login that validates credentials'), 'should include subtask prompt');
+    });
+
+    it('includes the diff content', () => {
+      const subtask = { title: 'Fix bug', prompt: 'Fix the null check' };
+      const diff = '- if (x) {\n+ if (x != null) {';
+      const result = buildSubtaskReviewPrompt(subtask, diff);
+
+      assert.ok(result.includes(diff), 'should include the diff');
+    });
+
+    it('asks for JSON reply', () => {
+      const subtask = { title: 'Task', prompt: 'Do something' };
+      const diff = '+ code';
+      const result = buildSubtaskReviewPrompt(subtask, diff);
+
+      assert.ok(result.includes('Reply with JSON'), 'should ask for JSON reply');
+    });
+
+    it('mentions pass, issues, and severity in expected output format', () => {
+      const subtask = { title: 'Task', prompt: 'Do something' };
+      const diff = '+ code';
+      const result = buildSubtaskReviewPrompt(subtask, diff);
+
+      assert.ok(result.includes('pass'), 'should mention pass field');
+      assert.ok(result.includes('issues'), 'should mention issues field');
+      assert.ok(result.includes('severity'), 'should mention severity field');
+    });
+  });
+
+  describe('buildFinalReviewPrompt', () => {
+    it('includes the original request', () => {
+      const request = 'Build a REST API for user management';
+      const diff = '+ const express = require("express");';
+      const result = buildFinalReviewPrompt(request, diff);
+
+      assert.ok(result.includes(request), 'should include the original request');
+    });
+
+    it('includes the diff', () => {
+      const request = 'Build something';
+      const diff = '+ new code line\n- old code line';
+      const result = buildFinalReviewPrompt(request, diff);
+
+      assert.ok(result.includes(diff), 'should include the diff');
+    });
+
+    it('mentions cross-file consistency', () => {
+      const result = buildFinalReviewPrompt('request', 'diff');
+
+      assert.ok(
+        result.toLowerCase().includes('cross-file consistency'),
+        'should mention cross-file consistency'
+      );
+    });
+
+    it('asks for JSON reply with summary field', () => {
+      const result = buildFinalReviewPrompt('request', 'diff');
+
+      assert.ok(result.includes('Reply with JSON'), 'should ask for JSON reply');
+      assert.ok(result.includes('summary'), 'should mention summary field');
+    });
+  });
+
+  describe('parseVerdict', () => {
+    it('parses valid JSON from mixed text', () => {
+      const text = 'Here is my review:\n\n```json\n{"pass": true, "issues": [], "severity": "minor"}\n```\nDone.';
+      const result = parseVerdict(text);
+
+      assert.strictEqual(result.pass, true);
+      assert.deepStrictEqual(result.issues, []);
+      assert.strictEqual(result.severity, 'minor');
+    });
+
+    it('parses JSON without code fences', () => {
+      const text = 'The code looks good. {"pass": true, "issues": [], "severity": "minor"} That is all.';
+      const result = parseVerdict(text);
+
+      assert.strictEqual(result.pass, true);
+    });
+
+    it('parses a failing verdict with issues', () => {
+      const text = '{"pass": false, "issues": ["Missing input validation", "SQL injection risk"], "severity": "blocker"}';
+      const result = parseVerdict(text);
+
+      assert.strictEqual(result.pass, false);
+      assert.strictEqual(result.issues.length, 2);
+      assert.strictEqual(result.severity, 'blocker');
+    });
+
+    it('parses verdict with summary field', () => {
+      const text = '{"pass": true, "issues": [], "severity": "minor", "summary": "All good"}';
+      const result = parseVerdict(text);
+
+      assert.strictEqual(result.summary, 'All good');
+    });
+
+    it('returns blocker on unparseable text', () => {
+      const result = parseVerdict('No JSON here at all');
+
+      assert.strictEqual(result.pass, false);
+      assert.strictEqual(result.severity, 'blocker');
+      assert.ok(result.issues.length > 0, 'should have at least one issue');
+      assert.ok(result.issues[0].includes('parse'), 'should mention parse failure');
+    });
+
+    it('returns blocker on empty input', () => {
+      const result = parseVerdict('');
+
+      assert.strictEqual(result.pass, false);
+      assert.strictEqual(result.severity, 'blocker');
+    });
+
+    it('ignores JSON objects without a pass field', () => {
+      const text = '{"foo": "bar"} and then {"pass": false, "issues": ["bug"], "severity": "major"}';
+      const result = parseVerdict(text);
+
+      assert.strictEqual(result.pass, false);
+      assert.deepStrictEqual(result.issues, ['bug']);
+      assert.strictEqual(result.severity, 'major');
+    });
+  });
+});