Implementation Guide: Synthesize stakeholder interview data into themes and findings for deliverables

jabra-direct --check-firmware --update

sudo apt update && sudo apt install python3.11 python3.11-venv -y
python3.11 -m venv ~/interview-synthesis-env
source ~/interview-synthesis-env/bin/activate
pip install openai==1.40.0 tiktoken==0.7.0 python-docx==1.1.0 pandas==2.2.0 pyyaml==6.0.1 python-pptx==0.6.23

mkdir -p ~/interview-synthesis
cd ~/interview-synthesis

cat > .env << 'EOF'
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxx
OPENAI_MODEL=gpt-5.4
OPENAI_ORG_ID=org-xxxxxxxxxxxxxxxxxxxx
MAX_TOKENS_PER_REQUEST=16000
TEMPERATURE=0.3
OUTPUT_DIR=./outputs
TRANSCRIPT_DIR=./transcripts
EOF

python3 -c "from openai import OpenAI; client = OpenAI(); print(client.models.list().data[0].id)"

{"file_path": "{{file_url}}", "project": "{{folder_name}}"}

import json
import os
import yaml
from openai import OpenAI
from pathlib import Path
import tiktoken

class TranscriptProcessor:
    def __init__(self, config_path='config/prompts.yaml'):
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        self.model = os.getenv('OPENAI_MODEL', 'gpt-5.4')
        self.encoding = tiktoken.encoding_for_model(self.model)
        with open(config_path, 'r') as f:
            self.prompts = yaml.safe_load(f)

    def count_tokens(self, text: str) -> int:
        return len(self.encoding.encode(text))

    def chunk_transcript(self, transcript: str, max_tokens: int = 12000) -> list:
        """Split long transcripts into overlapping chunks for processing."""
        paragraphs = transcript.split('\n\n')
        chunks = []
        current_chunk = []
        current_tokens = 0
        for para in paragraphs:
            para_tokens = self.count_tokens(para)
            if current_tokens + para_tokens > max_tokens and current_chunk:
                chunks.append('\n\n'.join(current_chunk))
                # Keep last 2 paragraphs for overlap
                current_chunk = current_chunk[-2:]
                current_tokens = sum(self.count_tokens(p) for p in current_chunk)
            current_chunk.append(para)
            current_tokens += para_tokens
        if current_chunk:
            chunks.append('\n\n'.join(current_chunk))
        return chunks

    def process_transcript(self, transcript_text: str, metadata: dict) -> dict:
        """Process a single interview transcript and return structured analysis."""
        system_prompt = self.prompts['system_prompt']
        user_prompt = self.prompts['user_prompt_template'].format(
            project_name=metadata.get('project_name', 'Unknown Project'),
            project_description=metadata.get('project_description', ''),
            interviewee_name=metadata.get('interviewee_name', 'Unknown'),
            interviewee_role=metadata.get('interviewee_role', 'Unknown'),
            interview_date=metadata.get('interview_date', 'Unknown'),
            interviewer_name=metadata.get('interviewer_name', 'Unknown'),
            transcript_text=transcript_text
        )

        token_count = self.count_tokens(system_prompt + user_prompt)
        if token_count > 120000:  # GPT-5.4 context limit safety margin
            return self._process_chunked(transcript_text, metadata)

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {'role': 'system', 'content': system_prompt},
                {'role': 'user', 'content': user_prompt}
            ],
            temperature=0.3,
            response_format={'type': 'json_object'},
            max_tokens=int(os.getenv('MAX_TOKENS_PER_REQUEST', 16000))
        )

        result = json.loads(response.choices[0].message.content)
        result['_metadata'] = {
            'model': self.model,
            'tokens_used': response.usage.total_tokens,
            'input_tokens': response.usage.prompt_tokens,
            'output_tokens': response.usage.completion_tokens,
            'cost_estimate': self._estimate_cost(response.usage)
        }
        return result

    def _process_chunked(self, transcript_text: str, metadata: dict) -> dict:
        """Process very long transcripts by chunking and merging results."""
        chunks = self.chunk_transcript(transcript_text)
        chunk_results = []
        for i, chunk in enumerate(chunks):
            metadata_copy = metadata.copy()
            metadata_copy['chunk_info'] = f'Part {i+1} of {len(chunks)}'
            result = self.process_transcript(chunk, metadata_copy)
            chunk_results.append(result)
        return self._merge_chunk_results(chunk_results, metadata)

    def _merge_chunk_results(self, results: list, metadata: dict) -> dict:
        """Merge multiple chunk analyses into a single coherent result."""
        merged = {
            'interviewee_summary': results[0].get('interviewee_summary', {}),
            'themes_identified': [],
            'pain_points': [],
            'opportunities': [],
            'recommendations_from_interviewee': [],
            'contradictions_or_tensions': [],
            'notable_quotes': []
        }
        seen_themes = set()
        for r in results:
            for theme in r.get('themes_identified', []):
                if theme['theme_name'] not in seen_themes:
                    merged['themes_identified'].append(theme)
                    seen_themes.add(theme['theme_name'])
            merged['pain_points'].extend(r.get('pain_points', []))
            merged['opportunities'].extend(r.get('opportunities', []))
            merged['recommendations_from_interviewee'].extend(r.get('recommendations_from_interviewee', []))
            merged['contradictions_or_tensions'].extend(r.get('contradictions_or_tensions', []))
            merged['notable_quotes'].extend(r.get('notable_quotes', []))
        return merged

    def _estimate_cost(self, usage) -> str:
        input_cost = (usage.prompt_tokens / 1_000_000) * 2.50
        output_cost = (usage.completion_tokens / 1_000_000) * 10.00
        return f'${input_cost + output_cost:.4f}'

