interface TestSpecification {
  feature: string;
  requirements: Requirement[];
  testCases: TestCase[];
  acceptanceCriteria: AcceptanceCriterion[];
  coverage: CoverageRequirement;
}

interface TestCase {
  description: string;
  input: any;
  expectedOutput: any;
  edgeCases: EdgeCase[];
  errorScenarios: ErrorScenario[];
}

// Example
const authTestSpec: TestSpecification = {
  feature: "User Authentication",
  requirements: [
    { id: "REQ-001", description: "Users can register with email" },
    { id: "REQ-002", description: "Passwords must be secure" }
  ],
  testCases: [
    {
      description: "Should register user with valid email",
      input: { email: "[email protected]", password: "SecurePass123!" },
      expectedOutput: { success: true, userId: "string" },
      edgeCases: [
        { description: "Email with special characters" },
        { description: "Maximum length email" }
      ],
      errorScenarios: [
        { input: { email: "invalid" }, expectedError: "Invalid email format" }
      ]
    }
  ],
  acceptanceCriteria: [
    "All security requirements met",
    "Performance under 200ms",
    "Works with all supported databases"
  ],
  coverage: {
    minimum: 100,
    includeEdgeCases: true,
    includeErrorPaths: true
  }
};

class CoderAgentWorkflow {
  async implementFeature(testSpec: TestSpecification): Promise<Implementation> {
    // 1. Verify tests are red
    const redState = await this.verifyTestsRed(testSpec);
    if (!redState.allRed) {
      throw new Error('Tests must be red before implementation');
    }
    
    // 2. Analyze test requirements
    const requirements = await this.analyzeTests(testSpec);
    
    // 3. Implement iteratively
    let implementation = await this.createMinimalImplementation(requirements);
    let testResults = await this.runTests(implementation);
    
    while (!testResults.allPassing) {
      // Update Agent_Output.md with progress
      await this.updateStatus({
        phase: 'implementation',
        passing: testResults.passing,
        total: testResults.total,
        currentFocus: testResults.nextFailingTest
      });
      
      // Fix failing test
      implementation = await this.fixFailingTest(
        implementation,
        testResults.nextFailingTest
      );
      
      testResults = await this.runTests(implementation);
    }
    
    // 4. All tests green!
    await this.updateStatus({
      phase: 'green',
      allTestsPassing: true,
      coverage: testResults.coverage
    });
    
    return implementation;
  }
}

interface CodeReviewProcess {
  automated: {
    linting: boolean;
    formatting: boolean;
    complexity: boolean;
    security: boolean;
    testCoverage: boolean;
  };
  manual: {
    codeQuality: boolean;
    architecture: boolean;
    performance: boolean;
    documentation: boolean;
  };
}

// 1. PM Agent creates task
const task = {
  type: 'implement_feature',
  specification: authSpec,
  testFiles: ['auth.test.ts'],
  priority: 'high',
  deadline: '2025-12-30'
};

// 2. PM Agent notifies Coder Agent
await pmAgent.sendTask('coder-agent', task);

// 3. Coder Agent acknowledges
await coderAgent.acknowledge(task, {
  estimatedTime: '4 hours',
  startTime: new Date()
});

// 4. Coder Agent updates progress via Agent_Output.md
// Other agents monitor ../shared/Agent_Status/coder_status.md

// 5. Coder Agent completes and notifies
await coderAgent.notifyCompletion(task, {
  pullRequestUrl: 'https://github.com/org/repo/pull/123',
  testResults: { passing: 45, total: 45 },
  coverage: 98.5
});