loopwork 0.3.0

package/test/state.test.ts

@@ -0,0 +1,295 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { StateManager } from '../src/core/state'
+import type { Config } from '../src/core/config'
+
+describe('StateManager', () => {
+  let tempDir: string
+  let config: Config
+  let stateManager: StateManager
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loopwork-test-'))
+    config = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output'),
+      sessionId: 'test-session-123',
+      maxIterations: 50,
+      timeout: 600,
+      cli: 'opencode',
+      autoConfirm: false,
+      dryRun: false,
+      debug: false,
+    } as Config
+    stateManager = new StateManager(config)
+  })
+
+  afterEach(() => {
+    // Clean up temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  describe('acquireLock', () => {
+    test('acquires lock successfully when no lock exists', () => {
+      const result = stateManager.acquireLock()
+      expect(result).toBe(true)
+
+      const lockDir = path.join(tempDir, '.loopwork.lock')
+      expect(fs.existsSync(lockDir)).toBe(true)
+
+      const pidFile = path.join(lockDir, 'pid')
+      expect(fs.existsSync(pidFile)).toBe(true)
+      expect(fs.readFileSync(pidFile, 'utf-8')).toBe(process.pid.toString())
+    })
+
+    test('fails to acquire lock when another process holds it', () => {
+      // Create a lock with current process PID (simulating another instance)
+      const lockDir = path.join(tempDir, '.loopwork.lock')
+      fs.mkdirSync(lockDir)
+      fs.writeFileSync(path.join(lockDir, 'pid'), process.pid.toString())
+
+      const result = stateManager.acquireLock()
+      expect(result).toBe(false)
+    })
+
+    test('removes stale lock and acquires new one', () => {
+      // Create a lock with a non-existent PID
+      const lockDir = path.join(tempDir, '.loopwork.lock')
+      fs.mkdirSync(lockDir)
+      fs.writeFileSync(path.join(lockDir, 'pid'), '999999999') // Non-existent PID
+
+      const result = stateManager.acquireLock()
+      expect(result).toBe(true)
+
+      // Verify new lock has current PID
+      const pidFile = path.join(lockDir, 'pid')
+      expect(fs.readFileSync(pidFile, 'utf-8')).toBe(process.pid.toString())
+    })
+
+    test('fails after max retry attempts', () => {
+      const result = stateManager.acquireLock(4) // Already exceeded max retries
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('releaseLock', () => {
+    test('releases existing lock', () => {
+      stateManager.acquireLock()
+      const lockDir = path.join(tempDir, '.loopwork.lock')
+      expect(fs.existsSync(lockDir)).toBe(true)
+
+      stateManager.releaseLock()
+      expect(fs.existsSync(lockDir)).toBe(false)
+    })
+
+    test('does nothing when no lock exists', () => {
+      // Should not throw
+      stateManager.releaseLock()
+    })
+  })
+
+  describe('saveState', () => {
+    test('saves state to file', () => {
+      stateManager.saveState(123, 5)
+
+      const stateFile = path.join(tempDir, '.loopwork-state')
+      expect(fs.existsSync(stateFile)).toBe(true)
+
+      const content = fs.readFileSync(stateFile, 'utf-8')
+      expect(content).toContain('LAST_ISSUE=123')
+      expect(content).toContain('LAST_ITERATION=5')
+      expect(content).toContain('SESSION_ID=test-session-123')
+      expect(content).toContain('SAVED_AT=')
+    })
+
+    test('overwrites previous state', () => {
+      stateManager.saveState(100, 1)
+      stateManager.saveState(200, 10)
+
+      const stateFile = path.join(tempDir, '.loopwork-state')
+      const content = fs.readFileSync(stateFile, 'utf-8')
+      expect(content).toContain('LAST_ISSUE=200')
+      expect(content).toContain('LAST_ITERATION=10')
+      expect(content).not.toContain('LAST_ISSUE=100')
+    })
+  })
+
+  describe('loadState', () => {
+    test('returns null when no state file exists', () => {
+      const result = stateManager.loadState()
+      expect(result).toBeNull()
+    })
+
+    test('loads state from file', () => {
+      stateManager.saveState(456, 20)
+
+      const result = stateManager.loadState()
+      expect(result).not.toBeNull()
+      expect(result!.lastIssue).toBe(456)
+      expect(result!.lastIteration).toBe(20)
+    })
+
+    test('returns null when state file is malformed', () => {
+      const stateFile = path.join(tempDir, '.loopwork-state')
+      fs.writeFileSync(stateFile, 'invalid content without equals sign')
+
+      const result = stateManager.loadState()
+      expect(result).toBeNull()
+    })
+
+    test('handles missing optional fields', () => {
+      const stateFile = path.join(tempDir, '.loopwork-state')
+      fs.writeFileSync(stateFile, 'LAST_ISSUE=789')
+
+      const result = stateManager.loadState()
+      expect(result).not.toBeNull()
+      expect(result!.lastIssue).toBe(789)
+      expect(result!.lastIteration).toBe(0)
+      expect(result!.lastOutputDir).toBe('')
+    })
+  })
+
+  describe('clearState', () => {
+    test('removes state file', () => {
+      stateManager.saveState(123, 5)
+      const stateFile = path.join(tempDir, '.loopwork-state')
+      expect(fs.existsSync(stateFile)).toBe(true)
+
+      stateManager.clearState()
+      expect(fs.existsSync(stateFile)).toBe(false)
+    })
+
+    test('does nothing when no state file exists', () => {
+      // Should not throw
+      stateManager.clearState()
+    })
+  })
+})
+
+describe('StateManager with namespace', () => {
+  let tempDir: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loopwork-ns-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  test('uses default namespace by default', () => {
+    const config = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output'),
+      sessionId: 'test-session',
+      namespace: 'default',
+    } as Config
+
+    const stateManager = new StateManager(config)
+    expect(stateManager.getNamespace()).toBe('default')
+    expect(stateManager.getStateFile()).toBe(path.join(tempDir, '.loopwork-state'))
+    expect(stateManager.getLockFile()).toBe(path.join(tempDir, '.loopwork.lock'))
+  })
+
+  test('uses custom namespace in file paths', () => {
+    const config = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output'),
+      sessionId: 'test-session',
+      namespace: 'feature-a',
+    } as Config
+
+    const stateManager = new StateManager(config)
+    expect(stateManager.getNamespace()).toBe('feature-a')
+    expect(stateManager.getStateFile()).toBe(path.join(tempDir, '.loopwork-state-feature-a'))
+    expect(stateManager.getLockFile()).toBe(path.join(tempDir, '.loopwork-feature-a.lock'))
+  })
+
+  test('multiple namespaces can coexist', () => {
+    const configA = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output-a'),
+      sessionId: 'session-a',
+      namespace: 'feature-a',
+    } as Config
+
+    const configB = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output-b'),
+      sessionId: 'session-b',
+      namespace: 'feature-b',
+    } as Config
+
+    const managerA = new StateManager(configA)
+    const managerB = new StateManager(configB)
+
+    // Both should acquire locks independently
+    expect(managerA.acquireLock()).toBe(true)
+    expect(managerB.acquireLock()).toBe(true)
+
+    // Save state independently
+    managerA.saveState(100, 1)
+    managerB.saveState(200, 2)
+
+    // Load state independently
+    const stateA = managerA.loadState()
+    const stateB = managerB.loadState()
+
+    expect(stateA!.lastIssue).toBe(100)
+    expect(stateB!.lastIssue).toBe(200)
+
+    // Clean up
+    managerA.releaseLock()
+    managerB.releaseLock()
+  })
+
+  test('saves namespace in state file', () => {
+    const config = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output'),
+      sessionId: 'test-session',
+      namespace: 'my-namespace',
+    } as Config
+
+    const stateManager = new StateManager(config)
+    stateManager.saveState(123, 5)
+
+    const stateFile = stateManager.getStateFile()
+    const content = fs.readFileSync(stateFile, 'utf-8')
+    expect(content).toContain('NAMESPACE=my-namespace')
+  })
+
+  test('namespace does not affect lock acquisition for different namespaces', () => {
+    const defaultConfig = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output'),
+      sessionId: 'default-session',
+      namespace: 'default',
+    } as Config
+
+    const customConfig = {
+      projectRoot: tempDir,
+      outputDir: path.join(tempDir, 'output-custom'),
+      sessionId: 'custom-session',
+      namespace: 'custom',
+    } as Config
+
+    const defaultManager = new StateManager(defaultConfig)
+    const customManager = new StateManager(customConfig)
+
+    // Acquire lock for default namespace
+    expect(defaultManager.acquireLock()).toBe(true)
+
+    // Custom namespace should still be able to acquire its own lock
+    expect(customManager.acquireLock()).toBe(true)
+
+    // Both locks should exist
+    expect(fs.existsSync(defaultManager.getLockFile())).toBe(true)
+    expect(fs.existsSync(customManager.getLockFile())).toBe(true)
+
+    defaultManager.releaseLock()
+    customManager.releaseLock()
+  })
+})

