pip install click python-dotenv jira openai gitpython

# devlog.py
import click
import os
import subprocess
from datetime import datetime, timedelta
from jira import JIRA
import openai
from git import Repo
from pathlib import Path

# Configuration
CONFIG_TEMPLATE = """
# DevLog Configuration
GIT_REPO_PATH={git_path}
JIRA_SERVER={jira_server}
JIRA_EMAIL={jira_email}
JIRA_API_TOKEN={jira_token}
OPENAI_API_KEY={openai_key}
OUTPUT_DIR={output_dir}
"""

class DevLogGenerator:
    def __init__(self, config_path='.devlog.env'):
        """Initialize with configuration"""
        self.config_path = config_path
        self.config = self._load_config()
        
    def _load_config(self):
        """Load configuration from .env file"""
        if not os.path.exists(self.config_path):
            click.echo(f"Configuration file not found at {self.config_path}")
            click.echo("Run 'devlog init' to set up configuration")
            return None
            
        from dotenv import load_dotenv
        load_dotenv(self.config_path)
        
        return {
            'git_path': os.getenv('GIT_REPO_PATH'),
            'jira_server': os.getenv('JIRA_SERVER'),
            'jira_email': os.getenv('JIRA_EMAIL'),
            'jira_token': os.getenv('JIRA_API_TOKEN'),
            'openai_key': os.getenv('OPENAI_API_KEY'),
            'output_dir': os.getenv('OUTPUT_DIR', './devlogs')
        }
    
    def get_today_git_commits(self):
        """Get today's git commits"""
        if not self.config['git_path']:
            return []
            
        try:
            repo = Repo(self.config['git_path'])
            today = datetime.now().date()
            yesterday = today - timedelta(days=1)
            
            commits = []
            for commit in repo.iter_commits(since=yesterday.strftime('%Y-%m-%d'), 
                                          until=today.strftime('%Y-%m-%d')):
                commits.append({
                    'hash': commit.hexsha[:7],
                    'message': commit.message.strip(),
                    'author': commit.author.name,
                    'time': commit.committed_datetime
                })
            return commits
        except Exception as e:
            click.echo(f"Git error: {e}")
            return []
    
    def get_today_jira_tickets(self):
        """Get Jira tickets worked on today"""
        if not all([self.config['jira_server'], self.config['jira_email'], 
                   self.config['jira_token']]):
            return []
            
        try:
            jira = JIRA(
                server=self.config['jira_server'],
                basic_auth=(self.config['jira_email'], self.config['jira_token'])
            )
            
            today = datetime.now().date()
            jql = f"assignee = currentUser() AND updated >= {today.strftime('%Y-%m-%d')}"
            issues = jira.search_issues(jql)
            
            tickets = []
            for issue in issues:
                tickets.append({
                    'key': issue.key,
                    'summary': issue.fields.summary,
                    'status': issue.fields.status.name,
                    'url': f"{self.config['jira_server']}/browse/{issue.key}"
                })
            return tickets
        except Exception as e:
            click.echo(f"Jira error: {e}")
            return []
    
    def transcribe_voice_note(self, audio_path):
        """Transcribe voice note using OpenAI Whisper"""
        if not self.config['openai_key']:
            return "OpenAI API key not configured"
            
        try:
            openai.api_key = self.config['openai_key']
            
            with open(audio_path, "rb") as audio_file:
                transcript = openai.Audio.transcribe("whisper-1", audio_file)
                return transcript['text']
        except Exception as e:
            click.echo(f"Voice transcription error: {e}")
            return "Could not transcribe voice note"
    
    def generate_summary(self, git_commits, jira_tickets, voice_transcript):
        """Generate AI-powered summary"""
        if not self.config['openai_key']:
            return "AI summary generation not available"
            
        try:
            openai.api_key = self.config['openai_key']
            
            prompt = f"""
            As a technical project manager, summarize this developer's day:
            
            GIT COMMITS:
            {chr(10).join([f"- {c['message']}" for c in git_commits])}
            
            JIRA TICKETS:
            {chr(10).join([f"- {t['key']}: {t['summary']} ({t['status']})" for t in jira_tickets])}
            
            VOICE NOTE TRANSCRIPT:
            {voice_transcript}
            
            Provide:
            1. Overall progress summary
            2. Key achievements
            3. Blockers or challenges mentioned
            4. Tomorrow's focus areas (if mentioned)
            
            Format as markdown with clear headings.
            """
            
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": prompt}]
            )
            
            return response.choices[0].message.content
        except Exception as e:
            click.echo(f"Summary generation error: {e}")
            return "AI summary generation failed"
    
    def generate_markdown_report(self, git_commits, jira_tickets, voice_transcript, ai_summary):
        """Generate final markdown report"""
        today = datetime.now().strftime('%Y-%m-%d')
        
        report = f"""# Daily Dev Log - {today}

## 📊 Summary
{ai_summary}

## 📝 Git Commits
"""
        
        if git_commits:
            for commit in git_commits:
                report += f"- **{commit['hash']}** - {commit['message']} ({commit['author']})\n"
        else:
            report += "No commits today\n"
        
        report += "\n## 🎫 Jira Tickets\n"
        
        if jira_tickets:
            for ticket in jira_tickets:
                report += f"- **[{ticket['key']}]({ticket['url']})** - {ticket['summary']} *({ticket['status']})*\n"
        else:
            report += "No Jira activity today\n"
        
        report += f"\n## 🎤 Voice Note\n\n{voice_transcript}\n"
        
        # Add blocker detection
        blocker_keywords = ['block', 'stuck', 'unable', 'issue', 'problem', 'error']
        lower_transcript = voice_transcript.lower()
        
        blockers = [keyword for keyword in blocker_keywords if keyword in lower_transcript]
        
        if blockers:
            report += "\n## 🚧 Flagged Blockers\n"
            report += "Potential blockers detected in voice note:\n"
            for blocker in set(blockers):
                report += f"- ⚠️ '{blocker}' mentioned\n"
        
        return report

