claude-code-swarm 0.3.4 → 0.3.6

package/references/opentasks/tests/e2e/helpers/fixtures.ts

@@ -0,0 +1,236 @@
+/**
+ * E2E Test Fixtures
+ *
+ * Reusable fixture helpers for creating test data.
+ * These generate unique names and set up common data structures.
+ */
+
+import type { TestAgent } from './test-agent.js'
+import type { ProviderNode } from '../../../src/providers/types.js'
+
+// Counter for unique names
+let fixtureCounter = 0
+
+/**
+ * Generate a unique name for a fixture
+ */
+function uniqueName(prefix: string, name?: string): string {
+  fixtureCounter++
+  const timestamp = Date.now()
+  return name ? `${prefix}: ${name} (${timestamp}-${fixtureCounter})` : `${prefix} ${timestamp}-${fixtureCounter}`
+}
+
+/**
+ * Reset the fixture counter (useful for test isolation)
+ */
+export function resetFixtureCounter(): void {
+  fixtureCounter = 0
+}
+
+/**
+ * Create a test context with a unique name
+ *
+ * @param agent - TestAgent with provider configured
+ * @param name - Optional name suffix
+ * @param options - Optional additional context options
+ * @returns Created ProviderNode
+ *
+ * @example
+ * ```typescript
+ * const context = await createTestContext(agent, 'Auth Feature')
+ * // Creates context titled "Context: Auth Feature (1706536800000-1)"
+ * ```
+ */
+export async function createTestContext(
+  agent: TestAgent,
+  name?: string,
+  options?: { content?: string; priority?: number }
+): Promise<ProviderNode> {
+  return agent.createContext(uniqueName('Context', name), options)
+}
+
+/**
+ * Create a test task with a unique name
+ *
+ * @param agent - TestAgent with provider configured
+ * @param name - Optional name suffix
+ * @param options - Optional additional task options
+ * @returns Created ProviderNode
+ *
+ * @example
+ * ```typescript
+ * const task = await createTestTask(agent, 'Implement login')
+ * // Creates task titled "Task: Implement login (1706536800000-2)"
+ * ```
+ */
+export async function createTestTask(
+  agent: TestAgent,
+  name?: string,
+  options?: { description?: string; status?: string; priority?: number }
+): Promise<ProviderNode> {
+  return agent.createTask(uniqueName('Task', name), options)
+}
+
+/**
+ * Create a chain of blocking tasks: A blocks B blocks C...
+ *
+ * @param agent - TestAgent with provider configured
+ * @param count - Number of tasks in the chain
+ * @returns Array of ProviderNodes in order [A, B, C, ...]
+ *
+ * @example
+ * ```typescript
+ * const [a, b, c] = await createBlockingChain(agent, 3)
+ * // a blocks b, b blocks c
+ * // Only 'a' should be ready initially
+ * ```
+ */
+export async function createBlockingChain(
+  agent: TestAgent,
+  count: number
+): Promise<ProviderNode[]> {
+  if (count < 1) {
+    throw new Error('createBlockingChain requires count >= 1')
+  }
+
+  const tasks: ProviderNode[] = []
+
+  // Create all tasks first
+  for (let i = 0; i < count; i++) {
+    const task = await createTestTask(agent, `Chain ${i + 1}`)
+    tasks.push(task)
+  }
+
+  // Create blocking edges: 0 blocks 1, 1 blocks 2, etc.
+  for (let i = 0; i < count - 1; i++) {
+    await agent.blocks(tasks[i].id, tasks[i + 1].id)
+  }
+
+  return tasks
+}
+
+/**
+ * Diamond dependency result
+ */
+export interface DiamondDependency {
+  /** Top of diamond (no blockers) */
+  top: ProviderNode
+  /** Left branch (blocked by top) */
+  left: ProviderNode
+  /** Right branch (blocked by top) */
+  right: ProviderNode
+  /** Bottom (blocked by left and right) */
+  bottom: ProviderNode
+}
+
+/**
+ * Create a diamond dependency structure
+ *
+ * ```
+ *       top
+ *      /   \
+ *   left   right
+ *      \   /
+ *      bottom
+ * ```
+ *
+ * @param agent - TestAgent with provider configured
+ * @returns Object with top, left, right, bottom nodes
+ *
+ * @example
+ * ```typescript
+ * const { top, left, right, bottom } = await createDiamondDependency(agent)
+ * // top is ready
+ * // left and right are blocked by top
+ * // bottom is blocked by both left and right
+ * ```
+ */
+export async function createDiamondDependency(
+  agent: TestAgent
+): Promise<DiamondDependency> {
+  // Create all nodes
+  const top = await createTestTask(agent, 'Diamond Top')
+  const left = await createTestTask(agent, 'Diamond Left')
+  const right = await createTestTask(agent, 'Diamond Right')
+  const bottom = await createTestTask(agent, 'Diamond Bottom')
+
+  // Create edges
+  await agent.blocks(top.id, left.id)
+  await agent.blocks(top.id, right.id)
+  await agent.blocks(left.id, bottom.id)
+  await agent.blocks(right.id, bottom.id)
+
+  return { top, left, right, bottom }
+}
+
+/**
+ * Context with implementing tasks result
+ */
+export interface ContextWithTasks {
+  /** The parent context */
+  context: ProviderNode
+  /** Tasks implementing the context */
+  tasks: ProviderNode[]
+}
+
+/**
+ * Create a context with multiple implementing tasks
+ *
+ * @param agent - TestAgent with provider configured
+ * @param taskCount - Number of implementing tasks to create
+ * @param contextName - Optional name for the context
+ * @returns Object with context and tasks array
+ *
+ * @example
+ * ```typescript
+ * const { context, tasks } = await createContextWithTasks(agent, 3, 'Auth')
+ * // Creates a context and 3 tasks, each linked with 'implements' edge
+ * ```
+ */
+export async function createContextWithTasks(
+  agent: TestAgent,
+  taskCount: number,
+  contextName?: string
+): Promise<ContextWithTasks> {
+  const context = await createTestContext(agent, contextName)
+  const tasks: ProviderNode[] = []
+
+  for (let i = 0; i < taskCount; i++) {
+    const task = await createTestTask(agent, `Impl ${i + 1}`)
+    await agent.implements(task.id, context.id)
+    tasks.push(task)
+  }
+
+  return { context, tasks }
+}
+
+/**
+ * Create a task blocked by multiple other tasks
+ *
+ * @param agent - TestAgent with provider configured
+ * @param blockerCount - Number of blocking tasks to create
+ * @param blockedName - Optional name for the blocked task
+ * @returns Object with blocked task and array of blockers
+ *
+ * @example
+ * ```typescript
+ * const { blocked, blockers } = await createBlockedTask(agent, 2)
+ * // Creates one task blocked by 2 other tasks
+ * ```
+ */
+export async function createBlockedTask(
+  agent: TestAgent,
+  blockerCount: number,
+  blockedName?: string
+): Promise<{ blocked: ProviderNode; blockers: ProviderNode[] }> {
+  const blocked = await createTestTask(agent, blockedName ?? 'Blocked Task')
+  const blockers: ProviderNode[] = []
+
+  for (let i = 0; i < blockerCount; i++) {
+    const blocker = await createTestTask(agent, `Blocker ${i + 1}`)
+    await agent.blocks(blocker.id, blocked.id)
+    blockers.push(blocker)
+  }
+
+  return { blocked, blockers }
+}

