code-puppy 0.0.86__py3-none-any.whl → 0.0.88__py3-none-any.whl

code_puppy/agent_prompts.py

@@ -26,7 +26,7 @@ YOU MUST USE THESE TOOLS to complete tasks (do not just describe what should be
 
 File Operations:
    - list_files(directory=".", recursive=True): ALWAYS use this to explore directories before trying to read/modify files
-   - read_file(file_path): ALWAYS use this to read existing files before modifying them.
+   - read_file(file_path: str, start_line: int | None = None, num_lines: int | None = None): ALWAYS use this to read existing files before modifying them. By default, read the entire file. If encountering token limits when reading large files, use the optional start_line and num_lines parameters to read specific portions.
    - edit_file(path, diff): Use this single tool to create new files, overwrite entire files, perform targeted replacements, or delete snippets depending on the JSON/raw payload provided.
    - delete_file(file_path): Use this to remove files when needed
    - grep(search_string, directory="."): Use this to recursively search for a string across files starting from the specified directory, capping results at 200 matches.

code_puppy/command_line/meta_command_handler.py

@@ -14,7 +14,6 @@ META_COMMANDS_HELP = """
 [bold magenta]Meta Commands Help[/bold magenta]
 ~help, ~h             Show this help message
 ~cd <dir>             Change directory or show directories
-~codemap <dir>        Show code structure for <dir>
 ~m <model>            Set active model
 ~motd                 Show the latest message of the day (MOTD)
 ~show                 Show puppy config key-values
@@ -34,21 +33,6 @@ def handle_meta_command(command: str, console: Console) -> bool:
         print_motd(console, force=True)
         return True
 
-    # ~codemap (code structure visualization)
-    if command.startswith("~codemap"):
-        from code_puppy.tools.ts_code_map import make_code_map
-
-        tokens = command.split()
-        if len(tokens) > 1:
-            target_dir = os.path.expanduser(tokens[1])
-        else:
-            target_dir = os.getcwd()
-        try:
-            make_code_map(target_dir, ignore_tests=True)
-        except Exception as e:
-            console.print(f"[red]Error generating code map:[/red] {e}")
-        return True
-
     if command.startswith("~cd"):
         tokens = command.split()
         if len(tokens) == 1:

code_puppy/command_line/prompt_toolkit_completion.py

@@ -1,3 +1,7 @@
+
+
+
+
 # ANSI color codes are no longer necessary because prompt_toolkit handles
 # styling via the `Style` class. We keep them here commented-out in case
 # someone needs raw ANSI later, but they are unused in the current code.
@@ -171,7 +175,7 @@ async def get_input_with_combined_completion(
     def _(event):
         event.app.current_buffer.insert_text("\n")
 
-    @bindings.add(Keys.Escape)
+    @bindings.add('c-c')
     def _(event):
         """Cancel the current prompt when the user presses the ESC key alone."""
         event.app.exit(exception=KeyboardInterrupt)
@@ -222,4 +226,4 @@ if __name__ == "__main__":
                 break
         print("\nGoodbye!")
 
-    asyncio.run(main())
+    asyncio.run(main())

code_puppy/main.py

@@ -232,12 +232,19 @@ async def interactive_mode(history_file_path: str) -> None:
                                 local_cancelled = True
                     except Exception as e:
                         console.print(f"[dim]Shell kill error: {e}[/dim]")
+                    # On Windows, we need to reset the signal handler to avoid weird terminal behavior
+                    if sys.platform.startswith("win"):
+                        signal.signal(signal.SIGINT, original_handler or signal.SIG_DFL)
                 try:
                     original_handler = signal.getsignal(signal.SIGINT)
                     signal.signal(signal.SIGINT, keyboard_interrupt_handler)
                     result = await agent_task
                 except asyncio.CancelledError:
                     pass
+                except KeyboardInterrupt:
+                    # Handle Ctrl+C from terminal
+                    keyboard_interrupt_handler(signal.SIGINT, None)
+                    raise
                 finally:
                     if original_handler:
                         signal.signal(signal.SIGINT, original_handler)

code_puppy/message_history_processor.py

@@ -250,7 +250,7 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
 [bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f}
 """)
 
