all-hands-cli 0.1.0

package/.allhands/harness/src/__tests__/e2e/hooks.test.ts

@@ -0,0 +1,427 @@
+/**
+ * E2E Tests - Hook Contracts
+ *
+ * Tests hook I/O contracts to ensure hooks behave correctly
+ * with various inputs. These tests run hooks as separate processes
+ * with mock stdin and validate their stdout JSON.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import {
+  createFixture,
+  createMilestoneFixture,
+  runContextHook,
+  runEditInject,
+  runReadEnforcer,
+  runSearchRouter,
+  runValidationHook,
+  runHook,
+  testHookContracts,
+  assertHookAllowed,
+  assertHookDenied,
+  assertHookInjectedContext,
+  assertHookContextContains,
+  assertContractsPassed,
+  type TestFixture,
+  type HookContract,
+  PYTHON_SAMPLE,
+  TYPESCRIPT_SAMPLE,
+} from '../harness/index.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Test Setup
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('Hook Contracts E2E', () => {
+  let fixture: TestFixture;
+
+  beforeAll(() => {
+    fixture = createFixture({
+      name: 'hook-contracts-test',
+      files: {
+        'src/sample.py': PYTHON_SAMPLE,
+        'src/sample.ts': TYPESCRIPT_SAMPLE,
+        'src/small.py': '# Small file\nx = 1\n',
+        '.planning/test/prompts/01.md': `---
+status: pending
+---
+
+# Task 1
+`,
+      },
+    });
+  });
+
+  afterAll(() => {
+    fixture.cleanup();
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Context Hooks - PreToolUse
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('context hooks', () => {
+    describe('edit-inject', () => {
+      it('allows Edit tool and may inject context for Python files', async () => {
+        const result = await runEditInject(
+          `${fixture.root}/src/sample.py`,
+          fixture
+        );
+        // Hook should allow the edit
+        assertHookAllowed(result);
+      });
+
+      it('allows Edit tool for TypeScript files', async () => {
+        const result = await runEditInject(
+          `${fixture.root}/src/sample.ts`,
+          fixture
+        );
+        assertHookAllowed(result);
+      });
+
+      it('allows Edit tool for non-existent files', async () => {
+        const result = await runEditInject(
+          `${fixture.root}/src/new-file.py`,
+          fixture
+        );
+        // Should allow creating new files
+        assertHookAllowed(result);
+      });
+    });
+
+    describe('search-router', () => {
+      it('allows Grep with literal pattern', async () => {
+        const result = await runSearchRouter('hello', fixture);
+        assertHookAllowed(result);
+      });
+
+      it('allows Grep with regex pattern', async () => {
+        const result = await runSearchRouter('def\\s+\\w+', fixture);
+        assertHookAllowed(result);
+      });
+
+      it('allows Grep with function search pattern', async () => {
+        const result = await runSearchRouter('function add', fixture);
+        assertHookAllowed(result);
+      });
+    });
+
+    describe('read-enforcer', () => {
+      it('allows Read for small files without interception', async () => {
+        const result = await runReadEnforcer(
+          `${fixture.root}/src/small.py`,
+          fixture
+        );
+        assertHookAllowed(result);
+      });
+
+      it('allows Read with offset/limit (explicit range)', async () => {
+        const result = await runReadEnforcer(
+          `${fixture.root}/src/sample.py`,
+          fixture,
+          { offset: 1, limit: 10 }
+        );
+        // Offset/limit reads are allowed without interception
+        assertHookAllowed(result);
+      });
+
+      it('handles Read for non-existent file', async () => {
+        const result = await runReadEnforcer(
+          `${fixture.root}/src/nonexistent.py`,
+          fixture
+        );
+        // Should allow (file not found error comes later)
+        assertHookAllowed(result);
+      });
+    });
+
+    describe('tldr-inject', () => {
+      it('handles Task tool for debugging intent', async () => {
+        const result = await runContextHook(
+          'tldr-inject',
+          {
+            tool_name: 'Task',
+            tool_input: {
+              prompt: 'Debug why the function fails',
+              description: 'Investigate bug',
+            },
+          },
+          fixture
+        );
+        // Should allow, may inject context if TLDR available
+        assertHookAllowed(result);
+      });
+
+      it('handles Task tool for dataflow intent', async () => {
+        const result = await runContextHook(
+          'tldr-inject',
+          {
+            tool_name: 'Task',
+            tool_input: {
+              prompt: 'Trace where variable x comes from',
+              description: 'Dataflow analysis',
+            },
+          },
+          fixture
+        );
+        assertHookAllowed(result);
+      });
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Validation Hooks (schema-pre hook)
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('validation hooks', () => {
+    describe('schema-pre (PreWrite validation)', () => {
+      it('runs without crashing on valid prompt', async () => {
+        const result = await runHook(
+          'validation',
+          'schema-pre',
+          {
+            tool_name: 'Write',
+            tool_input: {
+              file_path: `${fixture.root}/.planning/test/prompts/02.md`,
+              content: `---
+number: 2
+title: New Task
+type: planned
+planning_session: 1
+status: pending
+---
+
+# Tasks
+
+- New Task
+
+# Acceptance Criteria
+
+- Works
+`,
+            },
+          },
+          fixture
+        );
+        // Should complete without crashing
+        expect(result.exitCode).toBeDefined();
+      });
+
+      it('runs without crashing on non-schema file', async () => {
+        const result = await runHook(
+          'validation',
+          'schema-pre',
+          {
+            tool_name: 'Write',
+            tool_input: {
+              file_path: `${fixture.root}/src/new-file.py`,
+              content: '# New Python file\n',
+            },
+          },
+          fixture
+        );
+        expect(result.exitCode).toBeDefined();
+      });
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Contract Testing
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('contract compliance', () => {
+    const contracts: HookContract[] = [
+      {
+        name: 'edit-inject allows Python edit',
+        hookType: 'context',
+        hookName: 'edit-inject',
+        input: {
+          tool_name: 'Edit',
+          tool_input: { file_path: '/tmp/test.py', old_string: '', new_string: '' },
+        },
+        expect: {
+          success: true,
+          allowed: true,
+        },
+      },
+      {
+        name: 'search-router allows grep',
+        hookType: 'context',
+        hookName: 'search-router',
+        input: {
+          tool_name: 'Grep',
+          tool_input: { pattern: 'test' },
+        },
+        expect: {
+          success: true,
+          allowed: true,
+        },
+      },
+      {
+        name: 'read-enforcer allows small file read',
+        hookType: 'context',
+        hookName: 'read-enforcer',
+        input: {
+          tool_name: 'Read',
+          tool_input: { file_path: '/tmp/small.txt' },
+        },
+        expect: {
+          success: true,
+          allowed: true,
+        },
+      },
+    ];
+
+    it('all core contracts pass', async () => {
+      const results = await testHookContracts(contracts, fixture);
+      assertContractsPassed(results);
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Edge Cases
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('edge cases', () => {
+    it('handles empty hook input gracefully', async () => {
+      const result = await runContextHook(
+        'edit-inject',
+        {
+          tool_name: 'Edit',
+          tool_input: {},
+        },
+        fixture
+      );
+      // Should not crash
+      expect(result.exitCode).toBeDefined();
+    });
+
+    it('handles missing tool_name gracefully', async () => {
+      const result = await runContextHook(
+        'edit-inject',
+        {
+          tool_input: { file_path: '/tmp/test.py' },
+        } as any,
+        fixture
+      );
+      expect(result.exitCode).toBeDefined();
+    });
+
+    it('handles very long file paths', async () => {
+      const longPath = '/tmp/' + 'a'.repeat(200) + '.py';
+      const result = await runEditInject(longPath, fixture);
+      expect(result.exitCode).toBeDefined();
+    });
+
+    it('handles unicode in patterns', async () => {
+      const result = await runSearchRouter('函数.*定义', fixture);
+      expect(result.exitCode).toBeDefined();
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Hook Chain Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('Hook Chain E2E', () => {
+  let fixture: TestFixture;
+
+  beforeAll(() => {
+    fixture = createMilestoneFixture('hook-chain-test', 2);
+  });
+
+  afterAll(() => {
+    fixture.cleanup();
+  });
+
+  describe('search → edit chain', () => {
+    it('search-router then edit-inject work in sequence', async () => {
+      // First, search for something
+      const searchResult = await runSearchRouter('Calculator', fixture);
+      assertHookAllowed(searchResult);
+
+      // Then, edit the file
+      const editResult = await runEditInject(
+        `${fixture.root}/src/sample.py`,
+        fixture
+      );
+      assertHookAllowed(editResult);
+    });
+  });
+
+  describe('read → edit chain', () => {
+    it('read-enforcer then edit-inject work in sequence', async () => {
+      // Read a file
+      const readResult = await runReadEnforcer(
+        `${fixture.root}/src/sample.py`,
+        fixture
+      );
+      assertHookAllowed(readResult);
+
+      // Edit the file
+      const editResult = await runEditInject(
+        `${fixture.root}/src/sample.py`,
+        fixture
+      );
+      assertHookAllowed(editResult);
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Performance Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('Hook Performance E2E', () => {
+  let fixture: TestFixture;
+
+  beforeAll(() => {
+    fixture = createFixture({ name: 'hook-perf-test' });
+  });
+
+  afterAll(() => {
+    fixture.cleanup();
+  });
+
+  it('edit-inject completes within 3 seconds', async () => {
+    const result = await runEditInject(`${fixture.root}/src/test.py`, fixture);
+    expect(result.duration).toBeLessThan(3000);
+  });
+
+  it('search-router completes within 2 seconds', async () => {
+    const result = await runSearchRouter('test', fixture);
+    expect(result.duration).toBeLessThan(2000);
+  });
+
+  it('schema-pre completes within 2 seconds', async () => {
+    const result = await runHook(
+      'validation',
+      'schema-pre',
+      {
+        tool_name: 'Write',
+        tool_input: {
+          file_path: `${fixture.root}/.planning/test/prompts/01.md`,
+          content: `---
+number: 1
+title: Test
+type: planned
+planning_session: 1
+status: pending
+---
+
+# Tasks
+
+- Task
+
+# Acceptance Criteria
+
+- Works
+`,
+        },
+      },
+      fixture
+    );
+    expect(result.duration).toBeLessThan(2000);
+  });
+});

package/.allhands/harness/src/__tests__/e2e/new-initiative-routing.test.ts

@@ -0,0 +1,137 @@
+/**
+ * New Initiative Routing Integration Tests
+ *
+ * Validates:
+ * - Unified scoping flow routing (all spec types → IDEATION_SCOPING.md)
+ * - WORKFLOW_DOMAIN_PATH resolution for each spec type
+ * - buildActionItems() always-visible guarantee for new-initiative and initiative-steering
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import type { SpecType } from '../../lib/specs.js';
+import { UNIFIED_SCOPING_FLOW } from '../../commands/tui.js';
+import { buildActionItems, type ToggleState } from '../../tui/actions.js';
+import { getFlowsDirectory } from '../../lib/flows.js';
+
+/** Resolve .allhands/workflows/ relative to .allhands/flows/ */
+const workflowsDir = join(dirname(getFlowsDirectory()), 'workflows');
+
+const ALL_SPEC_TYPES: SpecType[] = [
+  'milestone',
+  'investigation',
+  'optimization',
+  'refactor',
+  'documentation',
+  'triage',
+];
+
+// ─── Task 1: Unified scoping flow routing ────────────────────────────────────
+
+describe('Unified scoping flow routing', () => {
+  it('UNIFIED_SCOPING_FLOW is IDEATION_SCOPING.md', () => {
+    expect(UNIFIED_SCOPING_FLOW).toBe('IDEATION_SCOPING.md');
+  });
+
+  it('unified scoping flow file exists on disk', () => {
+    const flowsDir = getFlowsDirectory();
+    const fullPath = join(flowsDir, UNIFIED_SCOPING_FLOW);
+    expect(existsSync(fullPath)).toBe(true);
+  });
+
+  it.each(ALL_SPEC_TYPES)(
+    '%s has a corresponding workflow domain config file on disk',
+    (specType) => {
+      const domainPath = join(workflowsDir, `${specType}.md`);
+      expect(existsSync(domainPath)).toBe(true);
+    }
+  );
+});
+
+// ─── Task 2: WORKFLOW_DOMAIN_PATH resolution per spec type ───────────────────
+
+describe('WORKFLOW_DOMAIN_PATH resolution', () => {
+  it.each(ALL_SPEC_TYPES)(
+    '%s workflow domain config exists at .allhands/workflows/%s.md',
+    (specType) => {
+      const domainPath = join(workflowsDir, `${specType}.md`);
+      expect(existsSync(domainPath)).toBe(true);
+    }
+  );
+
+  it('initiative-steering action is present in buildActionItems', () => {
+    const items = buildActionItems({
+      loopEnabled: false,
+      parallelEnabled: false,
+      prActionState: 'create-pr',
+    });
+    const steering = items.find((item) => item.id === 'initiative-steering');
+    expect(steering).toBeDefined();
+    expect(steering!.type).toBe('action');
+    expect(steering!.key).toBe('=');
+  });
+});
+
+// ─── Task 3: buildActionItems() always-visible guarantee ─────────────────────
+
+describe('buildActionItems always-visible guarantee', () => {
+  const prActionStates = ['create-pr', 'awaiting-review', 'rerun-pr-review'] as const;
+
+  const toggleCombinations: ToggleState[] = [];
+  for (const loop of [true, false]) {
+    for (const parallel of [true, false]) {
+      for (const pr of prActionStates) {
+        toggleCombinations.push({
+          loopEnabled: loop,
+          parallelEnabled: parallel,
+          prActionState: pr,
+        });
+      }
+    }
+  }
+
+  it.each(toggleCombinations)(
+    'new-initiative is present with loop=$loopEnabled, parallel=$parallelEnabled, pr=$prActionState',
+    (toggleState) => {
+      const items = buildActionItems(toggleState);
+      const newInitiative = items.find((item) => item.id === 'new-initiative');
+      expect(newInitiative).toBeDefined();
+      expect(newInitiative!.type).toBe('action');
+    }
+  );
+
+  it.each(toggleCombinations)(
+    'initiative-steering is present with loop=$loopEnabled, parallel=$parallelEnabled, pr=$prActionState',
+    (toggleState) => {
+      const items = buildActionItems(toggleState);
+      const steering = items.find((item) => item.id === 'initiative-steering');
+      expect(steering).toBeDefined();
+      expect(steering!.type).toBe('action');
+      expect(steering!.key).toBe('=');
+    }
+  );
+
+  it('no action items have hidden or disabled properties', () => {
+    const items = buildActionItems({
+      loopEnabled: false,
+      parallelEnabled: false,
+      prActionState: 'create-pr',
+    });
+
+    for (const item of items) {
+      // ActionItem interface at actions.ts:21 has: id, label, key?, type, highlight?, checked?
+      // No hidden or disabled fields exist
+      expect(item).not.toHaveProperty('hidden');
+      expect(item).not.toHaveProperty('disabled');
+    }
+  });
+
+  it('returns consistent action count across all toggle states', () => {
+    const counts = toggleCombinations.map(
+      (ts) => buildActionItems(ts).length
+    );
+    const uniqueCounts = new Set(counts);
+    expect(uniqueCounts.size).toBe(1);
+  });
+});

