PRD Machine: Building a Self-Writing Product Requirements Distillery

def main():
    parser = argparse.ArgumentParser(
        description='PRD MACHINE - The Self-Writing, Self-Evolving Product Reality Distillery'
    )
    
    subparsers = parser.add_subparsers(dest='command')
    
    # Sync command
    sync_parser = subparsers.add_parser('sync', help='Generate or update PRD.md')
    sync_parser.add_argument('--days', type=int, default=30)
    sync_parser.add_argument('--output', type=str, default='PRD.md')
    
    # Status command
    subparsers.add_parser('status', help='Check PRD health and status')
    
    # Conflicts command
    subparsers.add_parser('conflicts', help='Show detected requirement conflicts')

def ingest_git_commits(self, days: int = 30) -> List[Dict]:
    """Ingest git commit messages as signals."""
    since_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
    
    result = subprocess.run(
        ['git', 'log', f'--since={since_date}', '--pretty=format:%H|%s|%b|%an|%ad'],
        capture_output=True, text=True
    )
    
    commits = []
    for line in result.stdout.strip().split('\n'):
        if line:
            parts = line.split('|')
            commits.append({
                'type': 'commit',
                'sha': parts[0][:7],
                'subject': parts[1],
                'body': parts[2] if len(parts) > 2 else '',
                'author': parts[3] if len(parts) > 3 else '',
                'date': parts[4] if len(parts) > 4 else ''
            })
    
    return commits

def ingest_markdown_files(self) -> List[Dict]:
    """Ingest markdown files as signals."""
    patterns = ['pages/**/*.md', 'docs/**/*.md', '*.md']
    files = []
    
    for pattern in patterns:
        for filepath in glob.glob(pattern, recursive=True):
            with open(filepath, 'r', encoding='utf-8') as f:
                content = f.read()
            
            # Parse frontmatter
            frontmatter = self.parse_frontmatter(content)
            
            files.append({
                'type': 'markdown',
                'path': filepath,
                'title': frontmatter.get('title', filepath),
                'description': frontmatter.get('description', ''),
                'tags': frontmatter.get('tags', [])
            })
    
    return files

def ingest_feature_definitions(self) -> List[Dict]:
    """Ingest feature definitions from features.yml."""
    features_path = Path(self.repo_path) / 'features' / 'features.yml'
    
    if features_path.exists():
        with open(features_path, 'r') as f:
            data = yaml.safe_load(f)
        return data.get('features', [])
    
    return []

def detect_conflicts(self) -> List[Dict]:
    """Detect conflicts in signals."""
    conflicts = []
    commits = self.signals.get('commits', [])
    
    for commit in commits:
        subject = commit.get('subject', '').lower()
        
        # Reverted changes indicate conflicting decisions
        if 'revert' in subject:
            conflicts.append({
                'type': 'revert',
                'source': commit,
                'description': 'A change was reverted, indicating potential conflict',
                'resolution': 'Review the original change and revert reason'
            })
        
        # Bug fixes suggest incomplete requirements
        if subject.startswith('fix:') or 'bug' in subject:
            conflicts.append({
                'type': 'bug_fix',
                'source': commit,
                'description': 'Bug fix suggests requirements were incomplete',
                'resolution': 'Update requirements to prevent similar issues'
            })
    
    return conflicts

def generate_prd(self) -> str:
    """Generate the complete PRD content."""
    sections = [
        self.generate_frontmatter(),
        self.generate_header(),
        self.generate_why_section(),
        self.generate_mvp_section(),
        self.generate_ux_section(),
        self.generate_api_section(),
        self.generate_nfr_section(),
        self.generate_edge_section(),
        self.generate_oos_section(),
        self.generate_road_section(),
        self.generate_risk_section(),
        self.generate_done_section(),
        self.generate_footer()
    ]
    
    return '\n\n'.join(sections)

def generate_mvp_section(self) -> str:
    """Generate MVP section with signal status."""
    commit_count = len(self.signals.get('commits', []))
    md_count = len(self.signals.get('markdown', []))
    feature_count = len(self.signals.get('features', []))
    conflict_count = len(self.conflicts)
    
    return f"""## 1. MVP (Minimum Viable Promise)

### Current Signal Status

| Source | Count | Status |
|--------|-------|--------|
| Git Commits | {commit_count} | ✅ Ingested |
| Markdown Files | {md_count} | ✅ Ingested |
| Features | {feature_count} | ✅ Parsed |
| Conflicts | {conflict_count} | {'⚠️' if conflict_count > 0 else '✅'} Detected |
"""

def check_status(self):
    """Check PRD health and status."""
    prd_path = Path(self.repo_path) / 'PRD.md'
    
    if not prd_path.exists():
        self.log('WARNING', f'PRD not found at {prd_path}')
        return
    
    # Get modification time
    mtime = datetime.fromtimestamp(prd_path.stat().st_mtime, tz=timezone.utc)
    age_hours = (datetime.now(timezone.utc) - mtime).total_seconds() / 3600
    
    # Determine health status
    if age_hours < 6:
        health = 'HEALTHY'
        self.log('SUCCESS', f'Health: {health}')
    elif age_hours < 24:
        health = 'STALE'
        self.log('WARNING', f'Health: {health}')
    else:
        health = 'OUTDATED'
        self.log('ERROR', f'Health: {health}')