Engineering AI Context: The Holographic Bridge for Self-Hosted Logs

AI_PHOOEY_CHOP = """\
/home/mike/repos/MikeLev.in/_posts//2025-12-14-semantic-clustering-rule-of-7-ai-friendly-site-hierarchy.md
/home/mike/repos/MikeLev.in/_posts//2025-12-15-ai-ready-web-navigation-caching.md
/home/mike/repos/MikeLev.in/_posts//2025-12-15-industrializing-intelligence-ai-content-pipelines.md
/home/mike/repos/MikeLev.in/_posts//2025-12-15-the-gold-pan-hybrid-hierarchies-ai.md
"""

AI_PHOOEY_CHOP = """\
scripts/articles/contextualizer.py
/home/mike/repos/MikeLev.in/_posts/_context/2025-12-14-semantic-clustering-rule-of-7-ai-friendly-site-hierarchy.json
/home/mike/repos/MikeLev.in/_posts/_context/2025-12-15-ai-ready-web-navigation-caching.json
/home/mike/repos/MikeLev.in/_posts/_context/2025-12-15-industrializing-intelligence-ai-content-pipelines.json
/home/mike/repos/MikeLev.in/_posts/_context/2025-12-15-the-gold-pan-hybrid-hierarchies-ai.json
foo_files.py
prompt_foo.py

#!/usr/bin/env python3
# prompt_foo.py

# > We've got content, it's groovy context
# > Our concatenation just won't stop
# > Making stories art for a super-smart
# > AI-Phooey chop (Hi-Ya!)

import os
import re
import sys
import pydot
import yaml
import argparse
import tiktoken
import subprocess
import tempfile
import shutil
import json
from datetime import datetime
from typing import Dict, List, Optional, Tuple, Any, Union

try:
    import jupytext
    JUPYTEXT_AVAILABLE = True
except ImportError:
    JUPYTEXT_AVAILABLE = False

# ============================================================================
# --- Logging & Capture ---
# ============================================================================
class Logger:
    """Captures stdout for inclusion in the generated prompt."""
    def __init__(self):
        self.logs = []

    def print(self, *args, **kwargs):
        # Construct the string exactly as print would
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        text = sep.join(map(str, args)) + end
        
        # Capture it
        self.logs.append(text)
        
        # Actually print it to stdout
        print(*args, **kwargs)

    def get_captured_text(self):
        return "".join(self.logs)

# Global logger instance
logger = Logger()

def load_targets():
    """Loads publishing targets from external config."""
    config_path = os.path.expanduser("~/.config/articleizer/targets.json")
    if os.path.exists(config_path):
        try:
            with open(config_path, 'r') as f:
                return json.load(f)
        except json.JSONDecodeError:
            logger.print(f"Warning: Could not decode JSON from {config_path}")
    return {}

# ============================================================================
# --- Configuration ---
# ============================================================================
def find_repo_root(start_path: str) -> str:
    """Find the git repository root from a starting path."""
    path = os.path.abspath(start_path)
    while path != os.path.dirname(path):
        if os.path.isdir(os.path.join(path, '.git')):
            return path
        path = os.path.dirname(path)
    raise FileNotFoundError("Could not find the repository root (.git directory).")

REPO_ROOT = find_repo_root(os.path.dirname(__file__))

CONFIG = {
    "PROJECT_NAME": "pipulate",
    "POSTS_DIRECTORY": "/home/mike/repos/MikeLev.in/_posts",
    "URL_MAP": {} # Populated if needed or loaded from config
}

# ============================================================================
# --- Literary Size Scale & Token/Word Counting ---
# ============================================================================
LITERARY_SIZE_SCALE = [
    (3000, "Short Essay"), (7500, "Short Story"), (20000, "Novelette"),
    (50000, "Novella or a Master's Dissertation"),
    (80000, "Average Paperback Novel or a Ph.D. Dissertation"),
    (120000, "Long Novel"), (200000, "Epic Fantasy Novel"),
    (500000, "Seriously Long Epic (like 'Infinite Jest')"),
]

def get_literary_perspective(word_count: int, token_word_ratio: float) -> str:
    description = f"Longer than {LITERARY_SIZE_SCALE[-1][1]}"
    for words, desc in LITERARY_SIZE_SCALE:
        if word_count <= words:
            description = desc
            break
    density_warning = ""
    if token_word_ratio > 1.8:
        density_warning = (
            f" (Note: With a token/word ratio of {token_word_ratio:.2f}, "
            f"this content is far denser and more complex than typical prose of this length)."
        )
    return f"📚 Equivalent in length to a **{description}**{density_warning}"

def count_tokens(text: str, model: str = "gpt-4o") -> int:
    try:
        encoding = tiktoken.encoding_for_model(model)
        return len(encoding.encode(text))
    except Exception:
        return len(text.split())

def count_words(text: str) -> int:
    return len(text.split())

# ============================================================================
# --- Auto-Context Generation (UML, Tree, Narrative) ---
# ============================================================================
def generate_uml_and_dot(target_file: str, project_name: str) -> Dict:
    pyreverse_exec = shutil.which("pyreverse")
    plantuml_exec = shutil.which("plantuml")
    if not pyreverse_exec or not plantuml_exec:
        msg = []
        if not pyreverse_exec: msg.append("`pyreverse` (from pylint)")
        if not plantuml_exec: msg.append("`plantuml`")
        return {"ascii_uml": f"Skipping: Required command(s) not found: {', '.join(msg)}."}

    target_path = target_file if os.path.isabs(target_file) else os.path.join(REPO_ROOT, target_file)
    if not os.path.exists(target_path):
        return {"ascii_uml": f"Skipping: Target file for UML generation not found: {target_path}"}

    with tempfile.TemporaryDirectory() as temp_dir:
        dot_file_path = os.path.join(temp_dir, "classes.dot")
        puml_file_path = os.path.join(temp_dir, "diagram.puml")
        try:
            pyreverse_cmd = [pyreverse_exec, "-f", "dot", "-o", "dot", "-p", project_name, target_path]
            subprocess.run(pyreverse_cmd, check=True, capture_output=True, text=True, cwd=temp_dir)
            generated_dot_name = f"classes_{project_name}.dot"
            os.rename(os.path.join(temp_dir, generated_dot_name), dot_file_path)
        except (subprocess.CalledProcessError, FileNotFoundError) as e:
            error_msg = e.stderr if hasattr(e, 'stderr') else str(e)
            return {"ascii_uml": f"Error: pyreverse failed. {error_msg}", "dot_graph": None}

        try:
            graphs = pydot.graph_from_dot_file(dot_file_path)
            if not graphs:
                return {"ascii_uml": f"Note: No classes found in {target_file} to generate a diagram.", "dot_graph": None}
            graph = graphs[0]
            dot_content = graph.to_string()
            puml_lines = ["@startuml", "skinparam linetype ortho", ""]
            def sanitize_line(line):
                clean = re.sub(r'<br[^>]*>', '', line)
                clean = re.sub(r'<[^>]+>', '', clean)
                return clean.strip()
            for node in graph.get_nodes():
                label = node.get_label()
                if not label: continue
                parts = label.strip('<>{} ').split('|')
                class_name = sanitize_line(parts[0])
                puml_lines.append(f"class {class_name} {{")
                if len(parts) > 1:
                    for attr in re.split(r'<br[^>]*>', parts[1]):
                        clean_attr = sanitize_line(attr).split(':')[0].strip()
                        if clean_attr: puml_lines.append(f"  - {clean_attr}")
                if len(parts) > 2:
                    method_block = parts[2].strip()
                    for method_line in re.split(r'<br[^>]*>', method_block):
                        clean_method = sanitize_line(method_line)
                        if clean_method: puml_lines.append(f"  + {clean_method}")
                puml_lines.append("}\n")
            for edge in graph.get_edges():
                source_name = edge.get_source().strip('"').split('.')[-1]
                dest_name = edge.get_destination().strip('"').split('.')[-1]
                puml_lines.append(f"{source_name} ..> {dest_name}")
            puml_lines.append("@enduml")
            with open(puml_file_path, 'w') as f: f.write('\n'.join(puml_lines))
        except Exception as e:
            with open(dot_file_path, 'r') as f: dot_content_on_error = f.read()
            return {"ascii_uml": f"Error: DOT to PUML conversion failed. {str(e)}", "dot_graph": dot_content_on_error}

        try:
            plantuml_cmd = ["plantuml", "-tutxt", puml_file_path]
            subprocess.run(plantuml_cmd, check=True, capture_output=True, text=True, cwd=temp_dir)
            utxt_file_path = puml_file_path.replace(".puml", ".utxt")
            with open(utxt_file_path, 'r') as f: ascii_uml = f.read()
            lines = ascii_uml.splitlines()
            non_empty_lines = [line for line in lines if line.strip()]
            if non_empty_lines:
                min_indent = min(len(line) - len(line.lstrip(' ')) for line in non_empty_lines)
                dedented_lines = [line[min_indent:] for line in lines]
                stripped_lines = [line.rstrip() for line in dedented_lines]
                ascii_uml = '\n'.join(stripped_lines)
                if ascii_uml: ascii_uml = '\n' + ascii_uml
        except (subprocess.CalledProcessError, FileNotFoundError) as e:
            error_msg = e.stderr if hasattr(e, 'stderr') else str(e)
            return {"ascii_uml": f"Error: plantuml failed. {error_msg}", "dot_graph": dot_content}

    return {"ascii_uml": ascii_uml, "dot_graph": dot_content}

def _get_article_list_data(posts_dir: str = CONFIG["POSTS_DIRECTORY"]) -> List[Dict]:
    posts_data = []
    if not os.path.isdir(posts_dir):
        logger.print(f"Warning: Article directory not found at {posts_dir}", file=sys.stderr)
        return []

    # Simple URL config loader if ~/.config/articleizer/url_map.json exists
    url_config = {}
    config_path = os.path.expanduser("~/.config/articleizer/url_map.json")
    if os.path.exists(config_path):
        try:
            with open(config_path) as f:
                url_map = json.load(f)
                url_config = url_map.get(posts_dir, {})
        except: pass

    for filename in os.listdir(posts_dir):
        if not filename.endswith((".md", ".markdown")): continue
        filepath = os.path.join(posts_dir, filename)
        try:
            date_str = filename[:10]
            try:
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                # Fallback if filename doesn't start with date
                post_date = datetime.min.date()

            with open(filepath, 'r', encoding='utf-8') as f: content = f.read()
            
            # Simple frontmatter parse
            if content.startswith('---'):
                parts = content.split('---', 2)
                front_matter = yaml.safe_load(parts[1]) or {}
                
                full_url = ""
                if url_config:
                    slug = front_matter.get('permalink', '').strip('/')
                    if not slug:
                        raw_slug = os.path.splitext(filename)[0]
                        # Strip date prefix if present for slug
                        if re.match(r'\d{4}-\d{2}-\d{2}-', raw_slug):
                             raw_slug = raw_slug[11:]
                        style = url_config.get('permalink_style', '/:slug/')
                        slug_path = style.replace(':slug', raw_slug)
                    else:
                          slug_path = "/" + slug.lstrip('/')
                    full_url = f"{url_config.get('base_url', '')}{slug_path}"

                article_tokens = count_tokens(content)
                article_bytes = len(content.encode('utf-8'))
                
                posts_data.append({
                    'path': filepath,
                    'filename': filename,
                    'date': post_date,
                    'sort_order': int(front_matter.get('sort_order', 0)),
                    'title': front_matter.get('title', 'Untitled'),
                    'summary': front_matter.get('meta_description', front_matter.get('description', '')),
                    'url': full_url,
                    'tokens': article_tokens,
                    'bytes': article_bytes
                })
        except (ValueError, yaml.YAMLError, IndexError, OSError): 
            continue
            
    # Sort by date (descending usually preferred for blogs, but we sort ascending then can slice)
    # Actually, standard blog order is usually reverse chrono. 
    # Let's sort Oldest -> Newest so [:] makes chronological sense, or [-5:] gets most recent.
    return sorted(posts_data, key=lambda p: (p['date'], p['sort_order']))

def parse_slice_arg(arg_str: str) -> Optional[Union[int, slice]]:
    if not arg_str: return None
    # Handle simple integer "5" as "[-5:]" shortcut? 
    # No, keep it Pythonic. User must provide brackets for slice.
    if not (arg_str.startswith('[') and arg_str.endswith(']')):
        return None
        
    content = arg_str[1:-1].strip()
    if ':' in content:
        parts = content.split(':', 1)
        start = int(parts[0].strip()) if parts[0].strip() else None
        end = int(parts[1].strip()) if parts[1].strip() else None
        return slice(start, end)
    elif content:
        return int(content)
    return slice(None, None)

def run_tree_command() -> str:
    eza_exec = shutil.which("eza")
    if not eza_exec: return "Skipping: `eza` command not found."
    try:
        # Added --level 3 to keep the tree from exploding if the repo grows deeper
        result = subprocess.run(
            [eza_exec, '--tree', '--level', '3', '--git-ignore', '--color=never'],
            capture_output=True, text=True, cwd=REPO_ROOT, check=True
        )
        return result.stdout
    except Exception as e: return f"Error running eza command: {e}"

# ============================================================================
# --- Helper Functions (File Parsing, Clipboard) ---
# ============================================================================
def parse_file_list_from_config() -> List[Tuple[str, str]]:
    try:
        import foo_files
        files_raw = foo_files.AI_PHOOEY_CHOP
    except (ImportError, AttributeError):
        logger.print("ERROR: foo_files.py not found or doesn't contain AI_PHOOEY_CHOP.")
        sys.exit(1)
    lines = files_raw.strip().splitlines()
    seen_files, parsed_files = set(), []
    for line in lines:
        line = line.strip()
        if not line or line.startswith('#'): continue
        parts = re.split(r'\s*<--\s*|\s*#\s*', line, 1)
        file_path = parts[0].strip()
        comment = parts[1].strip() if len(parts) > 1 else ""
        if file_path and file_path not in seen_files:
            seen_files.add(file_path)
            parsed_files.append((file_path, comment))
    return parsed_files

def copy_to_clipboard(text: str):
    if not shutil.which('xclip'):
        logger.print("\nWarning: 'xclip' not found. Cannot copy to clipboard.")
        return
    try:
        subprocess.run(['xclip', '-selection', 'clipboard'], input=text.encode('utf-8'), check=True)
        logger.print("Markdown output copied to clipboard")
    except Exception as e:
        logger.print(f"\nWarning: Could not copy to clipboard: {e}")

def check_dependencies():
    logger.print("Checking for required external dependencies...")
    dependencies = {
        "pyreverse": "Provided by `pylint`. Install with: pip install pylint",
        "plantuml": "A Java-based tool. See https://plantuml.com/starting",
        "eza": "A modern replacement for `ls`. See https://eza.rocks/install",
        "xclip": "Clipboard utility for Linux. Install with your package manager (e.g., sudo apt-get install xclip)",
    }
    missing = []
    for tool, instructions in dependencies.items():
        if not shutil.which(tool):
            missing.append((tool, instructions))
    
    if not missing:
        logger.print("✅ All dependencies found.")
    else:
        logger.print("\n❌ Missing dependencies detected:")
        for tool, instructions in missing:
            logger.print(f"  - Command not found: `{tool}`")
            logger.print(f"    ↳ {instructions}")
        logger.print("\nPlease install the missing tools and ensure they are in your system's PATH.")
        sys.exit(1)

# ============================================================================
# --- Refined PromptBuilder Class ---
# ============================================================================
class PromptBuilder:
    """
    Builds a complete, structured Markdown prompt with consistent START/END markers.
    Includes a convergence loop to ensure the Summary section reflects the final token count.
    """
    def __init__(self, processed_files: List[Dict], prompt_text: str, context_only: bool = False, 
                 list_arg: Optional[str] = None, context_arg: Optional[str] = None):
        self.processed_files = processed_files
        self.prompt_text = prompt_text
        self.context_only = context_only
        self.list_arg = list_arg
        self.context_arg = context_arg
        self.auto_context = {}
        self.all_sections = {}
        self.command_line = " ".join(sys.argv)
        self.manifest_key = "Manifest (Table of Contents)"

    def add_auto_context(self, title: str, content: str):
        # Filter Logic to ensure we don't add empty or error-heavy sections unintentionally
        # Allowed titles:
        allowed_titles = [
            "Recent Narrative Context", 
            "Full Article Content", 
            "Holographic Context Shards",
            "Codebase Structure (eza --tree)"
        ]
        
        is_allowed = title in allowed_titles or "UML" in title
        content_is_valid = bool(content) and content.strip()
        
        # Simple heuristic to avoid adding sections that are just error messages
        filter_passed = "error" not in content.lower() and "skipping" not in content.lower()
        
        if content_is_valid and (is_allowed or filter_passed):
            self.auto_context[title] = {
                'content': content, 
                'tokens': count_tokens(content), 
                'words': count_words(content)
            }

    def _build_manifest_content(self) -> str:
        lines = []
        # Added Summary to section order
        section_order = ["Story", "File Tree", "UML Diagrams", "Articles", "Codebase", "Summary", "Context Recapture", "Prompt"]
        for section_name in section_order:
            if section_name in self.all_sections:
                data = self.all_sections[section_name]
                token_str = f"({data['tokens']:,} tokens)" if data['tokens'] > 0 else ""
                lines.append(f"- {section_name} {token_str}")
                
                # Detailed list for Codebase for searching (absolute paths)
                if section_name == "Codebase" and not self.context_only and self.processed_files:
                     for f in self.processed_files:
                         byte_len = len(f['content'].encode('utf-8'))
                         lines.append(f"  - {f['path']} ({f['tokens']:,} tokens | {byte_len:,} bytes)")
                         
        return "\n".join(lines)

    def _build_story_content(self) -> str:
        title = "Recent Narrative Context"
        return self.auto_context.get(title, {}).get('content', '').strip()

    def _build_tree_content(self) -> str:
        title = "Codebase Structure (eza --tree)"
        if title in self.auto_context:
            content = self.auto_context[title]['content'].strip()
            return f"```text\n{content}\n```"
        return ""

    def _build_uml_content(self) -> str:
        uml_parts = []
        for title, data in self.auto_context.items():
            if "UML Class Diagram" in title:
                uml_parts.append(f"## {title}\n```text\n{data['content']}\n```")
        return "\n\n".join(uml_parts)

    def _build_articles_content(self) -> str:
        parts = []
        # 1. Full Content
        title_full = "Full Article Content"
        if title_full in self.auto_context:
            parts.append(self.auto_context[title_full]['content'].strip())
        
        # 2. Holographic Context (JSONs)
        title_holo = "Holographic Context Shards"
        if title_holo in self.auto_context:
            parts.append(self.auto_context[title_holo]['content'].strip())
            
        return "\n\n".join(parts).strip()

    def _build_codebase_content(self) -> str:
        if self.context_only: return ""
        if not self.processed_files: return ""
        
        lines = []
        for f in self.processed_files:
            # Using Absolute Paths in markers
            lines.append(f"--- START: {f['path']} ({f['tokens']:,} tokens) ---")
            lines.append(f"```{f['lang']}:{f['path']}")
            lines.append(f['content'])
            lines.append("```")
            lines.append(f"--- END: {f['path']} ---\n")
        return "\n".join(lines).strip()

    def _build_recapture_content(self) -> str:
        """Generates the commented-out variable block for reconstructing this context."""
        lines = ["```python", "# # PURPOSE OF CONTEXT: ", '# AI_PHOOEY_CHOP = """\\']
        for f in self.processed_files:
            path_str = f['path']
            # Keep relative if inside repo, absolute if outside
            if path_str.startswith(REPO_ROOT):
                path_str = os.path.relpath(path_str, REPO_ROOT)
            lines.append(f"# {path_str}")
        lines.append('# """')
        lines.append("```")
        return "\n".join(lines)

    def _build_prompt_content(self) -> str:
        checklist = self._generate_ai_checklist()
        return f"{checklist}\n\n{self.prompt_text}"

    def _generate_ai_checklist(self) -> str:
        return '''# AI Self-Correction Checklist

Before addressing the user's prompt, perform the following verification steps:

1.  **Review the Manifest vs. Codebase Structure:** Compare the file list in the manifest against the `eza --tree` output. Are there any obviously related, critical files missing from the manifest that would be necessary to understand the user's request? (e.g., if `core.py` is present, is `__init__.py` also present?).
2.  **Analyze Import Statements:** Briefly scan the `import` statements in the provided Python files. Do they suggest dependencies on local files that were *not* included in the manifest?
3.  **Check for Incompleteness:** If you determine that critical files are missing, do not proceed. Instead, your **primary task** is to inform me of the missing files and recommend adding them to `foo_files.py` to create a more complete context.
4.  **Confirm Understanding:** If the context appears complete, state "Context verified." and then proceed with the user's request.
5.  **Descriptions:** When describing the passion represented here, you may refer to it as a blueprint, treatise, soliloquy, methodology, philosophy or way. NEVER refer to it as a manifesto which has a negative connotation.
'''

    def _generate_summary_content(self, verified_token_count: int) -> str:
        """Generates the content for the Summary section."""
        lines = []
        
        # Command Line
        lines.append(f"**Command:** `{self.command_line}`\n")

        # Execution Log (Captured from Logger)
        logs = logger.get_captured_text().strip()
        if logs:
            lines.append("--- Processing Log ---")
            lines.append(f"```\n{logs}\n```\n")

        # Files Included
        lines.append("--- Files Included ---")
        for f in self.processed_files:
            if self.context_only:
                lines.append(f"• {f['path']} (content omitted)")
            else:
                byte_len = len(f['content'].encode('utf-8'))
                lines.append(f"• {f['path']} ({f['tokens']:,} tokens | {byte_len:,} bytes)")
        
        if self.auto_context:
            lines.append("\n--- Auto-Context Included ---")
            for title, data in self.auto_context.items():
                byte_len = len(data['content'].encode('utf-8'))
                lines.append(f"• {title} ({data['tokens']:,} tokens | {byte_len:,} bytes)")

        # Metrics
        total_tokens = sum(v.get('tokens', 0) for k, v in self.all_sections.items() if k != self.manifest_key)
        
        total_words = 0
        final_content_for_metrics = ""
        for section, data in self.all_sections.items():
            content_part = data.get('content', '')
            final_content_for_metrics += content_part
            if section != "Prompt":
                total_words += count_words(content_part)

        char_count = len(final_content_for_metrics)
        byte_count = len(final_content_for_metrics.encode('utf-8'))

        lines.append("\n--- Prompt Summary ---")
        if self.context_only:
            lines.append("NOTE: Running in --context-only mode. File contents are excluded.")
        
        lines.append(f"Summed Tokens:    {total_tokens:,} (from section parts)")
        lines.append(f"Verified Tokens: {verified_token_count:,} (from final output)")
        
        if total_tokens != verified_token_count:
            diff = verified_token_count - total_tokens
            lines.append(f"  (Difference: {diff:+,})")
            
        lines.append(f"Total Words:      {total_words:,} (content only)")
        lines.append(f"Total Chars:      {char_count:,}")
        lines.append(f"Total Bytes:      {byte_count:,} (UTF-8)")

        # Literary Perspective
        ratio = verified_token_count / total_words if total_words > 0 else 0
        perspective = get_literary_perspective(total_words, ratio)
        lines.append("\n--- Size Perspective ---")
        lines.append(perspective)

        return "\n".join(lines)

    def build_final_prompt(self) -> str:
        """Assembles all parts into the final Markdown string with convergence loop for accuracy."""
        
        # 1. Build static sections
        story_content = self._build_story_content()
        tree_content = self._build_tree_content()
        uml_content = self._build_uml_content()
        articles_content = self._build_articles_content()
        codebase_content = self._build_codebase_content()
        recapture_content = self._build_recapture_content()
        prompt_content = self._build_prompt_content()

        # Placeholders
        placeholders = {
            "Story": f"# Narrative context not requested. Use the -l or --list flag to include recent articles.",
            "File Tree": "# File tree generation failed or was skipped.",
            "UML Diagrams": "# No Python files with classes were included, or UML generation failed.",
            "Articles": "# No full articles requested. Use the -a or --article flag to include full article content.",
            "Codebase": ("# No files were specified for inclusion in the codebase." if not self.processed_files 
                         else "# Running in --context-only mode. File contents are omitted."),
        }
        
        # Update placeholder if context arg was used but articles arg wasn't
        if self.context_arg is not None and not articles_content:
             # Should be covered by _build_articles_content returning empty if nothing added
             pass

        # Store basic sections
        self.all_sections["Story"] = {'content': story_content, 'tokens': count_tokens(story_content)}
        self.all_sections["File Tree"] = {'content': tree_content, 'tokens': count_tokens(tree_content)}
        self.all_sections["UML Diagrams"] = {'content': uml_content, 'tokens': count_tokens(uml_content)}
        self.all_sections["Articles"] = {'content': articles_content, 'tokens': count_tokens(articles_content)}
        self.all_sections["Codebase"] = {'content': codebase_content, 'tokens': sum(f['tokens'] for f in self.processed_files) if not self.context_only else 0}
        self.all_sections["Context Recapture"] = {'content': recapture_content, 'tokens': count_tokens(recapture_content)}
        self.all_sections["Prompt"] = {'content': prompt_content, 'tokens': count_tokens(prompt_content)}

        # Helper to assemble text
        def assemble_text(manifest_txt, summary_txt):
            parts = [f"# KUNG FU PROMPT CONTEXT\n\nWhat you will find below is:\n\n- {self.manifest_key}\n- Story\n- File Tree\n- UML Diagrams\n- Articles\n- Codebase\n- Summary\n- Context Recapture\n- Prompt"]
            
            def add(name, content, placeholder):
                # If name is Articles, we check if content is meaningful. 
                # If we have holograms but no full text, it is still "Articles" section content.
                final = content.strip() if content and content.strip() else placeholder
                # Special case for Articles placeholder: if list_arg or context_arg used, message changes?
                # For now, stick to standard placeholders unless content exists.
                parts.append(f"--- START: {name} ---\n{final}\n--- END: {name} ---")

            add(self.manifest_key, manifest_txt, "# Manifest generation failed.")
            
            # Story Placeholder logic
            story_ph = placeholders["Story"]
            if self.list_arg is not None:
                 if not story_content: story_ph = "# No articles found for the specified list slice."
            
            add("Story", story_content, story_ph)
            add("File Tree", tree_content, placeholders["File Tree"])
            add("UML Diagrams", uml_content, placeholders["UML Diagrams"])
            
            # Articles Placeholder logic
            art_ph = placeholders["Articles"]
            if self.context_arg is not None or (self.list_arg and not story_content): 
                 pass # Logic already handled by content existence check
            
            add("Articles", articles_content, art_ph)
            add("Codebase", codebase_content, placeholders["Codebase"])
            add("Summary", summary_txt, "# Summary generation failed.")
            add("Context Recapture", recapture_content, "# Context Recapture failed.")
            add("Prompt", prompt_content, "# No prompt was provided.")
            
            return "\n\n".join(parts)

        # 2. Convergence Loop
        # We need the Summary to contain the final token count, but the Summary is part of the text.
        # We iterate to allow the numbers to stabilize.
        
        current_token_count = 0
        final_output_text = ""
        
        # Initial estimate (sum of static parts)
        current_token_count = sum(v['tokens'] for v in self.all_sections.values())
        
        for _ in range(3): # Max 3 iterations, usually converges in 2
            # Generate Summary with current count
            summary_content = self._generate_summary_content(current_token_count)
            self.all_sections["Summary"] = {'content': summary_content, 'tokens': count_tokens(summary_content)}
            
            # Generate Manifest (might change if Summary token count changes length like 999->1000)
            manifest_content = self._build_manifest_content()
            self.all_sections[self.manifest_key] = {'content': manifest_content, 'tokens': count_tokens(manifest_content)}
            
            # Assemble full text
            final_output_text = assemble_text(manifest_content, summary_content)
            
            # Verify count
            new_token_count = count_tokens(final_output_text)
            
            if new_token_count == current_token_count:
                break # Converged
            
            current_token_count = new_token_count

        return final_output_text