if __name__ == '__main__':
    import sys
    processor = TranscriptProcessor()
    transcript_file = sys.argv[1]
    with open(transcript_file, 'r') as f:
        text = f.read()
    metadata = {
        'project_name': sys.argv[2] if len(sys.argv) > 2 else 'Test',
        'interviewee_name': Path(transcript_file).stem
    }
    result = processor.process_transcript(text, metadata)
    print(json.dumps(result, indent=2))

import json
import os
import yaml
from openai import OpenAI
from datetime import datetime

class ThemeSynthesizer:
    def __init__(self, config_path='config/prompts.yaml'):
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        self.model = os.getenv('OPENAI_MODEL', 'gpt-5.4')
        with open(config_path, 'r') as f:
            self.prompts = yaml.safe_load(f)

    def synthesize_themes(self, interview_analyses: list, project_metadata: dict) -> dict:
        """Synthesize themes across multiple interview analyses."""
        # Prepare condensed version of analyses to fit in context window
        condensed = self._condense_analyses(interview_analyses)

        system_prompt = self.prompts['theme_synthesis_system_prompt']
        user_prompt = self.prompts['theme_synthesis_user_prompt'].format(
            interview_count=len(interview_analyses),
            project_name=project_metadata.get('project_name', 'Unknown'),
            project_description=project_metadata.get('project_description', ''),
            interview_analyses_json=json.dumps(condensed, indent=2)
        )

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {'role': 'system', 'content': system_prompt},
                {'role': 'user', 'content': user_prompt}
            ],
            temperature=0.3,
            response_format={'type': 'json_object'},
            max_tokens=16000
        )

        result = json.loads(response.choices[0].message.content)
        result['_processing_metadata'] = {
            'model': self.model,
            'total_tokens': response.usage.total_tokens,
            'cost_estimate': self._estimate_cost(response.usage),
            'processed_at': datetime.now().isoformat(),
            'interview_count': len(interview_analyses)
        }
        return result

    def _condense_analyses(self, analyses: list) -> list:
        """Remove verbose fields to fit more interviews in context."""
        condensed = []
        for a in analyses:
            c = {
                'interviewee': a.get('interviewee_summary', {}),
                'themes': [{
                    'name': t['theme_name'],
                    'description': t.get('description', ''),
                    'sentiment': t.get('sentiment', ''),
                    'quotes': [q['quote'] for q in t.get('supporting_quotes', [])[:3]]
                } for t in a.get('themes_identified', [])],
                'pain_points': a.get('pain_points', []),
                'opportunities': a.get('opportunities', []),
                'recommendations': a.get('recommendations_from_interviewee', []),
                'contradictions': a.get('contradictions_or_tensions', []),
                'top_quotes': [q['quote'] for q in a.get('notable_quotes', [])[:5]]
            }
            condensed.append(c)
        return condensed

    def _estimate_cost(self, usage) -> str:
        input_cost = (usage.prompt_tokens / 1_000_000) * 2.50
        output_cost = (usage.completion_tokens / 1_000_000) * 10.00
        return f'${input_cost + output_cost:.4f}'

    def generate_theme_summary_markdown(self, synthesis: dict) -> str:
        """Generate a human-readable Markdown summary from the synthesis."""
        md = f"# Thematic Analysis: {synthesis.get('synthesis_metadata', {}).get('project_name', 'Project')}\n\n"
        md += f"## Executive Summary\n\n{synthesis.get('executive_summary', '')}\n\n"
        md += f"## Major Themes\n\n"
        for theme in synthesis.get('major_themes', []):
            freq = theme.get('frequency', {})
            md += f"### {theme['theme_id']}: {theme['theme_name']}\n\n"
            md += f"{theme.get('theme_description', '')}\n\n"
            md += f"**Strength:** {theme.get('strength', 'N/A')} | "
            md += f"**Mentioned by:** {freq.get('stakeholders_mentioning', '?')}/{freq.get('total_stakeholders', '?')} stakeholders\n\n"
            for sp in theme.get('stakeholder_perspectives', []):
                md += f'- **{sp["stakeholder_name"]}** ({sp["role"]}): "{sp["key_quote"]}"\n'
            md += f"\n**Implications:** {theme.get('implications', '')}\n\n"
        md += f"## Areas of Consensus\n\n"
        for area in synthesis.get('alignment_analysis', {}).get('areas_of_consensus', []):
            md += f"- **{area['topic']}**: {area['description']}\n"
        md += f"\n## Areas of Divergence\n\n"
        for div in synthesis.get('alignment_analysis', {}).get('areas_of_divergence', []):
            md += f"### {div['topic']}\n\n{div.get('significance', '')}\n\n"
        md += f"## Priority Findings\n\n"
        for f in synthesis.get('priority_findings', []):
            md += f"- **[{f['finding_id']}]** {f['finding']} (Impact: {f.get('impact', 'N/A')}, Urgency: {f.get('urgency', 'N/A')})\n"
        return md

