Content Ops

{
  "name": "content-ops",
  "installedAt": 1776152091412,
  "source": "marketplace",
  "iconSource": "content-ops",
  "version": "1.0.0"
}

# ── Required ──

# Anthropic API key (for LLM-powered features: editorial brain, content transform, expert panel)
ANTHROPIC_API_KEY=sk-ant-...

# ── Optional: Data directory ──

# Override default data directory (default: ./data/)
# CONTENT_OPS_DATA_DIR=./data

# ── Optional: Editorial Brain ──

# Override default model for editorial brain clip discovery
# EDITORIAL_BRAIN_MODEL=claude-sonnet-4-20250514

# ── Optional: Quote Mining Engine ──

# Path to feeds JSON config: {"Feed Name": "https://feed-url/rss", ...}
# QUOTE_MINING_FEEDS_FILE=./config/feeds.json

# Inline feeds JSON (alternative to file)
# QUOTE_MINING_FEEDS={"My Podcast": "https://feeds.example.com/rss"}

# Directory containing meeting notes (markdown files) to scan for quotes
# QUOTE_MINING_NOTES_DIR=./notes/

# Speaker name to extract from meeting notes (e.g., "John Smith")
# QUOTE_MINING_SPEAKER=

# ── Optional: Content Transform ──

# Voice configuration file (markdown describing your brand voice)
# VOICE_CONFIG_FILE=./config/voice.md

# Style guide file (markdown with writing style rules)
# STYLE_GUIDE_FILE=./config/style-guide.md

{
  "My Marketing Podcast": "https://feeds.example.com/marketing-podcast/rss",
  "Industry Show": "https://feeds.example.com/industry-show/rss"
}

# Core dependencies
anthropic>=0.39.0        # Claude API client (for LLM-powered features)
feedparser>=6.0.0        # RSS feed parsing (quote mining engine)

# Optional: for video clip cutting (editorial brain)
# yt-dlp                 # YouTube subtitle/video download (install separately)
# ffmpeg                 # Video cutting (install via system package manager)

#!/usr/bin/env python3
"""
Content Quality Gate — CI/CD-style gate for content publishing.

Filters drafts through quality scorer before they publish.
Nothing goes live without passing automated quality scoring.

Usage:
    python content-quality-gate.py --input drafts.json
    python content-quality-gate.py --input drafts.json --conservative
    python content-quality-gate.py --input drafts.json --threshold 75
"""

import json
import os
import sys
import argparse
from pathlib import Path
from datetime import datetime, timezone
import subprocess

SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_DIR = SCRIPT_DIR.parent
DATA_DIR = Path(os.environ.get("CONTENT_OPS_DATA_DIR", PROJECT_DIR / "data"))

DRAFTS_INPUT_FILE = DATA_DIR / "content-drafts-latest.json"
DRAFTS_OUTPUT_FILE = DATA_DIR / "content-drafts-filtered.json"
QUALITY_SCORES_FILE = DATA_DIR / "quality-scores-latest.json"


def run_quality_scorer(input_file, verbose=False):
    """Run the quality scorer on the drafts file."""
    scorer_script = SCRIPT_DIR / "content-quality-scorer.py"
    cmd = [
        sys.executable,
        str(scorer_script),
        "--input", str(input_file)
    ]

    if verbose:
        cmd.append("--verbose")

    print(f"🔍 Running quality scorer...")
    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        print(f"❌ Quality scorer failed:")
        print(f"STDOUT: {result.stdout}")
        print(f"STDERR: {result.stderr}")
        return False

    if verbose:
        print(result.stdout)

    return True


def load_quality_scores():
    """Load the latest quality scoring results."""
    if not QUALITY_SCORES_FILE.exists():
        print(f"❌ Quality scores file not found: {QUALITY_SCORES_FILE}")
        return None

    try:
        with open(QUALITY_SCORES_FILE) as f:
            return json.load(f)
    except Exception as e:
        print(f"❌ Error loading quality scores: {e}")
        return None


def filter_drafts_by_quality(drafts, quality_results, conservative_mode=False):
    """Filter drafts based on quality scores."""
    if not quality_results or "results" not in quality_results:
        print("❌ No quality results available for filtering")
        return drafts, []

    passed_ids = set()
    failed_drafts = []
    quality_by_id = {}

    for result in quality_results["results"]:
        draft_id = result.get("draft_id")
        quality_by_id[draft_id] = result

        if result.get("passed", False):
            passed_ids.add(draft_id)
        else:
            failed_drafts.append({
                "draft_id": draft_id,
                "platform": result.get("platform"),
                "score": result.get("total_score"),
                "reasons": result.get("failure_reasons", [])
            })

    filtered_drafts = []

    for draft in drafts:
        draft_id = draft.get("id")

        if draft_id in quality_by_id:
            quality_info = quality_by_id[draft_id]
            draft["quality_score"] = quality_info.get("total_score")
            draft["quality_passed"] = quality_info.get("passed")
            draft["quality_reasons"] = quality_info.get("failure_reasons", [])
            draft["quality_scored_at"] = quality_info.get("scored_at")

        if conservative_mode:
            filtered_drafts.append(draft)
        elif draft_id in passed_ids:
            filtered_drafts.append(draft)

    return filtered_drafts, failed_drafts


def save_filtered_drafts(original_data, filtered_drafts, quality_results):
    """Save filtered drafts with quality metadata."""
    filtered_data = original_data.copy()
    filtered_data["drafts"] = filtered_drafts
    filtered_data["filtered_at"] = datetime.now(timezone.utc).isoformat()
    filtered_data["quality_gate_applied"] = True
    filtered_data["original_draft_count"] = original_data.get("draft_count", len(original_data.get("drafts", [])))
    filtered_data["filtered_draft_count"] = len(filtered_drafts)
    filtered_data["quality_threshold"] = quality_results.get("threshold")
    filtered_data["quality_pass_rate"] = quality_results.get("pass_rate")
    filtered_data["quality_average_score"] = quality_results.get("average_score")
    filtered_data["draft_count"] = len(filtered_drafts)

    DRAFTS_OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
    with open(DRAFTS_OUTPUT_FILE, 'w') as f:
        json.dump(filtered_data, f, indent=2)

    return filtered_data


