loopwork 0.3.0 → 0.3.1

package/test/github-tasks.test.ts

@@ -1,191 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from 'bun:test'
-import { GitHubTaskAdapter } from '../src/backends/github'
-
-// Note: GitHubIssue is internal to the adapter, so we define it here for testing
-interface GitHubIssue {
-  number: number
-  title: string
-  body: string
-  state: 'open' | 'closed'
-  labels: { name: string }[]
-  url: string
-}
-
-describe('GitHubTaskAdapter', () => {
-  let manager: GitHubTaskAdapter
-
-  beforeEach(() => {
-    manager = new GitHubTaskAdapter({ type: 'github' })
-  })
-
-  describe('adaptIssue conversion', () => {
-    test('extracts task ID from title', () => {
-      const issue: GitHubIssue = {
-        number: 123,
-        title: 'TASK-025-01: Add health score calculation',
-        body: '## Goal\nCalculate health score',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }, { name: 'loopwork:pending' }],
-        url: 'https://github.com/owner/repo/issues/123',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.id).toBe('TASK-025-01')
-      expect(task.metadata.issueNumber).toBe(123)
-      expect(task.status).toBe('pending')
-    })
-
-    test('generates GH-{number} ID when no task ID in title', () => {
-      const issue: GitHubIssue = {
-        number: 456,
-        title: 'Fix the login bug',
-        body: 'Fix it',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }],
-        url: 'https://github.com/owner/repo/issues/456',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.id).toBe('GH-456')
-    })
-
-    test('detects in-progress status from labels', () => {
-      const issue: GitHubIssue = {
-        number: 789,
-        title: 'TASK-001-01: Test',
-        body: 'Test',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }, { name: 'loopwork:in-progress' }],
-        url: 'https://github.com/owner/repo/issues/789',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.status).toBe('in-progress')
-    })
-
-    test('detects failed status from labels', () => {
-      const issue: GitHubIssue = {
-        number: 101,
-        title: 'TASK-002-01: Another test',
-        body: 'Body',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }, { name: 'loopwork:failed' }],
-        url: 'https://github.com/owner/repo/issues/101',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.status).toBe('failed')
-    })
-
-    test('detects completed status from closed state', () => {
-      const issue: GitHubIssue = {
-        number: 102,
-        title: 'TASK-003-01: Closed task',
-        body: 'Done',
-        state: 'closed',
-        labels: [{ name: 'loopwork-task' }],
-        url: 'https://github.com/owner/repo/issues/102',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.status).toBe('completed')
-    })
-
-    test('extracts priority from labels', () => {
-      const highPriority: GitHubIssue = {
-        number: 1,
-        title: 'TASK-001-01: High',
-        body: '',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }, { name: 'priority:high' }],
-        url: 'https://github.com/owner/repo/issues/1',
-      }
-
-      const lowPriority: GitHubIssue = {
-        number: 2,
-        title: 'TASK-001-02: Low',
-        body: '',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }, { name: 'priority:low' }],
-        url: 'https://github.com/owner/repo/issues/2',
-      }
-
-      expect((manager as any).adaptIssue(highPriority).priority).toBe('high')
-      expect((manager as any).adaptIssue(lowPriority).priority).toBe('low')
-    })
-
-    test('extracts feature from labels', () => {
-      const issue: GitHubIssue = {
-        number: 3,
-        title: 'TASK-025-01: Feature task',
-        body: '',
-        state: 'open',
-        labels: [
-          { name: 'loopwork-task' },
-          { name: 'feat:profile-health' },
-        ],
-        url: 'https://github.com/owner/repo/issues/3',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.feature).toBe('profile-health')
-    })
-
-    test('defaults to medium priority when not specified', () => {
-      const issue: GitHubIssue = {
-        number: 4,
-        title: 'TASK-001-01: No priority',
-        body: '',
-        state: 'open',
-        labels: [{ name: 'loopwork-task' }],
-        url: 'https://github.com/owner/repo/issues/4',
-      }
-
-      const task = (manager as any).adaptIssue(issue)
-
-      expect(task.priority).toBe('medium')
-    })
-  })
-
-  describe('repoFlag', () => {
-    test('returns empty string when no repo specified', () => {
-      const mgr = new GitHubTaskAdapter({ type: 'github' })
-      expect((mgr as any).repoFlag()).toBe('')
-    })
-
-    test('returns --repo flag when repo specified', () => {
-      const mgr = new GitHubTaskAdapter({ type: 'github', repo: 'owner/repo' })
-      expect((mgr as any).repoFlag()).toBe('--repo owner/repo')
-    })
-  })
-})
-
-describe('Types', () => {
-  test('LABELS constants are correct', async () => {
-    const { LABELS } = await import('../src/contracts')
-
-    expect(LABELS.LOOPWORK_TASK).toBe('loopwork-task')
-    expect(LABELS.STATUS_PENDING).toBe('loopwork:pending')
-    expect(LABELS.STATUS_IN_PROGRESS).toBe('loopwork:in-progress')
-    expect(LABELS.STATUS_FAILED).toBe('loopwork:failed')
-    expect(LABELS.PRIORITY_HIGH).toBe('priority:high')
-    expect(LABELS.PRIORITY_MEDIUM).toBe('priority:medium')
-    expect(LABELS.PRIORITY_LOW).toBe('priority:low')
-  })
-
-  test('DEFAULT_CONFIG has expected values', async () => {
-    const { DEFAULT_CONFIG } = await import('../src/contracts')
-
-    expect(DEFAULT_CONFIG.maxIterations).toBe(50)
-    expect(DEFAULT_CONFIG.timeout).toBe(600)
-    expect(DEFAULT_CONFIG.cli).toBe('opencode')
-    expect(DEFAULT_CONFIG.autoConfirm).toBe(false)
-    expect(DEFAULT_CONFIG.dryRun).toBe(false)
-  })
-})