# Python implementation (deliverable_drafter.py)

import json
import os
from docx import Document
from docx.shared import Inches, Pt, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
from pptx import Presentation
from pptx.util import Inches as PptxInches, Pt as PptxPt
from datetime import datetime

class DeliverableDrafter:
    def __init__(self, template_dir='templates'):
        self.template_dir = template_dir

    def generate_word_report(self, synthesis: dict, output_path: str, template_path: str = None):
        """Generate a Word document from synthesis results."""
        if template_path and os.path.exists(template_path):
            doc = Document(template_path)
        else:
            doc = Document()

        # Title
        title = doc.add_heading(level=0)
        title.text = f"Stakeholder Interview Findings"
        subtitle = doc.add_paragraph()
        subtitle.text = f"{synthesis.get('synthesis_metadata', {}).get('project_name', 'Project')}\n"
        subtitle.text += f"Date: {datetime.now().strftime('%B %d, %Y')}\n"
        subtitle.text += f"Interviews Conducted: {synthesis.get('synthesis_metadata', {}).get('total_interviews', 'N/A')}"
        subtitle.style = doc.styles['Subtitle']

        # Executive Summary
        doc.add_heading('Executive Summary', level=1)
        exec_summary = synthesis.get('executive_summary', '')
        for para in exec_summary.split('\n\n'):
            doc.add_paragraph(para.strip())

        # Key Messages Box
        rec_structure = synthesis.get('recommended_deliverable_structure', {})
        key_messages = rec_structure.get('key_messages', [])
        if key_messages:
            doc.add_heading('Key Messages', level=2)
            for msg in key_messages:
                p = doc.add_paragraph(msg, style='List Bullet')

        # Major Themes
        doc.add_heading('Major Themes', level=1)
        for theme in synthesis.get('major_themes', []):
            doc.add_heading(f"{theme['theme_id']}: {theme['theme_name']}", level=2)
            doc.add_paragraph(theme.get('theme_description', ''))

            # Frequency info
            freq = theme.get('frequency', {})
            freq_text = f"Mentioned by {freq.get('stakeholders_mentioning', '?')} of {freq.get('total_stakeholders', '?')} stakeholders ({freq.get('percentage', 0):.0f}%). Theme strength: {theme.get('strength', 'N/A').upper()}"
            p = doc.add_paragraph(freq_text)
            p.runs[0].italic = True

            # Stakeholder perspectives with quotes
            if theme.get('stakeholder_perspectives'):
                doc.add_heading('Stakeholder Perspectives', level=3)
                for sp in theme['stakeholder_perspectives']:
                    p = doc.add_paragraph()
                    runner = p.add_run(f"{sp['stakeholder_name']} ({sp['role']}): ")
                    runner.bold = True
                    p.add_run(sp.get('perspective', ''))
                    if sp.get('key_quote'):
                        quote_para = doc.add_paragraph()
                        quote_run = quote_para.add_run(f'"{sp["key_quote"]}')
                        quote_run.italic = True
                        quote_para.paragraph_format.left_indent = Inches(0.5)

            # Implications
            if theme.get('implications'):
                doc.add_heading('Implications', level=3)
                doc.add_paragraph(theme['implications'])

            # Recommended Actions
            if theme.get('recommended_actions'):
                doc.add_heading('Recommended Actions', level=3)
                for action in theme['recommended_actions']:
                    doc.add_paragraph(action, style='List Bullet')

        # Alignment Analysis
        alignment = synthesis.get('alignment_analysis', {})
        doc.add_heading('Stakeholder Alignment Analysis', level=1)

        if alignment.get('areas_of_consensus'):
            doc.add_heading('Areas of Consensus', level=2)
            for area in alignment['areas_of_consensus']:
                doc.add_paragraph(f"{area['topic']}: {area['description']}")

        if alignment.get('areas_of_divergence'):
            doc.add_heading('Areas of Divergence', level=2)
            for div in alignment['areas_of_divergence']:
                doc.add_heading(div['topic'], level=3)
                doc.add_paragraph(div.get('significance', ''))
                pa = div.get('perspective_a', {})
                pb = div.get('perspective_b', {})
                if pa:
                    p = doc.add_paragraph()
                    p.add_run('View A: ').bold = True
                    p.add_run(f"{pa.get('position', '')} (Held by: {', '.join(pa.get('stakeholders', []))}")
                if pb:
                    p = doc.add_paragraph()
                    p.add_run('View B: ').bold = True
                    p.add_run(f"{pb.get('position', '')} (Held by: {', '.join(pb.get('stakeholders', []))}")

        # Priority Findings
        doc.add_heading('Priority Findings', level=1)
        for finding in synthesis.get('priority_findings', []):
            p = doc.add_paragraph()
            p.add_run(f"[{finding['finding_id']}] ").bold = True
            p.add_run(finding['finding'])
            detail = f"Evidence: {finding.get('evidence_strength', 'N/A')} | Impact: {finding.get('impact', 'N/A')} | Urgency: {finding.get('urgency', 'N/A')}"
            det_p = doc.add_paragraph(detail)
            det_p.runs[0].italic = True

        # Cross-cutting Insights
        if synthesis.get('cross_cutting_insights'):
            doc.add_heading('Cross-Cutting Insights', level=1)
            for insight in synthesis['cross_cutting_insights']:
                doc.add_paragraph(insight['insight'])
                if insight.get('evidence'):
                    ev = doc.add_paragraph(f"Evidence: {insight['evidence']}")
                    ev.runs[0].italic = True

        # Save
        doc.save(output_path)
        return output_path

    def generate_pptx_summary(self, synthesis: dict, output_path: str, template_path: str = None):
        """Generate a PowerPoint summary from synthesis results."""
        if template_path and os.path.exists(template_path):
            prs = Presentation(template_path)
        else:
            prs = Presentation()

        # Title slide
        slide = prs.slides.add_slide(prs.slide_layouts[0])
        slide.shapes.title.text = 'Stakeholder Interview Findings'
        slide.placeholders[1].text = f"{synthesis.get('synthesis_metadata', {}).get('project_name', '')}\n{datetime.now().strftime('%B %Y')}"

        # Executive Summary slide
        slide = prs.slides.add_slide(prs.slide_layouts[1])
        slide.shapes.title.text = 'Executive Summary'
        exec_text = synthesis.get('executive_summary', '')
        # Truncate for slide
        if len(exec_text) > 800:
            exec_text = exec_text[:797] + '...'
        slide.placeholders[1].text = exec_text

        # Key Messages slide
        key_messages = synthesis.get('recommended_deliverable_structure', {}).get('key_messages', [])
        if key_messages:
            slide = prs.slides.add_slide(prs.slide_layouts[1])
            slide.shapes.title.text = 'Key Messages'
            body = '\n'.join([f'• {msg}' for msg in key_messages])
            slide.placeholders[1].text = body

        # Theme overview slide
        themes = synthesis.get('major_themes', [])
        if themes:
            slide = prs.slides.add_slide(prs.slide_layouts[1])
            slide.shapes.title.text = f'Themes Overview ({len(themes)} Themes Identified)'
            theme_list = '\n'.join([f"• {t['theme_id']}: {t['theme_name']} ({t.get('strength', 'N/A')})" for t in themes])
            slide.placeholders[1].text = theme_list

        # Individual theme slides
        for theme in themes[:8]:  # Limit to 8 theme slides
            slide = prs.slides.add_slide(prs.slide_layouts[1])
            slide.shapes.title.text = f"{theme['theme_id']}: {theme['theme_name']}"
            freq = theme.get('frequency', {})
            content = f"{theme.get('theme_description', '')}\n\n"
            content += f"Mentioned by {freq.get('stakeholders_mentioning', '?')}/{freq.get('total_stakeholders', '?')} stakeholders\n\n"
            perspectives = theme.get('stakeholder_perspectives', [])[:3]
            for sp in perspectives:
                content += f'• "{sp.get("key_quote", "")}" — {sp["stakeholder_name"]}\n'
            if theme.get('implications'):
                content += f"\nImplications: {theme['implications']}"
            slide.placeholders[1].text = content

        # Priority Findings slide
        findings = synthesis.get('priority_findings', [])
        if findings:
            slide = prs.slides.add_slide(prs.slide_layouts[1])
            slide.shapes.title.text = 'Priority Findings'
            findings_text = '\n'.join([f"• [{f['finding_id']}] {f['finding']}" for f in findings[:6]])
            slide.placeholders[1].text = findings_text

        prs.save(output_path)
        return output_path

