Implemented HatchboxManager to manage the lifecycle of Hatchboxes. Fixes #41.

Author: acreeger

src/commands/start.test.ts

@@ -5,6 +5,25 @@ import { GitHubService } from '../lib/GitHubService.js'
 // Mock the GitHubService
 vi.mock('../lib/GitHubService.js')
 
+// Mock the HatchboxManager and its dependencies
+vi.mock('../lib/HatchboxManager.js', () => ({
+	HatchboxManager: vi.fn(() => ({
+		createHatchbox: vi.fn().mockResolvedValue({
+			id: 'test-hatchbox-123',
+			path: '/test/path',
+			branch: 'test-branch',
+			type: 'issue',
+			identifier: 123,
+			port: 3123,
+			createdAt: new Date(),
+			githubData: null,
+		}),
+	})),
+}))
+vi.mock('../lib/GitWorktreeManager.js')
+vi.mock('../lib/EnvironmentManager.js')
+vi.mock('../lib/ClaudeContextManager.js')
+
 // Mock the logger to prevent console output during tests
 vi.mock('../utils/logger.js', () => ({
 	logger: {
@@ -14,6 +33,13 @@ vi.mock('../utils/logger.js', () => ({
 		debug: vi.fn(),
 		success: vi.fn(),
 	},
+	createLogger: vi.fn(() => ({
+		info: vi.fn(),
+		error: vi.fn(),
+		warn: vi.fn(),
+		debug: vi.fn(),
+		success: vi.fn(),
+	})),
 }))
 
 describe('StartCommand', () => {

src/commands/start.ts

@@ -1,5 +1,9 @@
 import { logger } from '../utils/logger.js'
 import { GitHubService } from '../lib/GitHubService.js'
+import { HatchboxManager } from '../lib/HatchboxManager.js'
+import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { EnvironmentManager } from '../lib/EnvironmentManager.js'
+import { ClaudeContextManager } from '../lib/ClaudeContextManager.js'
 import type { StartOptions } from '../types/index.js'
 
 export interface StartCommandInput {
@@ -16,9 +20,18 @@ export interface ParsedInput {
 
 export class StartCommand {
 	private gitHubService: GitHubService
+	private hatchboxManager: HatchboxManager
 
-	constructor(gitHubService?: GitHubService) {
+	constructor(gitHubService?: GitHubService, hatchboxManager?: HatchboxManager) {
 		this.gitHubService = gitHubService ?? new GitHubService()
+		this.hatchboxManager =
+			hatchboxManager ??
+			new HatchboxManager(
+				new GitWorktreeManager(),
+				this.gitHubService,
+				new EnvironmentManager(),
+				new ClaudeContextManager()
+			)
 	}
 
 	/**
@@ -32,15 +45,31 @@ export class StartCommand {
 			// Step 2: Validate based on type
 			await this.validateInput(parsed)
 
-			// Step 3: Log success and prepare for next steps (HatchboxManager)
+			// Step 3: Log success and create hatchbox
 			logger.info(`✅ Validated input: ${this.formatParsedInput(parsed)}`)
 
-			// TODO: Issue #41 - Create hatchbox using HatchboxManager
-			// The HatchboxManager will orchestrate the creation of the workspace
-			// including worktree setup, environment configuration, and Claude integration
-			logger.warn(
-				'Hatchbox creation not yet implemented (requires Issue #41 - HatchboxManager)'
-			)
+			// Step 4: Create hatchbox using HatchboxManager
+			const identifier =
+				parsed.type === 'branch'
+					? parsed.branchName ?? ''
+					: parsed.number ?? 0
+
+			const hatchbox = await this.hatchboxManager.createHatchbox({
+				type: parsed.type,
+				identifier,
+				originalInput: parsed.originalInput,
+				options: {
+					...(input.options.urgent !== undefined && { urgent: input.options.urgent }),
+					skipClaude: !input.options.claude,
+				},
+			})
+
+			logger.success(`✅ Created hatchbox: ${hatchbox.id} at ${hatchbox.path}`)
+			logger.info(`   Branch: ${hatchbox.branch}`)
+			logger.info(`   Port: ${hatchbox.port}`)
+			if (hatchbox.githubData?.title) {
+				logger.info(`   Title: ${hatchbox.githubData.title}`)
+			}
 		} catch (error) {
 			if (error instanceof Error) {
 				logger.error(`❌ ${error.message}`)

src/lib/EnvironmentManager.integration.test.ts

@@ -22,15 +22,11 @@ describe('EnvironmentManager integration', () => {
       const envPath = path.join(testDir, '.env')
 
       // Create .env file
-      const result1 = await manager.setEnvVar(envPath, 'DATABASE_URL', 'postgres://localhost/db')
-      expect(result1.success).toBe(true)
+      await manager.setEnvVar(envPath, 'DATABASE_URL', 'postgres://localhost/db')
 
       // Add more variables
-      const result2 = await manager.setEnvVar(envPath, 'API_KEY', 'test-key-123')
-      expect(result2.success).toBe(true)
-
-      const result3 = await manager.setEnvVar(envPath, 'NODE_ENV', 'development')
-      expect(result3.success).toBe(true)
+      await manager.setEnvVar(envPath, 'API_KEY', 'test-key-123')
+      await manager.setEnvVar(envPath, 'NODE_ENV', 'development')
 
       // Set port for workspace
       const port = await manager.setPortForWorkspace(envPath, 42)
@@ -77,8 +73,7 @@ NODE_ENV="development"`
       await fs.writeFile(envPath, initialContent, 'utf8')
 
       // Update a value
-      const result = await manager.setEnvVar(envPath, 'API_KEY', 'new-key')
-      expect(result.success).toBe(true)
+      await manager.setEnvVar(envPath, 'API_KEY', 'new-key')
 
       // Read the file content directly
       const fileContent = await fs.readFile(envPath, 'utf8')
@@ -105,24 +100,24 @@ NODE_ENV="development"`
       await manager.setEnvVar(envPath, 'KEY2', 'value2')
 
       // Update with backup
-      const result = await manager.setEnvVar(envPath, 'KEY1', 'new-value', true)
-      expect(result.success).toBe(true)
-      expect(result.backupPath).toBeDefined()
+      const backupPath = await manager.setEnvVar(envPath, 'KEY1', 'new-value', true)
+      expect(backupPath).toBeDefined()
+      expect(typeof backupPath).toBe('string')
 
       // Verify backup exists
-      const backupExists = await fs.pathExists(result.backupPath!)
+      const backupExists = await fs.pathExists(backupPath as string)
       expect(backupExists).toBe(true)
 
       // Verify backup contains old value
-      const backupContent = await fs.readFile(result.backupPath!, 'utf8')
+      const backupContent = await fs.readFile(backupPath as string, 'utf8')
       expect(backupContent).toContain('KEY1="value1"')
 
       // Verify main file has new value
       const mainContent = await manager.readEnvFile(envPath)
       expect(mainContent.get('KEY1')).toBe('new-value')
 
       // Recovery: restore from backup
-      await manager.copyEnvFile(result.backupPath!, envPath)
+      await manager.copyEnvFile(backupPath as string, envPath)
       const restoredContent = await manager.readEnvFile(envPath)
       expect(restoredContent.get('KEY1')).toBe('value1')
     })
@@ -139,8 +134,7 @@ NODE_ENV="development"`
       ]
 
       for (const [key, value] of specialValues) {
-        const result = await manager.setEnvVar(envPath, key, value)
-        expect(result.success).toBe(true)
+        await manager.setEnvVar(envPath, key, value)
       }
 
       // Read back and verify
@@ -183,12 +177,10 @@ NODE_ENV="development"`
     it('should handle missing directories gracefully', async () => {
       const envPath = path.join(testDir, 'nonexistent', 'directory', '.env')
 
-      // Should fail because parent directory doesn't exist
-      const result = await manager.setEnvVar(envPath, 'KEY', 'value')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(result.error).toContain('no such file or directory')
+      // Should throw because parent directory doesn't exist
+      await expect(
+        manager.setEnvVar(envPath, 'KEY', 'value')
+      ).rejects.toThrow('no such file or directory')
     })
 
     it('should handle read-only files', async () => {
@@ -197,10 +189,10 @@ NODE_ENV="development"`
       await fs.writeFile(envPath, 'KEY="value"', 'utf8')
       await fs.chmod(envPath, 0o444) // Read-only
 
-      const result = await manager.setEnvVar(envPath, 'KEY', 'new-value')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBeDefined()
+      // Should throw because file is read-only
+      await expect(
+        manager.setEnvVar(envPath, 'KEY', 'new-value')
+      ).rejects.toThrow('permission denied')
 
       // Cleanup
       await fs.chmod(envPath, 0o644)
@@ -231,23 +223,20 @@ _VALID_KEY="value"`
       const envPath = path.join(testDir, '.env')
 
       // Test case 1: Create new file
-      const result1 = await manager.setEnvVar(envPath, 'KEY', 'value')
-      expect(result1.success).toBe(true)
+      await manager.setEnvVar(envPath, 'KEY', 'value')
 
       let content = await fs.readFile(envPath, 'utf8')
       expect(content).toBe('KEY="value"')
 
       // Test case 2: Add variable to existing file
-      const result2 = await manager.setEnvVar(envPath, 'KEY2', 'value2')
-      expect(result2.success).toBe(true)
+      await manager.setEnvVar(envPath, 'KEY2', 'value2')
 
       content = await fs.readFile(envPath, 'utf8')
       expect(content).toContain('KEY="value"')
       expect(content).toContain('KEY2="value2"')
 
       // Test case 3: Update existing variable
-      const result3 = await manager.setEnvVar(envPath, 'KEY', 'new-value')
-      expect(result3.success).toBe(true)
+      await manager.setEnvVar(envPath, 'KEY', 'new-value')
 
       content = await fs.readFile(envPath, 'utf8')
       expect(content).toContain('KEY="new-value"')
@@ -270,8 +259,7 @@ _VALID_KEY="value"`
 
       // The bash script uses: escaped_value="${var_value//\"/\\\"}"
       const valueWithQuotes = 'value with "quotes" inside'
-      const result = await manager.setEnvVar(envPath, 'KEY', valueWithQuotes)
-      expect(result.success).toBe(true)
+      await manager.setEnvVar(envPath, 'KEY', valueWithQuotes)
 
       const fileContent = await fs.readFile(envPath, 'utf8')
       expect(fileContent).toBe('KEY="value with \\"quotes\\" inside"')