package/test/loopwork-config-types.test.ts

@@ -1,288 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  defineConfig,
-  withTelegram,
-  withCostTracking,
-  withJSON,
-  withGitHub,
-  withPlugin,
-  withAsana,
-  withEverhour,
-  withTodoist,
-  withDiscord,
-  compose,
-  defaults,
-} from '../src/plugins'
-
-describe('loopwork-config-types', () => {
-  describe('defineConfig', () => {
-    test('returns config with defaults', () => {
-      const config = defineConfig({
-        backend: { type: 'json', tasksFile: 'tasks.json' },
-      })
-
-      expect(config.backend).toEqual({ type: 'json', tasksFile: 'tasks.json' })
-      expect(config.cli).toBe('opencode')
-      expect(config.maxIterations).toBe(50)
-      expect(config.timeout).toBe(600)
-      expect(config.namespace).toBe('default')
-      expect(config.plugins).toEqual([])
-    })
-
-    test('overrides defaults with provided values', () => {
-      const config = defineConfig({
-        backend: { type: 'github', repo: 'owner/repo' },
-        cli: 'claude',
-        maxIterations: 100,
-        timeout: 300,
-      })
-
-      expect(config.cli).toBe('claude')
-      expect(config.maxIterations).toBe(100)
-      expect(config.timeout).toBe(300)
-    })
-  })
-
-  describe('withTelegram', () => {
-    test('adds telegram config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withTelegram()(base)
-
-      expect(config.telegram).toBeDefined()
-      expect(config.telegram?.notifications).toBe(true)
-      expect(config.telegram?.silent).toBe(false)
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withTelegram({
-        botToken: 'test-token',
-        chatId: 'test-chat',
-        silent: true,
-      })(base)
-
-      expect(config.telegram?.botToken).toBe('test-token')
-      expect(config.telegram?.chatId).toBe('test-chat')
-      expect(config.telegram?.silent).toBe(true)
-    })
-  })
-
-  describe('withCostTracking', () => {
-    test('adds cost tracking config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withCostTracking()(base)
-
-      expect(config.costTracking).toBeDefined()
-      expect(config.costTracking?.enabled).toBe(true)
-      expect(config.costTracking?.defaultModel).toBe('claude-3.5-sonnet')
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withCostTracking({
-        enabled: false,
-        defaultModel: 'gpt-4',
-      })(base)
-
-      expect(config.costTracking?.enabled).toBe(false)
-      expect(config.costTracking?.defaultModel).toBe('gpt-4')
-    })
-  })
-
-  describe('withJSON', () => {
-    test('sets json backend with defaults', () => {
-      const base = defineConfig({ backend: { type: 'github' } })
-      const config = withJSON()(base)
-
-      expect(config.backend.type).toBe('json')
-      expect(config.backend.tasksFile).toBe('.specs/tasks/tasks.json')
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'github' } })
-      const config = withJSON({ tasksFile: 'custom/tasks.json', tasksDir: 'custom' })(base)
-
-      expect(config.backend.tasksFile).toBe('custom/tasks.json')
-      expect(config.backend.tasksDir).toBe('custom')
-    })
-  })
-
-  describe('withGitHub', () => {
-    test('sets github backend', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withGitHub({ repo: 'owner/repo' })(base)
-
-      expect(config.backend.type).toBe('github')
-      expect(config.backend.repo).toBe('owner/repo')
-    })
-  })
-
-  describe('withPlugin', () => {
-    test('adds plugin to plugins array', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const plugin = { name: 'test-plugin' }
-      const config = withPlugin(plugin)(base)
-
-      expect(config.plugins).toHaveLength(1)
-      expect(config.plugins?.[0].name).toBe('test-plugin')
-    })
-
-    test('appends to existing plugins', () => {
-      const base = defineConfig({
-        backend: { type: 'json' },
-        plugins: [{ name: 'existing' }],
-      })
-      const config = withPlugin({ name: 'new-plugin' })(base)
-
-      expect(config.plugins).toHaveLength(2)
-      expect(config.plugins?.[0].name).toBe('existing')
-      expect(config.plugins?.[1].name).toBe('new-plugin')
-    })
-  })
-
-  describe('withAsana', () => {
-    test('adds asana config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withAsana()(base)
-
-      expect(config.asana).toBeDefined()
-      expect(config.asana?.autoCreate).toBe(false)
-      expect(config.asana?.syncStatus).toBe(true)
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withAsana({
-        accessToken: 'test-token',
-        projectId: 'project-123',
-        autoCreate: true,
-      })(base)
-
-      expect(config.asana?.accessToken).toBe('test-token')
-      expect(config.asana?.projectId).toBe('project-123')
-      expect(config.asana?.autoCreate).toBe(true)
-    })
-  })
-
-  describe('withEverhour', () => {
-    test('adds everhour config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withEverhour()(base)
-
-      expect(config.everhour).toBeDefined()
-      expect(config.everhour?.autoStartTimer).toBe(true)
-      expect(config.everhour?.autoStopTimer).toBe(true)
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withEverhour({
-        apiKey: 'test-key',
-        autoStartTimer: false,
-      })(base)
-
-      expect(config.everhour?.apiKey).toBe('test-key')
-      expect(config.everhour?.autoStartTimer).toBe(false)
-    })
-  })
-
-  describe('withTodoist', () => {
-    test('adds todoist config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withTodoist()(base)
-
-      expect(config.todoist).toBeDefined()
-      expect(config.todoist?.syncStatus).toBe(true)
-      expect(config.todoist?.addComments).toBe(true)
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withTodoist({
-        apiToken: 'test-token',
-        projectId: 'project-456',
-        addComments: false,
-      })(base)
-
-      expect(config.todoist?.apiToken).toBe('test-token')
-      expect(config.todoist?.projectId).toBe('project-456')
-      expect(config.todoist?.addComments).toBe(false)
-    })
-  })
-
-  describe('withDiscord', () => {
-    test('adds discord config with defaults', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withDiscord()(base)
-
-      expect(config.discord).toBeDefined()
-      expect(config.discord?.username).toBe('Loopwork')
-      expect(config.discord?.notifyOnStart).toBe(false)
-      expect(config.discord?.notifyOnComplete).toBe(true)
-      expect(config.discord?.notifyOnFail).toBe(true)
-      expect(config.discord?.notifyOnLoopEnd).toBe(true)
-    })
-
-    test('uses provided options', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = withDiscord({
-        webhookUrl: 'https://discord.com/webhook',
-        username: 'Custom Bot',
-        mentionOnFail: '<@123>',
-      })(base)
-
-      expect(config.discord?.webhookUrl).toBe('https://discord.com/webhook')
-      expect(config.discord?.username).toBe('Custom Bot')
-      expect(config.discord?.mentionOnFail).toBe('<@123>')
-    })
-  })
-
-  describe('compose', () => {
-    test('composes multiple wrappers', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = compose(
-        withTelegram({ botToken: 'tg-token' }),
-        withCostTracking({ enabled: true }),
-        withDiscord({ webhookUrl: 'discord-url' })
-      )(base)
-
-      expect(config.telegram?.botToken).toBe('tg-token')
-      expect(config.costTracking?.enabled).toBe(true)
-      expect(config.discord?.webhookUrl).toBe('discord-url')
-    })
-
-    test('applies wrappers in order', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = compose(
-        withJSON({ tasksFile: 'first.json' }),
-        withJSON({ tasksFile: 'second.json' })
-      )(base)
-
-      // Last wrapper wins
-      expect(config.backend.tasksFile).toBe('second.json')
-    })
-
-    test('works with empty wrappers', () => {
-      const base = defineConfig({ backend: { type: 'json' } })
-      const config = compose()(base)
-
-      expect(config).toEqual(base)
-    })
-  })
-
-  describe('defaults', () => {
-    test('has expected default values', () => {
-      expect(defaults.cli).toBe('opencode')
-      expect(defaults.maxIterations).toBe(50)
-      expect(defaults.timeout).toBe(600)
-      expect(defaults.namespace).toBe('default')
-      expect(defaults.autoConfirm).toBe(false)
-      expect(defaults.dryRun).toBe(false)
-      expect(defaults.debug).toBe(false)
-      expect(defaults.maxRetries).toBe(3)
-      expect(defaults.circuitBreakerThreshold).toBe(5)
-      expect(defaults.taskDelay).toBe(2000)
-      expect(defaults.retryDelay).toBe(3000)
-    })
-  })
-})