def run_quality_gate(input_file=None, conservative_mode=False, verbose=False):
    """Run the complete quality gate process."""
    input_path = Path(input_file) if input_file else DRAFTS_INPUT_FILE

    if not input_path.exists():
        print(f"❌ Input file not found: {input_path}")
        return None

    try:
        with open(input_path) as f:
            original_data = json.load(f)
        drafts = original_data.get("drafts", [])
        print(f"📊 Loaded {len(drafts)} drafts from {input_path}")
    except Exception as e:
        print(f"❌ Error loading drafts: {e}")
        return None

    if not drafts:
        print("❌ No drafts found in input file")
        return None

    if not run_quality_scorer(input_path, verbose):
        return None

    quality_results = load_quality_scores()
    if not quality_results:
        return None

    filtered_drafts, failed_drafts = filter_drafts_by_quality(drafts, quality_results, conservative_mode)
    filtered_data = save_filtered_drafts(original_data, filtered_drafts, quality_results)

    original_count = len(drafts)
    filtered_count = len(filtered_drafts)
    filtered_out = original_count - filtered_count

    print(f"\n{'='*60}")
    print(f"QUALITY GATE RESULTS")
    print(f"{'='*60}")
    print(f"Original drafts: {original_count}")
    print(f"Passed quality gate: {filtered_count}")
    print(f"Filtered out: {filtered_out}")
    print(f"Pass rate: {quality_results.get('pass_rate', 0):.1f}%")
    print(f"Average score: {quality_results.get('average_score', 0):.1f}/100")
    print(f"Threshold: {quality_results.get('threshold', 60)}/100")

    if conservative_mode:
        print(f"\n⚠️  CONSERVATIVE MODE: All drafts passed through with quality flags")

    platform_stats = {}
    for draft in filtered_drafts:
        platform = draft.get("platform", "unknown")
        platform_stats[platform] = platform_stats.get(platform, 0) + 1

    if platform_stats:
        print(f"\n📱 Filtered Drafts by Platform:")
        for platform, count in sorted(platform_stats.items()):
            print(f"  {platform}: {count}")

    if failed_drafts:
        failure_reasons = {}
        for failed in failed_drafts:
            for reason in failed["reasons"]:
                failure_reasons[reason] = failure_reasons.get(reason, 0) + 1

        if failure_reasons:
            print(f"\n❌ Top Failure Reasons:")
            for reason, count in sorted(failure_reasons.items(), key=lambda x: x[1], reverse=True)[:3]:
                print(f"  {reason}: {count} drafts")

    print(f"\n💾 Filtered drafts saved to: {DRAFTS_OUTPUT_FILE}")

    if filtered_count == 0:
        print("\n⚠️  WARNING: No drafts passed quality gate!")
        print("Consider lowering threshold or improving content quality.")
        return None

    return filtered_data


def main():
    parser = argparse.ArgumentParser(description="Filter content drafts through quality gate")
    parser.add_argument("--input", type=str, help="Input drafts JSON file")
    parser.add_argument("--conservative", action="store_true", help="Pass all drafts but add quality flags")
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
    parser.add_argument("--threshold", type=float, help="Override quality threshold")
    args = parser.parse_args()

    if args.threshold:
        weights_file = DATA_DIR / "quality-scorer-weights.json"
        if weights_file.exists():
            try:
                with open(weights_file) as f:
                    weights_data = json.load(f)
                weights_data["threshold"] = args.threshold
                with open(weights_file, 'w') as f:
                    json.dump(weights_data, f, indent=2)
                print(f"🎯 Set threshold to {args.threshold}")
            except Exception as e:
                print(f"⚠ Could not update threshold: {e}")

    filtered_data = run_quality_gate(
        input_file=args.input,
        conservative_mode=args.conservative,
        verbose=args.verbose
    )

    if filtered_data:
        filtered_count = filtered_data.get("filtered_draft_count", 0)
        if filtered_count > 0:
            print(f"\n📤 Next: Pass filtered drafts to your publishing pipeline")
        else:
            print(f"\n⚠️  No drafts to publish. Consider:")
            print(f"  • Lowering threshold: --threshold 50")
            print(f"  • Conservative mode: --conservative")
            print(f"  • Improving content quality in transform step")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Content Quality Scorer — Automated content scoring engine.

Scores drafts against configurable voice patterns BEFORE they publish.
Five scoring dimensions: voice similarity, specificity, AI slop detection,
length appropriateness, and engagement potential.

Input: JSON file with drafts array
Output: scored drafts with pass/fail recommendations

Usage:
    python content-quality-scorer.py --input drafts.json --verbose
    python content-quality-scorer.py --input drafts.json --threshold 75
    python content-quality-scorer.py --init-weights  # Create default weights file