-    if proportion_used > 0.9:
+    if proportion_used > 0.85:
         summary = summarize_messages(messages)
         result_messages = [messages[0], summary]
         final_token_count = sum(

code_puppy/token_utils.py

@@ -0,0 +1,70 @@
+import json
+import tiktoken
+
+import pydantic
+from pydantic_ai.messages import ModelMessage
+
+
+def get_tokenizer():
+    """
+    Always use cl100k_base tokenizer regardless of model type.
+    This is a simple approach that works reasonably well for most models.
+    """
+    return tiktoken.get_encoding("cl100k_base")
+
+
+def stringify_message_part(part) -> str:
+    """
+    Convert a message part to a string representation for token estimation or other uses.
+
+    Args:
+        part: A message part that may contain content or be a tool call
+
+    Returns:
+        String representation of the message part
+    """
+    result = ""
+    if hasattr(part, "part_kind"):
+        result += part.part_kind + ": "
+    else:
+        result += str(type(part)) + ": "
+
+    # Handle content
+    if hasattr(part, "content") and part.content:
+        # Handle different content types
+        if isinstance(part.content, str):
+            result = part.content
+        elif isinstance(part.content, pydantic.BaseModel):
+            result = json.dumps(part.content.model_dump())
+        elif isinstance(part.content, dict):
+            result = json.dumps(part.content)
+        else:
+            result = str(part.content)
+
+    # Handle tool calls which may have additional token costs
+    # If part also has content, we'll process tool calls separately
+    if hasattr(part, "tool_name") and part.tool_name:
+        # Estimate tokens for tool name and parameters
+        tool_text = part.tool_name
+        if hasattr(part, "args"):
+            tool_text += f" {str(part.args)}"
+        result += tool_text
+
+    return result
+
+
+def estimate_tokens_for_message(message: ModelMessage) -> int:
+    """
+    Estimate the number of tokens in a message using tiktoken with cl100k_base encoding.
+    This is more accurate than character-based estimation.
+    """
+    tokenizer = get_tokenizer()
+    total_tokens = 0
+
+    for part in message.parts:
+        part_str = stringify_message_part(part)
+        if part_str:
+            tokens = tokenizer.encode(part_str)
+            total_tokens += len(tokens)
+
+    return max(1, total_tokens)

code_puppy/tools/common.py

@@ -2,14 +2,44 @@ import os
 import fnmatch
 
 from typing import Optional, Tuple
-
+import tiktoken
 from rapidfuzz.distance import JaroWinkler
 from rich.console import Console
 
+# get_model_context_length will be imported locally where needed to avoid circular imports
+
 NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
 console = Console(no_color=NO_COLOR)
 
 
+def get_model_context_length() -> int:
+    """
+    Get the context length for the currently configured model from models.json
+    """
+    # Import locally to avoid circular imports
+    from code_puppy.model_factory import ModelFactory
+    from code_puppy.config import get_model_name
+    import os
+    from pathlib import Path
+
+    # Load model configuration
+    models_path = os.environ.get("MODELS_JSON_PATH")
+    if not models_path:
+        models_path = Path(__file__).parent.parent / "models.json"
+    else:
+        models_path = Path(models_path)
+
+    model_configs = ModelFactory.load_config(str(models_path))
+    model_name = get_model_name()
+
+    # Get context length from model config
+    model_config = model_configs.get(model_name, {})
+    context_length = model_config.get("context_length", 128000)  # Default value
+
+    # Reserve 10% of context for response
+    return int(context_length)
+
+
 # -------------------
 # Shared ignore patterns/helpers
 # -------------------

code_puppy/tools/file_operations.py

@@ -3,11 +3,12 @@
 import os
 from typing import List
 
-from pydantic import BaseModel
+from pydantic import BaseModel, conint
 from pydantic_ai import RunContext
 
 from code_puppy.tools.common import console
-
+from code_puppy.token_utils import get_tokenizer
+from code_puppy.tools.token_check import token_guard
 # ---------------------------------------------------------------------------
 # Module-level helper functions (exposed for unit tests _and_ used as tools)
 # ---------------------------------------------------------------------------
@@ -180,24 +181,55 @@ def _list_files(
 
 class ReadFileOutput(BaseModel):
     content: str | None
+    num_tokens: conint(lt=10000)
+    error: str | None = None
 
 
-def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
+def _read_file(context: RunContext, file_path: str, start_line: int | None = None, num_lines: int | None = None) -> ReadFileOutput:
     file_path = os.path.abspath(file_path)
-    console.print(
-        f"\n[bold white on blue] READ FILE [/bold white on blue] \U0001f4c2 [bold cyan]{file_path}[/bold cyan]"
-    )
+    
+    # Build console message with optional parameters
+    console_msg = f"\n[bold white on blue] READ FILE [/bold white on blue] \U0001f4c2 [bold cyan]{file_path}[/bold cyan]"
+    if start_line is not None and num_lines is not None:
+        console_msg += f" [dim](lines {start_line}-{start_line + num_lines - 1})[/dim]"
+    console.print(console_msg)
+    
     console.print("[dim]" + "-" * 60 + "[/dim]")
     if not os.path.exists(file_path):
-        return ReadFileOutput(content=f"File '{file_path}' does not exist")
+        error_msg = f"File {file_path} does not exist"
+        return ReadFileOutput(content=error_msg, num_tokens=0, error=error_msg)
     if not os.path.isfile(file_path):
-        return ReadFileOutput(content=f"'{file_path}' is not a file")
+        error_msg = f"{file_path} is not a file"
+        return ReadFileOutput(content=error_msg, num_tokens=0, error=error_msg)
     try:
         with open(file_path, "r", encoding="utf-8") as f:
-            content = f.read()
-        return ReadFileOutput(content=content)
-    except Exception:
-        return ReadFileOutput(content="FILE NOT FOUND")
+            if start_line is not None and num_lines is not None:
+                # Read only the specified lines
+                lines = f.readlines()
+                # Adjust for 1-based line numbering
+                start_idx = start_line - 1
+                end_idx = start_idx + num_lines
+                # Ensure indices are within bounds
+                start_idx = max(0, start_idx)
+                end_idx = min(len(lines), end_idx)
+                content = ''.join(lines[start_idx:end_idx])
+            else:
+                # Read the entire file
+                content = f.read()
+
+            tokenizer = get_tokenizer()
+            num_tokens = len(tokenizer.encode(content))
+            if num_tokens > 10000:
+                raise ValueError("The file is massive, greater than 10,000 tokens which is dangerous to read entirely. Please read this file in chunks.")
+            token_guard(num_tokens)
+        return ReadFileOutput(content=content, num_tokens=num_tokens)
+    except (FileNotFoundError, PermissionError):
+        # For backward compatibility with tests, return "FILE NOT FOUND" for these specific errors
+        error_msg = "FILE NOT FOUND"
+        return ReadFileOutput(content=error_msg, num_tokens=0, error=error_msg)
+    except Exception as e:
+        message = f"An error occurred trying to read the file: {e}"
+        return ReadFileOutput(content=message, num_tokens=0, error=message)
 
 
 class MatchInfo(BaseModel):
@@ -238,7 +270,7 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
                                 **{
                                     "file_path": file_path,
                                     "line_number": line_number,
-                                    "line_content": line_content.strip(),
+                                    "line_content": line_content.rstrip("\n\r"),
                                 }
                             )
                             matches.append(match_info)
@@ -282,8 +314,8 @@ def list_files(
     return _list_files(context, directory, recursive)
 
 
-def read_file(context: RunContext, file_path: str = "") -> ReadFileOutput:
-    return _read_file(context, file_path)
+def read_file(context: RunContext, file_path: str = "", start_line: int | None = None, num_lines: int | None = None) -> ReadFileOutput:
+    return _read_file(context, file_path, start_line, num_lines)
 
 
 def grep(

code_puppy/tools/token_check.py

@@ -0,0 +1,11 @@
+from code_puppy.tools.common import get_model_context_length
+from code_puppy.token_utils import estimate_tokens_for_message
+
+
+def token_guard(num_tokens: int):
+    from code_puppy import state_management
+    current_history = state_management.get_message_history()
+    message_hist_tokens = sum(estimate_tokens_for_message(msg) for msg in current_history)
+
+    if message_hist_tokens + num_tokens > (get_model_context_length() * 0.9):
+        raise ValueError("Tokens produced by this tool call would exceed model capacity")

{code_puppy-0.0.86.dist-info → code_puppy-0.0.88.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.86
+Version: 0.0.88
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

{code_puppy-0.0.86.dist-info → code_puppy-0.0.88.dist-info}/RECORD

@@ -1,30 +1,31 @@
 code_puppy/__init__.py,sha256=CWH46ZAmJRmHAbOiAhG07OrWYEcEt4yvDTkZU341Wag,169
 code_puppy/agent.py,sha256=7_1FpGPnw8U632OXP0hLmFIozfVvllF491q8gCpaa8c,3284
-code_puppy/agent_prompts.py,sha256=wTah_TvakCMhkb_KwuWCsw4_UR1QsjTZeOT1I8at_nc,6593
+code_puppy/agent_prompts.py,sha256=t3-lqDKrDxCKxFa_va4Suze9BT-JOu1dh9iGiAVNFO4,6828
 code_puppy/config.py,sha256=r5nw5ChOP8xd_K5yo8U5OtO2gy2bFhARiyNtDp1JrwQ,5013
-code_puppy/main.py,sha256=qtBokZZfPQRGF91KNl_n_ywutONwF2f-zTwmt_ROsEU,11080
-code_puppy/message_history_processor.py,sha256=jpoxGE6emBX3MAkeeezPZ4QEOzONRhbN6mZe_efG9vI,9248
+code_puppy/main.py,sha256=NLA6TI2is3htFRc5BGTwF4Xp68EtnN-6nOExD9D8i_g,11513
+code_puppy/message_history_processor.py,sha256=2k9y4wXkyZ9v4XLpfH6E3TKLzf303i-k1hXBE-aIf9U,9249
 code_puppy/model_factory.py,sha256=HXuFHNkVjkCcorAd3ScFmSvBILO932UTq6OmNAqisT8,10898
 code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
 code_puppy/state_management.py,sha256=JkTkmq6f9rl_RHPDoBqJvbAzgaMsIkJf-k38ragItIo,1692
 code_puppy/summarization_agent.py,sha256=jHUQe6iYJsMT0ywEwO7CrhUIKEamO5imhAsDwvNuvow,2684
+code_puppy/token_utils.py,sha256=g7Jj6NAy_a2ab7BXpwyhktruR-QlUV670H_mCPZV1N4,2110
 code_puppy/version_checker.py,sha256=aRGulzuY4C4CdFvU1rITduyL-1xTFsn4GiD1uSfOl_Y,396
 code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
 code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
-code_puppy/command_line/meta_command_handler.py,sha256=L7qP2g0Faz0V7bMH4YK3s03OWWuQFtK7Sh-Kt2zmmEQ,6182
+code_puppy/command_line/meta_command_handler.py,sha256=d5eVWzRoThYD3cR-GS0CMwHxDvBK4ezLdSIqwWDrq0g,5620
 code_puppy/command_line/model_picker_completion.py,sha256=NkyZZG7IhcVWSJ3ADytwCA5f8DpNeVs759Qtqs4fQtY,3733
 code_puppy/command_line/motd.py,sha256=FoZsiVpXGF8WpAmEJX4O895W7MDuzCtNWvFAOShxUXY,1572
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=_gP0FIOgHDNHTTWLNL0XNzr6sO0ISe7Mec1uQNo9kcM,8337
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=De_grHDPOvCRph-HDOGCSgX6r_q6akoXArTRwgAskLU,8334
 code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
 code_puppy/tools/__init__.py,sha256=WTHYIfRk2KMmk6o45TELpbB3GIiAm8s7GmfJ7Zy_tww,503
 code_puppy/tools/command_runner.py,sha256=9UWCSPpuEndaPx8Ecc8TRsn3rMHNd2AqerirvYPGRIw,14358
-code_puppy/tools/common.py,sha256=M53zhiXZAmPdvi1Y_bzCxgvEmifOvRRJvYPARYRZqHw,2253
+code_puppy/tools/common.py,sha256=UkhnfLG1bmd4f9nZCcmno088AtKtAnEES1tydxUN-Fk,3265
 code_puppy/tools/file_modifications.py,sha256=BzQrGEacS2NZr2ru9N30x_Qd70JDudBKOAPO1XjBohg,13861
-code_puppy/tools/file_operations.py,sha256=ypk4yL90LDSVRr0xyWafttzt956J_nXhhenCXhOOit8,11326
-code_puppy/tools/ts_code_map.py,sha256=o-u8p5vsYwitfDtVEoPS-7MwWn2xHzwtIQLo1_WMhQs,17647
-code_puppy-0.0.86.data/data/code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
-code_puppy-0.0.86.dist-info/METADATA,sha256=MhZ1w27mLtvfIsjEztFH9BuAGabfD_uCS4ZQQnDVSwg,6351
-code_puppy-0.0.86.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.86.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.86.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.86.dist-info/RECORD,,
+code_puppy/tools/file_operations.py,sha256=hXOoRWhOyUyVEX_uAah8VBMZr5AsuyhMvj9uL8osUpE,13257
+code_puppy/tools/token_check.py,sha256=F3eygdI8fgb6dfCrSkGw_OLI7cb_Kpa5ILft4BQ7hvY,525
+code_puppy-0.0.88.data/data/code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
+code_puppy-0.0.88.dist-info/METADATA,sha256=oKP59tXivzgNzTHFCWRbxVr7otqp5URAZ96y0cHSQHc,6351
+code_puppy-0.0.88.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.88.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.88.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.88.dist-info/RECORD,,

code_puppy/tools/ts_code_map.py

@@ -1,515 +0,0 @@
-import os
-from code_puppy.tools.common import should_ignore_path
-from pathlib import Path
-from rich.text import Text
-from rich.tree import Tree as RichTree
-from rich.console import Console
-from tree_sitter_language_pack import get_parser
-
-from functools import partial, wraps
-
-
-def _f(fmt):  # helper to keep the table tidy
-    return lambda name, _fmt=fmt: _fmt.format(name=name)
-
-
-def mark_export(label_fn, default=False):
-    """Decorator to prefix 'export ' (or 'export default ') when requested."""
-
-    @wraps(label_fn)
-    def _wrap(name, *, exported=False):
-        prefix = "export default " if default else "export " if exported else ""
-        return prefix + label_fn(name)
-
-    return _wrap
-
-
-LANGS = {
-    ".py": {
-        "lang": "python",
-        "name_field": "name",
-        "nodes": {
-            "function_definition": partial(_f("def {name}()"), style="green"),
-            "class_definition": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".rb": {
-        "lang": "ruby",
-        "name_field": "name",
-        "nodes": {
-            "method": partial(_f("def {name}"), style="green"),
-            "class": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".php": {
-        "lang": "php",
-        "name_field": "name",
-        "nodes": {
-            "function_definition": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".lua": {
-        "lang": "lua",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green")
-        },
-    },
-    ".pl": {
-        "lang": "perl",
-        "name_field": "name",
-        "nodes": {"sub_definition": partial(_f("sub {name}()"), style="green")},
-    },
-    ".r": {
-        "lang": "r",
-        "name_field": "name",
-        "nodes": {"function_definition": partial(_f("func {name}()"), style="green")},
-    },
-    ".js": {
-        "lang": "javascript",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-            "export_default_statement": partial(
-                _f("export default {name}"), style="yellow"
-            ),
-        },
-    },
-    ".mjs": {
-        "lang": "javascript",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-            "export_default_statement": partial(
-                _f("export default {name}"), style="yellow"
-            ),
-        },
-    },
-    ".cjs": {
-        "lang": "javascript",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-            "export_default_statement": partial(
-                _f("export default {name}"), style="yellow"
-            ),
-        },
-    },
-    ".jsx": {
-        "lang": "jsx",
-        "name_field": None,
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-        },
-    },
-    ".ts": {
-        "lang": "tsx",
-        "name_field": None,
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-        },
-    },
-    ".tsx": {
-        "lang": "tsx",
-        "name_field": None,
-        "nodes": {
-            "function_declaration": partial(_f("function {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-            "export_statement": partial(_f("export {name}"), style="yellow"),
-            "interface_declaration": partial(_f("interface {name}"), style="green"),
-        },
-    },
-    # ─────────  systems / compiled  ────────────────────────────────────
-    ".c": {
-        "lang": "c",
-        "name_field": "declarator",  # struct ident is under declarator
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".h": {
-        "lang": "c",
-        "name_field": "declarator",  # struct ident is under declarator
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".cpp": {
-        "lang": "cpp",
-        "name_field": "declarator",
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "class_specifier": partial(_f("class {name}"), style="magenta"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".hpp": {
-        "lang": "cpp",
-        "name_field": "declarator",
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "class_specifier": partial(_f("class {name}"), style="magenta"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".cc": {
-        "lang": "cpp",
-        "name_field": "declarator",
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "class_specifier": partial(_f("class {name}"), style="magenta"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".hh": {
-        "lang": "cpp",
-        "name_field": "declarator",
-        "nodes": {
-            "function_definition": partial(_f("fn {name}()"), style="green"),
-            "class_specifier": partial(_f("class {name}"), style="magenta"),
-            "struct_specifier": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".cs": {
-        "lang": "c_sharp",
-        "name_field": "name",
-        "nodes": {
-            "method_declaration": partial(_f("method {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".java": {
-        "lang": "java",
-        "name_field": "name",
-        "nodes": {
-            "method_declaration": partial(_f("method {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".kt": {
-        "lang": "kotlin",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("fun {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".swift": {
-        "lang": "swift",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("func {name}()"), style="green"),
-            "class_declaration": partial(_f("class {name}"), style="magenta"),
-        },
-    },
-    ".go": {
-        "lang": "go",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("func {name}()"), style="green"),
-            "type_spec": partial(_f("type {name}"), style="magenta"),
-        },
-    },
-    ".rs": {
-        "lang": "rust",
-        "name_field": "name",
-        "nodes": {
-            "function_item": partial(_f("fn {name}()"), style="green"),
-            "struct_item": partial(_f("struct {name}"), style="magenta"),
-            "trait_item": partial(_f("trait {name}"), style="magenta"),
-        },
-    },
-    ".zig": {
-        "lang": "zig",
-        "name_field": "name",
-        "nodes": {
-            "fn_proto": partial(_f("fn {name}()"), style="green"),
-            "struct_decl": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    ".scala": {
-        "lang": "scala",
-        "name_field": "name",
-        "nodes": {
-            "function_definition": partial(_f("def {name}()"), style="green"),
-            "class_definition": partial(_f("class {name}"), style="magenta"),
-            "object_definition": partial(_f("object {name}"), style="magenta"),
-        },
-    },
-    ".hs": {
-        "lang": "haskell",
-        "name_field": "name",
-        "nodes": {
-            "function_declaration": partial(_f("fun {name}"), style="green"),
-            "type_declaration": partial(_f("type {name}"), style="magenta"),
-        },
-    },
-    ".jl": {
-        "lang": "julia",
-        "name_field": "name",
-        "nodes": {
-            "function_definition": partial(_f("function {name}()"), style="green"),
-            "abstract_type_definition": partial(_f("abstract {name}"), style="magenta"),
-            "struct_definition": partial(_f("struct {name}"), style="magenta"),
-        },
-    },
-    # ────────  markup / style  ─────────────────────────────────────────
-    ".html": {
-        "lang": "html",
-        "name_field": None,
-        "nodes": {
-            # rely on parser presence; generic element handling not needed for tests
-        },
-    },
-    ".css": {
-        "lang": "css",
-        "name_field": None,
-        "nodes": {},
-    },
-    # ─────────  scripting (shell / infra)  ─────────────────────────────
-    ".sh": {
-        "lang": "bash",
-        "name_field": "name",
-        "nodes": {"function_definition": partial(_f("fn {name}()"), style="green")},
-    },
-    ".ps1": {
-        "lang": "powershell",
-        "name_field": "name",
-        "nodes": {
-            "function_definition": partial(_f("function {name}()"), style="green")
-        },
-    },
-}
-
-# ---------------------------------------------------------------------------
-# Emoji helpers (cute! 🐶)
-# ---------------------------------------------------------------------------
-
-_NODE_EMOJIS = {
-    "function": "🦴",
-    "class": "🏠",
-    "struct": "🏗️",
-    "interface": "🎛️",
-    "trait": "💎",
-    "type": "🧩",
-    "object": "📦",
-    "export": "📤",
-}
-
-_FILE_EMOJIS = {
-    ".py": "🐍",
-    ".js": "✨",
-    ".jsx": "✨",
-    ".ts": "🌀",
-    ".tsx": "🌀",
-    ".rb": "💎",
-    ".go": "🐹",
-    ".rs": "🦀",
-    ".java": "☕️",
-    ".c": "🔧",
-    ".cpp": "➕",
-    ".hpp": "➕",
-    ".swift": "🕊️",
-    ".kt": "🤖",
-}
-_PARSER_CACHE = {}
-
-
-def parser_for(lang_name):
-    if lang_name not in _PARSER_CACHE:
-        _PARSER_CACHE[lang_name] = get_parser(lang_name)
-    return _PARSER_CACHE[lang_name]
-
-
-# ----------------------------------------------------------------------
-# helper: breadth-first search for an identifier-ish node
-# ----------------------------------------------------------------------
-def _first_identifier(node):
-    from collections import deque
-
-    q = deque([node])
-    while q:
-        n = q.popleft()
-        if n.type in {"identifier", "property_identifier", "type_identifier"}:
-            return n
-        q.extend(n.children)
-    return None
-
-
-def _span(node):
-    """Return "[start:end]" lines (1‑based, inclusive)."""
-    start_line = node.start_point[0] + 1
-    end_line = node.end_point[0] + 1
-    return Text(f"  [{start_line}:{end_line}]", style="bold white")
-
-
-def _emoji_for_node_type(ts_type: str) -> str:
-    """Return a cute emoji for a given Tree-sitter node type (best-effort)."""
-    # naive mapping based on substrings – keeps it simple
-    if "function" in ts_type or "method" in ts_type or ts_type.startswith("fn_"):
-        return _NODE_EMOJIS["function"]
-    if "class" in ts_type:
-        return _NODE_EMOJIS["class"]
-    if "struct" in ts_type:
-        return _NODE_EMOJIS["struct"]
-    if "interface" in ts_type:
-        return _NODE_EMOJIS["interface"]
-    if "trait" in ts_type:
-        return _NODE_EMOJIS["trait"]
-    if "type_spec" in ts_type or "type_declaration" in ts_type:
-        return _NODE_EMOJIS["type"]
-    if "object" in ts_type:
-        return _NODE_EMOJIS["object"]
-    if ts_type.startswith("export"):
-        return _NODE_EMOJIS["export"]
-    return ""
-
-
-# ----------------------------------------------------------------------
-# traversal (clean)
-# ----------------------------------------------------------------------
-
-
-def _walk_fix(ts_node, rich_parent, info):
-    """Recursive traversal adding child nodes with emoji labels."""
-    nodes_cfg = info["nodes"]
-    name_field = info["name_field"]
-
-    for child in ts_node.children:
-        n_type = child.type
-        if n_type in nodes_cfg:
-            style = nodes_cfg[n_type].keywords["style"]
-            ident = (
-                child.child_by_field_name(name_field)
-                if name_field
-                else _first_identifier(child)
-            )
-            label_text = ident.text.decode() if ident else "<anon>"
-            label = nodes_cfg[n_type].func(label_text)
-            emoji = _emoji_for_node_type(n_type)
-            if emoji:
-                label = f"{emoji} {label}"
-            branch = rich_parent.add(Text(label, style=style) + _span(child))
-            _walk_fix(child, branch, info)
-        else:
-            _walk_fix(child, rich_parent, info)
-
-
-# ----------------------------------------------------------------------
-
-
-def _walk(ts_node, rich_parent, info):
-    nodes_cfg = info["nodes"]
-    name_field = info["name_field"]
-
-    for child in ts_node.children:
-        t = child.type
-        if t in nodes_cfg:
-            style = nodes_cfg[t].keywords["style"]
-
-            if name_field:
-                ident = child.child_by_field_name(name_field)
-            else:
-                ident = _first_identifier(child)
-
-            label_text = ident.text.decode() if ident else "<anon>"
-            label = nodes_cfg[t].func(label_text)
-            emoji = _emoji_for_node_type(t)
-            if emoji:
-                label = f"{emoji} {label}"
-            branch = rich_parent.add(Text(label, style=style) + _span(child))
-            _walk(child, branch, info)
-        else:
-            _walk(child, rich_parent, info)
-
-
-def map_code_file(filepath):
-    ext = Path(filepath).suffix
-    info = LANGS.get(ext)
-    if not info:
-        return None
-
-    code = Path(filepath).read_bytes()
-    parser = parser_for(info["lang"])
-    tree = parser.parse(code)
-
-    file_emoji = _FILE_EMOJIS.get(ext, "📄")
-    root_label = f"{file_emoji} {Path(filepath).name}"
-    base = RichTree(Text(root_label, style="bold cyan"))
-
-    if tree.root_node.has_error:
-        base.add(Text("⚠️  syntax error", style="bold red"))
-
-    _walk_fix(tree.root_node, base, info)
-    return base
-
-
-def make_code_map(directory: str, ignore_tests: bool = True) -> str:
-    """Generate a Rich-rendered code map including directory hierarchy.
-
-    Args:
-        directory: Root directory to scan.
-        ignore_tests: Whether to skip files with 'test' in the name.
-
-    Returns:
-        Plain-text rendering of the generated Rich tree (last 1k chars).
-    """
-    # Create root of tree representing starting directory
-    base_tree = RichTree(Text(Path(directory).name, style="bold magenta"))
-
-    # Cache to ensure we reuse RichTree nodes per directory path
-    dir_nodes: dict[str, RichTree] = {
-        Path(directory).resolve(): base_tree
-    }  # key=abs path
-
-    for root, dirs, files in os.walk(directory):
-        # ignore dot-folders early
-        dirs[:] = [d for d in dirs if not d.startswith(".")]
-
-        abs_root = Path(root).resolve()
-
-        # Ensure current directory has a node; create if coming from parent
-        if abs_root not in dir_nodes and abs_root != Path(directory).resolve():
-            rel_parts = abs_root.relative_to(directory).parts
-            parent_path = Path(directory).resolve()
-            for part in rel_parts:  # walk down creating nodes as needed
-                parent_node = dir_nodes[parent_path]
-                current_path = parent_path / part
-                if current_path not in dir_nodes:
-                    dir_label = Text(part, style="bold magenta")
-                    dir_node = parent_node.add(dir_label)
-                    dir_nodes[current_path] = dir_node
-                parent_path = current_path
-
-        current_node = dir_nodes.get(abs_root, base_tree)
-
-        for f in files:
-            file_path = os.path.join(root, f)
-            if should_ignore_path(file_path):
-                continue
-            if ignore_tests and "test" in f:
-                continue
-            try:
-                file_tree = map_code_file(file_path)
-                if file_tree is not None:
-                    current_node.add(file_tree)
-            except Exception:
-                current_node.add(Text(f"[error reading {f}]", style="bold red"))
-
-    # Render and return last 1000 characters
-    buf = Console(record=True, width=120)
-    buf.print(base_tree)
-    return buf.export_text()[-1000:]