package/test/monitor.test.ts

@@ -1,123 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import fs from 'fs'
-import path from 'path'
-import os from 'os'
-import { LoopworkMonitor } from '../src/monitor'
-
-describe('LoopworkMonitor', () => {
-  let tempDir: string
-  let monitor: LoopworkMonitor
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ralph-monitor-test-'))
-    monitor = new LoopworkMonitor(tempDir)
-  })
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  test('getRunningProcesses returns empty array when no state', () => {
-    const result = monitor.getRunningProcesses()
-    expect(result).toEqual([])
-  })
-
-  test('getRunningProcesses cleans up dead processes', () => {
-    const stateFile = path.join(tempDir, '.loopwork-monitor-state.json')
-    fs.writeFileSync(stateFile, JSON.stringify({
-      processes: [{
-        namespace: 'dead-ns',
-        pid: 999999999,
-        startedAt: new Date().toISOString(),
-        logFile: '/tmp/test.log',
-        args: [],
-      }]
-    }))
-
-    const result = monitor.getRunningProcesses()
-    expect(result).toEqual([])
-
-    const newState = JSON.parse(fs.readFileSync(stateFile, 'utf-8'))
-    expect(newState.processes).toEqual([])
-  })
-
-  test('getRunningProcesses returns alive processes', () => {
-    const stateFile = path.join(tempDir, '.loopwork-monitor-state.json')
-    fs.writeFileSync(stateFile, JSON.stringify({
-      processes: [{
-        namespace: 'alive-ns',
-        pid: process.pid,
-        startedAt: new Date().toISOString(),
-        logFile: '/tmp/test.log',
-        args: [],
-      }]
-    }))
-
-    const running = monitor.getRunningProcesses()
-    expect(running.length).toBe(1)
-    expect(running[0].namespace).toBe('alive-ns')
-  })
-
-  test('getStatus returns empty when no runs', () => {
-    const result = monitor.getStatus()
-    expect(result.running).toEqual([])
-    expect(result.namespaces).toEqual([])
-  })
-
-  test('getStatus discovers namespaces from directories', () => {
-    const ns1Dir = path.join(tempDir, 'loopwork-runs', 'feature-a', '2024-01-01T00-00-00')
-    const ns2Dir = path.join(tempDir, 'loopwork-runs', 'feature-b', '2024-01-02T00-00-00')
-    fs.mkdirSync(ns1Dir, { recursive: true })
-    fs.mkdirSync(ns2Dir, { recursive: true })
-
-    const result = monitor.getStatus()
-    expect(result.namespaces.length).toBe(2)
-    expect(result.namespaces.map(n => n.name).sort()).toEqual(['feature-a', 'feature-b'])
-  })
-
-  test('getLogs returns message when no logs', () => {
-    const result = monitor.getLogs('nonexistent')
-    expect(result[0]).toContain('No logs found')
-  })
-
-  test('getLogs reads from monitor-logs directory', () => {
-    const logsDir = path.join(tempDir, 'loopwork-runs', 'test-ns', 'monitor-logs')
-    fs.mkdirSync(logsDir, { recursive: true })
-    fs.writeFileSync(path.join(logsDir, '2024-01-01.log'), 'Line 1\nLine 2\nLine 3')
-
-    const result = monitor.getLogs('test-ns', 10)
-    const joined = result.join('\n')
-    expect(joined).toContain('Line 1')
-    expect(joined).toContain('Line 2')
-    expect(joined).toContain('Line 3')
-  })
-
-  test('stop returns error when namespace not found', () => {
-    const result = monitor.stop('nonexistent')
-    expect(result.success).toBe(false)
-    expect(result.error).toContain('No running loop found')
-  })
-
-  test('stopAll returns empty when nothing running', () => {
-    const result = monitor.stopAll()
-    expect(result.stopped).toEqual([])
-    expect(result.errors).toEqual([])
-  })
-
-  test('start fails for duplicate namespace', async () => {
-    const stateFile = path.join(tempDir, '.loopwork-monitor-state.json')
-    fs.writeFileSync(stateFile, JSON.stringify({
-      processes: [{
-        namespace: 'test-ns',
-        pid: process.pid,
-        startedAt: new Date().toISOString(),
-        logFile: '/tmp/test.log',
-        args: [],
-      }]
-    }))
-
-    const result = await monitor.start('test-ns')
-    expect(result.success).toBe(false)
-    expect(result.error).toContain('already running')
-  })
-})