package/references/opentasks/tests/e2e/helpers/index.ts

@@ -0,0 +1,122 @@
+/**
+ * E2E Test Helpers
+ *
+ * Shared utilities for end-to-end tests.
+ */
+
+// Test flags
+export {
+  AGENT_TESTS,
+  AGENT_SKIP_MESSAGE,
+  SLOW_TESTS,
+} from './system-setup.js'
+
+// System setup
+export type {
+  StorageType,
+  E2ESystemOptions,
+  E2ESystemContext,
+  MultiE2ESystemContext,
+} from './system-setup.js'
+
+export {
+  setupE2ESystem,
+  withE2ESystem,
+  setupMultiE2ESystems,
+} from './system-setup.js'
+
+// Re-export GraphStore for direct access
+export type { GraphStore } from '../../../src/graph/store.js'
+
+// Re-export provider types for E2E tests
+export type {
+  Provider,
+  ProviderRegistry,
+  ProviderNode,
+  ProviderCreateInput,
+  ProviderUpdateInput,
+} from '../../../src/providers/types.js'
+
+// Re-export graph types for E2E tests
+export type { GraphologyAdapter } from '../../../src/graph/GraphologyAdapter.js'
+export type { HydratingFederatedGraph, CacheConfig } from '../../../src/graph/HydratingFederatedGraph.js'
+export type { MaterializationManager } from '../../../src/providers/materialization.js'
+
+// Test agent
+export type {
+  TestAgentOptions,
+  ExtendedLinkParams,
+  QuickCreateContextParams,
+  QuickCreateTaskParams,
+  CreateContextOptions,
+  CreateTaskOptions,
+  TestAgent,
+  MultiAgentContext,
+} from './test-agent.js'
+
+export {
+  createTestAgent,
+  createMultiAgents,
+} from './test-agent.js'
+
+// Assertions
+export type {
+  ExpectFeedbackOptions,
+} from './assertions.js'
+
+export {
+  expectReady,
+  expectNotReady,
+  expectBlocks,
+  expectBlockers,
+  expectFeedback,
+  expectStatus,
+  expectTitle,
+} from './assertions.js'
+
+// Fixtures
+export type {
+  DiamondDependency,
+  ContextWithTasks,
+} from './fixtures.js'
+
+export {
+  resetFixtureCounter,
+  createTestContext,
+  createTestTask,
+  createBlockingChain,
+  createDiamondDependency,
+  createContextWithTasks,
+  createBlockedTask,
+} from './fixtures.js'
+
+// Re-export integration helpers that are useful for E2E tests
+export {
+  sleep,
+  waitFor,
+  retry,
+  type WaitOptions,
+} from '../../integration/helpers/index.js'
+
+// Beads helpers for provider sync tests
+export type {
+  CreateBeadsTaskOptions,
+  UpdateBeadsTaskOptions,
+  BeadsTask,
+  BeadsWorkspaceContext,
+} from './beads-helpers.js'
+
+export {
+  isBdAvailable,
+  getBdExecutable,
+  resetBdAvailableCache,
+  BD_SKIP_MESSAGE,
+  createBeadsWorkspace,
+  createBeadsTask,
+  getBeadsTask,
+  updateBeadsStatus,
+  updateBeadsTask,
+  deleteBeadsTask,
+  linkBeadsTasks,
+  listBeadsTasks,
+} from './beads-helpers.js'

