@ivannikov-pro/ai-context-surgeon 1.0.0

package/skills/prompt-engineering/scripts/prompt_dna_analyzer.py

@@ -0,0 +1,692 @@
+#!/usr/bin/env python3
+"""
+prompt_dna_analyzer.py — Generates a "DNA profile" of any system prompt.
+Analyzes power word density, restriction ratio, blind spots, and priority structure.
+
+v2.0 — Added file-type profiles, anti-gaming penalties, batch mode with uniqueness check.
+
+Usage:
+    python3 scripts/prompt_dna_analyzer.py /tmp/system_prompt_logs.txt
+    python3 scripts/prompt_dna_analyzer.py --dump 19   # analyze specific dump
+    python3 scripts/prompt_dna_analyzer.py some_prompt.txt --output dna_report.md
+    python3 scripts/prompt_dna_analyzer.py some_prompt.txt --type role
+    python3 scripts/prompt_dna_analyzer.py --batch .agents/ --check-uniqueness
+"""
+
+import re
+import sys
+import os
+import json
+import argparse
+import hashlib
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+
+# ============================================================================
+# ANALYSIS PATTERNS
+# ============================================================================
+
+ENFORCEMENT_PATTERNS = {
+    'MUST': r'\bMUST\b',
+    'MUST NOT': r'\bMUST NOT\b',
+    'NEVER': r'\bNEVER\b',
+    'ALWAYS': r'\bALWAYS\b',
+    'DO NOT': r'\bDO NOT\b',
+    'SHALL': r'\bSHALL\b',
+    'REQUIRED': r'\bREQUIRED\b',
+    'FORBIDDEN': r'\bFORBIDDEN\b',
+    'PROHIBITED': r'\bPROHIBITED\b',
+    'MANDATORY': r'\bMANDATORY\b',
+    'CRITICAL': r'\bCRITICAL\b',
+    'ESSENTIAL': r'\bESSENTIAL\b',
+    'IMPORTANT': r'\bIMPORTANT\b',
+    'UNACCEPTABLE': r'\bUNACCEPTABLE\b',
+    'FAILED': r'\bFAILED\b',
+}
+
+ENABLING_PATTERNS = {
+    'may': r'\byou may\b',
+    'can': r'\byou can\b',
+    'could': r'\byou could\b',
+    'consider': r'\bconsider\b',
+    'optional': r'\boptional\b',
+    'if needed': r'\bif needed\b',
+    'when appropriate': r'\bwhen appropriate\b',
+    'exercise judgement': r'\bexercise judgement\b',
+}
+
+STRUCTURE_TAGS = [
+    'identity', 'user_rules', 'RULE', 'communication_style',
+    'planning_mode', 'planning_mode_artifacts', 'ephemeral_message',
+    'EPHEMERAL_MESSAGE', 'web_application_development', 'skills',
+    'plugins', 'persistent_context', 'artifacts', 'workflows',
+    'user_information', 'mcp_servers', 'functions', 'function',
+    'bash_command_reminder', 'ADDITIONAL_METADATA', 'USER_REQUEST',
+    'USER_SETTINGS_CHANGE', 'WORKFLOW', 'conversation_summaries',
+]
+
+SECURITY_CHECKPOINTS = {
+    'auth_mentioned': r'\bauth(?:entication|orization)?\b',
+    'security_rules': r'\bsecurity\b',
+    'input_validation': r'\bvalidat(?:e|ion)\b',
+    'rate_limiting': r'\brate.?limit\b',
+    'encryption': r'\bencrypt\b',
+    'sanitization': r'\bsaniti[zs]e?\b',
+    'xss_prevention': r'\bXSS\b',
+    'csrf_prevention': r'\bCSRF\b',
+    'injection_prevention': r'\binjection\b',
+    'secrets_handling': r'\bsecrets?\b',
+    'api_key_protection': r'\bapi.?key\b',
+    'privacy': r'\bprivacy\b',
+    'data_protection': r'\bdata.?protect\b',
+}
+
+TOOL_PATTERN = re.compile(r'"name":\s*"([^"]+)"')
+
+# Known generic boilerplate blocks that inflate scores without adding value
+GENERIC_BOILERPLATE = [
+    "You MUST ALWAYS read and follow instructions strictly",
+    "You NEVER ignore error handling or validation steps",
+    "You MUST NOT bypass or skip workflow phases",
+    "You ALWAYS enforce strict standards",
+    "You MUST NEVER guess requirements",
+    "CRITICAL MANDATORY INSTRUCTION",
+]
+
+# ============================================================================
+# FILE-TYPE PROFILES
+# ============================================================================
+
+FILE_TYPE_PROFILES = {
+    'role': {
+        'description': 'Agent role definitions (as-*.md)',
+        'target_hardness': 70,
+        'label': '🎭 Role',
+    },
+    'workflow': {
+        'description': 'Step-by-step guides',
+        'target_hardness': 60,
+        'label': '📋 Workflow',
+    },
+    'knowledge': {
+        'description': 'Context documents',
+        'target_hardness': 40,
+        'label': '📚 Knowledge',
+    },
+    'reference': {
+        'description': 'API/SDK/tool docs (SKILL.md)',
+        'target_hardness': 20,
+        'label': '📖 Reference',
+    },
+    'config': {
+        'description': 'Config files (AGENTS.md, README)',
+        'target_hardness': 50,
+        'label': '⚙️ Config',
+    },
+}
+
+
+def detect_file_type(filepath):
+    """Auto-detect file type from path patterns."""
+    path = str(filepath)
+    basename = os.path.basename(path)
+
+    if basename == 'SKILL.md':
+        return 'reference'
+    if basename.startswith('as-') and path.endswith('.md'):
+        return 'role'
+    if 'workflows/' in path:
+        return 'workflow'
+    if 'knowledge/' in path:
+        return 'knowledge'
+    if basename in ('AGENTS.md', 'README.md'):
+        return 'config'
+
+    return 'workflow'  # default
+
+
+# ============================================================================
+# ANTI-GAMING DETECTION
+# ============================================================================
+
+def detect_gaming(text, enforcement_total):
+    """Detect score inflation attempts. Returns penalties dict."""
+    penalties = {}
+    word_count = len(text.split())
+
+    if word_count < 20:
+        return penalties
+
+    # 1. EOF concentration: >70% enforcement words in last 20% of text
+    split_point = len(text) * 4 // 5
+    tail = text[split_point:]
+    tail_enforcement = 0
+    for pattern in ENFORCEMENT_PATTERNS.values():
+        tail_enforcement += len(re.findall(pattern, tail, re.IGNORECASE))
+
+    if enforcement_total > 3 and tail_enforcement > enforcement_total * 0.7:
+        penalties['eof_concentration'] = {
+            'penalty': -20,
+            'reason': f'Enforcement concentrated at EOF ({tail_enforcement}/{enforcement_total} = {tail_enforcement/enforcement_total:.0%})',
+        }
+
+    # 2. Generic boilerplate detection
+    boilerplate_hits = 0
+    for block in GENERIC_BOILERPLATE:
+        if block in text:
+            boilerplate_hits += 1
+
+    if boilerplate_hits >= 3:
+        penalties['generic_boilerplate'] = {
+            'penalty': -15,
+            'reason': f'Generic boilerplate detected ({boilerplate_hits}/{len(GENERIC_BOILERPLATE)} known patterns)',
+        }
+
+    # 3. Repeated identical lines (copy-paste indicator)
+    lines = [l.strip() for l in text.split('\n') if l.strip() and len(l.strip()) > 30]
+    line_counts = Counter(lines)
+    duplicates = {l: c for l, c in line_counts.items() if c > 1}
+    if len(duplicates) > 2:
+        penalties['duplicate_lines'] = {
+            'penalty': -10,
+            'reason': f'{len(duplicates)} lines appear multiple times',
+        }
+
+    return penalties
+
+
+# ============================================================================
+# CORE ANALYSIS
+# ============================================================================
+
+def analyze_prompt(text, label="Input", file_type=None, filepath=None):
+    """Generate a DNA profile for a prompt text."""
+    # Auto-detect file type if not specified
+    if file_type is None and filepath:
+        file_type = detect_file_type(filepath)
+    elif file_type is None:
+        file_type = 'workflow'
+
+    profile = {
+        'label': label,
+        'file_type': file_type,
+        'file_type_profile': FILE_TYPE_PROFILES.get(file_type, FILE_TYPE_PROFILES['workflow']),
+        'size_bytes': len(text),
+        'line_count': text.count('\n') + 1,
+        'word_count': len(text.split()),
+    }
+
+    # 1. Enforcement word frequency
+    enforcement = {}
+    for name, pattern in ENFORCEMENT_PATTERNS.items():
+        count = len(re.findall(pattern, text, re.IGNORECASE))
+        if count:
+            enforcement[name] = count
+    profile['enforcement_words'] = enforcement
+    profile['enforcement_total'] = sum(enforcement.values())
+
+    # 2. Enabling word frequency
+    enabling = {}
+    for name, pattern in ENABLING_PATTERNS.items():
+        count = len(re.findall(pattern, text, re.IGNORECASE))
+        if count:
+            enabling[name] = count
+    profile['enabling_words'] = enabling
+    profile['enabling_total'] = sum(enabling.values())
+
+    # 3. Restriction ratio
+    total_directives = profile['enforcement_total'] + profile['enabling_total']
+    if total_directives > 0:
+        profile['restriction_ratio'] = round(profile['enforcement_total'] / total_directives, 2)
+    else:
+        profile['restriction_ratio'] = 0
+
+    # 4. Hardness score (0-100) — with anti-gaming
+    density = profile['enforcement_total'] / max(1, profile['word_count']) * 1000
+
+    # Base score from density (0-60 range)
+    base = min(60, int(density * 3))
+
+    # Bonus for high-impact words (0-40 range)
+    bonus = min(40, (
+        enforcement.get('CRITICAL', 0) * 3 +
+        enforcement.get('MANDATORY', 0) * 4 +
+        enforcement.get('UNACCEPTABLE', 0) * 8 +
+        enforcement.get('FAILED', 0) * 6 +
+        enforcement.get('MUST', 0) * 1 +
+        enforcement.get('NEVER', 0) * 2
+    ))
+
+    raw_hardness = min(100, base + bonus)
+
+    # Anti-gaming penalties
+    gaming_penalties = detect_gaming(text, profile['enforcement_total'])
+    total_penalty = sum(p['penalty'] for p in gaming_penalties.values())
+
+    hardness = max(0, min(100, raw_hardness + total_penalty))
+
+    profile['hardness_score'] = hardness
+    profile['hardness_raw'] = raw_hardness
+    profile['gaming_penalties'] = gaming_penalties
+    profile['total_penalty'] = total_penalty
+    profile['enforcement_density'] = round(density, 1)
+
+    # 5. Target assessment based on file type
+    target = profile['file_type_profile']['target_hardness']
+    profile['target_hardness'] = target
+    profile['meets_target'] = hardness >= target
+    profile['target_delta'] = hardness - target
+
+    # 6. Structure tags found
+    tags_found = []
+    tags_missing = []
+    for tag in STRUCTURE_TAGS:
+        if re.search(r'<' + re.escape(tag) + r'[\s>]', text):
+            tags_found.append(tag)
+        else:
+            tags_missing.append(tag)
+    profile['tags_found'] = tags_found
+    profile['tags_missing'] = tags_missing
+    profile['structure_completeness'] = round(len(tags_found) / len(STRUCTURE_TAGS) * 100, 1)
+
+    # 7. Security blind spots
+    security_present = []
+    security_missing = []
+    for name, pattern in SECURITY_CHECKPOINTS.items():
+        if re.search(pattern, text, re.IGNORECASE):
+            security_present.append(name)
+        else:
+            security_missing.append(name)
+    profile['security_present'] = security_present
+    profile['security_missing'] = security_missing
+    profile['security_coverage'] = round(len(security_present) / len(SECURITY_CHECKPOINTS) * 100, 1)
+
+    # 8. Tool count
+    tools = list(set(TOOL_PATTERN.findall(text)))
+    tools = [t for t in tools if not t.startswith('$') and t not in ('type', 'string', 'integer')]
+    profile['tools'] = sorted(tools)
+    profile['tool_count'] = len(tools)
+
+    # 9. Priority channels detected
+    channels = []
+    if re.search(r'<user_rules>', text):
+        channels.append('user_rules (TOP PRIORITY)')
+    if re.search(r'<EPHEMERAL_MESSAGE>', text):
+        channels.append('EPHEMERAL_MESSAGE (runtime override)')
+    if re.search(r'CRITICAL INSTRUCTION', text):
+        channels.append('CRITICAL INSTRUCTION (embedded directive)')
+    if re.search(r'MANDATORY RULE', text):
+        channels.append('MANDATORY RULE (enforcement)')
+    if re.search(r'<planning_mode>', text):
+        channels.append('planning_mode (behavioral)')
+    if re.search(r'<identity>', text):
+        channels.append('identity (baseline)')
+    profile['priority_channels'] = channels
+
+    # 10. Content hash for uniqueness checking
+    # Hash the last 20% of the file (where boilerplate is typically appended)
+    tail_start = len(text) * 4 // 5
+    profile['tail_hash'] = hashlib.md5(text[tail_start:].encode()).hexdigest()[:12]
+
+    return profile
+
+
+# ============================================================================
+# BATCH MODE & UNIQUENESS
+# ============================================================================
+
+def batch_analyze(directory, check_uniqueness=False):
+    """Analyze all .md files in a directory tree."""
+    dir_path = Path(directory)
+    profiles = []
+
+    for md_file in sorted(dir_path.rglob("*.md")):
+        # Skip non-agent files
+        rel = str(md_file.relative_to(dir_path))
+        if any(skip in rel for skip in ['node_modules', 'dist', '.git', 'projects/']):
+            continue
+
+        try:
+            text = md_file.read_text(encoding='utf-8', errors='replace')
+        except Exception:
+            continue
+
+        file_type = detect_file_type(md_file)
+        profile = analyze_prompt(text, label=rel, file_type=file_type, filepath=str(md_file))
+        profile['filepath'] = str(md_file)
+        profiles.append(profile)
+
+    # Uniqueness analysis
+    uniqueness_report = None
+    if check_uniqueness:
+        uniqueness_report = check_content_uniqueness(profiles, dir_path)
+
+    return profiles, uniqueness_report
+
+
+def check_content_uniqueness(profiles, base_dir):
+    """Detect copy-pasted blocks across files."""
+    report = {
+        'total_files': len(profiles),
+        'duplicate_blocks': [],
+        'uniqueness_score': 100,
+    }
+
+    # Check tail hashes for identical endings
+    tail_groups = defaultdict(list)
+    for p in profiles:
+        tail_groups[p['tail_hash']].append(p['label'])
+
+    for tail_hash, files in tail_groups.items():
+        if len(files) > 2:
+            report['duplicate_blocks'].append({
+                'hash': tail_hash,
+                'count': len(files),
+                'files': files[:10],
+                'more': max(0, len(files) - 10),
+            })
+
+    # Check for exact line repetitions across files
+    line_to_files = defaultdict(set)
+    for p in profiles:
+        filepath = p.get('filepath', '')
+        try:
+            text = Path(filepath).read_text(encoding='utf-8', errors='replace')
+            for line in text.split('\n'):
+                stripped = line.strip()
+                if len(stripped) > 40:  # Only meaningful lines
+                    line_to_files[stripped].add(p['label'])
+        except Exception:
+            continue
+
+    # Lines appearing in >5 files = suspicious
+    suspicious_lines = {
+        line: files for line, files in line_to_files.items()
+        if len(files) > 5 and not line.startswith('|') and not line.startswith('#')
+    }
+
+    if suspicious_lines:
+        # Group by similarity
+        for line, files in sorted(suspicious_lines.items(), key=lambda x: -len(x[1])):
+            report['duplicate_blocks'].append({
+                'type': 'repeated_line',
+                'line': line[:100],
+                'count': len(files),
+                'files': sorted(files)[:5],
+                'more': max(0, len(files) - 5),
+            })
+
+    # Calculate uniqueness score
+    total_duplicates = sum(b['count'] for b in report['duplicate_blocks'])
+    if report['total_files'] > 0:
+        penalty = min(80, total_duplicates * 2)
+        report['uniqueness_score'] = max(0, 100 - penalty)
+
+    return report
+
+
+# ============================================================================
+# REPORT RENDERING
+# ============================================================================
+
+def render_report(profile):
+    """Render a profile as a Markdown report."""
+    lines = []
+    lines.append(f"# 🧬 Prompt DNA Profile: {profile['label']}")
+    lines.append(f"> Generated: {datetime.now().isoformat()}")
+    lines.append(f"> Size: {profile['size_bytes']:,} bytes | {profile['line_count']} lines | {profile['word_count']} words")
+    lines.append(f"> Type: {profile['file_type_profile']['label']} ({profile['file_type']})")
+    lines.append("")
+
+    # Hardness meter
+    h = profile['hardness_score']
+    target = profile['target_hardness']
+    bar = '█' * (h // 5) + '░' * (20 - h // 5)
+    label = '🟢 Soft' if h < 30 else '🟡 Moderate' if h < 60 else '🔴 Hard' if h < 85 else '💀 Nuclear'
+    status = '✅ PASS' if profile['meets_target'] else '❌ FAIL'
+    lines.append(f"## Hardness Score: {h}/100 {label} (Target: {target}) {status}")
+    lines.append(f"```")
+    lines.append(f"[{bar}] {h}%")
+    lines.append(f"```")
+
+    # Show penalties if any
+    if profile['gaming_penalties']:
+        lines.append("")
+        lines.append("### ⚠️ Gaming Penalties Applied")
+        for name, info in profile['gaming_penalties'].items():
+            lines.append(f"- **{name}**: {info['penalty']} — {info['reason']}")
+        lines.append(f"- Raw score: {profile['hardness_raw']} → Adjusted: {profile['hardness_score']}")
+    lines.append("")
+
+    # Restriction ratio
+    r = profile['restriction_ratio']
+    lines.append(f"## Restriction Ratio: {r:.0%}")
+    lines.append(f"- Enforcement words: **{profile['enforcement_total']}**")
+    lines.append(f"- Enabling words: **{profile['enabling_total']}**")
+    lines.append(f"- Ratio: {r:.0%} restrictive / {1-r:.0%} permissive")
+    lines.append(f"- Density: **{profile.get('enforcement_density', 0)}** enforcement words per 1000 words")
+    lines.append("")
+
+    # Enforcement breakdown
+    lines.append("## Enforcement Words")
+    lines.append("| Word | Count | Impact |")
+    lines.append("|----|----|----|")
+    for word, count in sorted(profile['enforcement_words'].items(), key=lambda x: -x[1]):
+        impact = '🔴' if word in ('CRITICAL', 'MANDATORY', 'UNACCEPTABLE', 'FAILED') else '🟡' if word in ('MUST', 'NEVER', 'ALWAYS') else '🟢'
+        lines.append(f"| {word} | {count} | {impact} |")
+    lines.append("")
+
+    # Priority channels
+    lines.append("## Priority Channels Detected")
+    for i, ch in enumerate(profile['priority_channels'], 1):
+        lines.append(f"{i}. {ch}")
+    lines.append("")
+
+    # Structure
+    lines.append(f"## Structure Completeness: {profile['structure_completeness']}%")
+    lines.append(f"- Tags found ({len(profile['tags_found'])}): {', '.join(f'`<{t}>`' for t in profile['tags_found'][:15])}")
+    if profile['tags_missing']:
+        lines.append(f"- Tags missing ({len(profile['tags_missing'])}): {', '.join(f'`<{t}>`' for t in profile['tags_missing'][:10])}")
+    lines.append("")
+
+    # Security
+    cov = profile['security_coverage']
+    sec_label = '🟢 Good' if cov > 60 else '🟡 Partial' if cov > 30 else '🔴 Weak'
+    lines.append(f"## Security Coverage: {cov}% {sec_label}")
+    if profile['security_present']:
+        lines.append(f"- ✅ Present: {', '.join(profile['security_present'])}")
+    if profile['security_missing']:
+        lines.append(f"- ❌ Missing: {', '.join(profile['security_missing'])}")
+    lines.append("")
+
+    # Tools
+    if profile['tools']:
+        lines.append(f"## Tools: {profile['tool_count']}")
+        lines.append(', '.join(f'`{t}`' for t in profile['tools']))
+        lines.append("")
+
+    # Recommendations
+    lines.append("## 💡 Recommendations")
+    if not profile['meets_target']:
+        lines.append(f"- ⬆️ Hardness {h} is below target {target} for {profile['file_type']} files")
+    if profile['gaming_penalties']:
+        lines.append("- 🚫 Remove generic boilerplate — add contextual enforcement instead")
+    if h < 40 and profile['file_type'] in ('role', 'workflow'):
+        lines.append("- ⬆️ Add MUST/NEVER directives to enforce critical behaviors")
+        lines.append("- ⬆️ Add CRITICAL INSTRUCTION blocks for non-negotiable rules")
+    if cov < 50:
+        lines.append("- 🔒 Add security directives (input validation, sanitization, etc.)")
+    if profile['structure_completeness'] < 50:
+        lines.append("- 📐 Add structure tags for better organization")
+    if h > 80:
+        lines.append("- ✅ Prompt is well-enforced. Consider adding enabling words for flexibility.")
+
+    return '\n'.join(lines)
+
+
+def render_batch_report(profiles, uniqueness_report=None):
+    """Render a batch analysis report."""
+    lines = []
+    lines.append("# 🧬 Batch DNA Analysis Report")
+    lines.append(f"> Generated: {datetime.now().isoformat()}")
+    lines.append(f"> Files analyzed: {len(profiles)}")
+    lines.append("")
+
+    # Summary by type
+    by_type = defaultdict(list)
+    for p in profiles:
+        by_type[p['file_type']].append(p)
+
+    lines.append("## Summary by Type")
+    lines.append("")
+    lines.append("| Type | Count | Target | Pass | Fail | Avg Hardness |")
+    lines.append("|----|----|----|----|----|----|")
+    for ft, type_profiles in sorted(by_type.items()):
+        target = FILE_TYPE_PROFILES.get(ft, {}).get('target_hardness', 60)
+        passing = sum(1 for p in type_profiles if p['meets_target'])
+        failing = len(type_profiles) - passing
+        avg = sum(p['hardness_score'] for p in type_profiles) / max(1, len(type_profiles))
+        status = '✅' if failing == 0 else '❌'
+        lines.append(f"| {ft} | {len(type_profiles)} | {target} | {passing} | {failing} {status} | {avg:.0f} |")
+    lines.append("")
+
+    # Full table
+    lines.append("## All Files")
+    lines.append("")
+    lines.append("| File | Type | Hardness | Target | Status | Penalties |")
+    lines.append("|----|----|----|----|----|----|")
+    for p in sorted(profiles, key=lambda x: x['hardness_score']):
+        status = '✅' if p['meets_target'] else '❌'
+        penalties = ', '.join(p['gaming_penalties'].keys()) if p['gaming_penalties'] else '—'
+        lines.append(f"| {p['label']} | {p['file_type']} | {p['hardness_score']} | {p['target_hardness']} | {status} | {penalties} |")
+    lines.append("")
+
+    # Gaming detected
+    gamed = [p for p in profiles if p['gaming_penalties']]
+    if gamed:
+        lines.append(f"## ⚠️ Gaming Detected ({len(gamed)} files)")
+        lines.append("")
+        for p in gamed:
+            lines.append(f"### {p['label']}")
+            for name, info in p['gaming_penalties'].items():
+                lines.append(f"- **{name}**: {info['penalty']} — {info['reason']}")
+            lines.append("")
+
+    # Uniqueness report
+    if uniqueness_report:
+        lines.append(f"## 🔄 Uniqueness Score: {uniqueness_report['uniqueness_score']}%")
+        lines.append("")
+        if uniqueness_report['duplicate_blocks']:
+            lines.append("### Duplicate Blocks Found")
+            lines.append("")
+            for block in uniqueness_report['duplicate_blocks'][:10]:
+                block_type = block.get('type', 'tail_hash')
+                if block_type == 'repeated_line':
+                    lines.append(f"- **Line repeated in {block['count']} files**: `{block['line']}`")
+                    files_str = ', '.join(block['files'])
+                    if block['more'] > 0:
+                        files_str += f" (+{block['more']} more)"
+                    lines.append(f"  Files: {files_str}")
+                else:
+                    lines.append(f"- **Identical endings in {block['count']} files** (hash: {block['hash']})")
+                    files_str = ', '.join(block['files'])
+                    if block['more'] > 0:
+                        files_str += f" (+{block['more']} more)"
+                    lines.append(f"  Files: {files_str}")
+                lines.append("")
+        else:
+            lines.append("✅ No duplicate blocks detected. Content is unique across files.")
+            lines.append("")
+
+    return '\n'.join(lines)
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description='Prompt DNA Analyzer v2.0')
+    parser.add_argument('input', nargs='?', help='Input file to analyze')
+    parser.add_argument('--output', '-o', help='Output file for report')
+    parser.add_argument('--json', '-j', action='store_true', help='Output as JSON')
+    parser.add_argument('--dump', '-d', type=int, help='Analyze specific dump number from logs')
+    parser.add_argument('--type', '-t', choices=list(FILE_TYPE_PROFILES.keys()),
+                        help='File type profile (auto-detected if not specified)')
+    parser.add_argument('--batch', '-b', help='Analyze all .md files in directory')
+    parser.add_argument('--check-uniqueness', '-u', action='store_true',
+                        help='Check for duplicate content across files (batch mode only)')
+    args = parser.parse_args()
+
+    # Batch mode
+    if args.batch:
+        profiles, uniqueness_report = batch_analyze(
+            args.batch,
+            check_uniqueness=args.check_uniqueness,
+        )
+
+        if args.json:
+            result = json.dumps({
+                'profiles': profiles,
+                'uniqueness': uniqueness_report,
+            }, indent=2, ensure_ascii=False, default=str)
+        else:
+            result = render_batch_report(profiles, uniqueness_report)
+
+        if args.output:
+            with open(args.output, 'w', encoding='utf-8') as f:
+                f.write(result)
+            print(f"Batch report written to: {args.output}")
+        else:
+            print(result)
+
+        # Exit code: 1 if any files fail their target
+        failures = [p for p in profiles if not p['meets_target']]
+        if failures:
+            print(f"\n❌ {len(failures)} file(s) below target hardness", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print(f"\n✅ All {len(profiles)} files meet their type-based targets", file=sys.stderr)
+        return
+
+    # Single file mode
+    if not args.input:
+        parser.error("Either 'input' file or '--batch' directory is required")
+
+    with open(args.input, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+
+    # If --dump specified, extract that dump
+    if args.dump:
+        pattern = r'={10,}\nTIMESTAMP:\s*(.+?)(?:\n={10,})'
+        splits = re.split(pattern, content)
+        dump_idx = (args.dump - 1) * 2 + 1
+        if dump_idx < len(splits):
+            ts = splits[dump_idx].strip()
+            body = splits[dump_idx + 1] if dump_idx + 1 < len(splits) else ''
+            content = body
+            label = f"Dump #{args.dump} ({ts[:50]})"
+        else:
+            print(f"Error: dump #{args.dump} not found", file=sys.stderr)
+            sys.exit(1)
+    else:
+        label = os.path.basename(args.input)
+
+    profile = analyze_prompt(content, label, file_type=args.type, filepath=args.input)
+
+    if args.json:
+        result = json.dumps(profile, indent=2, ensure_ascii=False)
+    else:
+        result = render_report(profile)
+
+    if args.output:
+        with open(args.output, 'w', encoding='utf-8') as f:
+            f.write(result)
+        print(f"Report written to: {args.output}")
+    else:
+        print(result)
+
+
+if __name__ == '__main__':
+    main()