@ivannikov-pro/ai-context-surgeon 1.0.0

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

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""
+extract_instructions.py — Extracts ALL instructions, directives, rules, and their
+variants from system_prompt_logs.txt across multiple dump sessions.
+
+Outputs a structured report to /tmp/extracted_instructions_report.md
+
+Sections extracted:
+  1. Dump timestamps & model info
+  2. All XML/HTML tags found (identity, planning_mode, etc.)
+  3. CRITICAL INSTRUCTION 1 & 2 variants
+  4. MANDATORY RULE variants
+  5. CRITICAL REMINDER variants
+  6. EPHEMERAL_MESSAGE content variants
+  7. Tool schemas (names only, with counts)
+  8. Section-by-section diff across dumps
+"""
+
+import re
+import os
+import hashlib
+from collections import defaultdict, OrderedDict
+from datetime import datetime
+
+INPUT_FILE = '/tmp/system_prompt_logs.txt'
+OUTPUT_FILE = '/tmp/extracted_instructions_report.md'
+
+
+
+def read_file(path):
+    with open(path, 'r', encoding='utf-8', errors='replace') as f:
+        return f.read()
+
+
+def split_dumps(content):
+    """Split the log file into individual dump sessions by TIMESTAMP markers."""
+    pattern = r'={10,}\nTIMESTAMP:\s*(.+?)(?:\n={10,})'
+    splits = re.split(pattern, content)
+    
+    dumps = []
+    # splits[0] is content before first timestamp (may be empty or preamble)
+    if splits[0].strip():
+        dumps.append({
+            'timestamp': 'INITIAL (no timestamp header)',
+            'content': splits[0].strip()
+        })
+    
+    # After that, pairs of (timestamp, content)
+    for i in range(1, len(splits) - 1, 2):
+        timestamp = splits[i].strip()
+        body = splits[i + 1].strip() if i + 1 < len(splits) else ''
+        dumps.append({
+            'timestamp': timestamp,
+            'content': body
+        })
+    
+    return dumps
+
+
+def extract_xml_tags(content):
+    """Find all XML-like tags used in the content."""
+    # Opening tags
+    opening = re.findall(r'<(\w[\w_-]*)(?:\s[^>]*)?>',  content)
+    # Filter out common HTML and keep system-level tags
+    system_tags = set()
+    for tag in opening:
+        tag_lower = tag.lower()
+        if tag_lower in ('h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'br', 'hr', 'div', 
+                         'span', 'ul', 'ol', 'li', 'a', 'img', 'code', 'pre', 'em', 
+                         'strong', 'b', 'i', 'table', 'tr', 'td', 'th', 'thead', 'tbody'):
+            continue
+        system_tags.add(tag)
+    return sorted(system_tags)
+
+
+def extract_tag_content(content, tag_name):
+    """Extract the full content between <tag_name> and </tag_name>."""
+    pattern = re.compile(
+        r'<' + re.escape(tag_name) + r'[^>]*>(.*?)</' + re.escape(tag_name) + r'>',
+        re.DOTALL
+    )
+    matches = pattern.findall(content)
+    return [m.strip() for m in matches]
+
+
+def extract_critical_instructions(content):
+    """Extract CRITICAL INSTRUCTION blocks."""
+    results = {}
+    
+    # CRITICAL INSTRUCTION 1
+    pat1 = re.compile(
+        r'CRITICAL INSTRUCTION 1:\s*(.*?)(?=CRITICAL INSTRUCTION 2:|$)',
+        re.DOTALL
+    )
+    m1 = pat1.findall(content)
+    if m1:
+        results['CRITICAL INSTRUCTION 1'] = [x.strip()[:500] for x in m1]
+    
+    # CRITICAL INSTRUCTION 2
+    pat2 = re.compile(
+        r'CRITICAL INSTRUCTION 2:\s*(.*?)(?=<\/|$)',
+        re.DOTALL
+    )
+    m2 = pat2.findall(content)
+    if m2:
+        results['CRITICAL INSTRUCTION 2'] = [x.strip()[:500] for x in m2]
+    
+    return results
+
+
+def extract_mandatory_rules(content):
+    """Extract MANDATORY RULE blocks."""
+    pattern = re.compile(r'MANDATORY RULE:\s*(.*?)(?:\n\n|\n<|$)', re.DOTALL)
+    matches = pattern.findall(content)
+    return [m.strip()[:300] for m in matches]
+
+
+def extract_critical_reminders(content):
+    """Extract CRITICAL REMINDER blocks."""
+    pattern = re.compile(r'CRITICAL REMINDER:\s*(.*?)(?:\n<|$)', re.DOTALL)
+    matches = pattern.findall(content)
+    return [m.strip()[:300] for m in matches]
+
+
+def extract_tool_names(content):
+    """Extract tool/function names from JSON schemas."""
+    pattern = re.compile(r'"name":\s*"([^"]+)"')
+    names = pattern.findall(content)
+    # Filter to likely tool names (not parameter names)
+    tool_names = []
+    for n in names:
+        if n.startswith('$') or n in ('type', 'string', 'integer', 'boolean', 'array', 'object'):
+            continue
+        tool_names.append(n)
+    return sorted(set(tool_names))
+
+
+def content_hash(text):
+    """Short hash for dedup."""
+    return hashlib.md5(text.encode('utf-8', errors='replace')).hexdigest()[:8]
+
+
+def extract_section_content(content, section_header):
+    """Extract content under === SECTION === headers."""
+    pattern = re.compile(
+        r'===\s*' + re.escape(section_header) + r'\s*===\s*\n(.*?)(?====\s*\w|$)',
+        re.DOTALL
+    )
+    matches = pattern.findall(content)
+    return [m.strip() for m in matches]
+
+
+# Key system tags to track
+SYSTEM_TAGS = [
+    'identity', 'web_application_development', 'ephemeral_message',
+    'skills', 'plugins', 'persistent_context', 'artifacts',
+    'planning_mode', 'planning_mode_artifacts', 'communication_style',
+    'user_information', 'mcp_servers', 'user_rules', 'workflows',
+    'USER_REQUEST', 'ADDITIONAL_METADATA', 'USER_SETTINGS_CHANGE',
+    'EPHEMERAL_MESSAGE', 'WORKFLOW', 'RULE', 'function', 'functions'
+]
+
+# Named section headers to track
+SECTION_HEADERS = [
+    'PREAMBLE & TOOLS', 'IDENTITY', 'WEB APP DEV', 'EPHEMERAL MESSAGE DEF',
+    'SKILLS DEF', 'PLUGINS DEF', 'PERSISTENT CONTEXT', 'ARTIFACTS',
+    'PLANNING MODE', 'PLANNING MODE ARTIFACTS', 'COMMUNICATION STYLE',
+    'INSTRUCTION INVOCATION', 'USER INFORMATION', 'MCP SERVERS',
+    'USER RULES', 'WORKFLOWS', 'ACTIVE SKILLS', 'CONVERSATION HISTORY',
+    'USER REQUEST', 'ADDITIONAL METADATA', 'EPHEMERAL INTERRUPT',
+    'RUNTIME EPHEMERAL_MESSAGE'
+]
+
+
+def main():
+    print(f"Reading {INPUT_FILE}...")
+    content = read_file(INPUT_FILE)
+    print(f"  File size: {len(content):,} bytes, {content.count(chr(10)):,} lines")
+    
+    # 1. Split into dumps
+    dumps = split_dumps(content)
+    print(f"  Found {len(dumps)} dump session(s)")
+    
+    # 2. Analyze each dump
+    analysis = []
+    for i, dump in enumerate(dumps):
+        info = {
+            'index': i + 1,
+            'timestamp': dump['timestamp'],
+            'size': len(dump['content']),
+            'lines': dump['content'].count('\n'),
+            'xml_tags': extract_xml_tags(dump['content']),
+            'critical_instructions': extract_critical_instructions(dump['content']),
+            'mandatory_rules': extract_mandatory_rules(dump['content']),
+            'critical_reminders': extract_critical_reminders(dump['content']),
+            'tool_names': extract_tool_names(dump['content']),
+            'tag_contents': {},
+            'section_contents': {},
+        }
+        
+        # Extract content for each system tag
+        for tag in SYSTEM_TAGS:
+            contents = extract_tag_content(dump['content'], tag)
+            if contents:
+                info['tag_contents'][tag] = contents
+        
+        # Extract named sections
+        for header in SECTION_HEADERS:
+            sections = extract_section_content(dump['content'], header)
+            if sections:
+                info['section_contents'][header] = sections
+        
+        analysis.append(info)
+    
+    # 3. Build the report
+    report = []
+    report.append("# System Prompt Instructions — Full Extraction Report\n")
+    report.append(f"> Generated: {datetime.now().isoformat()}\n")
+    report.append(f"> Source: `/tmp/system_prompt_logs.txt` ({len(content):,} bytes, {content.count(chr(10)):,} lines)\n")
+    report.append(f"> Dumps found: **{len(dumps)}**\n\n")
+    
+    # --- Overview table ---
+    report.append("## 1. Dump Sessions Overview\n\n")
+    report.append("| # | Timestamp | Size | Lines | Tools | XML Tags |\n")
+    report.append("|---|----|----|----|----|----|\n")
+    for a in analysis:
+        report.append(f"| {a['index']} | {a['timestamp'][:60]} | {a['size']:,} | {a['lines']} | {len(a['tool_names'])} | {len(a['xml_tags'])} |\n")
+    report.append("\n")
+    
+    # --- All XML tags across all dumps ---
+    report.append("## 2. All System XML Tags Found\n\n")
+    all_tags = set()
+    for a in analysis:
+        all_tags.update(a['xml_tags'])
+    for tag in sorted(all_tags):
+        occurrences = sum(1 for a in analysis if tag in a['xml_tags'])
+        report.append(f"- `<{tag}>` — found in {occurrences}/{len(analysis)} dumps\n")
+    report.append("\n")
+    
+    # --- Tool names ---
+    report.append("## 3. Tool/Function Names\n\n")
+    all_tools = set()
+    for a in analysis:
+        all_tools.update(a['tool_names'])
+    report.append(f"**Total unique tools: {len(all_tools)}**\n\n")
+    for tool in sorted(all_tools):
+        occurrences = sum(1 for a in analysis if tool in a['tool_names'])
+        report.append(f"- `{tool}` — in {occurrences}/{len(analysis)} dumps\n")
+    report.append("\n")
+    
+    # --- CRITICAL INSTRUCTIONs ---
+    report.append("## 4. CRITICAL INSTRUCTION Variants\n\n")
+    for ci_name in ['CRITICAL INSTRUCTION 1', 'CRITICAL INSTRUCTION 2']:
+        report.append(f"### {ci_name}\n\n")
+        variants = defaultdict(list)
+        for a in analysis:
+            ci_data = a['critical_instructions'].get(ci_name, [])
+            for text in ci_data:
+                h = content_hash(text)
+                variants[h].append((a['index'], text))
+        
+        if not variants:
+            report.append("*Not found in any dump.*\n\n")
+        else:
+            report.append(f"**{len(variants)} unique variant(s):**\n\n")
+            for h, occurrences in variants.items():
+                dump_ids = [str(o[0]) for o in occurrences]
+                report.append(f"**Variant `{h}`** (dumps: {', '.join(dump_ids)}):\n")
+                report.append("```\n")
+                report.append(occurrences[0][1][:400] + "\n")
+                report.append("```\n\n")
+    
+    # --- MANDATORY RULES ---
+    report.append("## 5. MANDATORY RULE Variants\n\n")
+    variants = defaultdict(list)
+    for a in analysis:
+        for text in a['mandatory_rules']:
+            h = content_hash(text)
+            variants[h].append((a['index'], text))
+    
+    if not variants:
+        report.append("*Not found.*\n\n")
+    else:
+        report.append(f"**{len(variants)} unique variant(s):**\n\n")
+        for h, occurrences in variants.items():
+            dump_ids = [str(o[0]) for o in occurrences]
+            report.append(f"**Variant `{h}`** (dumps: {', '.join(dump_ids)}):\n")
+            report.append("```\n")
+            report.append(occurrences[0][1][:300] + "\n")
+            report.append("```\n\n")
+    
+    # --- CRITICAL REMINDERs ---
+    report.append("## 6. CRITICAL REMINDER Variants\n\n")
+    variants = defaultdict(list)
+    for a in analysis:
+        for text in a['critical_reminders']:
+            h = content_hash(text)
+            variants[h].append((a['index'], text))
+    
+    if not variants:
+        report.append("*Not found.*\n\n")
+    else:
+        report.append(f"**{len(variants)} unique variant(s):**\n\n")
+        for h, occurrences in variants.items():
+            dump_ids = [str(o[0]) for o in occurrences]
+            report.append(f"**Variant `{h}`** (dumps: {', '.join(dump_ids)}):\n")
+            report.append("```\n")
+            report.append(occurrences[0][1][:300] + "\n")
+            report.append("```\n\n")
+    
+    # --- Tag content comparison ---
+    report.append("## 7. System Tag Content — Cross-Dump Comparison\n\n")
+    report.append("For each system tag, shows how many unique content variants exist across dumps.\n\n")
+    
+    tag_variants = {}
+    for tag in SYSTEM_TAGS:
+        variants = defaultdict(list)
+        for a in analysis:
+            contents = a['tag_contents'].get(tag, [])
+            for c in contents:
+                h = content_hash(c)
+                variants[h].append(a['index'])
+        if variants:
+            tag_variants[tag] = variants
+    
+    report.append("| Tag | Unique Variants | In Dumps |\n")
+    report.append("|----|----|----|\n")
+    for tag, variants in sorted(tag_variants.items()):
+        all_dumps = set()
+        for dump_ids in variants.values():
+            all_dumps.update(dump_ids)
+        report.append(f"| `<{tag}>` | {len(variants)} | {sorted(all_dumps)} |\n")
+    report.append("\n")
+    
+    # --- Detailed tag content for key sections ---
+    KEY_TAGS = ['identity', 'communication_style', 'user_rules', 'EPHEMERAL_MESSAGE']
+    report.append("## 8. Key Tag Content Details\n\n")
+    for tag in KEY_TAGS:
+        report.append(f"### `<{tag}>`\n\n")
+        if tag not in tag_variants:
+            report.append("*Not found.*\n\n")
+            continue
+        
+        for h, dump_ids in tag_variants[tag].items():
+            # Find the actual content from one of the dumps
+            sample_text = None
+            for a in analysis:
+                contents = a['tag_contents'].get(tag, [])
+                for c in contents:
+                    if content_hash(c) == h:
+                        sample_text = c
+                        break
+                if sample_text:
+                    break
+            
+            report.append(f"**Variant `{h}`** (dumps: {dump_ids}):\n")
+            report.append("```\n")
+            # Truncate very long content
+            if sample_text and len(sample_text) > 600:
+                report.append(sample_text[:600] + "\n... [truncated, " + str(len(sample_text)) + " chars total]\n")
+            elif sample_text:
+                report.append(sample_text + "\n")
+            report.append("```\n\n")
+    
+    # --- Section headers comparison ---
+    report.append("## 9. Named Sections (=== HEADER ===) Across Dumps\n\n")
+    for header in SECTION_HEADERS:
+        found_in = []
+        for a in analysis:
+            if header in a['section_contents']:
+                found_in.append(a['index'])
+        if found_in:
+            report.append(f"- **{header}** — in dumps: {found_in}\n")
+    report.append("\n")
+    
+    # --- All unique directives/imperatives ---
+    report.append("## 10. All Directive Keywords Found\n\n")
+    report.append("Scanning for imperative phrases across all dumps...\n\n")
+    
+    directive_patterns = [
+        (r'MUST\s+(?:ALWAYS\s+)?(?:NOT\s+)?[\w\s]+', 'MUST ...'),
+        (r'NEVER\s+[\w\s]+', 'NEVER ...'),
+        (r'ALWAYS\s+[\w\s]+', 'ALWAYS ...'),
+        (r'DO\s+NOT\s+[\w\s]+', 'DO NOT ...'),
+        (r'IMPORTANT:\s*[^\n]+', 'IMPORTANT: ...'),
+        (r'UNACCEPTABLE', 'UNACCEPTABLE'),
+        (r'FAILED!', 'FAILED!'),
+        (r'CRITICAL\s+\w+', 'CRITICAL ...'),
+        (r'MANDATORY\s+\w+', 'MANDATORY ...'),
+    ]
+    
+    for pat_str, label in directive_patterns:
+        pat = re.compile(pat_str)
+        all_matches = set()
+        for dump in dumps:
+            matches = pat.findall(dump['content'])
+            for m in matches:
+                all_matches.add(m.strip()[:120])
+        
+        if all_matches:
+            report.append(f"### `{label}` ({len(all_matches)} unique)\n\n")
+            for m in sorted(all_matches):
+                report.append(f"- `{m}`\n")
+            report.append("\n")
+    
+    # Write report
+    report_text = ''.join(report)
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
+        f.write(report_text)
+    
+    print(f"\nReport written to: {OUTPUT_FILE}")
+    print(f"  Size: {len(report_text):,} bytes, {report_text.count(chr(10)):,} lines")
+
+
+if __name__ == '__main__':
+    main()