"""

import json
import re
import os
import sys
import argparse
from pathlib import Path
from datetime import datetime, timezone
from collections import Counter
import math

# ── Configuration (all paths relative/configurable) ──

SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_DIR = SCRIPT_DIR.parent
DATA_DIR = Path(os.environ.get("CONTENT_OPS_DATA_DIR", PROJECT_DIR / "data"))

DRAFTS_FILE = DATA_DIR / "content-drafts-latest.json"
WEIGHTS_FILE = DATA_DIR / "quality-scorer-weights.json"
LOG_FILE = DATA_DIR / "quality-scores-log.json"

# Default scoring threshold (adjustable)
DEFAULT_THRESHOLD = 60

# Platform character limits
PLATFORM_LIMITS = {
    "x": {"min": 50, "max": 280, "optimal_min": 150, "optimal_max": 260},
    "linkedin": {"min": 200, "max": 1500, "optimal_min": 500, "optimal_max": 1200},
    "youtube_short": {"min": 100, "max": 800, "optimal_min": 200, "optimal_max": 600},
    "newsletter": {"min": 300, "max": 2000, "optimal_min": 800, "optimal_max": 1600},
}

# Banned AI words — penalized in scoring
BANNED_WORDS = [
    "leverage", "synergy", "ecosystem", "holistic", "at the end of the day",
    "delve", "tapestry", "landscape", "multifaceted", "nuanced", "pivotal",
    "realm", "robust", "seamless", "testament", "transformative", "underscore",
    "utilize", "whilst", "keen", "embark", "comprehensive", "intricate",
    "commendable", "meticulous", "paramount", "groundbreaking", "innovative",
    "cutting-edge", "paradigm", "Additionally", "crucial", "enduring",
    "enhance", "fostering", "garner", "highlight", "interplay", "intricacies",
    "showcase", "vibrant", "valuable", "profound", "renowned", "breathtaking",
    "nestled", "stunning", "I'm excited to share", "I think maybe",
    "It could potentially", "dive into", "game-changer", "unlock"
]

# AI patterns to detect
AI_PATTERNS = [
    (r"pivotal moment|is a testament|stands as", "significance_inflation"),
    (r"boasts|vibrant|commitment to", "promotional_language"),
    (r"experts believe|industry reports|studies show", "vague_attribution"),
    (r"despite.{1,50}continues to", "formulaic_structure"),
    (r"serves as|acts as|functions as", "copula_avoidance"),
    (r"it's not just .{1,30}, it's", "negative_parallelism"),
    (r"could potentially|might possibly|may perhaps", "excessive_hedging"),
    (r"the future looks bright|exciting times ahead|stay tuned", "generic_conclusion"),
]

# Voice markers — configurable positive signals for your brand voice
# Override these by setting VOICE_MARKERS_FILE env var pointing to a JSON file
VOICE_MARKERS = [
    # Numbers with specificity
    (r'\$[\d,]+[KkMmBb]?(?:\+)?', 2.0, "revenue_markers"),
    (r'\d+%', 1.5, "percentage_stats"),
    (r'\d+x', 1.5, "multiplier_stats"),
    (r'\d+ (?:hours?|minutes?|days?|weeks?|months?|years?)', 1.0, "time_specifics"),
    (r'\d+ (?:pages?|pieces?|tools?|agents?|companies|founders?|members)', 1.0, "count_specifics"),
    # Personal framing
    (r'I (?:built|found|asked|remember|had lunch)', 2.0, "personal_framing"),
    (r'Here\'s what happened|A friend who|I asked \d+', 1.5, "story_framing"),
    # Contrarian hooks
    (r'Most people .{1,50} wrong|Everyone says .{1,30} That\'s', 2.0, "contrarian_hooks"),
    (r'Harsh reality:', 1.5, "harsh_reality"),
    # Engagement patterns
    (r'What\'s your take\?|What did I miss\?|What would you do', 1.0, "engagement_cta"),
    # Short sentences (under 15 words)
    (r'[.!?]\s+[A-Z][^.!?]{1,75}[.!?]', 0.5, "short_sentences"),
]

# Default scoring weights
DEFAULT_WEIGHTS = {
    "voice_similarity": 0.35,
    "specificity": 0.25,
    "slop_penalty": 0.20,
    "length_appropriateness": 0.10,
    "engagement_potential": 0.10,
}


def load_weights():
    """Load scoring weights from file or return defaults."""
    if WEIGHTS_FILE.exists():
        try:
            with open(WEIGHTS_FILE) as f:
                data = json.load(f)
                weights = data.get("weights", DEFAULT_WEIGHTS)
                threshold = data.get("threshold", DEFAULT_THRESHOLD)
                return weights, threshold
        except Exception as e:
            print(f"⚠ Error loading weights: {e}, using defaults")
    return DEFAULT_WEIGHTS, DEFAULT_THRESHOLD


def save_weights(weights, threshold):
    """Save scoring weights and threshold to file."""
    data = {
        "weights": weights,
        "threshold": threshold,
        "updated_at": datetime.now(timezone.utc).isoformat(),
        "version": "1.0"
    }
    WEIGHTS_FILE.parent.mkdir(parents=True, exist_ok=True)
    with open(WEIGHTS_FILE, 'w') as f:
        json.dump(data, f, indent=2)


def log_score(draft_id, platform, scores, passed, reasons):
    """Log scoring results for analysis."""
    log_entry = {
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "draft_id": draft_id,
        "platform": platform,
        "scores": scores,
        "total_score": sum(scores.values()),
        "passed": passed,
        "failure_reasons": reasons,
    }

    log_data = []
    if LOG_FILE.exists():
        try:
            with open(LOG_FILE) as f:
                log_data = json.load(f)
        except Exception:
            log_data = []

    log_data.append(log_entry)

    # Keep only last 1000 entries
    if len(log_data) > 1000:
        log_data = log_data[-1000:]

    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
    with open(LOG_FILE, 'w') as f:
        json.dump(log_data, f, indent=2)


def score_voice_similarity(draft_text):
    """Score how well draft matches voice patterns (0-100)."""
    score = 0
    matches = {}

    for pattern, weight, category in VOICE_MARKERS:
        pattern_matches = re.findall(pattern, draft_text, re.IGNORECASE)
        if pattern_matches:
            match_count = len(pattern_matches)
            category_score = min(weight * math.log(match_count + 1) * 10, weight * 25)
            score += category_score
            matches[category] = matches.get(category, 0) + match_count

    # Bonus for short punchy sentences
    sentences = re.split(r'[.!?]+', draft_text)
    short_sentences = [s for s in sentences if len(s.split()) <= 15 and len(s.split()) >= 3]
    sentence_ratio = len(short_sentences) / max(len(sentences), 1)
    score += sentence_ratio * 15

    return min(score, 100), matches


def score_specificity(draft_text):
    """Score specificity — real numbers, examples, named entities (0-100)."""
    score = 0

    number_patterns = [
        r'\$[\d,]+[KkMmBb]?(?:\+)?',
        r'\d+%',
        r'\d+x',
        r'\d+[\.,]?\d*\s*(?:hours?|minutes?|days?|weeks?|months?|years?)',
        r'\d+\s*(?:pages?|pieces?|tools?|agents?|companies|founders?|members)',
    ]

    total_numbers = 0
    for pattern in number_patterns:
        matches = re.findall(pattern, draft_text, re.IGNORECASE)
        total_numbers += len(matches)

    word_count = len(draft_text.split())
    number_density = total_numbers / max(word_count / 50, 1)
    score += min(number_density * 30, 50)

    # Named entities and specific examples
    entity_patterns = [
        r'[A-Z][a-z]+ [A-Z][a-z]+(?:\s[A-Z][a-z]+)*',
        r'@[A-Za-z0-9_]+',
        r'(?:Apple|Google|Meta|Microsoft|Amazon|Tesla|ChatGPT|Claude|OpenAI)',
    ]

    entity_count = 0
    for pattern in entity_patterns:
        matches = re.findall(pattern, draft_text)
        entity_count += len(matches)

    score += min(entity_count * 10, 30)

    # Before/after comparisons
    comparison_patterns = [
        r'\d+.*→.*\d+',
        r'from \d+.*to \d+',
        r'before.*\d+.*after.*\d+',
        r'used to.*now.*'
    ]

    for pattern in comparison_patterns:
        if re.search(pattern, draft_text, re.IGNORECASE):
            score += 10
            break

    return min(score, 100)


def score_slop_penalty(draft_text):
    """Detect and penalize AI slop and banned phrases (0-100, higher = less slop)."""
    score = 100
    detected_issues = []

    text_lower = draft_text.lower()

    banned_found = []
    for word in BANNED_WORDS:
        if word.lower() in text_lower:
            banned_found.append(word)
            score -= 10

    if banned_found:
        detected_issues.append(f"Banned words: {', '.join(banned_found[:3])}")

    ai_patterns_found = []
    for pattern, pattern_name in AI_PATTERNS:
        matches = re.findall(pattern, draft_text, re.IGNORECASE)
        if matches:
            ai_patterns_found.append(pattern_name)
            score -= 8

    if ai_patterns_found:
        detected_issues.append(f"AI patterns: {', '.join(ai_patterns_found[:3])}")

    # Em dash overuse
    em_dash_count = draft_text.count('—')
    word_count = len(draft_text.split())
    if em_dash_count > word_count / 200:
        score -= 5
        detected_issues.append("Excessive em dash usage")

    # Corporate speak
    corporate_patterns = [
        r'I\'m excited to share',
        r'it is important to note',
        r'in order to',
        r'we are pleased to announce',
        r'stay tuned for',
    ]

    for pattern in corporate_patterns:
        if re.search(pattern, draft_text, re.IGNORECASE):
            score -= 15
            detected_issues.append("Corporate speak detected")
            break

    return max(score, 0), detected_issues


def score_length_appropriateness(draft_text, platform):
    """Score if content length is appropriate for platform (0-100)."""
    char_count = len(draft_text)
    limits = PLATFORM_LIMITS.get(platform, PLATFORM_LIMITS["x"])

    if char_count < limits["min"]:
        shortfall_ratio = char_count / limits["min"]
        return max(shortfall_ratio * 100, 20)
    elif char_count > limits["max"]:
        excess_ratio = limits["max"] / char_count
        return max(excess_ratio * 100, 30)
    elif limits["optimal_min"] <= char_count <= limits["optimal_max"]:
        return 100
    else:
        return 85


def score_engagement_potential(draft_text, platform):
    """Score engagement potential based on CTAs and hooks (0-100)."""
    score = 0

    cta_patterns = {
        "x": [r'What\'s your take\?', r'What did I miss\?', r'Reply with'],
        "linkedin": [r'What would you do', r'What do you think', r'Drop .* below', r'curious.*your'],
        "youtube_short": [r'Comment.*and I\'ll', r'Follow for more'],
        "newsletter": [r'subscribe', r'read more', r'check it out'],
    }

    platform_ctas = cta_patterns.get(platform, cta_patterns["x"])
    for pattern in platform_ctas:
        if re.search(pattern, draft_text, re.IGNORECASE):
            score += 25
            break

    # Strong hooks (first 100 characters)
    hook = draft_text[:100]
    hook_patterns = [
        r'^\d+.*\.',
        r'^Most people.*wrong',
        r'^I (?:built|found|asked)',
        r'^Harsh reality:',
        r'^Here\'s what',
    ]

    for pattern in hook_patterns:
        if re.search(pattern, hook, re.IGNORECASE):
            score += 25
            break

    # Question-based engagement
    question_count = len(re.findall(r'\?', draft_text))
    if question_count >= 1:
        score += min(question_count * 15, 30)

    # Debate invitation
    debate_patterns = [
        r'Agree or disagree',
        r'What\'s your experience',
        r'Change my mind',
    ]

    for pattern in debate_patterns:
        if re.search(pattern, draft_text, re.IGNORECASE):
            score += 20
            break

    return min(score, 100)


def score_draft(draft, weights, threshold):
    """Score a single draft against all criteria."""
    platform = draft.get("platform", "x")
    draft_text = draft.get("draft", "")

    voice_score, voice_matches = score_voice_similarity(draft_text)
    specificity_score = score_specificity(draft_text)
    slop_score, slop_issues = score_slop_penalty(draft_text)
    length_score = score_length_appropriateness(draft_text, platform)
    engagement_score = score_engagement_potential(draft_text, platform)

    scores = {
        "voice_similarity": voice_score,
        "specificity": specificity_score,
        "slop_penalty": slop_score,
        "length_appropriateness": length_score,
        "engagement_potential": engagement_score,
    }

    total_score = sum(scores[key] * weights[key] for key in scores.keys())
    total_score = round(total_score, 1)

    passed = total_score >= threshold

    failure_reasons = []
    if voice_score < 50:
        failure_reasons.append("Low voice match - lacks brand voice patterns")
    if specificity_score < 40:
        failure_reasons.append("Not specific enough - needs real numbers/examples")
    if slop_score < 70:
        failure_reasons.append("Contains AI slop - " + "; ".join(slop_issues))
    if length_score < 60:
        failure_reasons.append(f"Length issue for {platform}")
    if engagement_score < 40:
        failure_reasons.append("Weak engagement - needs better CTA/hook")

    result = {
        "draft_id": draft.get("id"),
        "platform": platform,
        "total_score": total_score,
        "scores": scores,
        "passed": passed,
        "failure_reasons": failure_reasons,
        "voice_matches": voice_matches,
        "slop_issues": slop_issues,
        "char_count": len(draft_text),
        "scored_at": datetime.now(timezone.utc).isoformat(),
    }

    log_score(draft.get("id"), platform, scores, passed, failure_reasons)
    return result


def score_drafts_file(file_path=None, output_path=None, threshold_override=None, verbose=False):
    """Score all drafts in a file."""
    input_file = Path(file_path) if file_path else DRAFTS_FILE

    if not input_file.exists():
        print(f"❌ Input file not found: {input_file}")
        return None

    with open(input_file) as f:
        data = json.load(f)

    drafts = data.get("drafts", [])
    if not drafts:
        print("❌ No drafts found in input file")
        return None

    weights, threshold = load_weights()
    if threshold_override:
        threshold = threshold_override
        print(f"📊 Using threshold override: {threshold}")

    print(f"📊 Scoring {len(drafts)} drafts with threshold {threshold}")
    if verbose:
        print(f"📊 Weights: {weights}")

    results = []
    passed_count = 0

    for i, draft in enumerate(drafts):
        result = score_draft(draft, weights, threshold)
        results.append(result)

        if result["passed"]:
            passed_count += 1

        if verbose:
            print(f"\n[{i+1}/{len(drafts)}] {result['platform']} | Score: {result['total_score']}/100")
            if result["passed"]:
                print(f"  ✅ PASS")
            else:
                print(f"  ❌ FAIL: {'; '.join(result['failure_reasons'])}")

    total_scores = [r["total_score"] for r in results]
    avg_score = sum(total_scores) / len(total_scores)
    pass_rate = (passed_count / len(results)) * 100

    summary = {
        "scored_at": datetime.now(timezone.utc).isoformat(),
        "total_drafts": len(drafts),
        "passed_count": passed_count,
        "pass_rate": round(pass_rate, 1),
        "average_score": round(avg_score, 1),
        "threshold": threshold,
        "weights": weights,
        "results": results,
    }

    if output_path:
        output_file = Path(output_path)
    else:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = DATA_DIR / f"quality-scores-{timestamp}.json"

    output_file.parent.mkdir(parents=True, exist_ok=True)
    with open(output_file, 'w') as f:
        json.dump(summary, f, indent=2)

    latest_file = DATA_DIR / "quality-scores-latest.json"
    with open(latest_file, 'w') as f:
        json.dump(summary, f, indent=2)

    print(f"\n{'='*60}")
    print(f"QUALITY SCORING RESULTS")
    print(f"{'='*60}")
    print(f"Total drafts: {len(drafts)}")
    print(f"Passed: {passed_count} ({pass_rate:.1f}%)")
    print(f"Failed: {len(drafts) - passed_count}")
    print(f"Average score: {avg_score:.1f}/100")
    print(f"Threshold: {threshold}/100")
    print(f"\nSaved to: {output_file}")
    print(f"Saved to: {latest_file}")

    if verbose:
        print(f"\n🏆 TOP SCORING DRAFTS:")
        top_drafts = sorted(results, key=lambda x: x["total_score"], reverse=True)[:3]
        for i, result in enumerate(top_drafts):
            status = "✅ PASS" if result["passed"] else "❌ FAIL"
            print(f"  {i+1}. {result['platform']} | {result['total_score']}/100 | {status}")

    return summary


def main():
    parser = argparse.ArgumentParser(description="Score content drafts for quality")
    parser.add_argument("--input", type=str, help="Input drafts JSON file")
    parser.add_argument("--output", type=str, help="Output scores JSON file")
    parser.add_argument("--threshold", type=float, help="Scoring threshold override")
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
    parser.add_argument("--init-weights", action="store_true", help="Initialize default weights file")
    args = parser.parse_args()

    if args.init_weights:
        save_weights(DEFAULT_WEIGHTS, DEFAULT_THRESHOLD)
        print(f"✅ Initialized weights file: {WEIGHTS_FILE}")
        return

    score_drafts_file(
        file_path=args.input,
        output_path=args.output,
        threshold_override=args.threshold,
        verbose=args.verbose
    )


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Content Transform — Repurpose long-form content into platform-native drafts.

Reads content atoms, generates platform-native drafts using Claude API + optional
expert panel quality gate. Supports X threads/posts, LinkedIn, YouTube Shorts, and
newsletter formats.

LLM mode is DEFAULT. Use --template-only for fast template-based drafts (no API needed).

Usage:
    python content-transform.py --atoms atoms.json --top-n 10
    python content-transform.py --atoms atoms.json --template-only
    python content-transform.py --atoms atoms.json --no-expert-panel
"""