package/.allhands/harness/src/__tests__/e2e/run-e2e.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env tsx
+/**
+ * E2E Test Runner
+ *
+ * Standalone script to run E2E tests with proper setup.
+ * Can be run directly: npx tsx src/__tests__/e2e/run-e2e.ts
+ *
+ * Options:
+ *   --verbose    Show detailed output
+ *   --filter     Filter tests by name pattern
+ *   --list       List available test suites without running
+ */
+
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readdirSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const harnessRoot = join(__dirname, '..', '..', '..');
+
+interface RunOptions {
+  verbose: boolean;
+  filter?: string;
+  list: boolean;
+}
+
+function parseArgs(): RunOptions {
+  const args = process.argv.slice(2);
+  return {
+    verbose: args.includes('--verbose') || args.includes('-v'),
+    filter: args.find((a) => a.startsWith('--filter='))?.split('=')[1],
+    list: args.includes('--list'),
+  };
+}
+
+function listTestSuites(): void {
+  console.log('\nAvailable E2E Test Suites:\n');
+
+  const e2eDir = __dirname;
+  const files = readdirSync(e2eDir).filter((f) => f.endsWith('.test.ts'));
+
+  for (const file of files) {
+    console.log(`  • ${file.replace('.test.ts', '')}`);
+  }
+
+  console.log('\nRun with: npm run test:e2e');
+  console.log('Or:       npx vitest run src/__tests__/e2e/');
+  console.log('Filter:   npx vitest run src/__tests__/e2e/ -t "pattern"');
+}
+
+async function runTests(options: RunOptions): Promise<number> {
+  console.log('\n🧪 Running E2E Tests\n');
+  console.log('━'.repeat(60));
+
+  const args = ['vitest', 'run', 'src/__tests__/e2e/'];
+
+  if (options.verbose) {
+    args.push('--reporter=verbose');
+  }
+
+  if (options.filter) {
+    args.push('-t', options.filter);
+  }
+
+  return new Promise((resolve) => {
+    const child = spawn('npx', args, {
+      cwd: harnessRoot,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        // Ensure consistent output
+        FORCE_COLOR: '1',
+      },
+    });
+
+    child.on('close', (code) => {
+      console.log('\n' + '━'.repeat(60));
+      if (code === 0) {
+        console.log('✅ All E2E tests passed\n');
+      } else {
+        console.log(`❌ E2E tests failed with code ${code}\n`);
+      }
+      resolve(code ?? 1);
+    });
+
+    child.on('error', (err) => {
+      console.error('Failed to run tests:', err);
+      resolve(1);
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  const options = parseArgs();
+
+  if (options.list) {
+    listTestSuites();
+    process.exit(0);
+  }
+
+  const exitCode = await runTests(options);
+  process.exit(exitCode);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});