package/references/opentasks/tests/e2e/helpers/sudocode-helpers.ts

@@ -0,0 +1,341 @@
+/**
+ * Sudocode E2E Test Helpers
+ *
+ * CLI wrappers and workspace setup for testing the Sudocode provider
+ * against the real sudocode binary. Follows the same pattern as beads-helpers.ts.
+ */
+
+import { exec as execCallback } from 'child_process'
+import { promisify } from 'util'
+import { mkdir, rm } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+
+const execAsync = promisify(execCallback)
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface SudocodeTask {
+  id: string
+  title: string
+  uri: string
+  status?: string
+  content?: string
+  priority?: number
+}
+
+export interface SudocodeWorkspaceContext {
+  path: string
+  cleanup(): Promise<void>
+}
+
+// ============================================================================
+// Sudocode CLI Availability
+// ============================================================================
+
+let _sudocodeAvailable: boolean | null = null
+let _sudocodeExecutable: string | null = null
+
+/**
+ * Check if sudocode CLI is available in PATH.
+ * Result is cached. Prefers direct 'sudocode' over 'npx sudocode' for speed.
+ */
+export async function isSudocodeAvailable(): Promise<boolean> {
+  if (_sudocodeAvailable !== null) return _sudocodeAvailable
+
+  try {
+    await execAsync('sudocode --version', { timeout: 10000 })
+    _sudocodeAvailable = true
+    _sudocodeExecutable = 'sudocode'
+    return true
+  } catch {
+    try {
+      await execAsync('npx sudocode --version', { timeout: 30000 })
+      _sudocodeAvailable = true
+      _sudocodeExecutable = 'npx sudocode'
+      return true
+    } catch {
+      _sudocodeAvailable = false
+      _sudocodeExecutable = null
+      return false
+    }
+  }
+}
+
+export function getSudocodeExecutable(): string {
+  return _sudocodeExecutable ?? 'npx sudocode'
+}
+
+export const SUDOCODE_SKIP_MESSAGE =
+  'Skipping: sudocode CLI not available (npm install -g sudocode)'
+
+// ============================================================================
+// Workspace Management
+// ============================================================================
+
+/**
+ * Create an isolated sudocode workspace for testing.
+ * Initializes git repo + sudocode init in the specified directory.
+ */
+export async function createSudocodeWorkspace(
+  dir: string
+): Promise<SudocodeWorkspaceContext> {
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true })
+  }
+
+  await execAsync('git init', { cwd: dir })
+  await execAsync('git config user.email "test@test.com"', { cwd: dir })
+  await execAsync('git config user.name "Test User"', { cwd: dir })
+  await execAsync('git config commit.gpgSign false', { cwd: dir })
+  await execAsync(
+    'touch .gitkeep && git add . && git commit --no-gpg-sign -m "init"',
+    { cwd: dir }
+  )
+
+  const scExec = getSudocodeExecutable()
+  await execAsync(`${scExec} init`, { cwd: dir, timeout: 30000 })
+
+  return {
+    path: dir,
+    async cleanup(): Promise<void> {
+      if (existsSync(dir)) {
+        await rm(dir, { recursive: true, force: true })
+      }
+    },
+  }
+}
+
+// ============================================================================
+// CLI Execution
+// ============================================================================
+
+function shellEscape(arg: string): string {
+  if (/['\s"\\$`!]/.test(arg)) {
+    return `'${arg.replace(/'/g, "'\\''")}'`
+  }
+  return arg
+}
+
+/**
+ * Execute a sudocode CLI command in a workspace directory.
+ * Handles stdout from both exit code 0 and non-zero (some sudocode commands
+ * like `delete --hard` exit with code 1 but still produce valid JSON on stdout).
+ */
+async function execSc(
+  workspace: string,
+  args: string[],
+  timeout: number = 30000
+): Promise<string> {
+  const scExec = getSudocodeExecutable()
+  const command = [scExec, ...args.map(shellEscape)].join(' ')
+
+  try {
+    const { stdout } = await execAsync(command, {
+      cwd: workspace,
+      timeout,
+      env: { ...process.env },
+    })
+    return stdout.trim()
+  } catch (error) {
+    const err = error as {
+      code?: string | number
+      message?: string
+      killed?: boolean
+      stdout?: string
+      stderr?: string
+    }
+
+    // Some sudocode commands exit non-zero but still provide valid stdout
+    if (err.stdout && err.stdout.trim()) {
+      return err.stdout.trim()
+    }
+
+    if (err.code === 'ENOENT') {
+      throw new Error('Sudocode CLI not found')
+    }
+
+    if (err.killed) {
+      throw new Error(`Command timed out: ${command}`)
+    }
+
+    throw new Error(
+      `Sudocode CLI error: ${err.stderr || err.message || 'Unknown error'}`
+    )
+  }
+}
+
+// ============================================================================
+// Issue Operations
+// ============================================================================
+
+export async function createSudocodeIssue(
+  workspace: string,
+  title: string,
+  options: { content?: string; priority?: number } = {}
+): Promise<SudocodeTask> {
+  const args = ['--json', 'issue', 'create', title]
+  if (options.content) args.push('-d', options.content)
+  if (options.priority !== undefined) args.push('-p', String(options.priority))
+
+  const output = await execSc(workspace, args)
+  const data = JSON.parse(output) as { id: string; title: string; status?: string }
+
+  return {
+    id: data.id,
+    title: data.title,
+    uri: `sudocode://./${data.id}`,
+    status: data.status ?? 'open',
+    content: options.content,
+    priority: options.priority,
+  }
+}
+
+export async function getSudocodeIssue(
+  workspace: string,
+  id: string
+): Promise<SudocodeTask | null> {
+  try {
+    const output = await execSc(workspace, ['--json', 'issue', 'show', id])
+    const data = JSON.parse(output) as {
+      id: string
+      title: string
+      status?: string
+      content?: string
+      priority?: number
+    }
+
+    if (!data || !data.id) return null
+
+    return {
+      id: data.id,
+      title: data.title,
+      uri: `sudocode://./${data.id}`,
+      status: data.status,
+      content: data.content,
+      priority: data.priority,
+    }
+  } catch (error) {
+    const message = (error as Error).message?.toLowerCase() || ''
+    if (message.includes('not found')) return null
+    throw error
+  }
+}
+
+export async function updateSudocodeIssue(
+  workspace: string,
+  id: string,
+  updates: { title?: string; description?: string; status?: string; priority?: number }
+): Promise<SudocodeTask> {
+  const args = ['--json', 'issue', 'update', id]
+  if (updates.title) args.push('--title', updates.title)
+  if (updates.description) args.push('--description', updates.description)
+  if (updates.status) args.push('-s', updates.status)
+  if (updates.priority !== undefined) args.push('-p', String(updates.priority))
+
+  const output = await execSc(workspace, args)
+  const data = JSON.parse(output) as {
+    id: string
+    title: string
+    status?: string
+    content?: string
+    priority?: number
+  }
+
+  return {
+    id: data.id,
+    title: data.title,
+    uri: `sudocode://./${data.id}`,
+    status: data.status,
+    content: data.content,
+    priority: data.priority,
+  }
+}
+
+export async function deleteSudocodeIssue(
+  workspace: string,
+  id: string
+): Promise<void> {
+  await execSc(workspace, ['issue', 'delete', '--hard', id])
+}
+
+export async function listSudocodeIssues(
+  workspace: string
+): Promise<SudocodeTask[]> {
+  const output = await execSc(workspace, ['--json', 'issue', 'list'])
+  const data = JSON.parse(output) as Array<{
+    id: string
+    title: string
+    status?: string
+    content?: string
+    priority?: number
+  }>
+
+  return data.map((d) => ({
+    id: d.id,
+    title: d.title,
+    uri: `sudocode://./${d.id}`,
+    status: d.status,
+    content: d.content,
+    priority: d.priority,
+  }))
+}
+
+// ============================================================================
+// Spec Operations
+// ============================================================================
+
+export async function createSudocodeSpec(
+  workspace: string,
+  title: string,
+  options: { content?: string; priority?: number } = {}
+): Promise<SudocodeTask> {
+  const args = ['--json', 'spec', 'create', title]
+  if (options.content) args.push('-d', options.content)
+  if (options.priority !== undefined) args.push('-p', String(options.priority))
+
+  const output = await execSc(workspace, args)
+  const data = JSON.parse(output) as { id: string; title: string }
+
+  return {
+    id: data.id,
+    title: data.title,
+    uri: `sudocode://./${data.id}`,
+    content: options.content,
+    priority: options.priority,
+  }
+}
+
+export async function listSudocodeSpecs(
+  workspace: string
+): Promise<SudocodeTask[]> {
+  const output = await execSc(workspace, ['--json', 'spec', 'list'])
+  const data = JSON.parse(output) as Array<{
+    id: string
+    title: string
+    content?: string
+    priority?: number
+  }>
+
+  return data.map((d) => ({
+    id: d.id,
+    title: d.title,
+    uri: `sudocode://./${d.id}`,
+    content: d.content,
+    priority: d.priority,
+  }))
+}
+
+// ============================================================================
+// Relationship Operations
+// ============================================================================
+
+export async function linkSudocodeEntities(
+  workspace: string,
+  fromId: string,
+  toId: string,
+  type: string = 'references'
+): Promise<void> {
+  await execSc(workspace, ['link', fromId, toId, '-t', type])
+}