if __name__ == '__main__':
    import sys
    synthesis_file = sys.argv[1]
    with open(synthesis_file, 'r') as f:
        synthesis = json.load(f)
    drafter = DeliverableDrafter()
    drafter.generate_word_report(synthesis, 'outputs/findings_report.docx')
    drafter.generate_pptx_summary(synthesis, 'outputs/findings_summary.pptx')
    print('Deliverables generated successfully.')

# Main orchestrator for interview synthesis pipeline

#!/usr/bin/env python3
# synthesis_pipeline.py - Main orchestrator for interview synthesis pipeline

import json
import os
import sys
import argparse
import glob
from pathlib import Path
from datetime import datetime
from transcript_processor import TranscriptProcessor
from theme_synthesizer import ThemeSynthesizer
from deliverable_drafter import DeliverableDrafter

def load_project_config(config_path: str) -> dict:
    """Load project configuration from JSON file."""
    with open(config_path, 'r') as f:
        return json.load(f)

def discover_transcripts(transcript_dir: str) -> list:
    """Find all transcript files in the specified directory."""
    extensions = ['*.txt', '*.md', '*.vtt', '*.srt']
    files = []
    for ext in extensions:
        files.extend(glob.glob(os.path.join(transcript_dir, ext)))
    return sorted(files)