# ============================================================================
# --- Main Execution Logic ---
# ============================================================================
def main():
    """Main function to parse args, process files, and generate output."""
    parser = argparse.ArgumentParser(description='Generate a Markdown context file for AI code assistance.')
    parser.add_argument('prompt', nargs='?', default=None, help='A prompt string or path to a prompt file (e.g., prompt.md).')
    parser.add_argument('-o', '--output', type=str, help='Optional: Output filename.')
    parser.add_argument('--no-clipboard', action='store_true', help='Disable copying output to clipboard.')
    parser.add_argument('--check-dependencies', action='store_true', help='Verify that all required external tools are installed.')
    parser.add_argument('--context-only', action='store_true', help='Generate a context-only prompt without file contents.')
    parser.add_argument(
        '-t', '--target',
        type=int,
        help='Specify a target ID from targets.json to set the article source.'
    )
    parser.add_argument(
        '-l', '--list',
        nargs='?', const='[-5:]', default=None,
        help='Include a list of recent articles (Summary/Narrative). Optionally provide a slice, e.g., "[:]". Defaults to "[-5:]".'
    )
    parser.add_argument(
        '-a', '--article',
        nargs='?', const='[-1:]', default=None,
        help='Include FULL CONTENT of recent articles. Provide a slice, e.g., "[-5:]". Defaults to "[-1:]".'
    )
    parser.add_argument(
        '-c', '--context',
        nargs='?', const='[-5:]', default=None,
        help='Include HOLOGRAPHIC CONTEXT JSONs. Provide a slice, e.g., "[:]". Defaults to "[-5:]".'
    )
    args = parser.parse_args()

    if args.check_dependencies:
        check_dependencies()
        sys.exit(0)

    targets = load_targets()
    if args.target is not None:
        target_id_str = str(args.target)
        if targets and target_id_str in targets:
            selected_target = targets[target_id_str]
            CONFIG["POSTS_DIRECTORY"] = selected_target["path"]
            logger.print(f"🎯 Target set to: {selected_target['name']}")
        else:
            logger.print(f"Error: Target ID '{args.target}' not found in configuration.", file=sys.stderr)
            sys.exit(1)

    # 1. Handle user prompt
    prompt_content = "Please review the provided context and assist with the codebase."
    if args.prompt:
        if os.path.exists(args.prompt):
            with open(args.prompt, 'r', encoding='utf-8') as f: prompt_content = f.read()
        else:
            prompt_content = args.prompt
    elif os.path.exists("prompt.md"):
        with open("prompt.md", 'r', encoding='utf-8') as f: prompt_content = f.read()

    # 2. Process all specified files (Codebase)
    files_to_process = parse_file_list_from_config()
    processed_files_data = []
    logger.print("--- Processing Files ---")
    for path, comment in files_to_process:
        # ABSOLUTE PATH CERTAINTY
        full_path = os.path.join(REPO_ROOT, path) if not os.path.isabs(path) else path
        
        if not os.path.exists(full_path):
            logger.print(f"Warning: File not found and will be skipped: {full_path}")
            continue
        content, lang = "", "text"
        ext = os.path.splitext(full_path)[1].lower()
        if ext == '.ipynb':
            if JUPYTEXT_AVAILABLE:
                logger.print(f"   -> Converting notebook: {full_path}")
                try:
                    notebook = jupytext.read(full_path)
                    content = jupytext.writes(notebook, fmt='py:percent')
                    lang = 'python'
                except Exception as e:
                    content = f"# FAILED TO CONVERT NOTEBOOK: {full_path}\n# ERROR: {e}"
                    logger.print(f"Warning: Failed to convert {full_path}: {e}")
            else:
                content = f"# SKIPPING NOTEBOOK CONVERSION: jupytext not installed for {full_path}"
                logger.print(f"Warning: `jupytext` library not found. Skipping conversion for {full_path}.")
        else:
            try:
                with open(full_path, 'r', encoding='utf-8') as f: content = f.read()
                lang_map = {'.py': 'python', '.js': 'javascript', '.html': 'html', '.css': 'css', '.md': 'markdown', '.json': 'json', '.nix': 'nix', '.sh': 'bash'}
                lang = lang_map.get(ext, 'text')
            except Exception as e:
                logger.print(f"ERROR: Could not read or process {full_path}: {e}")
                sys.exit(1)
        
        processed_files_data.append({
            "path": full_path, "comment": comment, "content": content,
            "tokens": count_tokens(content), "words": count_words(content), "lang": lang
        })

    # 3. Build the prompt and add auto-generated context
    builder = PromptBuilder(processed_files_data, prompt_content, context_only=args.context_only, 
                            list_arg=args.list, context_arg=args.context)
    
    # Codebase Tree
    include_tree = any(f['path'].endswith('.py') for f in processed_files_data)
    if include_tree:
        logger.print("Python file(s) detected. Generating codebase tree diagram...", end='', flush=True)
        tree_output = run_tree_command()
        title = "Codebase Structure (eza --tree)"
        builder.add_auto_context(title, tree_output)
        tree_data = builder.auto_context.get(title, {})
        t_count = tree_data.get('tokens', 0)
        b_count = len(tree_data.get('content', '').encode('utf-8'))
        logger.print(f" ({t_count:,} tokens | {b_count:,} bytes)")
    else:
        logger.print("Skipping codebase tree (no .py files included).")

    # --- ARTICLE & CONTEXT PROCESSING (The Bridge) ---
    need_articles = (args.list is not None) or (args.article is not None) or (args.context is not None)
    
    if need_articles:
        logger.print("Loading article index...", end='', flush=True)
        all_articles = _get_article_list_data(CONFIG["POSTS_DIRECTORY"])
        logger.print(f" ({len(all_articles)} articles found)")

        # A. Narrative Index (-l)
        if args.list is not None:
            logger.print("Adding narrative context...", end='', flush=True)
            sliced_list = []
            try:
                slice_or_index = parse_slice_arg(args.list)
                if isinstance(slice_or_index, int): sliced_list = [all_articles[slice_or_index]]
                elif isinstance(slice_or_index, slice): sliced_list = all_articles[slice_or_index]
            except (ValueError, IndexError):
                logger.print(f" (invalid slice '{args.list}')")
            
            if sliced_list:
                narrative_content = ""
                for article in sliced_list:
                    narrative_content += f"### {article['title']} ({article['date']} | {article['tokens']:,} tok)\n"
                    if article.get('url'):
                        narrative_content += f"URL: {article['url']}\n"
                    narrative_content += f"Path: {article['path']}\n"
                    narrative_content += f"Sum: {article['summary']}\n\n"
                
                title = "Recent Narrative Context"
                builder.add_auto_context(title, narrative_content.strip())
                ndata = builder.auto_context.get(title, {})
                logger.print(f" ({len(sliced_list)} items | {ndata.get('tokens',0):,} tokens)")
            else:
                logger.print(" (slice returned empty)")

        # B. Full Articles (-a)
        if args.article is not None:
            logger.print("Adding full article content...", end='', flush=True)
            sliced_full = []
            try:
                slice_or_index = parse_slice_arg(args.article)
                if isinstance(slice_or_index, int): sliced_full = [all_articles[slice_or_index]]
                elif isinstance(slice_or_index, slice): sliced_full = all_articles[slice_or_index]
            except (ValueError, IndexError):
                logger.print(f" (invalid slice '{args.article}')")

            if sliced_full:
                full_content_parts = []
                for article in sliced_full:
                    try:
                        with open(article['path'], 'r', encoding='utf-8') as f:
                            content = f.read()
                        full_content_parts.append(f"--- START: Article: {os.path.basename(article['path'])} ---\n{content.strip()}\n--- END: Article ---\n")
                    except Exception as e:
                        logger.print(f"\nWarning: Could not read article {article['path']}: {e}")
                
                if full_content_parts:
                    title = "Full Article Content"
                    builder.add_auto_context(title, "\n".join(full_content_parts))
                    adata = builder.auto_context.get(title, {})
                    logger.print(f" ({len(sliced_full)} items | {adata.get('tokens',0):,} tokens)")
            else:
                logger.print(" (slice returned empty)")

        # C. Holographic Context / JSONs (-c)
        if args.context is not None:
            logger.print("Adding holographic context shards...", end='', flush=True)
            sliced_context = []
            try:
                slice_or_index = parse_slice_arg(args.context)
                if isinstance(slice_or_index, int): sliced_context = [all_articles[slice_or_index]]
                elif isinstance(slice_or_index, slice): sliced_context = all_articles[slice_or_index]
            except (ValueError, IndexError):
                logger.print(f" (invalid slice '{args.context}')")

            if sliced_context:
                json_parts = []
                found_count = 0
                for article in sliced_context:
                    # Construct expected JSON path: _posts/_context/{filename_stem}.json
                    article_path = article['path']
                    parent_dir = os.path.dirname(article_path)
                    filename = os.path.basename(article_path)
                    stem = os.path.splitext(filename)[0]
                    # Handle both .md and .markdown just in case
                    context_dir = os.path.join(parent_dir, "_context")
                    json_path = os.path.join(context_dir, f"{stem}.json")
                    
                    if os.path.exists(json_path):
                        try:
                            with open(json_path, 'r', encoding='utf-8') as f:
                                json_content = f.read().strip()
                                # Add file header for context clarity
                                json_parts.append(f"--- START: {json_path} ---\n{json_content}\n--- END: {json_path} ---")
                                found_count += 1
                        except Exception as e:
                            logger.print(f"\nWarning: Error reading JSON {json_path}: {e}")
                    # If JSON doesn't exist, we just skip it (silently or verbosely? Silent is cleaner for bulk)
                
                if json_parts:
                    title = "Holographic Context Shards"
                    builder.add_auto_context(title, "\n".join(json_parts))
                    cdata = builder.auto_context.get(title, {})
                    logger.print(f" ({found_count}

#!/usr/bin/env python3
# prompt_foo.py

# > We've got content, it's groovy context
# > Our concatenation just won't stop
# > Making stories art for a super-smart
# > AI-Phooey chop (Hi-Ya!)

import os
import re
import sys
import pydot
import yaml
import argparse
import tiktoken
import subprocess
import tempfile
import shutil
import json
from datetime import datetime
from typing import Dict, List, Optional, Tuple, Any, Union

try:
    import jupytext
    JUPYTEXT_AVAILABLE = True
except ImportError:
    JUPYTEXT_AVAILABLE = False

# ============================================================================
# --- Logging & Capture ---
# ============================================================================
class Logger:
    """Captures stdout for inclusion in the generated prompt."""
    def __init__(self):
        self.logs = []

    def print(self, *args, **kwargs):
        # Construct the string exactly as print would
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        text = sep.join(map(str, args)) + end
        
        # Capture it
        self.logs.append(text)
        
        # Actually print it to stdout
        print(*args, **kwargs)

    def get_captured_text(self):
        return "".join(self.logs)

# Global logger instance
logger = Logger()

def load_targets():
    """Loads publishing targets from external config."""
    config_path = os.path.expanduser("~/.config/articleizer/targets.json")
    if os.path.exists(config_path):
        try:
            with open(config_path, 'r') as f:
                return json.load(f)
        except json.JSONDecodeError:
            logger.print(f"Warning: Could not decode JSON from {config_path}")
    return {}

# ============================================================================
# --- Configuration ---
# ============================================================================
def find_repo_root(start_path: str) -> str:
    """Find the git repository root from a starting path."""
    path = os.path.abspath(start_path)
    while path != os.path.dirname(path):
        if os.path.isdir(os.path.join(path, '.git')):
            return path
        path = os.path.dirname(path)
    raise FileNotFoundError("Could not find the repository root (.git directory).")

REPO_ROOT = find_repo_root(os.path.dirname(__file__))

CONFIG = {
    "PROJECT_NAME": "pipulate",
    "POSTS_DIRECTORY": "/home/mike/repos/MikeLev.in/_posts",
    "URL_MAP": {} # Populated if needed or loaded from config
}

# ============================================================================
# --- Literary Size Scale & Token/Word Counting ---
# ============================================================================
LITERARY_SIZE_SCALE = [
    (3000, "Short Essay"), (7500, "Short Story"), (20000, "Novelette"),
    (50000, "Novella or a Master's Dissertation"),
    (80000, "Average Paperback Novel or a Ph.D. Dissertation"),
    (120000, "Long Novel"), (200000, "Epic Fantasy Novel"),
    (500000, "Seriously Long Epic (like 'Infinite Jest')"),
]

def get_literary_perspective(word_count: int, token_word_ratio: float) -> str:
    description = f"Longer than {LITERARY_SIZE_SCALE[-1][1]}"
    for words, desc in LITERARY_SIZE_SCALE:
        if word_count <= words:
            description = desc
            break
    density_warning = ""
    if token_word_ratio > 1.8:
        density_warning = (
            f" (Note: With a token/word ratio of {token_word_ratio:.2f}, "
            f"this content is far denser and more complex than typical prose of this length)."
        )
    return f"📚 Equivalent in length to a **{description}**{density_warning}"

def count_tokens(text: str, model: str = "gpt-4o") -> int:
    try:
        encoding = tiktoken.encoding_for_model(model)
        return len(encoding.encode(text))
    except Exception:
        return len(text.split())

def count_words(text: str) -> int:
    return len(text.split())

# ============================================================================
# --- Auto-Context Generation (UML, Tree, Narrative) ---
# ============================================================================
def generate_uml_and_dot(target_file: str, project_name: str) -> Dict:
    pyreverse_exec = shutil.which("pyreverse")
    plantuml_exec = shutil.which("plantuml")
    if not pyreverse_exec or not plantuml_exec:
        msg = []
        if not pyreverse_exec: msg.append("`pyreverse` (from pylint)")
        if not plantuml_exec: msg.append("`plantuml`")
        return {"ascii_uml": f"Skipping: Required command(s) not found: {', '.join(msg)}."}

    target_path = target_file if os.path.isabs(target_file) else os.path.join(REPO_ROOT, target_file)
    if not os.path.exists(target_path):
        return {"ascii_uml": f"Skipping: Target file for UML generation not found: {target_path}"}

    with tempfile.TemporaryDirectory() as temp_dir:
        dot_file_path = os.path.join(temp_dir, "classes.dot")
        puml_file_path = os.path.join(temp_dir, "diagram.puml")
        try:
            pyreverse_cmd = [pyreverse_exec, "-f", "dot", "-o", "dot", "-p", project_name, target_path]
            subprocess.run(pyreverse_cmd, check=True, capture_output=True, text=True, cwd=temp_dir)
            generated_dot_name = f"classes_{project_name}.dot"
            os.rename(os.path.join(temp_dir, generated_dot_name), dot_file_path)
        except (subprocess.CalledProcessError, FileNotFoundError) as e:
            error_msg = e.stderr if hasattr(e, 'stderr') else str(e)
            return {"ascii_uml": f"Error: pyreverse failed. {error_msg}", "dot_graph": None}

        try:
            graphs = pydot.graph_from_dot_file(dot_file_path)
            if not graphs:
                return {"ascii_uml": f"Note: No classes found in {target_file} to generate a diagram.", "dot_graph": None}
            graph = graphs[0]
            dot_content = graph.to_string()
            puml_lines = ["@startuml", "skinparam linetype ortho", ""]
            def sanitize_line(line):
                clean = re.sub(r'<br[^>]*>', '', line)
                clean = re.sub(r'<[^>]+>', '', clean)
                return clean.strip()
            for node in graph.get_nodes():
                label = node.get_label()
                if not label: continue
                parts = label.strip('<>{} ').split('|')
                class_name = sanitize_line(parts[0])
                puml_lines.append(f"class {class_name} {{")
                if len(parts) > 1:
                    for attr in re.split(r'<br[^>]*>', parts[1]):
                        clean_attr = sanitize_line(attr).split(':')[0].strip()
                        if clean_attr: puml_lines.append(f"  - {clean_attr}")
                if len(parts) > 2:
                    method_block = parts[2].strip()
                    for method_line in re.split(r'<br[^>]*>', method_block):
                        clean_method = sanitize_line(method_line)
                        if clean_method: puml_lines.append(f"  + {clean_method}")
                puml_lines.append("}\n")
            for edge in graph.get_edges():
                source_name = edge.get_source().strip('"').split('.')[-1]
                dest_name = edge.get_destination().strip('"').split('.')[-1]
                puml_lines.append(f"{source_name} ..> {dest_name}")
            puml_lines.append("@enduml")
            with open(puml_file_path, 'w') as f: f.write('\n'.join(puml_lines))
        except Exception as e:
            with open(dot_file_path, 'r') as f: dot_content_on_error = f.read()
            return {"ascii_uml": f"Error: DOT to PUML conversion failed. {str(e)}", "dot_graph": dot_content_on_error}

        try:
            plantuml_cmd = ["plantuml", "-tutxt", puml_file_path]
            subprocess.run(plantuml_cmd, check=True, capture_output=True, text=True, cwd=temp_dir)
            utxt_file_path = puml_file_path.replace(".puml", ".utxt")
            with open(utxt_file_path, 'r') as f: ascii_uml = f.read()
            lines = ascii_uml.splitlines()
            non_empty_lines = [line for line in lines if line.strip()]
            if non_empty_lines:
                min_indent = min(len(line) - len(line.lstrip(' ')) for line in non_empty_lines)
                dedented_lines = [line[min_indent:] for line in lines]
                stripped_lines = [line.rstrip() for line in dedented_lines]
                ascii_uml = '\n'.join(stripped_lines)
                if ascii_uml: ascii_uml = '\n' + ascii_uml
        except (subprocess.CalledProcessError, FileNotFoundError) as e:
            error_msg = e.stderr if hasattr(e, 'stderr') else str(e)
            return {"ascii_uml": f"Error: plantuml failed. {error_msg}", "dot_graph": dot_content}

    return {"ascii_uml": ascii_uml, "dot_graph": dot_content}

def _get_article_list_data(posts_dir: str = CONFIG["POSTS_DIRECTORY"]) -> List[Dict]:
    posts_data = []
    if not os.path.isdir(posts_dir):
        logger.print(f"Warning: Article directory not found at {posts_dir}", file=sys.stderr)
        return []

    # Simple URL config loader if ~/.config/articleizer/url_map.json exists
    url_config = {}
    config_path = os.path.expanduser("~/.config/articleizer/url_map.json")
    if os.path.exists(config_path):
        try:
            with open(config_path) as f:
                url_map = json.load(f)
                url_config = url_map.get(posts_dir, {})
        except: pass

    for filename in os.listdir(posts_dir):
        if not filename.endswith((".md", ".markdown")): continue
        filepath = os.path.join

#!/usr/bin/env python3
# prompt_foo.py

import os
import re
import sys
import pydot
import yaml
import argparse
import tiktoken
import subprocess
import tempfile
import shutil
import json
from datetime import datetime
from typing import Dict, List, Optional, Tuple, Union

try:
    import jupytext
    JUPYTEXT_AVAILABLE = True
except ImportError:
    JUPYTEXT_AVAILABLE = False

# ============================================================================
# --- Logging & Capture ---
# ============================================================================
class Logger:
    def __init__(self):
        self.logs = []
    def print(self, *args, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        text = sep.join(map(str, args)) + end
        self.logs.append(text)
        print(*args, **kwargs)
    def get_captured_text(self):
        return "".join(self.logs)

logger = Logger()

def load_targets():
    config_path = os.path.expanduser("~/.config/articleizer/targets.json")
    if os.path.exists(config_path):
        try:
            with open(config_path, 'r') as f: return json.load(f)
        except json.JSONDecodeError:
            logger.print(f"Warning: Could not decode JSON from {config_path}")
    return {}

# ============================================================================
# --- Configuration ---
# ============================================================================
def find_repo_root(start_path: str) -> str:
    path = os.path.abspath(start_path)
    while path != os.path.dirname(path):
        if os.path.isdir(os.path.join(path, '.git')): return path
        path = os.path.dirname(path)
    raise FileNotFoundError("Could not find the repository root (.git directory).")

REPO_ROOT = find_repo_root(os.path.dirname(__file__))

CONFIG = {
    "PROJECT_NAME": "pipulate",
    "POSTS_DIRECTORY": "/home/mike/repos/MikeLev.in/_posts",
    "URL_MAP": {} 
}

# ============================================================================
# --- Literary Size Scale ---
# ============================================================================
LITERARY_SIZE_SCALE = [
    (3000, "Short Essay"), (7500, "Short Story"), (20000, "Novelette"),
    (50000, "Novella or a Master's Dissertation"),
    (80000, "Average Paperback Novel or a Ph.D. Dissertation"),
    (120000, "Long Novel"), (200000, "Epic Fantasy Novel"),
    (500000, "Seriously Long Epic (like 'Infinite Jest')"),
]

def get_literary_perspective(word_count: int, token_word_ratio: float) -> str:
    description = f"Longer than {LITERARY_SIZE_SCALE[-1][1]}"
    for words, desc in LITERARY_SIZE_SCALE:
        if word_count <= words:
            description = desc
            break
    density_warning = ""
    if token_word_ratio > 1.8:
        density_warning = f" (Note: Token/word ratio {token_word_ratio:.2f} implies high density)."
    return f"📚 Equivalent in length to a **{description}**{density_warning}"

def count_tokens(text: str, model: str = "gpt-4o") -> int:
    try:
        return len(tiktoken.encoding_for_model(model).encode(text))
    except Exception:
        return len(text.split())

def count_words(text: str) -> int:
    return len(text.split())

# ============================================================================
# --- Auto-Context Generation ---
# ============================================================================
def generate_uml_and_dot(target_file: str, project_name: str) -> Dict:
    pyreverse_exec = shutil.which("pyreverse")
    plantuml_exec = shutil.which("plantuml")
    if not pyreverse_exec or not plantuml_exec:
        return {"ascii_uml": "Skipping: Required command(s) (pyreverse/plantuml) not found."}

    target_path = target_file if os.path.isabs(target_file) else os.path.join(REPO_ROOT, target_file)
    if not os.path.exists(target_path):
        return {"ascii_uml": f"Skipping: File not found: {target_path}"}

    with tempfile.TemporaryDirectory() as temp_dir:
        dot_file_path = os.path.join(temp_dir, "classes.dot")
        puml_file_path = os.path.join(temp_dir, "diagram.puml")
        try:
            subprocess.run([pyreverse_exec, "-f", "dot", "-o", "dot", "-p", project_name, target_path], 
                         check=True, capture_output=True, text=True, cwd=temp_dir)
            os.rename(os.path.join(temp_dir, f"classes_{project_name}.dot"), dot_file_path)
            
            graphs = pydot.graph_from_dot_file(dot_file_path)
            if not graphs: return {"ascii_uml": "Note: No classes found.", "dot_graph": None}
            
            graph = graphs[0]
            dot_content = graph.to_string()
            puml_lines = ["@startuml", "skinparam linetype ortho", ""]
            
            def sanitize(line): return re.sub(r'<[^>]+>', '', line).strip()
            
            for node in graph.get_nodes():
                label = node.get_label()
                if not label: continue
                parts = label.strip('<>{} ').split('|')
                puml_lines.append(f"class {sanitize(parts[0])} {{")
                if len(parts) > 1:
                    for attr in parts[1].split(r'\n'):
                        if sanitize(attr): puml_lines.append(f"  - {sanitize(attr)}")
                if len(parts) > 2:
                    for meth in parts[2].split(r'\n'):
                        if sanitize(meth): puml_lines.append(f"  + {sanitize(meth)}")
                puml_lines.append("}\n")
            
            for edge in graph.get_edges():
                src = edge.get_source().strip('"').split('.')[-1]
                dst = edge.get_destination().strip('"').split('.')[-1]
                puml_lines.append(f"{src} ..> {dst}")
            
            puml_lines.append("@enduml")
            with open(puml_file_path, 'w') as f: f.write('\n'.join(puml_lines))
            
            subprocess.run([plantuml_exec, "-tutxt", puml_file_path], check=True, capture_output=True, cwd=temp_dir)
            utxt_path = puml_file_path.replace(".puml", ".utxt")
            with open(utxt_path, 'r') as f: ascii_uml = f.read()
            
            # Dedent
            lines = [line for line in ascii_uml.splitlines()]
            non_empty = [l for l in lines if l.strip()]
            if non_empty:
                min_indent = min(len(l) - len(l.lstrip()) for l in non_empty)
                ascii_uml = '\n'.join([l[min_indent:].rstrip() for l in lines])
                
            return {"ascii_uml": '\n' + ascii_uml, "dot_graph": dot_content}

        except Exception as e:
            return {"ascii_uml": f"Error: {e}", "dot_graph": None}

def _get_article_list_data(posts_dir: str = CONFIG["POSTS_DIRECTORY"]) -> List[Dict]:
    posts_data = []
    if not os.path.isdir(posts_dir):
        logger.print(f"Warning: Article directory not found at {posts_dir}", file=sys.stderr)
        return []

    url_config = {}
    config_path = os.path.expanduser("~/.config/articleizer/url_map.json")
    if os.path.exists(config_path):
        try:
            with open(config_path) as f: url_config = json.load(f).get(posts_dir, {})
        except: pass

    for filename in os.listdir(posts_dir):
        if not filename.endswith((".md", ".markdown")): continue
        filepath = os.path.join(posts_dir, filename)
        try:
            date_str = filename[:10]
            try: post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError: post_date = datetime.min.date()

            with open(filepath, 'r', encoding='utf-8') as f: content = f.read()
            
            if content.startswith('---'):
                parts = content.split('---', 2)
                front_matter = yaml.safe_load(parts[1]) or {}
                
                full_url = ""
                if url_config:
                    slug = front_matter.get('permalink', '').strip('/')
                    if not slug:
                        raw_slug = os.path.splitext(filename)[0]
                        if re.match(r'\d{4}-\d{2}-\d{2}-', raw_slug): raw_slug = raw_slug[11:]
                        style = url_config.get('permalink_style', '/:slug/')
                        slug_path = style.replace(':slug', raw_slug)
                    else:
                        slug_path = "/" + slug.lstrip('/')
                    full_url = f"{url_config.get('base_url', '')}{slug_path}"

                posts_data.append({
                    'path': filepath, 'filename': filename, 'date': post_date,
                    'sort_order': int(front_matter.get('sort_order', 0)),
                    'title': front_matter.get('title', 'Untitled'),
                    'summary': front_matter.get('meta_description', front_matter.get('description', '')),
                    'url': full_url,
                    'tokens': count_tokens(content),
                    'bytes': len(content.encode('utf-8'))
                })
        except Exception: continue
            
    return sorted(posts_data, key=lambda p: (p['date'], p['sort_order']))

def parse_slice_arg(arg_str: str) -> Optional[Union[int, slice]]:
    if not arg_str: return None
    if not (arg_str.startswith('[') and arg_str.endswith(']')): return None
    content = arg_str[1:-1].strip()
    if ':' in content:
        parts = content.split(':', 1)
        start = int(parts[0]) if parts[0].strip() else None
        end = int(parts[1]) if parts[1].strip() else None
        return slice(start, end)
    elif content: return int(content)
    return slice(None, None)

def run_tree_command() -> str:
    eza_exec = shutil.which("eza")
    if not eza_exec: return "Skipping: `eza` command not found."
    try:
        result = subprocess.run([eza_exec, '--tree', '--level', '3', '--git-ignore', '--color=never'],
            capture_output=True, text=True, cwd=REPO_ROOT, check=True)
        return result.stdout
    except Exception as e: return f"Error running eza command: {e}"

# ============================================================================
# --- Helper Functions ---
# ============================================================================
def parse_file_list_from_config() -> List[Tuple[str, str]]:
    try:
        import foo_files
        files_raw = foo_files.AI_PHOOEY_CHOP
    except (ImportError, AttributeError):
        logger.print("ERROR: foo_files.py not found or doesn't contain AI_PHOOEY_CHOP.")
        sys.exit(1)
    seen, parsed = set(), []
    for line in files_raw.strip().splitlines():
        line = line.strip()
        if not line or line.startswith('#'): continue
        parts = re.split(r'\s*<--\s*|\s*#\s*', line, 1)
        path = parts[0].strip()
        if path and path not in seen:
            seen.add(path)
            parsed.append((path, parts[1].strip() if len(parts)>1 else ""))
    return parsed

def copy_to_clipboard(text: str):
    if not shutil.which('xclip'):
        logger.print("\nWarning: 'xclip' not found.")
        return
    try:
        subprocess.run(['xclip', '-selection', 'clipboard'], input=text.encode('utf-8'), check=True)
        logger.print("Markdown output copied to clipboard")
    except Exception as e: logger.print(f"\nWarning: Clipboard copy failed: {e}")

def check_dependencies():
    logger.print("Checking dependencies...")
    missing = []
    for tool in ["pyreverse", "plantuml", "eza", "xclip"]:
        if not shutil.which(tool): missing.append(tool)
    if not missing: logger.print("✅ All dependencies found.")
    else:
        logger.print(f"❌ Missing: {', '.join(missing)}")
        sys.exit(1)

# ============================================================================
# --- PromptBuilder ---
# ============================================================================
class PromptBuilder:
    def __init__(self, processed_files: List[Dict], prompt_text: str, context_only: bool, list_arg: Optional[str], context_arg: bool):
        self.processed_files = processed_files
        self.prompt_text = prompt_text
        self.context_only = context_only
        self.list_arg = list_arg
        self.context_arg = context_arg
        self.auto_context = {}
        self.all_sections = {}
        self.command_line = " ".join(sys.argv)
        self.manifest_key = "Manifest (Table of Contents)"

    def add_auto_context(self, title: str, content: str):
        allowed = ["Recent Narrative Context", "Full Article Content", "Holographic Context Shards", "Codebase Structure (eza --tree)"]
        if content and content.strip() and (title in allowed or "UML" in title):
             self.auto_context[title] = {'content': content, 'tokens': count_tokens(content), 'words': count_words(content)}

    def _build_manifest_content(self) -> str:
        lines = []
        for section in ["Story", "File Tree", "UML Diagrams", "Articles", "Codebase", "Summary", "Context Recapture", "Prompt"]:
            if section in self.all_sections:
                data = self.all_sections[section]
                token_str = f"({data['tokens']:,} tokens)" if data['tokens'] > 0 else ""
                lines.append(f"- {section} {token_str}")
                if section == "Codebase" and not self.context_only and self.processed_files:
                     for f in self.processed_files:
                         lines.append(f"  - {f['path']} ({f['tokens']:,} tokens | {len(f['content'].encode('utf-8')):,} bytes)")
        return "\n".join(lines)

    def _build_articles_content(self) -> str:
        parts = []
        if "Full Article Content" in self.auto_context:
            parts.append(self.auto_context["Full Article Content"]['content'].strip())
        if "Holographic Context Shards" in self.auto_context:
            parts.append(self.auto_context["Holographic Context Shards"]['content'].strip())
        return "\n\n".join(parts).strip()

    def _build_codebase_content(self) -> str:
        if self.context_only or not self.processed_files: return ""
        lines = []
        for f in self.processed_files:
            lines.append(f"--- START: {f['path']} ({f['tokens']:,} tokens) ---")
            lines.append(f"```{f['lang']}:{f['path']}\n{f['content']}\n```")
            lines.append(f"--- END: {f['path']} ---\n")
        return "\n".join(lines).strip()

    def _build_recapture_content(self) -> str:
        lines = ["```python", "# # PURPOSE OF CONTEXT: ", '# AI_PHOOEY_CHOP = """\\']
        for f in self.processed_files:
            path_str = os.path.relpath(f['path'], REPO_ROOT) if f['path'].startswith(REPO_ROOT) else f['path']
            lines.append(f"# {path_str}")
        lines.append('# """\n```')
        return "\n".join(lines)

    def _generate_ai_checklist(self) -> str:
        return '''# AI Self-Correction Checklist

Before addressing the user's prompt, perform the following verification steps:
1.  **Review the Manifest vs. Codebase Structure:** Compare the file list in the manifest against the `eza --tree` output.
2.  **Analyze Import Statements:** Do they suggest dependencies on local files that were *not* included?
3.  **Check for Incompleteness:** If critical files are missing, inform me.
4.  **Confirm Understanding:** If complete, state "Context verified."
5.  **Descriptions:** Refer to this as a blueprint, treatise, or philosophy. NEVER a manifesto.
'''

    def _generate_summary_content(self, verified_token_count: int) -> str:
        lines = [f"**Command:** `{self.command_line}`\n"]
        if logs := logger.get_captured_text().strip():
            lines.append(f"--- Processing Log ---\n```\n{logs}\n```\n")
        lines.append("--- Files Included ---")
        for f in self.processed_files:
             lines.append(f"• {f['path']} ({f['tokens']:,} tokens)" if not self.context_only else f"• {f['path']} (omitted)")
        if self.auto_context:
            lines.append("\n--- Auto-Context Included ---")
            for title, data in self.auto_context.items():
                lines.append(f"• {title} ({data['tokens']:,} tokens)")
        
        total_tokens = sum(v.get('tokens', 0) for k, v in self.all_sections.items() if k != self.manifest_key)
        lines.append(f"\n--- Prompt Summary ---\nSummed Tokens:    {total_tokens:,}")
        lines.append(f"Verified Tokens: {verified_token_count:,}")
        if total_tokens != verified_token_count: lines.append(f"  (Difference: {verified_token_count - total_tokens:+,})")
        
        total_words = sum(count_words(d.get('content', '')) for k, d in self.all_sections.items() if k != "Prompt")
        lines.append(f"\n--- Size Perspective ---\n{get_literary_perspective(total_words, verified_token_count/total_words if total_words else 0)}")
        return "\n".join(lines)

    def build_final_prompt(self) -> str:
        story = self.auto_context.get("Recent Narrative Context", {}).get('content', '').strip()
        tree = self.auto_context.get("Codebase Structure (eza --tree)", {}).get('content', '').strip()
        if tree: tree = f"```text\n{tree}\n```"
        uml = "\n\n".join([f"## {t}\n```text\n{d['content']}\n```" for t, d in self.auto_context.items() if "UML" in t])
        
        articles = self._build_articles_content()
        codebase = self._build_codebase_content()
        recapture = self._build_recapture_content()
        prompt = f"{self._generate_ai_checklist()}\n\n{self.prompt_text}"

        self.all_sections = {
            "Story": {'content': story, 'tokens': count_tokens(story)},
            "File Tree": {'content': tree, 'tokens': count_tokens(tree)},
            "UML Diagrams": {'content': uml, 'tokens': count_tokens(uml)},
            "Articles": {'content': articles, 'tokens': count_tokens(articles)},
            "Codebase": {'content': codebase, 'tokens': sum(f['tokens'] for f in self.processed_files) if not self.context_only else 0},
            "Context Recapture": {'content': recapture, 'tokens': count_tokens(recapture)},
            "Prompt": {'content': prompt, 'tokens': count_tokens(prompt)}
        }

        # Convergence Loop
        current_toks = sum(v['tokens'] for v in self.all_sections.values())
        final_text = ""
        for _ in range(3):
            summary = self._generate_summary_content(current_toks)
            self.all_sections["Summary"] = {'content': summary, 'tokens': count_tokens(summary)}
            manifest = self._build_manifest_content()
            self.all_sections[self.manifest_key] = {'content': manifest, 'tokens': count_tokens(manifest)}

            parts = [f"# KUNG FU PROMPT CONTEXT\n\nWhat you will find below is:\n\n- {self.manifest_key}\n- Story\n- File Tree\n- UML Diagrams\n- Articles\n- Codebase\n- Summary\n- Context Recapture\n- Prompt"]
            
            def add(n, c, p): parts.append(f"--- START: {n} ---\n{c.strip() if c and c.strip() else p}\n--- END: {n} ---")
            
            add(self.manifest_key, manifest, "# Failed.")
            add("Story", story, "# No narrative context." if not self.list_arg else "# No articles found.")
            add("File Tree", tree, "# Tree generation failed.")
            add("UML Diagrams", uml, "# No UML.")
            add("Articles", articles, "# No articles requested." if not (self.list_arg or self.context_arg) else "# No content found.")
            add("Codebase", codebase, "# Codebase empty.")
            add("Summary", summary, "# Summary failed.")
            add("Context Recapture", recapture, "# Recapture failed.")
            add("Prompt", prompt, "# No prompt.")