#!/usr/bin/env python3
"""
Transcribe audio to text using Whisper
Usage: python3 voice-to-text.py <audio_file>
"""

import sys
import subprocess
import os

def transcribe_whisper_local(audio_path, model="base"):
    """Transcribe using local Whisper"""
    result = subprocess.run(
        ["whisper", audio_path, "--model", model, "--language", "id", "--output_format", "txt"],
        capture_output=True,
        text=True
    )
    
    # Read output file
    txt_path = audio_path.replace(os.path.splitext(audio_path)[1], ".txt")
    with open(txt_path, "r") as f:
        return f.read().strip()

def transcribe_whisper_api(audio_path):
    """Transcribe using OpenAI API"""
    import openai
    
    with open(audio_path, "rb") as audio_file:
        transcript = openai.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file,
            language="id"  # or "en" for English
        )
    return transcript.text

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 voice-to-text.py <audio_file>")
        sys.exit(1)
    
    audio_path = sys.argv[1]
    
    print("🎙️ Transcribing...")
    
    # Choose method
    if os.getenv("OPENAI_API_KEY"):
        text = transcribe_whisper_api(audio_path)
    else:
        text = transcribe_whisper_local(audio_path)
    
    print("✅ Transcription:")
    print(text)
    
    # Save to file
    output_path = audio_path + ".transcript.txt"
    with open(output_path, "w") as f:
        f.write(text)
    
    print(f"\n📝 Saved to: {output_path}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Extract action items from transcript using AI
Usage: python3 extract-actions.py <transcript_file>
"""

import sys
import json
import re
from datetime import datetime, timedelta

def extract_with_ai(transcript):
    """Use OpenClaw/AI to extract structured tasks"""
    
    prompt = f"""Analyze this transcript and extract action items.

Transcript:
"""{transcript}"""

Extract in this JSON format:
{{
  "summary": "Brief summary of the discussion",
  "tasks": [
    {{
      "task": "Clear task description",
      "deadline": "YYYY-MM-DD or null",
      "priority": "high/medium/low",
      "category": "work/personal/urgent",
      "context": "Any relevant context"
    }}
  ]
}}

Guidelines:
- Convert vague statements to clear action items
- Infer deadlines from phrases like "besok", "minggu depan", "hari Jumat"
- Set priority based on urgency words
- Include context for clarity"""

    # Call your AI (OpenClaw, OpenAI, etc.)
    response = call_ai_model(prompt)
    return json.loads(response)

def parse_relative_dates(text):
    """Convert relative dates to absolute"""
    today = datetime.now()
    
    mappings = {
        r"besok|tomorrow": today + timedelta(days=1),
        r"lusa": today + timedelta(days=2),
        r"minggu depan|next week": today + timedelta(weeks=1),
        r"bulan depan|next month": today + timedelta(days=30),
        r"hari ini|today": today,
    }
    
    for pattern, date in mappings.items():
        if re.search(pattern, text, re.IGNORECASE):
            return date.strftime("%Y-%m-%d")
    
    return None

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 extract-actions.py <transcript_file>")
        sys.exit(1)
    
    transcript_path = sys.argv[1]
    
    with open(transcript_path, "r") as f:
        transcript = f.read()
    
    print("🤖 Extracting action items...")
    result = extract_with_ai(transcript)
    
    print(f"\n📋 Summary: {result['summary']}")
    print(f"\n✅ Found {len(result['tasks'])} tasks:\n")
    
    for i, task in enumerate(result['tasks'], 1):
        print(f"{i}. {task['task']}")
        if task['deadline']:
            print(f"   📅 Deadline: {task['deadline']}")
        print(f"   🏷️ Priority: {task['priority']}")
        print(f"   📂 Category: {task['category']}")
        print()
    
    # Save structured data
    output_path = transcript_path.replace(".txt", ".tasks.json")
    with open(output_path, "w") as f:
        json.dump(result, f, indent=2)
    
    print(f"💾 Saved to: {output_path}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create tasks in Google Tasks from JSON
Usage: python3 create-tasks.py <tasks_json_file>
"""

import sys
import json
import subprocess

def create_google_task(task):
    """Create task using gog CLI"""
    
    # Build command
    cmd = ["gog", "tasks", "create", task['task']]
    
    # Add notes with context
    notes = f"From voice memo\nPriority: {task['priority']}\nContext: {task.get('context', 'N/A')}"
    cmd.extend(["--notes", notes])
    
    # Add due date if available
    if task.get('deadline'):
        cmd.extend(["--due", task['deadline']])
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.returncode == 0

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 create-tasks.py <tasks_json_file>")
        sys.exit(1)
    
    with open(sys.argv[1], "r") as f:
        data = json.load(f)
    
    print(f"📝 Creating {len(data['tasks'])} tasks...\n")
    
    created = 0
    for task in data['tasks']:
        if create_google_task(task):
            print(f"✅ Created: {task['task'][:50]}...")
            created += 1
        else:
            print(f"❌ Failed: {task['task'][:50]}...")
    
    print(f"\n📊 Summary: {created}/{len(data['tasks'])} tasks created")

if __name__ == "__main__":
    main()

# In your Telegram bot handler
import subprocess
import os

async def handle_voice(message):
    """Process voice messages"""
    
    # Download voice file
    voice_file = await message.voice.get_file()
    audio_path = f"/tmp/voice_{message.message_id}.ogg"
    await voice_file.download(audio_path)
    
    # Process
    await message.reply("🎙️ Processing your voice memo...")
    
    result = subprocess.run(
        ["bash", "scripts/voice-to-action.sh", audio_path],
        capture_output=True,
        text=True
    )
    
    # Parse results
    if result.returncode == 0:
        # Extract task count from output
        summary = parse_summary(result.stdout)
        await message.reply(
            f"✅ Voice memo processed!\n\n"
            f"📋 {summary['task_count']} tasks created\n"
            f"📅 {summary['with_deadline']} with deadlines\n"
            f"🔥 {summary['high_priority']} high priority\n\n"
            f"Check your Google Tasks!"
        )
    else:
        await message.reply("❌ Failed to process. Please try again.")
    
    # Cleanup
    os.remove(audio_path)

def detect_language(text):
    """Detect language and set Whisper language"""
    # Simple heuristic
    indonesian_words = ["yang", "dan", "dengan", "untuk", "dari"]
    english_words = ["the", "and", "with", "for", "from"]
    
    words = text.lower().split()
    id_score = sum(1 for w in words if w in indonesian_words)
    en_score = sum(1 for w in words if w in english_words)
    
    return "id" if id_score > en_score else "en"

def schedule_reminder(task, minutes_before=30):
    """Schedule reminder before deadline"""
    # Use cron or system scheduler
    pass

def link_to_original(task_id, audio_path):
    """Keep reference to original voice memo"""
    # Upload audio to Drive, link in task notes
    pass

import todoist_api_python

def create_todoist_task(task):
    api = todoist_api_python.TodoistAPI("your-token")
    api.add_task(
        content=task['task'],
        due_date=task.get('deadline'),
        priority=4 if task['priority'] == 'high' else 1
    )

from notion_client import Client

def create_notion_task(task):
    notion = Client(auth="your-token")
    notion.pages.create(
        parent={"database_id": "your-db-id"},
        properties={
            "Name": {"title": [{"text": {"content": task['task']}}]},
            "Status": {"select": {"name": "To Do"}},
            "Due": {"date": {"start": task.get('deadline')}} if task.get('deadline') else None
        }
    )