def parse_transcript_metadata(filepath: str) -> dict:
    """Extract metadata from transcript filename convention.
    Expected format: YYYY-MM-DD_IntervieweeName_Role.txt
    Falls back to filename as interviewee name if convention not followed."""
    stem = Path(filepath).stem
    parts = stem.split('_')
    if len(parts) >= 3:
        return {
            'interview_date': parts[0],
            'interviewee_name': parts[1].replace('-', ' '),
            'interviewee_role': ' '.join(parts[2:]).replace('-', ' ')
        }
    return {
        'interview_date': 'Unknown',
        'interviewee_name': stem.replace('-', ' ').replace('_', ' '),
        'interviewee_role': 'Unknown'
    }

def main():
    parser = argparse.ArgumentParser(description='AI Interview Synthesis Pipeline')
    parser.add_argument('--input', '-i', required=True, help='Directory of transcript files OR single transcript file')
    parser.add_argument('--project', '-p', required=True, help='Project name')
    parser.add_argument('--description', '-d', default='', help='Project description for context')
    parser.add_argument('--output', '-o', default='outputs', help='Output directory')
    parser.add_argument('--config', '-c', default=None, help='Path to project config JSON')
    parser.add_argument('--word-template', default=None, help='Path to Word template .docx')
    parser.add_argument('--pptx-template', default=None, help='Path to PowerPoint template .pptx')
    parser.add_argument('--skip-transcripts', action='store_true', help='Skip Stage 1 (use existing analyses)')
    parser.add_argument('--skip-deliverables', action='store_true', help='Skip Stage 3 (no deliverable generation)')
    args = parser.parse_args()

    # Setup output directory
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    output_dir = os.path.join(args.output, f"{args.project.replace(' ', '_')}_{timestamp}")
    os.makedirs(output_dir, exist_ok=True)
    os.makedirs(os.path.join(output_dir, 'individual_analyses'), exist_ok=True)

    project_metadata = {
        'project_name': args.project,
        'project_description': args.description,
        'processed_at': datetime.now().isoformat()
    }

    if args.config:
        project_metadata.update(load_project_config(args.config))

    print(f'\n=== Interview Synthesis Pipeline ===')
    print(f'Project: {args.project}')
    print(f'Output: {output_dir}')

    # Stage 1: Process Individual Transcripts
    individual_analyses = []
    if not args.skip_transcripts:
        print(f'\n--- Stage 1: Individual Transcript Analysis ---')
        processor = TranscriptProcessor()

        if os.path.isdir(args.input):
            transcript_files = discover_transcripts(args.input)
        else:
            transcript_files = [args.input]

        print(f'Found {len(transcript_files)} transcript(s)')

        for i, filepath in enumerate(transcript_files, 1):
            print(f'  Processing [{i}/{len(transcript_files)}]: {Path(filepath).name}')
            with open(filepath, 'r', encoding='utf-8') as f:
                transcript_text = f.read()

            metadata = parse_transcript_metadata(filepath)
            metadata.update(project_metadata)

            analysis = processor.process_transcript(transcript_text, metadata)
            individual_analyses.append(analysis)

            # Save individual analysis
            analysis_path = os.path.join(output_dir, 'individual_analyses', f'{Path(filepath).stem}_analysis.json')
            with open(analysis_path, 'w') as f:
                json.dump(analysis, f, indent=2)
            print(f'    -> Saved: {analysis_path}')
            if analysis.get('_metadata', {}).get('cost_estimate'):
                print(f'    -> Cost: {analysis["_metadata"]["cost_estimate"]}')
    else:
        print('\n--- Stage 1: SKIPPED (loading existing analyses) ---')
        analysis_dir = os.path.join(output_dir, 'individual_analyses')
        for f in sorted(glob.glob(os.path.join(analysis_dir, '*_analysis.json'))):
            with open(f, 'r') as fh:
                individual_analyses.append(json.load(fh))
        print(f'Loaded {len(individual_analyses)} existing analyses')

    if not individual_analyses:
        print('ERROR: No transcript analyses found. Exiting.')
        sys.exit(1)

    # Stage 2: Cross-Interview Theme Synthesis
    print(f'\n--- Stage 2: Cross-Interview Theme Synthesis ---')
    print(f'Synthesizing {len(individual_analyses)} interviews...')
    synthesizer = ThemeSynthesizer()
    synthesis = synthesizer.synthesize_themes(individual_analyses, project_metadata)

    synthesis_path = os.path.join(output_dir, 'theme_synthesis.json')
    with open(synthesis_path, 'w') as f:
        json.dump(synthesis, f, indent=2)
    print(f'  -> Saved: {synthesis_path}')

    # Save markdown version
    md_path = os.path.join(output_dir, 'theme_synthesis.md')
    md_content = synthesizer.generate_theme_summary_markdown(synthesis)
    with open(md_path, 'w') as f:
        f.write(md_content)
    print(f'  -> Markdown: {md_path}')

    theme_count = len(synthesis.get('major_themes', []))
    finding_count = len(synthesis.get('priority_findings', []))
    print(f'  -> {theme_count} major themes, {finding_count} priority findings identified')

    # Stage 3: Generate Deliverable Drafts
    if not args.skip_deliverables:
        print(f'\n--- Stage 3: Deliverable Draft Generation ---')
        drafter = DeliverableDrafter()

        word_path = os.path.join(output_dir, f"{args.project.replace(' ', '_')}_Findings_Report.docx")
        drafter.generate_word_report(synthesis, word_path, args.word_template)
        print(f'  -> Word Report: {word_path}')

        pptx_path = os.path.join(output_dir, f"{args.project.replace(' ', '_')}_Findings_Summary.pptx")
        drafter.generate_pptx_summary(synthesis, pptx_path, args.pptx_template)
        print(f'  -> PowerPoint Summary: {pptx_path}')

    # Summary
    print(f'\n=== Pipeline Complete ===')
    print(f'All outputs saved to: {output_dir}')
    total_cost = synthesis.get('_processing_metadata', {}).get('cost_estimate', 'N/A')
    print(f'Estimated API cost for synthesis stage: {total_cost}')
    print(f'Review the theme_synthesis.md file for a human-readable summary.')
    print(f'Open the Word/PPTX files and refine with Microsoft 365 Copilot for final polish.')