@click.group()
def cli():
    """DevLog - Auto-generate daily developer logs"""
    pass

@cli.command()
def init():
    """Initialize configuration"""
    click.echo("🚀 DevLog Configuration Setup")
    
    config_data = {
        'git_path': click.prompt('Git repository path', default='.'),
        'jira_server': click.prompt('Jira server URL', default=''),
        'jira_email': click.prompt('Jira email', default=''),
        'jira_token': click.prompt('Jira API token', default='', hide_input=True),
        'openai_key': click.prompt('OpenAI API key', default='', hide_input=True),
        'output_dir': click.prompt('Output directory', default='./devlogs')
    }
    
    config_content = CONFIG_TEMPLATE.format(**config_data)
    
    with open('.devlog.env', 'w') as f:
        f.write(config_content)
    
    click.echo("✅ Configuration saved to .devlog.env")

@cli.command()
@click.option('--git', is_flag=True, help='Include Git commits')
@click.option('--jira', is_flag=True, help='Include Jira tickets')
@click.option('--voice', type=click.Path(exists=True), help='Path to voice note file')
@click.option('--output', type=click.Path(), help='Output file path')
def generate(git, jira, voice, output):
    """Generate daily dev log"""
    generator = DevLogGenerator()
    
    if not generator.config:
        return
    
    click.echo("📝 Generating daily dev log...")
    
    # Collect data based on flags
    git_commits = generator.get_today_git_commits() if git else []
    jira_tickets = generator.get_today_jira_tickets() if jira else []
    voice_transcript = generator.transcribe_voice_note(voice) if voice else "No voice note provided"
    
    click.echo(f"📊 Found {len(git_commits)} commits, {len(jira_tickets)} Jira tickets")
    
    # Generate AI summary
    click.echo("🤖 Generating AI summary...")
    ai_summary = generator.generate_summary(git_commits, jira_tickets, voice_transcript)
    
    # Generate report
    click.echo("📄 Generating markdown report...")
    report = generator.generate_markdown_report(git_commits, jira_tickets, voice_transcript, ai_summary)
    
    # Save report
    output_path = output or f"{generator.config['output_dir']}/{datetime.now().strftime('%Y-%m-%d')}.md"
    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    
    with open(output_path, 'w') as f:
        f.write(report)
    
    click.echo(f"✅ Report saved to {output_path}")
    
    # Print preview
    click.echo("\n" + "="*50)
    click.echo(report[:500] + "..." if len(report) > 500 else report)

@cli.command()
def test():
    """Test all connections"""
    generator = DevLogGenerator()
    
    if not generator.config:
        return
        
    click.echo("🔍 Testing connections...")
    
    # Test Git
    commits = generator.get_today_git_commits()
    click.echo(f"✅ Git: {len(commits)} commits found")
    
    # Test Jira
    tickets = generator.get_today_jira_tickets()
    click.echo(f"✅ Jira: {len(tickets)} tickets found")
    
    # Test OpenAI
    if generator.config['openai_key']:
        click.echo("✅ OpenAI: API key configured")
    else:
        click.echo("❌ OpenAI: API key not configured")

if __name__ == '__main__':
    cli()

# 1. Install dependencies
pip install -r requirements.txt

# 2. Initialize configuration
python devlog.py init

# 3. Generate daily log with all sources
python devlog.py --git --jira --voice ~/notes/today.mp3

# 4. Or use specific sources
python devlog.py --git --voice ~/notes/today.mp3  # Git + voice only
python devlog.py --jira --voice ~/notes/today.mp3  # Jira + voice only

# 5. Test all connections
python devlog.py test

# devlog.py
import click
import os
from datetime import datetime, timedelta
import subprocess
from pathlib import Path