import json
import uuid
import argparse
import os
import re
import sys
import textwrap
from datetime import datetime, timezone
from pathlib import Path

# ── Configuration ──

SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_DIR = SCRIPT_DIR.parent
DATA_DIR = Path(os.environ.get("CONTENT_OPS_DATA_DIR", PROJECT_DIR / "data"))
SKILL_DIR = PROJECT_DIR

ATOMS_FILE = DATA_DIR / "content-atoms-latest.json"

# Voice configuration files (optional, for LLM mode)
VOICE_CONFIG_FILE = os.environ.get("VOICE_CONFIG_FILE", str(PROJECT_DIR / "config" / "voice.md"))
STYLE_GUIDE_FILE = os.environ.get("STYLE_GUIDE_FILE", str(PROJECT_DIR / "config" / "style-guide.md"))

PLATFORM_MAP = {
    "x": ["x_thread", "x_post"],
    "linkedin": ["linkedin_post"],
    "short_form": ["youtube_short_script"],
    "newsletter": ["newsletter_section"],
    "youtube_short": ["youtube_short_script"],
}

MISSING_TO_FORMAT = {
    "x": "x_thread",
    "linkedin": "linkedin_post",
    "short_form": "youtube_short_script",
    "newsletter": "newsletter_section",
    "youtube_short": "youtube_short_script",
}