if __name__ == '__main__':
    main()

# Flask API for Zapier integration. Run with: python webhook_api.py or
# deploy via gunicorn.

# webhook_api.py - Flask API for Zapier integration
# Run with: python webhook_api.py (or deploy via gunicorn)

import os
import json
import subprocess
import threading
from flask import Flask, request, jsonify
import requests
from datetime import datetime

app = Flask(__name__)

# Configuration
PIPELINE_SCRIPT = os.getenv('PIPELINE_SCRIPT', './synthesis_pipeline.py')
TRANSCRIPT_DIR = os.getenv('TRANSCRIPT_DIR', './transcripts')
OUTPUT_DIR = os.getenv('OUTPUT_DIR', './outputs')
CALLBACK_URL = os.getenv('ZAPIER_CALLBACK_URL', '')  # Zapier webhook catch URL
API_KEY = os.getenv('WEBHOOK_API_KEY', 'change-me-to-a-secure-key')

def verify_api_key(req):
    """Simple API key authentication."""
    key = req.headers.get('X-API-Key') or req.args.get('api_key')
    return key == API_KEY

def run_pipeline_async(project_name, transcript_dir, description=''):
    """Run the synthesis pipeline in a background thread."""
    def _run():
        try:
            cmd = [
                'python3', PIPELINE_SCRIPT,
                '--input', transcript_dir,
                '--project', project_name,
                '--description', description,
                '--output', OUTPUT_DIR
            ]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)

            # Send callback to Zapier
            if CALLBACK_URL:
                payload = {
                    'project_name': project_name,
                    'status': 'success' if result.returncode == 0 else 'error',
                    'output': result.stdout[-500:] if result.stdout else '',
                    'error': result.stderr[-500:] if result.stderr else '',
                    'completed_at': datetime.now().isoformat()
                }
                requests.post(CALLBACK_URL, json=payload, timeout=30)
        except Exception as e:
            if CALLBACK_URL:
                requests.post(CALLBACK_URL, json={
                    'project_name': project_name,
                    'status': 'error',
                    'error': str(e),
                    'completed_at': datetime.now().isoformat()
                }, timeout=30)

    thread = threading.Thread(target=_run, daemon=True)
    thread.start()

