claude-code-swarm 0.3.2 → 0.3.4

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

@@ -1,236 +0,0 @@
-/**
- * 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

@@ -1,122 +0,0 @@
-/**
- * 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

@@ -1,341 +0,0 @@
-/**
- * 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])
-}