MISSING_TO_PLATFORM = {
    "x": "x",
    "linkedin": "linkedin",
    "short_form": "youtube_short",
    "newsletter": "newsletter",
    "youtube_short": "youtube_short",
}

PLATFORM_TO_EXPERT = {
    "x": "x-articles.md",
    "linkedin": "linkedin.md",
    "youtube_short": "youtube-shorts.md",
    "newsletter": "newsletter.md",
}

EXPERT_PANEL_THRESHOLD = 95
EXPERT_PANEL_MAX_ITERATIONS = 3


def load_atoms(path=None):
    p = Path(path) if path else ATOMS_FILE
    with open(p) as f:
        data = json.load(f)
    return data.get("atoms", data) if isinstance(data, dict) else data


def rank_atoms(atoms, top_n=10):
    """Sort by repurpose_score * len(platforms_missing), take top N."""
    for a in atoms:
        a["_rank"] = a.get("repurpose_score", 0) * max(len(a.get("platforms_missing", [])), 1)
    ranked = sorted(atoms, key=lambda x: x["_rank"], reverse=True)
    return ranked[:top_n]


def clean_content(content):
    content = re.sub(r'^[\w]+\s*·\s*@[\w]+\s*·.*$', '', content, flags=re.MULTILINE)
    content = re.sub(r'\n{3,}', '\n\n', content)
    return content.strip()


def extract_hook(content, max_chars=200):
    content = clean_content(content)
    for sep in [". ", ".\n", "\n"]:
        idx = content.find(sep)
        if 0 < idx < max_chars:
            return content[:idx + 1].strip()
    return content[:max_chars].strip()


def extract_key_points(content, max_points=6):
    lines = content.split("\n")
    points = []
    for line in lines:
        line = line.strip()
        if not line:
            continue
        if line.startswith(("•", "-", "→", "*")) or re.match(r"^\d+[\.\)]", line):
            cleaned = re.sub(r"^[•\-→\*\d+\.\)]+\s*", "", line).strip()
            if len(cleaned) > 15:
                points.append(cleaned)
        elif len(line) > 20 and len(line) < 280:
            points.append(line)
    return points[:max_points] if points else [content[:200]]


def extract_numbers(content):
    patterns = [
        r'\$[\d,]+[KkMmBb]?(?:\+)?',
        r'\d+%',
        r'\d+x',
        r'\d+[\.,]?\d*\s*(?:hours?|minutes?|days?|weeks?|months?|years?)',
        r'\d+\s*(?:pages?|pieces?|tools?|agents?|companies|founders?|members)',
    ]
    numbers = []
    for p in patterns:
        numbers.extend(re.findall(p, content, re.IGNORECASE))
    return numbers[:5]


def shorten_sentence(s, max_words=15):
    words = s.split()
    if len(words) <= max_words:
        return s
    return " ".join(words[:max_words]) + "."


def make_punchy(text, max_words=15):
    sentences = re.split(r'(?<=[.!?])\s+', text)
    result = []
    for s in sentences:
        s = s.strip()
        if not s:
            continue
        if len(s.split()) > max_words:
            parts = re.split(r'[,;—]', s)
            for p in parts:
                p = p.strip()
                if p:
                    result.append(shorten_sentence(p) if not p.endswith(('.', '!', '?')) else p)
        else:
            result.append(s)
    return result


# ── TEMPLATE GENERATORS (used with --template-only) ──

def generate_x_thread(atom):
    content = clean_content(atom["content"])
    hook_text = extract_hook(content, 200)
    points = extract_key_points(content)
    numbers = extract_numbers(content)
    tags = atom.get("tags", [])

    atom_type = atom.get("atom_type", "")
    if "data" in atom_type or numbers:
        tweet1 = f"{hook_text}\n\nThe numbers tell a different story. 🧵"
    elif "story" in atom_type or "anecdote" in atom_type:
        tweet1 = f"{hook_text}\n\nHere's what happened next. 🧵"
    else:
        tweet1 = f"Most people get this wrong about {tags[0] if tags else 'this'}.\n\n{hook_text}"

    if len(tweet1) > 280:
        tweet1 = tweet1[:277] + "..."

    tweets = [tweet1]
    for i, point in enumerate(points[:5]):
        point_short = shorten_sentence(point, 15)
        if numbers and i < len(numbers):
            tweet = f"{point_short}\n\n{numbers[i]} — that's the real number."
        else:
            tweet = point_short
        if len(tweet) > 280:
            tweet = tweet[:277] + "..."
        tweets.append(tweet)

    ctas = [
        "What's your take? Reply with what you'd add.",
        "What did I miss? Drop your thoughts below.",
        "Agree or disagree? I want to hear your take.",
    ]
    tweets.append(ctas[hash(atom["id"]) % len(ctas)])
    while len(tweets) < 5:
        tweets.insert(-1, "The gap is only getting wider. Those who move now win.")

    thread = "\n\n---\n\n".join([f"🧵 {i+1}/{len(tweets)}\n{t}" for i, t in enumerate(tweets)])
    return thread, tweets[0]


def generate_x_post(atom):
    content = clean_content(atom["content"])
    hook = extract_hook(content, 180)
    numbers = extract_numbers(content)
    num_str = f"\n\n{numbers[0]}." if numbers else ""
    post = f"{hook}{num_str}\n\nWhat's your take?"
    if len(post) > 280:
        post = post[:277] + "..."
    return post, hook