@app.route('/api/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy', 'timestamp': datetime.now().isoformat()})

@app.route('/api/synthesize', methods=['POST'])
def synthesize():
    if not verify_api_key(request):
        return jsonify({'error': 'Unauthorized'}), 401

    data = request.json or {}
    project_name = data.get('project', 'Unknown Project')
    transcript_dir = data.get('transcript_dir', TRANSCRIPT_DIR)
    description = data.get('description', '')

    if not os.path.exists(transcript_dir):
        return jsonify({'error': f'Transcript directory not found: {transcript_dir}'}), 400

    run_pipeline_async(project_name, transcript_dir, description)

    return jsonify({
        'status': 'processing',
        'project': project_name,
        'message': 'Pipeline started. Callback will be sent to Zapier when complete.',
        'started_at': datetime.now().isoformat()
    }), 202

@app.route('/api/status', methods=['GET'])
def status():
    if not verify_api_key(request):
        return jsonify({'error': 'Unauthorized'}), 401
    # List recent output directories
    outputs = []
    if os.path.exists(OUTPUT_DIR):
        for d in sorted(os.listdir(OUTPUT_DIR), reverse=True)[:10]:
            dir_path = os.path.join(OUTPUT_DIR, d)
            if os.path.isdir(dir_path):
                has_synthesis = os.path.exists(os.path.join(dir_path, 'theme_synthesis.json'))
                outputs.append({'project': d, 'complete': has_synthesis})
    return jsonify({'recent_runs': outputs})

if __name__ == '__main__':
    port = int(os.getenv('PORT', 8443))
    app.run(host='0.0.0.0', port=port, debug=False)
    # For production: gunicorn -w 2 -b 0.0.0.0:8443 webhook_api:app

pip install flask==3.0.0 gunicorn==22.0.0 requests==2.32.0

pip list --outdated