code-puppy 0.0.60__tar.gz → 0.0.61__tar.gz

{code_puppy-0.0.60 → code_puppy-0.0.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.60
+Version: 0.0.61
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT
@@ -27,6 +27,8 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rapidfuzz>=3.13.0
 Requires-Dist: rich>=13.4.2
 Requires-Dist: ruff>=0.11.11
+Requires-Dist: tree-sitter-language-pack>=0.8.0
+Requires-Dist: tree-sitter-typescript>=0.23.2
 Description-Content-Type: text/markdown
 
 # 🐶 Code Puppy 🐶

{code_puppy-0.0.60 → code_puppy-0.0.61}/code_puppy/agent_prompts.py

@@ -30,6 +30,7 @@ File Operations:
    - 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_map(directory="."): Use this to generate a code map for the specified directory.
 
 Tool Usage Instructions:
 

{code_puppy-0.0.60 → code_puppy-0.0.61}/code_puppy/command_line/meta_command_handler.py

@@ -29,7 +29,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
 
     # ~codemap (code structure visualization)
     if command.startswith("~codemap"):
-        from code_puppy.tools.code_map import make_code_map
+        from code_puppy.tools.ts_code_map import make_code_map
 
         tokens = command.split()
         if len(tokens) > 1:
@@ -37,8 +37,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
         else:
             target_dir = os.getcwd()
         try:
-            tree = make_code_map(target_dir, show_doc=True)
-            console.print(tree)
+            make_code_map(target_dir, ignore_tests=True)
         except Exception as e:
             console.print(f"[red]Error generating code map:[/red] {e}")
         return True

{code_puppy-0.0.60 → code_puppy-0.0.61}/code_puppy/tools/common.py

@@ -1,4 +1,5 @@
 import os
+import fnmatch
 
 from typing import Optional, Tuple
 
@@ -8,6 +9,56 @@ from rich.console import Console
 NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
 console = Console(no_color=NO_COLOR)
 
+
+# -------------------
+# Shared ignore patterns/helpers
+# -------------------
+IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/node_modules/**/*.js",
+    "node_modules/**",
+    "node_modules",
+    "**/.git/**",
+    "**/.git",
+    ".git/**",
+    ".git",
+    "**/__pycache__/**",
+    "**/__pycache__",
+    "__pycache__/**",
+    "__pycache__",
+    "**/.DS_Store",
+    ".DS_Store",
+    "**/.env",
+    ".env",
+    "**/.venv/**",
+    "**/.venv",
+    "**/venv/**",
+    "**/venv",
+    "**/.idea/**",
+    "**/.idea",
+    "**/.vscode/**",
+    "**/.vscode",
+    "**/dist/**",
+    "**/dist",
+    "**/build/**",
+    "**/build",
+    "**/*.pyc",
+    "**/*.pyo",
+    "**/*.pyd",
+    "**/*.so",
+    "**/*.dll",
+    "**/.*",
+]
+
+
+def should_ignore_path(path: str) -> bool:
+    """Return True if *path* matches any pattern in IGNORE_PATTERNS."""
+    for pattern in IGNORE_PATTERNS:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+    return False
+
+
 JW_THRESHOLD = 0.95
 
 

{code_puppy-0.0.60 → code_puppy-0.0.61}/code_puppy/tools/file_operations.py

@@ -1,5 +1,5 @@
 # file_operations.py
-import fnmatch
+
 import os
 from typing import Any, Dict, List
 
@@ -10,50 +10,7 @@ from code_puppy.tools.common import console
 # ---------------------------------------------------------------------------
 # Module-level helper functions (exposed for unit tests _and_ used as tools)
 # ---------------------------------------------------------------------------
-IGNORE_PATTERNS = [
-    "**/node_modules/**",
-    "**/node_modules/**/*.js",
-    "node_modules/**",
-    "node_modules",
-    "**/.git/**",
-    "**/.git",
-    ".git/**",
-    ".git",
-    "**/__pycache__/**",
-    "**/__pycache__",
-    "__pycache__/**",
-    "__pycache__",
-    "**/.DS_Store",
-    ".DS_Store",
-    "**/.env",
-    ".env",
-    "**/.venv/**",
-    "**/.venv",
-    "**/venv/**",
-    "**/venv",
-    "**/.idea/**",
-    "**/.idea",
-    "**/.vscode/**",
-    "**/.vscode",
-    "**/dist/**",
-    "**/dist",
-    "**/build/**",
-    "**/build",
-    "**/*.pyc",
-    "**/*.pyo",
-    "**/*.pyd",
-    "**/*.so",
-    "**/*.dll",
-    "**/*.exe",
-]
-
-
-def should_ignore_path(path: str) -> bool:
-    """Return True if *path* matches any pattern in IGNORE_PATTERNS."""
-    for pattern in IGNORE_PATTERNS:
-        if fnmatch.fnmatch(path, pattern):
-            return True
-    return False
+from code_puppy.tools.common import should_ignore_path
 
 
 def _list_files(
@@ -323,3 +280,20 @@ def register_file_operations_tools(agent):
         context: RunContext, search_string: str, directory: str = "."
     ) -> List[Dict[str, Any]]:
         return _grep(context, search_string, directory)
+
+    @agent.tool
+    def code_map(context: RunContext, directory: str = ".") -> str:
+        """Generate a code map for the specified directory.
+           This will have a list of all function / class names and nested structure
+        Args:
+            context: The context object.
+            directory: The directory to generate the code map for.
+
+        Returns:
+            A string containing the code map.
+        """
+        console.print("[bold white on blue] CODE MAP [/bold white on blue]")
+        from code_puppy.tools.ts_code_map import make_code_map
+
+        result = make_code_map(directory, ignore_tests=True)
+        return result