def generate_linkedin_post(atom):
    content = clean_content(atom["content"])
    hook = extract_hook(content, 150)
    points = extract_key_points(content)
    numbers = extract_numbers(content)

    hook_section = f"{hook}\n\nHere's what I learned."
    punchy = make_punchy(content)
    story = "\n\n".join(punchy[:6])

    point_section = "\n".join([f"→ {p}" for p in points[:4]]) if len(points) > 2 else ""
    data_section = f"\nThe data: {', '.join(numbers[:3])}." if numbers else ""

    ctas = [
        "What would you do differently?",
        "What's your experience with this?",
        "Curious — what's your take?",
    ]
    cta = ctas[hash(atom["id"]) % len(ctas)]

    parts = [hook_section, story]
    if point_section:
        parts.append(point_section)
    if data_section:
        parts.append(data_section)
    parts.append(cta)

    post = "\n\n".join(parts)
    if len(post) > 1500:
        post = post[:1497] + "..."
    return post, hook


def generate_youtube_short(atom):
    content = clean_content(atom["content"])
    hook = extract_hook(content, 100)
    points = extract_key_points(content)
    numbers = extract_numbers(content)
    tags = atom.get("tags", [])
    topic = tags[0] if tags else "this"

    hook_line = f"[HOOK] (0:00-0:03)\n[Look directly at camera, energy up]\n\"{hook}\""
    setup_points = points[:2]
    setup_text = " ".join([shorten_sentence(p, 12) for p in setup_points])
    setup_line = f"[SETUP] (0:03-0:13)\n[Cut to B-roll or screen share]\n\"{setup_text}\""
    payoff_points = points[2:5] if len(points) > 2 else points
    payoff_items = "\n".join([f"  → {shorten_sentence(p, 12)}" for p in payoff_points])
    num_callout = f"\n[TEXT OVERLAY: {numbers[0]}]" if numbers else ""
    payoff_line = f"[PAYOFF] (0:13-0:40)\n[Quick cuts between points]{num_callout}\n{payoff_items}"
    cta_line = f"[CTA] (0:40-0:45)\n[Point at camera]\n\"Comment '{topic.upper()}' and I'll show you exactly how.\"\n[TEXT: Follow for more]"

    script = f"{hook_line}\n\n{setup_line}\n\n{payoff_line}\n\n{cta_line}"
    return script, hook


def generate_newsletter_section(atom):
    content = clean_content(atom["content"])
    hook = extract_hook(content, 150)
    points = extract_key_points(content)
    numbers = extract_numbers(content)

    headline = f"**{hook}**"
    punchy = make_punchy(content)
    para1 = " ".join(punchy[:4])
    para2 = " ".join(punchy[4:8]) if len(punchy) > 4 else ""
    data = f"The numbers: {', '.join(numbers[:3])}." if numbers else ""
    why = f"> **Why this matters:** {shorten_sentence(points[-1] if points else content[:100], 15)}"

    parts = [headline, para1]
    if para2:
        parts.append(para2)
    if data:
        parts.append(data)
    parts.append(why)

    return "\n\n".join([p for p in parts if p.strip()]), hook


FORMAT_GENERATORS = {
    "x_thread": generate_x_thread,
    "x_post": generate_x_post,
    "linkedin_post": generate_linkedin_post,
    "youtube_short_script": generate_youtube_short,
    "newsletter_section": generate_newsletter_section,
}


def estimate_engagement(atom, platform):
    score = atom.get("repurpose_score", 5)
    if score >= 8:
        return "high"
    elif score >= 5:
        return "medium"
    return "low"


def generate_drafts_for_atom(atom):
    drafts = []
    missing = atom.get("platforms_missing", [])
    for platform_key in missing:
        fmt = MISSING_TO_FORMAT.get(platform_key)
        platform = MISSING_TO_PLATFORM.get(platform_key)
        if not fmt or fmt not in FORMAT_GENERATORS:
            continue
        generator = FORMAT_GENERATORS[fmt]
        draft_text, hook = generator(atom)
        draft = {
            "id": str(uuid.uuid4()),
            "atom_id": atom["id"],
            "atom_content": atom["content"][:500],
            "atom_source": atom.get("source", "unknown"),
            "platform": platform,
            "format": fmt,
            "draft": draft_text,
            "hook": hook[:200],
            "char_count": len(draft_text),
            "estimated_engagement": estimate_engagement(atom, platform),
            "created_at": datetime.now(timezone.utc).isoformat(),
            "status": "draft",
            "expert_score": None,
            "iterations": 0,
            "key_improvements": [],
        }
        drafts.append(draft)
    return drafts


# ── ANTHROPIC API ──

def get_anthropic_key():
    """Get Anthropic API key from environment."""
    key = os.environ.get("ANTHROPIC_API_KEY")
    if key:
        return key
    print("ERROR: Set ANTHROPIC_API_KEY environment variable")
    return None


def load_file_safe(path):
    """Load a text file, return empty string if missing."""
    try:
        return Path(path).read_text()
    except Exception:
        return ""


def load_expert_panel(platform):
    """Load expert panel for a platform."""
    filename = PLATFORM_TO_EXPERT.get(platform, "x-articles.md")
    return load_file_safe(SKILL_DIR / "experts" / filename)


def load_scoring_rubric():
    """Load content quality scoring rubric."""
    return load_file_safe(SKILL_DIR / "scoring-rubrics" / "content-quality.md")


def load_voice_references():
    """Load voice/style references for content generation."""
    voice_config = load_file_safe(VOICE_CONFIG_FILE)
    style_guide = load_file_safe(STYLE_GUIDE_FILE)
    return voice_config, style_guide


def call_anthropic(client, messages, system=None, model="claude-sonnet-4-20250514", max_tokens=2000):
    """Call Anthropic API."""
    kwargs = {"model": model, "max_tokens": max_tokens, "messages": messages}
    if system:
        kwargs["system"] = system

    response = client.messages.create(**kwargs)
    return response.content[0].text.strip()


def llm_generate_draft(client, atom, platform, fmt, voice_config, style_guide):
    """Generate a draft using Claude API."""
    platform_instructions = {
        "x": "Write an X article (long-form X post). Include at least one ASCII diagram in a code block. Keep paragraphs to 1-3 sentences. End with a natural CTA.",
        "linkedin": "Write a LinkedIn post. Hook must work before the 'see more' fold (first 2-3 lines). Use line breaks for readability. Professional but personal. 800-1500 chars.",
        "youtube_short": "Write a YouTube Short script. Format: [HOOK] (0:00-0:03), [SETUP] (0:03-0:13), [PAYOFF] (0:13-0:40), [CTA] (0:40-0:45). Include visual directions. 30-60 seconds total.",
        "newsletter": "Write a newsletter section. Subject line + scannable body. Headers, bullets, bold for skimmers. End with 'why this matters'.",
    }

    system_parts = ["You are a content writer creating platform-native content. Follow the configured voice and style EXACTLY."]

    if voice_config:
        system_parts.append(f"\nVOICE CONFIGURATION:\n{voice_config}")
    if style_guide:
        system_parts.append(f"\nSTYLE GUIDE:\n{style_guide[:2000]}")

    system_parts.append("""
RULES:
- Short punchy sentences. Max 15 words.
- Specific numbers always. Never vague.
- Contrarian angles backed by data.
- No corporate speak. No "I'm excited to share."
- Personal stories and specific examples.
- Every sentence earns its place.""")

    system = "\n".join(system_parts)

    topic_tags = atom.get('tags', [])
    prompt = f"""Create a {platform} draft from this content atom.

PLATFORM INSTRUCTIONS:
{platform_instructions.get(platform, platform_instructions['x'])}

SOURCE CONTENT:
{clean_content(atom['content'])}

SOURCE: {atom.get('source_title', 'unknown')}
TAGS: {', '.join(topic_tags)}

Write ONLY the draft content. No preamble, no explanation."""

    return call_anthropic(client, [{"role": "user", "content": prompt}], system=system)