package/test/utils.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test, beforeEach, afterEach, spyOn } from 'bun:test'
+import { logger } from '../src/core/utils'
+
+describe('utils', () => {
+  describe('logger', () => {
+    let consoleSpy: ReturnType<typeof spyOn>
+
+    beforeEach(() => {
+      consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      consoleSpy.mockRestore()
+    })
+
+    test('info logs message', () => {
+      logger.info('test message')
+      expect(consoleSpy).toHaveBeenCalled()
+      const args = consoleSpy.mock.calls[0]
+      expect(args.some((a: string) => a.includes('[INFO]') || a.includes('INFO'))).toBe(true)
+    })
+
+    test('success logs message', () => {
+      logger.success('test message')
+      expect(consoleSpy).toHaveBeenCalled()
+      const args = consoleSpy.mock.calls[0]
+      expect(args.some((a: string) => a.includes('[SUCCESS]') || a.includes('SUCCESS'))).toBe(true)
+    })
+
+    test('warn logs message', () => {
+      logger.warn('test message')
+      expect(consoleSpy).toHaveBeenCalled()
+      const args = consoleSpy.mock.calls[0]
+      expect(args.some((a: string) => a.includes('[WARN]') || a.includes('WARN'))).toBe(true)
+    })
+
+    test('error logs message', () => {
+      logger.error('test message')
+      expect(consoleSpy).toHaveBeenCalled()
+      const args = consoleSpy.mock.calls[0]
+      expect(args.some((a: string) => a.includes('[ERROR]') || a.includes('ERROR'))).toBe(true)
+    })
+
+    test('debug logs only when LOOPWORK_DEBUG is true', () => {
+      const originalDebug = process.env.LOOPWORK_DEBUG
+
+      // Should not log when LOOPWORK_DEBUG is not set
+      process.env.LOOPWORK_DEBUG = ''
+      logger.debug('test message')
+      expect(consoleSpy).not.toHaveBeenCalled()
+
+      // Should log when LOOPWORK_DEBUG is true
+      process.env.LOOPWORK_DEBUG = 'true'
+      logger.debug('test message')
+      expect(consoleSpy).toHaveBeenCalled()
+
+      process.env.LOOPWORK_DEBUG = originalDebug
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "composite": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "types": ["bun-types"]
+  }
+}