class DevLogProto:
    def __init__(self, config_path='.devlog.env'):
        self.config = self._load_config(config_path)
    
    def _load_config(self, path):
        """Load config from simple .env file"""
        if not os.path.exists(path):
            return {}
        
        config = {}
        with open(path) as f:
            for line in f:
                if '=' in line and not line.startswith('#'):
                    key, value = line.strip().split('=', 1)
                    config[key.lower()] = value
        return config
    
    def get_git_commits(self):
        """Get today's git commits"""
        try:
            repo_path = self.config.get('git_repo_path', '.')
            today = datetime.now().strftime('%Y-%m-%d')
            cmd = f"cd {repo_path} && git log --since='{today} 00:00' --until='{today} 23:59' --pretty=format:'%h|%s|%an'"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            commits = []
            for line in result.stdout.strip().split('\n'):
                if line and '|' in line:
                    hash, msg, author = line.split('|', 2)
                    commits.append({'hash': hash, 'message': msg, 'author': author})
            return commits
        except:
            return []
    
    def get_jira_tickets(self):
        """Get Jira tickets (mock version - replace with real API)"""
        # For prototype, returns empty. Real implementation needs jira library
        return []
    
    def transcribe_voice(self, audio_path):
        """Transcribe voice note (mock version - shows placeholder)"""
        if not audio_path:
            return "No voice note provided"
        
        # For real transcription, you'd use OpenAI Whisper API here
        return f"[Voice note transcribed from: {Path(audio_path).name}]"
    
    def generate_summary(self, commits, tickets, voice_text):
        """Simple summary generation without AI"""
        summary = f"### Progress Summary\n- **Commits**: {len(commits)}\n"
        summary += f"- **Jira Activity**: {len(tickets)} tickets updated\n"
        
        # Basic blocker detection
        blocker_words = ['block', 'stuck', 'issue', 'error', 'problem', 'cant', 'cannot']
        lower_voice = voice_text.lower()
        blockers = [word for word in blocker_words if word in lower_voice]
        
        if blockers:
            summary += "\n### 🚧 Potential Blockers Detected\n"
            for blocker in set(blockers):
                summary += f"- '{blocker}' mentioned in voice note\n"
        
        return summary
    
    def generate_report(self, commits, tickets, voice_text):
        """Generate markdown report"""
        today = datetime.now().strftime('%Y-%m-%d')
        
        report = f"""# Dev Log - {today}

## 📊 Summary
{self.generate_summary(commits, tickets, voice_text)}

## 💻 Git Commits
"""
        
        if commits:
            for c in commits:
                report += f"- `{c['hash']}` {c['message']} - *{c['author']}*\n"
        else:
            report += "No commits today\n"
        
        report += "\n## 🎫 Jira Tickets\n"
        if tickets:
            for t in tickets:
                report += f"- **{t}** (integration needed)\n"
        else:
            report += "No Jira activity today\n"
        
        report += f"\n## 🎤 Voice Note\n{voice_text}\n"
        
        return report

@click.group()
def cli():
    """DevLog Prototype - Daily Dev Log Generator"""
    pass

@cli.command()
def init():
    """Create configuration file"""
    click.echo("🚀 Setting up DevLog...")
    
    config = f"""# DevLog Configuration
GIT_REPO_PATH={click.prompt('Git repo path', default='.')}
JIRA_SERVER={click.prompt('Jira server', default='')}
JIRA_EMAIL={click.prompt('Jira email', default='')}
JIRA_TOKEN={click.prompt('Jira token', default='')}
OUTPUT_DIR={click.prompt('Output directory', default='./devlogs')}
OPENAI_KEY={click.prompt('OpenAI key (optional)', default='')}
"""
    
    with open('.devlog.env', 'w') as f:
        f.write(config)
    
    click.echo("✅ Config saved to .devlog.env")

@cli.command()
@click.option('--git', is_flag=True, help='Include Git commits')
@click.option('--jira', is_flag=True, help='Include Jira tickets')
@click.option('--voice', type=click.Path(exists=True), help='Voice note file path')
@click.option('--output', type=click.Path(), help='Custom output path')
def generate(git, jira, voice, output):
    """Generate today's dev log"""
    generator = DevLogProto()
    
    if not os.path.exists('.devlog.env'):
        click.echo("❌ No config found. Run 'devlog.py init' first.")
        return
    
    # Collect data
    commits = generator.get_git_commits() if git else []
    tickets = generator.get_jira_tickets() if jira else []
    voice_text = generator.transcribe_voice(voice) if voice else "No voice note"
    
    # Generate report
    report = generator.generate_report(commits, tickets, voice_text)
    
    # Save to file
    output_dir = generator.config.get('output_dir', './devlogs')
    os.makedirs(output_dir, exist_ok=True)
    
    if output:
        output_path = output
    else:
        output_path = f"{output_dir}/{datetime.now().strftime('%Y-%m-%d')}.md"
    
    with open(output_path, 'w') as f:
        f.write(report)
    
    click.echo(f"✅ Report saved: {output_path}")
    click.echo("\n" + "="*50)
    click.echo(report[:400] + "...")

@cli.command()
def test():
    """Test Git connection"""
    generator = DevLogProto()
    commits = generator.get_git_commits()
    click.echo(f"✅ Git test: Found {len(commits)} commits today")

if __name__ == '__main__':
    cli()

# 1. Install
pip install click

# 2. Configure (creates .devlog.env)
python devlog.py init

# 3. Generate log with just Git
python devlog.py --git

# 4. Generate with voice note
python devlog.py --git --voice ~/Desktop/note.m4a