def expert_panel_score(client, draft_text, platform, expert_panel, rubric, voice_config):
    """Run expert panel scoring. Returns (score, feedback_dict)."""
    system = f"""You are simulating 10 domain experts reviewing content for quality.

EXPERT PANEL:
{expert_panel}

SCORING RUBRIC:
{rubric}

VOICE REFERENCE:
{voice_config[:1000] if voice_config else 'No specific voice config provided.'}"""

    prompt = f"""Score this {platform} draft. Each of 11 experts scores 0-100 on the rubric criteria.
Expert #11 is the AI Writing Detector (Humanizer) — scores how AI-generated the draft sounds.

BANNED AI VOCABULARY (flag any occurrence):
delve, tapestry, landscape (abstract), leverage, multifaceted, nuanced, pivotal, realm, robust, seamless, testament, transformative, underscore (verb), utilize, whilst, keen, embark, comprehensive, intricate, commendable, meticulous, paramount, groundbreaking, innovative, cutting-edge, synergy, holistic, paradigm, ecosystem, Additionally, crucial, enduring, enhance, fostering, garner, highlight (verb), interplay, intricacies, showcase, vibrant, valuable, profound, renowned, breathtaking, nestled, stunning

AI PATTERNS TO CHECK:
- Significance inflation ("pivotal moment", "is a testament", "stands as")
- Superficial -ing phrases ("highlighting", "showcasing", "underscoring")
- Promotional language ("boasts", "vibrant", "commitment to")
- Vague attributions ("Experts believe", "Industry reports")
- Formulaic "despite challenges... continues to" structures
- Copula avoidance ("serves as" instead of "is")
- Negative parallelisms ("It's not just X, it's Y")
- Rule-of-three forcing (triple adjectives/clauses)
- Em dash overuse (max 1 per 200 words)
- Filler phrases ("In order to", "It is important to note")
- Excessive hedging ("could potentially")
- Generic positive conclusions ("The future looks bright")

If the Humanizer expert scores below 70, the draft MUST be flagged for revision.

DRAFT:
{draft_text}

Respond in this EXACT JSON format (no other text):
{{
  "average_score": <number>,
  "expert_scores": [<11 numbers>],
  "weaknesses": ["<specific weakness 1>", "<specific weakness 2>", ...],
  "line_feedback": ["<specific line-by-line fix 1>", "<specific line-by-line fix 2>", ...],
  "strengths": ["<strength 1>", "<strength 2>"],
  "ai_patterns_detected": ["<pattern 1>", "<pattern 2>", ...],
  "humanizer_score": <number>
}}

Be harsh. Score honestly."""

    response = call_anthropic(client, [{"role": "user", "content": prompt}], system=system, max_tokens=1500)

    try:
        json_match = re.search(r'\{[\s\S]*\}', response)
        if json_match:
            result = json.loads(json_match.group())
            return result.get("average_score", 0), result
        else:
            return 0, {"error": "No JSON in response"}
    except json.JSONDecodeError:
        return 0, {"error": "Invalid JSON", "raw": response[:500]}


def expert_panel_revise(client, draft_text, platform, feedback, voice_config, style_guide):
    """Revise draft based on expert feedback."""
    system_parts = ["You are revising content based on expert feedback."]
    if voice_config:
        system_parts.append(f"\nVOICE CONFIGURATION:\n{voice_config}")
    system_parts.append("""
RULES:
- Fix every weakness identified
- Keep all strengths
- Maintain configured voice exactly
- Short punchy sentences, specific numbers, contrarian angles""")

    system = "\n".join(system_parts)

    weaknesses = feedback.get("weaknesses", [])
    line_fixes = feedback.get("line_feedback", [])
    ai_patterns = feedback.get("ai_patterns_detected", [])

    ai_section = ""
    if ai_patterns:
        ai_section = f"""
AI PATTERNS DETECTED (MUST FIX ALL):
{chr(10).join(f'- {p}' for p in ai_patterns)}

BANNED VOCABULARY (replace every occurrence):
delve, tapestry, landscape (abstract), leverage, multifaceted, nuanced, pivotal, realm, robust, seamless, testament, transformative, underscore (verb), utilize, whilst, keen, embark, comprehensive, intricate, commendable, meticulous, paramount, groundbreaking, innovative, cutting-edge, synergy, holistic, paradigm, ecosystem, Additionally, crucial, enduring, enhance, fostering, garner, highlight (verb), interplay, intricacies, showcase, vibrant, valuable, profound, renowned, breathtaking, nestled, stunning
"""

    prompt = f"""Revise this {platform} draft based on expert feedback.

CURRENT DRAFT:
{draft_text}

WEAKNESSES TO FIX:
{chr(10).join(f'- {w}' for w in weaknesses)}

SPECIFIC LINE FIXES:
{chr(10).join(f'- {f}' for f in line_fixes)}
{ai_section}
CURRENT SCORE: {feedback.get('average_score', 'unknown')}
TARGET SCORE: {EXPERT_PANEL_THRESHOLD}+

Write ONLY the revised draft. No preamble."""

    return call_anthropic(client, [{"role": "user", "content": prompt}], system=system)


def process_draft_with_expert_panel(client, atom, platform, fmt, voice_config, style_guide):
    """Full expert panel pipeline: generate → score → revise loop."""
    expert_panel = load_expert_panel(platform)
    rubric = load_scoring_rubric()

    print(f"    Generating {platform} draft via Claude...")
    draft_text = llm_generate_draft(client, atom, platform, fmt, voice_config, style_guide)

    iterations = []
    best_draft = draft_text
    best_score = 0

    for iteration in range(1, EXPERT_PANEL_MAX_ITERATIONS + 1):
        print(f"    Expert panel scoring (iteration {iteration})...")
        score, feedback = expert_panel_score(client, draft_text, platform, expert_panel, rubric, voice_config)
        print(f"    Score: {score}/100")

        iteration_log = {
            "iteration": iteration,
            "score": score,
            "weaknesses": feedback.get("weaknesses", []),
            "line_feedback": feedback.get("line_feedback", []),
            "strengths": feedback.get("strengths", []),
        }
        iterations.append(iteration_log)

        if score > best_score:
            best_score = score
            best_draft = draft_text

        if score >= EXPERT_PANEL_THRESHOLD:
            print(f"    ✓ Passed threshold ({score} >= {EXPERT_PANEL_THRESHOLD})")
            break

        if iteration < EXPERT_PANEL_MAX_ITERATIONS:
            print(f"    Revising based on feedback...")
            draft_text = expert_panel_revise(client, draft_text, platform, feedback, voice_config, style_guide)

    key_improvements = []
    for it in iterations:
        for w in it.get("weaknesses", []):
            key_improvements.append(f"Iter {it['iteration']}: Fixed — {w}")

    return best_draft, best_score, len(iterations), key_improvements, iterations