code_puppy-0.0.61/code_puppy/tools/ts_code_map.py

@@ -0,0 +1,393 @@
+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"),
+        },
+    },
+    # ─────────  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")
+        },
+    },
+    # ─────────  web / data description (pure-function view)  ───────────
+    ".html": {
+        "lang": "html",
+        "name_field": "name",  # rarely useful, but included for completeness
+        "nodes": {"element": partial(_f("<{name}>"), style="yellow")},
+    },
+    ".css": {
+        "lang": "css",
+        "name_field": "name",
+        "nodes": {
+            "class_selector": partial(_f(".{name}"), style="yellow"),
+            "id_selector": partial(_f("#{name}"), style="yellow"),
+        },
+    },
+}
+
+# Cache parsers so we don’t re-create them file-after-file
+_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 _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)
+            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)
+
+    root_label = 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(tree.root_node, base, info)
+    return base
+
+
+def make_code_map(directory: str, ignore_tests: bool = True) -> str:
+    base_tree = RichTree(Text(Path(directory).name, style="bold magenta"))
+
+    for root, dirs, files in os.walk(directory):
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        for f in files:
+            if (
+                should_ignore_path(os.path.join(root, f))
+                or ignore_tests
+                and "test" in f
+            ):
+                continue
+            try:
+                file_tree = map_code_file(os.path.join(root, f))
+                if file_tree is not None:
+                    base_tree.add(file_tree)
+            except Exception:
+                base_tree.add(Text(f"[error reading {f}]", style="bold red"))
+
+    buf = Console(record=True, width=120)
+    buf.print(base_tree)
+    return buf.export_text()

{code_puppy-0.0.60 → code_puppy-0.0.61}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.60"
+version = "0.0.61"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -23,6 +23,8 @@ dependencies = [
     "pathspec>=0.11.0",
     "rapidfuzz>=3.13.0",
     "json-repair>=0.46.2",
+    "tree-sitter-language-pack>=0.8.0",
+    "tree-sitter-typescript>=0.23.2",
 ]
 dev-dependencies = [
     "pytest>=8.3.4",

code_puppy-0.0.60/code_puppy/tools/code_map.py

@@ -1,92 +0,0 @@
-import ast
-import os
-
-import pathspec
-from rich.text import Text
-from rich.tree import Tree
-
-
-def summarize_node(node: ast.AST) -> str:
-    if isinstance(node, ast.ClassDef):
-        return f"class {node.name}"
-    if isinstance(node, ast.FunctionDef):
-        return f"def {node.name}()"
-    return ""
-
-
-def get_docstring(node: ast.AST) -> str:
-    doc = ast.get_docstring(node)
-    if doc:
-        lines = doc.strip().split("\n")
-        return lines[0] if lines else doc.strip()
-    return ""
-
-
-def map_python_file(file_path: str, show_doc: bool = True) -> Tree:
-    tree = Tree(Text(file_path, style="bold cyan"))
-    with open(file_path, "r", encoding="utf-8") as f:
-        root = ast.parse(f.read(), filename=file_path)
-    for node in root.body:
-        summary = summarize_node(node)
-        if summary:
-            t = Tree(summary)
-            if show_doc:
-                doc = get_docstring(node)
-                if doc:
-                    t.add(Text(f'"{doc}"', style="dim"))
-            # Add inner functions
-            if hasattr(node, "body"):
-                for subnode in getattr(node, "body"):
-                    subsum = summarize_node(subnode)
-                    if subsum:
-                        sub_t = Tree(subsum)
-                        doc2 = get_docstring(subnode)
-                        if doc2:
-                            sub_t.add(Text(f'"{doc2}"', style="dim"))
-                        t.add(sub_t)
-            tree.add(t)
-    return tree
-
-
-def load_gitignore(directory: str):
-    gitignore_file = os.path.join(directory, ".gitignore")
-    if os.path.exists(gitignore_file):
-        with open(gitignore_file, "r") as f:
-            spec = pathspec.PathSpec.from_lines("gitwildmatch", f)
-        return spec
-    else:
-        return pathspec.PathSpec.from_lines("gitwildmatch", [])
-
-
-def make_code_map(directory: str, show_doc: bool = True) -> Tree:
-    """
-    Recursively build a Tree displaying the code structure of all .py files in a directory,
-    ignoring files listed in .gitignore if present.
-    """
-    base_tree = Tree(Text(directory, style="bold magenta"))
-
-    spec = load_gitignore(directory)
-    abs_directory = os.path.abspath(directory)
-
-    for root, dirs, files in os.walk(directory):
-        rel_root = os.path.relpath(root, abs_directory)
-        # Remove ignored directories in-place for os.walk to not descend
-        dirs[:] = [
-            d
-            for d in dirs
-            if not spec.match_file(os.path.normpath(os.path.join(rel_root, d)))
-        ]
-        for fname in files:
-            rel_file = os.path.normpath(os.path.join(rel_root, fname))
-            if fname.endswith(".py") and not fname.startswith("__"):
-                if not spec.match_file(rel_file):
-                    fpath = os.path.join(root, fname)
-                    try:
-                        file_tree = map_python_file(fpath, show_doc=show_doc)
-                        base_tree.add(file_tree)
-                    except Exception as e:
-                        err = Tree(
-                            Text(f"[error reading {fname}: {e}]", style="bold red")
-                        )
-                        base_tree.add(err)
-    return base_tree