def rewrite_with_llm(drafts, use_expert_panel=False, expert_panel_top_n=10):
    """Rewrite drafts using Claude API, optionally with expert panel."""
    try:
        import anthropic
    except ImportError:
        print("ERROR: anthropic package not installed. Run: pip install anthropic")
        return drafts

    api_key = get_anthropic_key()
    if not api_key:
        return drafts

    client = anthropic.Anthropic(api_key=api_key)
    voice_config, style_guide = load_voice_references()

    rewritten = []
    for i, draft in enumerate(drafts):
        atom = {"content": draft["atom_content"], "source_title": draft.get("atom_source", ""),
                "tags": [], "atom_type": ""}

        if use_expert_panel and i < expert_panel_top_n:
            print(f"\n  [{i+1}/{len(drafts)}] Expert panel: {draft['format']} (atom {draft['atom_id'][:8]})")
            try:
                import time as _time
                _start = _time.time()
                new_text, score, iters, improvements, iter_log = process_draft_with_expert_panel(
                    client, atom, draft["platform"], draft["format"],
                    voice_config, style_guide
                )
                _elapsed = _time.time() - _start
                draft["draft"] = new_text
                draft["hook"] = extract_hook(new_text, 200)
                draft["char_count"] = len(new_text)
                draft["expert_score"] = score
                draft["iterations"] = iters
                draft["key_improvements"] = improvements
                draft["iteration_log"] = iter_log
                status = "✓" if score >= EXPERT_PANEL_THRESHOLD else f"⚠ ({score})"
                print(f"    {status} Final: {score}/100 after {iters} iteration(s) [{_elapsed:.1f}s]")
            except Exception as e:
                print(f"    ✗ Expert panel failed ({type(e).__name__}): {e}")
                try:
                    new_text = llm_generate_draft(client, atom, draft["platform"], draft["format"],
                                                   voice_config, style_guide)
                    draft["draft"] = new_text
                    draft["hook"] = extract_hook(new_text, 200)
                    draft["char_count"] = len(new_text)
                    print(f"    ↳ Fell back to simple LLM rewrite")
                except Exception as e2:
                    print(f"    ✗ LLM rewrite also failed: {e2}")
        else:
            print(f"\n  [{i+1}/{len(drafts)}] LLM rewrite: {draft['format']} (atom {draft['atom_id'][:8]})")
            try:
                new_text = llm_generate_draft(client, atom, draft["platform"], draft["format"],
                                               voice_config, style_guide)
                draft["draft"] = new_text
                draft["hook"] = extract_hook(new_text, 200)
                draft["char_count"] = len(new_text)
                print(f"    ✓ Rewrote")
            except Exception as e:
                print(f"    ✗ LLM rewrite failed: {e}")

        rewritten.append(draft)

    return rewritten


def main():
    parser = argparse.ArgumentParser(description="Transform content atoms into platform-native drafts")
    parser.add_argument("--atoms", type=str, help="Path to atoms JSON file")
    parser.add_argument("--top-n", type=int, default=10, help="Number of top atoms to process")
    parser.add_argument("--template-only", action="store_true", help="Use template-based generation (no LLM)")
    parser.add_argument("--no-expert-panel", action="store_true", help="Disable expert panel quality gate")
    parser.add_argument("--expert-panel-top-n", type=int, default=10, help="Apply expert panel to top N drafts")
    parser.add_argument("--output", type=str, help="Output file path")
    args = parser.parse_args()

    use_llm = not args.template_only
    use_expert_panel = use_llm and not args.no_expert_panel

    atoms = load_atoms(args.atoms)
    print(f"Loaded {len(atoms)} atoms")

    top_atoms = rank_atoms(atoms, args.top_n)
    print(f"Selected top {len(top_atoms)} atoms by repurpose_score × missing platforms")

    all_drafts = []
    for atom in top_atoms:
        drafts = generate_drafts_for_atom(atom)
        all_drafts.extend(drafts)
        missing = atom.get("platforms_missing", [])
        print(f"  Atom {atom['id'][:8]}: {len(drafts)} drafts ({', '.join(missing)})")

    print(f"\nGenerated {len(all_drafts)} total drafts")

    if use_llm:
        mode = "LLM + Expert Panel" if use_expert_panel else "LLM only"
        print(f"\n{'='*60}")
        print(f"Rewriting with {mode}...")
        print(f"{'='*60}")
        all_drafts = rewrite_with_llm(all_drafts, use_expert_panel=use_expert_panel,
                                       expert_panel_top_n=args.expert_panel_top_n)

    by_platform = {}
    for d in all_drafts:
        by_platform[d["platform"]] = by_platform.get(d["platform"], 0) + 1
    print(f"\n{'='*60}")
    print("Drafts by platform:")
    for p, c in sorted(by_platform.items()):
        print(f"  {p}: {c}")

    scored = [d for d in all_drafts if d.get("expert_score")]
    if scored:
        avg = sum(d["expert_score"] for d in scored) / len(scored)
        passed = sum(1 for d in scored if d["expert_score"] >= EXPERT_PANEL_THRESHOLD)
        print(f"\nExpert panel: {len(scored)} scored, {passed} passed (≥{EXPERT_PANEL_THRESHOLD}), avg {avg:.1f}")

    today = datetime.now().strftime("%Y-%m-%d")
    output_path = Path(args.output) if args.output else DATA_DIR / f"content-drafts-{today}.json"
    latest_path = DATA_DIR / "content-drafts-latest.json"

    output = {
        "generated_at": datetime.now(timezone.utc).isoformat(),
        "atom_count": len(top_atoms),
        "draft_count": len(all_drafts),
        "used_llm": use_llm,
        "used_expert_panel": use_expert_panel,
        "expert_panel_threshold": EXPERT_PANEL_THRESHOLD if use_expert_panel else None,
        "drafts": all_drafts,
    }

    output_path.parent.mkdir(parents=True, exist_ok=True)
    with open(output_path, "w") as f:
        json.dump(output, f, indent=2)
    with open(latest_path, "w") as f:
        json.dump(output, f, indent=2)

    print(f"\nSaved to {output_path}")
    print(f"Saved to {latest_path}")

    if scored:
        print(f"\n{'='*60}")
        print("TOP DRAFTS BY SCORE:")
        print(f"{'='*60}")
        for d in sorted(scored, key=lambda x: x["expert_score"], reverse=True)[:5]:
            print(f"\n[{d['platform'].upper()}] Score: {d['expert_score']}/100 | Iterations: {d['iterations']}")
            print(f"Hook: {d['hook'][:100]}...")
            if d.get("key_improvements"):
                print(f"Key improvements: {d['key_improvements'][0]}")
            print(f"---")
            print(d["draft"][:300])
            print("...\n")


if __name__ == "__main__":
    main()