radixcodemap 0.2.0__tar.gz

radixcodemap-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jdotpy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

radixcodemap-0.2.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: radixcodemap
+Version: 0.2.0
+Summary: Summarize code repositories quickly and (soon) with multiple verbosity levels
+Home-page: https://github.com/jdotpy/radix-map
+Download-URL: https://github.com/jdotpy/radix-map/tarball/master
+Author: KJ
+Author-email: jdotpy@users.noreply.github.com
+Keywords: tools
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tree-sitter
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+
+
+# Radix: Configurable SourceCode summarizer
+
+Quickly summarize project structure with multiple verbosity levels (ok, so maybe there's only one option right now lol). More soon.
+
+
+## Installation
+---
+
+1. **Clone the repository:**
+   ```bash
+   git clone [https://github.com/jdotpy/radix-map.git](https://github.com/jdotpy/radix-map.git)
+   cd radix-map
+   pip install .
+   ```
+
+
+2. **Install Dependencies based on code you plan on using:**
+   ```bash
+   pip install tree-sitter-python
+   pip install tree-sitter-go
+   pip install tree-sitter-javascript
+   ```
+
+
+## Use
+---
+
+```bash
+radix map .
+```
+
+Example output:
+```bash
+#tests/test_integration.py
+└── ƒ get_test_pairs()
+
+#tests/snapshots/python_ex1.py
+├── ƒ global_helper()
+└── ○ class DataProcessor
+    ├── ƒ __init__(self, source: str)
+    ├── ƒ process(self)
+    └── ƒ _validate(self)
+
+#radix/scanner.py
+└── ○ class ProjectScanner
+    ├── ƒ __init__(self, registry, max_bytes: int = 200_000, extra_ignored_dirs: Optional[Set[str]] = None)
+    ├── ƒ is_visible(self, path: Path)
+    └── ƒ scan(self, target: str)
+```
+
+## Supported Languages
+
+
+| Language | Status | Package Requirement |
+|---|---|---|
+| Python	| ✅ functions & classes | tree-sitter-python | 
+| Go	| 🚧 | tree-sitter-go | 
+| JavaScript | 🚧 | tree-sitter-javascript | 
+
+```
+

radixcodemap-0.2.0/README.md

@@ -0,0 +1,63 @@
+
+
+# Radix: Configurable SourceCode summarizer
+
+Quickly summarize project structure with multiple verbosity levels (ok, so maybe there's only one option right now lol). More soon.
+
+
+## Installation
+---
+
+1. **Clone the repository:**
+   ```bash
+   git clone [https://github.com/jdotpy/radix-map.git](https://github.com/jdotpy/radix-map.git)
+   cd radix-map
+   pip install .
+   ```
+
+
+2. **Install Dependencies based on code you plan on using:**
+   ```bash
+   pip install tree-sitter-python
+   pip install tree-sitter-go
+   pip install tree-sitter-javascript
+   ```
+
+
+## Use
+---
+
+```bash
+radix map .
+```
+
+Example output:
+```bash
+#tests/test_integration.py
+└── ƒ get_test_pairs()
+
+#tests/snapshots/python_ex1.py
+├── ƒ global_helper()
+└── ○ class DataProcessor
+    ├── ƒ __init__(self, source: str)
+    ├── ƒ process(self)
+    └── ƒ _validate(self)
+
+#radix/scanner.py
+└── ○ class ProjectScanner
+    ├── ƒ __init__(self, registry, max_bytes: int = 200_000, extra_ignored_dirs: Optional[Set[str]] = None)
+    ├── ƒ is_visible(self, path: Path)
+    └── ƒ scan(self, target: str)
+```
+
+## Supported Languages
+
+
+| Language | Status | Package Requirement |
+|---|---|---|
+| Python	| ✅ functions & classes | tree-sitter-python | 
+| Go	| 🚧 | tree-sitter-go | 
+| JavaScript | 🚧 | tree-sitter-javascript | 
+
+```
+

radixcodemap-0.2.0/radix/__main__.py

@@ -0,0 +1,46 @@
+from . import core
+from . import cli
+import argparse
+import sys
+
+def create_parser():
+    parser = argparse.ArgumentParser(prog="radix", description="Codebase Mapping Tool")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+
+    # 'registry' subcommand
+    registry_parser = subparsers.add_parser("registry", help="Show registered file handlers and their libraries")
+
+    # 'map' subcommand
+    map_parser = subparsers.add_parser("map", help="Generate a structural map of the codebase")
+    
+    # Positional argument
+    map_parser.add_argument("path", help="Path to file or directory to scan")
+
+    # Fine-grained Overrides (Your original flags)
+    group = map_parser.add_argument_group("Detail Overrides")
+    group.add_argument("--calls", action="store_true", help="Include internal function calls")
+    group.add_argument("--lines", action="store_true", help="Include type definitions/properties")
+    
+    # Configuration
+    map_parser.add_argument("--max-size", type=int, default=200000, 
+                            help="Skip files larger than this size in bytes")
+
+
+
+    return parser
+
+
+def entrypoint():
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if args.command == "map":
+        cli.cli_map(args)
+    elif args.command == "registry":
+        cli.cli_registry(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    entrypoint()

radixcodemap-0.2.0/radix/cli.py

@@ -0,0 +1,32 @@
+from . import core
+from . import report
+from .handlers.registry import HandlerRegistry
+
+import sys
+import importlib.util
+
+
+def cli_map(args):
+    scanner = core.default_scanner(args.path)
+    source = core.default_source(args.path)
+    reports_by_file = core.analyze_project(scanner, source, calls=args.calls, lines=args.lines)
+    report.display_txt(
+        reports_by_file,
+        sys.stdout,
+        lines=args.lines,
+    )
+
+def cli_registry(args):
+    print('Supported languages:')
+    for file_type, info in HandlerRegistry.LIBRARIES.items():
+        spec = importlib.util.find_spec(info['lib'])
+        has_package = spec is not None
+        extra_info = []
+        if not has_package:
+            status = "Missing"
+            extra_info.append('\t')
+            extra_info.append(f'to install run `pip install {info["package_name"]}`')
+        else:
+            status = "Installed"
+        print('\t', file_type, '\t', status, *extra_info)
+

radixcodemap-0.2.0/radix/core.py

@@ -0,0 +1,31 @@
+from . import scanner
+from .handlers.registry import HandlerRegistry
+
+from pathlib import Path
+import sys
+
+def default_scanner(path: str):
+    registry = HandlerRegistry()
+    s = scanner.ProjectScanner(registry)
+    return s
+
+def default_source(path):
+    return scanner.DiskSource(path)
+
+def analyze_project(scanner, source, calls=False, lines=False):
+    reports = {}
+    for file_path, relative_path, handler, read_func in scanner.scan(source):
+        try:
+            source_file = handler(file_path, read_func())
+        except Exception as e:
+            sys.stderr.write(f'Failed to parse file={file_path} with handler={handler.__name__}. Skipping. Error="{str(e)}"')
+            continue
+
+        file_report = {
+            "path": str(file_path),
+            "lines": source_file.get_line_count(),
+            "functions": list(source_file.iter_functions(include_calls=calls)),
+            "definitions": list(source_file.iter_definitions(include_methods=True, include_calls=calls)),
+        }
+        reports[relative_path] = file_report
+    return reports

radixcodemap-0.2.0/radix/handlers/base.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+@dataclass
+class Variable:
+    name: str
+    type_hint: Optional[str] = None
+    value_snippet: Optional[str] = None  # For constants like MAX_RETRIES = 5
+
+    def __str__(self):
+        type_prefix = ''
+        if self.type_hint:
+            type_prefix = f'{self.type_hint} '
+        value_suffix = ''
+        if self.value_snippet:
+            value_suffix = f' {self.value_snippet}'
+        return f'{type_prefix}{self.name}{value_suffix}'
+
+@dataclass
+class Function:
+    name: str
+    source_lines: tuple[int, int]
+    arguments: str = ""
+    return_type: str = ""
+    is_public: bool = False
+    calls: List[str] = field(default_factory=list)
+
+    def __str__(self):
+        return_suffix = ''
+        if self.return_type:
+            return_suffix = ' ➜ {return_type}'
+        return f'ƒ {self.name}({self.arguments}){return_suffix}'
+
+
+@dataclass
+class Definition:
+    name: str
+    kind: str                 # "class", "struct", "interface"
+    source_lines: tuple[int, int]
+    properties: List[Variable] = field(default_factory=list)
+    methods: List[Function] = field(default_factory=list)
+    
+
+    def __str__(self):
+        return f'{self.kind} {self.name}'
+
+class SourceFile(ABC):
+    def __init__(self, path: str, code: bytes):
+        self.path = path
+        self.code = code
+        self._tree = self._parse()
+    
+    @abstractmethod
+    def get_line_count(self):
+        """Fetch total lines in source file"""
+        pass
+
+    @abstractmethod
+    def _parse(self):
+        """Initialize the Tree-sitter parser for the specific language."""
+        pass
+
+    @abstractmethod
+    def iter_definitions(self) -> List[Definition]:
+        """
+        Returns Classes or Structs. 
+        Implementation should populate .properties and .methods.
+        """
+        pass
+
+    @abstractmethod
+    def iter_functions(self) -> List[Function]:
+        """Returns top-level functions (logic not bound to a class/struct)."""
+        pass
+
+    @abstractmethod
+    def iter_globals(self) -> List[Variable]:
+        """Returns top-level constants and global variables."""
+        pass

radixcodemap-0.2.0/radix/handlers/handler_go.py

@@ -0,0 +1,126 @@
+from .base import Definition, Function, Variable, SourceFile
+from tree_sitter import Language, Parser
+import tree_sitter_go as tsgo
+
+from .tree_utils import ts_get_captures, ts_line_info, one, q
+
+class GoSourceFile(SourceFile):
+    lang = Language(tsgo.language())
+
+    def _parse(self):
+        self.parser = Parser(self.lang)
+        return self.parser.parse(self.code)
+
+    def _get_text(self, node):
+        if node is None:
+            return ''
+        return self.code[node.start_byte:node.end_byte].decode('utf-8')
+    
+    def get_line_count(self):
+        """Fetch total lines in source file"""
+        return ts_line_info(self._tree.root_node)['source_lines'][1]
+
+    def iter_definitions(self, include_calls=False, include_methods=False) -> list[Definition]:
+        """Returns Structs and Interfaces, populating their methods."""
+        # Query for type declarations (structs and interfaces)
+        query = q(self.lang, """
+            (type_declaration
+                (type_spec
+                    name: (type_identifier) @name
+                    type: [
+                        (struct_type) 
+                        (interface_type)
+                    ] @type_body)) @definition
+        """)
+        definitions = []
+        
+        all_methods = self._get_all_methods()
+
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            node = one(captures.get('definition'))
+            name_node = node.child_by_field_name("name") or node.named_child(0).child_by_field_name("name")
+            
+            if not name_node:
+                continue
+                
+            type_name = self._get_text(name_node)
+            type_body = node.named_child(0).child_by_field_name("type")
+            kind = "struct" if type_body.type == "struct_type" else "interface"
+            
+            defn = Definition(name=type_name, kind=kind, **ts_line_info(node))
+            defn.methods = [m for m in all_methods if m._receiver_type == type_name]
+            definitions.append(defn)
+            
+        return definitions
+
+    def iter_functions(self, include_calls=False) -> list[Function]:
+        """Returns top-level functions (those without receivers)."""
+        query = q(self.lang, """
+            (function_declaration
+                name: (identifier) @name
+                parameters: (parameter_list) @params) @func
+        """)
+        
+        functions = []
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            func_node = captures.get('func')
+            name = self._get_text(one(captures.get('name')))
+            params = self._get_text(one(captures.get('params'))).strip("()")
+            functions.append(Function(name=name, arguments=params, **ts_line_info(func_node)))
+                
+        return functions
+
+    def iter_globals(self) -> list[Variable]:
+        """Returns top-level var and const declarations."""
+        query = q(self.lang, """
+            (var_declaration
+                (var_spec name: (identifier) @name)) @var
+            (const_declaration
+                (const_spec name: (identifier) @name)) @const
+        """)
+        
+        variables = []
+        
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            # Simplification: grabbing the first identifier in the spec
+            node = captures.get('var') or captures.get('const')
+            name_node = node.named_child(0).child_by_field_name("name")
+            if name_node:
+                variables.append(Variable(name=self._get_text(name_node)))
+        
+        return variables
+
+    def _get_all_methods(self) -> list:
+        """Helper to find all method_declarations and identify their receiver type."""
+        query = q(self.lang, """
+            (method_declaration
+                receiver: (parameter_list 
+                    (parameter_declaration 
+                        type: [
+                            (pointer_type (type_identifier) @recv) 
+                            (type_identifier) @recv
+                        ]
+                    )
+                )
+                name: (field_identifier) @name
+                parameters: (parameter_list) @params
+            ) @method
+        """)
+        
+        methods = []
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            method_node = one(captures.get('method'))
+            name_node = one(captures.get('name'))
+            recv_node = one(captures.get('recv'))
+            param_node = one(captures.get('params'))
+            
+            func = Function(
+                name=self._get_text(name_node),
+                arguments=self._get_text(param_node).strip("()"),
+                **ts_line_info(method_node)
+            )
+            # Temporary attribute to help iter_definitions link them
+            func._receiver_type = self._get_text(recv_node)
+            methods.append(func)
+            
+        return methods

radixcodemap-0.2.0/radix/handlers/handler_js.py

@@ -0,0 +1,157 @@
+from .base import Variable, Function, Definition, SourceFile
+from tree_sitter import Language, Parser
+import tree_sitter_javascript as tsjavascript
+from .tree_utils import ts_get_captures, ts_line_info, one, q
+
+def get_child_by_type(node, node_type):
+    for child in node.children:
+        if child.type == node_type:
+            return child
+    return None
+
+class JsSourceFile(SourceFile):
+    lang = Language(tsjavascript.language())
+    
+    def _parse(self):
+        self.parser = Parser(self.lang)
+        self._tree = self.parser.parse(self.code)
+        return self._tree
+
+    def _get_text(self, node):
+        if node is None:
+            return ''
+        return self.code[node.start_byte:node.end_byte].decode('utf-8')
+    
+    def get_line_count(self):
+        """Fetch total lines in source file"""
+        return ts_line_info(self._tree.root_node)['source_lines'][1]
+
+    def iter_functions(self, include_calls=False) -> list[Function]:
+        """
+
+            Use case 1: Arrow functions:
+
+                query:
+                    (lexical_declaration
+                        (variable_declarator
+                            value: (arrow_function)
+                        )
+                    ) @arrowfunc1
+                example:
+                    const foobar = () => {
+                        console.log('im an arrow function')
+                    }
+
+            Use case 2: actual functions
+
+                query:
+                    (function_declaration) @func
+                example:
+                    function applyDiscount(p) {
+                        return p * 0.9;
+                    }
+            
+            Use case 3: anon functions
+
+                query:
+                    (lexical_declaration
+                        (variable_declarator
+                            value: (function_expression)
+                        )
+                    ) @anonFunc
+                example:
+                    const anonymousExpress = function(a, b) {
+                        return a + b;
+                    };
+
+
+
+        """
+        query = q(self.lang, """
+            (program [
+                ;; 1. Standard or Exported Declaration
+                (function_declaration 
+                    name: (identifier) @name 
+                    parameters: (formal_parameters) @params) @anchor
+                (export_statement 
+                    (function_declaration 
+                        name: (identifier) @name 
+                        parameters: (formal_parameters) @params)) @anchor
+
+                ;; 2. Lexical Assignments (Arrow or Expression)
+                (lexical_declaration
+                    (variable_declarator
+                        name: (identifier) @name
+                        value: [
+                            (function_expression parameters: (formal_parameters) @params)
+                            (arrow_function parameters: (formal_parameters) @params)
+                        ]
+                    )
+                ) @anchor
+            ])
+        """)
+        functions = []
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            
+            name_node = one(captures.get('name', [None]))
+            param_node = one(captures.get('params', [None]))
+            anchor_node = one(captures.get('anchor', [None]))
+
+            if name_node and param_node:
+                name = self._get_text(name_node)
+                args = self._get_text(param_node).strip("()")
+                
+                f = Function(name=name, arguments=args, **ts_line_info(anchor_node))
+                if include_calls and anchor_node:
+                    f.calls = self._extract_calls(anchor_node)
+                functions.append(f)
+
+        return functions
+
+    def iter_definitions(self, include_methods=False, include_calls=False) -> list[Definition]:
+        query = q(self.lang, """
+            (class_declaration 
+                name: (identifier) @name 
+                body: (class_body) @body) @class
+        """)
+        
+        definitions = []
+
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            name_node = one(captures.get('name'))
+            class_node = one(captures.get('class'))
+            class_name = self._get_text(name_node)
+            defn = Definition(name=class_name, kind="class", **ts_line_info(class_node))
+            
+            if not include_methods:
+                definitions.append(defn)
+                continue
+
+            body_node = class_node.child_by_field_name("body")
+            # In JS class_body, we look for method_definition
+            for child in body_node.children:
+                if child.type == "method_definition":
+                    name_node = child.child_by_field_name("name")
+                    param_node = child.child_by_field_name("parameters")
+                    
+                    method = Function(
+                        name=self._get_text(name_node),
+                        arguments=self._get_text(param_node).strip("()"),
+                        **ts_line_info()
+                    )
+                    if include_calls:
+                        method.calls = self._extract_calls(child)
+                    defn.methods.append(method)
+        
+            definitions.append(defn)
+        return definitions
+
+    def iter_globals(self):
+        query = q(self.lang, """
+            (program [
+                (lexical_declaration (variable_declarator name: (identifier) @name))
+                (variable_declaration (variable_declarator name: (identifier) @name))
+            ] @global)
+        """)
+        captures = query.captures(self._tree.root_node)
+        return [self._get_text(node.child_by_field_name("name")) for node in captures.get('global', [])]

radixcodemap-0.2.0/radix/handlers/handler_py.py

@@ -0,0 +1,89 @@
+import tree_sitter_python as tspython
+from tree_sitter import Language, Parser
+from .base import SourceFile, Function, Variable, Definition
+from .tree_utils import ts_get_captures,ts_line_info, one, q
+
+
+def extract_decorated_function(node):
+    for child in node.children:
+        if child.type == 'function_definition':
+            return child
+    return None
+
+
+class PythonSourceFile(SourceFile):
+    lang = Language(tspython.language())
+    
+    def _parse(self):
+        self.parser = Parser(self.lang)
+        return self.parser.parse(self.code)
+
+    def _get_text(self, node):
+        if node is None:
+            return ''
+        return self.code[node.start_byte:node.end_byte].decode('utf-8')
+
+    def get_line_count(self):
+        """Fetch total lines in source file"""
+        return ts_line_info(self._tree.root_node)['source_lines'][1]
+
+    def iter_functions(self, include_calls=False) -> list[Function]:
+        query = q(self.lang, """
+            (module (function_definition 
+                name: (identifier) @name
+                parameters: (parameters) @params) @func)
+        """)
+        functions = []
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            func_node = one(captures.get('func'))
+            name_node = one(captures.get("name"))
+            param_node = one(captures.get("params"))
+            
+            if name_node:
+                name = self._get_text(name_node)
+                params = self._get_text(param_node).strip("()")
+                
+                f = Function(name=name, arguments=params, **ts_line_info(func_node))
+                if include_calls:
+                    f.calls = self._extract_calls(func_node)
+                functions.append(f)
+                
+        return functions
+
+    def iter_definitions(self, include_methods=False, include_calls=False) -> list[Definition]:
+        # Query for the class and its internal methods
+        query = q(self.lang, """
+            (class_definition 
+                name: (identifier) @name
+                body: (block) @body) @class
+        """)
+        definitions = []
+        for _, captures in ts_get_captures(query, self._tree.root_node):
+            class_name = self._get_text(captures.get('name')[0])
+            body_node = one(captures.get('body'))
+            class_node = one(captures.get('class'))
+            
+            # Initialize the Definition
+            defn = Definition(name=class_name, kind="class", **ts_line_info(class_node))
+            
+            if not include_methods:
+                continue
+            # Walk the class body to find function_definitions (Methods)
+            for child in body_node.children:
+                entry = child
+                if entry.type == "decorated_definition":
+                    decorated_function = extract_decorated_function(entry)
+                    if decorated_function is not None:
+                        entry = decorated_function
+                if entry.type == "function_definition":
+                    method_name = self._get_text(entry.child_by_field_name("name"))
+                    params = self._get_text(entry.child_by_field_name("parameters")).strip("()")
+                    method = Function(name=method_name, arguments=params, **ts_line_info(child))
+                    if include_calls:
+                        method.calls = self._extract_calls(entry)
+                    defn.methods.append(method)
+            definitions.append(defn)
+        return definitions
+      
+    def iter_globals(self):
+        raise NotImplemented()

radixcodemap-0.2.0/radix/handlers/registry.py

@@ -0,0 +1,68 @@
+from typing import Dict, Callable, Type
+from .base import SourceFile
+
+import sys
+
+def _load_python():
+    from .handler_py import PythonSourceFile
+    return PythonSourceFile
+
+def _load_go():
+    from .handler_go import GoSourceFile
+    return GoSourceFile
+
+def _load_js():
+    from .handler_js import JsSourceFile
+    return JsSourceFile
+
+class HandlerRegistry:
+    LIBRARIES = {
+            "py": {
+                'package_name': 'tree-sitter-python',
+                'lib': 'tree_sitter_python',
+                'loader': _load_python,
+            },
+            "go": {
+                'package_name': 'tree-sitter-go',
+                'lib': 'tree_sitter_go',
+                'loader': _load_go,
+            },
+            "js": {
+                'package_name': 'tree-sitter-javascript',
+                'lib': 'tree_sitter_javascript',
+                'loader': _load_js,
+            },
+    }
+
+    def __init__(self):
+        # Maps extension -> A function that returns the Class
+        self._loaders = {
+            ".py": self.LIBRARIES['py']['loader'],
+            ".go": self.LIBRARIES['go']['loader'],
+            ".js": self.LIBRARIES['js']['loader'],
+        }
+        self._handlers: Dict[str, Type[SourceFile]] = {}
+        self._errors = {}
+
+    def get_handler_class(self, extension: str) -> Type[SourceFile]:
+        ext = extension.lower()
+        if not self.has_handler(ext):
+            raise ValueError(f"Unsupported extension: {ext}")
+
+        # Check cache so we don't re-import every time
+        if ext not in self._handlers:
+            loader_func = self._loaders[ext]
+            try:
+                self._handlers[ext] = loader_func()
+            except ModuleNotFoundError as e:
+                sys.stderr.write(f"Skipping files of type {ext} due to import failure for required module. Error: {str(e)}\n")
+                self._errors[ext] = e
+                return None
+        
+        return self._handlers[ext]
+
+    def has_handler(self, extension: str) -> bool:
+        ext = extension.lower()
+        if ext in self._errors:
+            return False
+        return ext in self._loaders or ext in self._handlers

radixcodemap-0.2.0/radix/handlers/tree_utils.py

@@ -0,0 +1,48 @@
+try:
+    from tree_sitter import QueryCursor, Query
+except (ImportError, AttributeError):
+    QueryCursor = None
+    Query = None
+
+def ts_line_info(node):
+    if isinstance(node, list) and len(node) == 1:
+        node = node[0]
+    return {'source_lines': (node.start_point[0], node.end_point[0])}
+
+def ts_get_captures(query, root_node):
+    """
+    A cross-version generator for tree-sitter captures.
+    """
+    # Version A: Modern API (0.21.0+) 
+    if QueryCursor is not None:
+        cursor = QueryCursor(query)
+        for index, captures in cursor.matches(root_node):
+            yield index, captures
+        return
+
+    # Version B: Older versions dont have cursor and allow query.captures(root_node) which returns a list
+    if hasattr(query, 'captures'):
+        results = query.matches(root_node)
+        for index, captures in results:
+            yield index, captures
+    else:
+        raise RuntimeError("No compatible tree-sitter capture method found.")
+
+def one(source):
+    """ helper that extracts the first element or child for a tree node or None """
+    if source is None:
+        return None
+    if hasattr(source, "children"):
+        source = source.children
+    if isinstance(source, list):
+        if len(source) >= 1:
+            return source[0]
+        else:
+            return None
+    raise ValueError("Unsupported type sent to one()")
+
+def q(lang, text):
+    if Query is not None:
+        return Query(lang, text)
+    return lang.query(text)
+    

radixcodemap-0.2.0/radix/report.py

@@ -0,0 +1,72 @@
+def as_sorted_dict(d):
+    return dict(sorted(d.items()))
+
+def line_count_pad_size(source):
+    m = 0
+    for report in source.values():
+        m = max(m, report['lines'])
+    return (len(str(m)) * 2) + len('[:]')
+
+def get_line_range_str(item=None, size=None, default=''):
+    if size == 0:
+        lines = (0, 0)
+    elif size is not None:
+        lines = (1, size)
+    elif hasattr(item, 'source_lines'):
+        lines = (item.source_lines[0], item.source_lines[1])
+    else:
+        return default
+
+    range_text = f"[{lines[0]}:{lines[1]}]"
+    return f"{range_text}"
+
+
+def display_txt(reports_by_file, output, lines=False):
+    if lines:
+        max_gutter = line_count_pad_size(reports_by_file) + 1 # for padding
+        gutter_spacing = " " * max_gutter
+    else:
+        max_gutter = 0
+        gutter_spacing = ''
+        line_range = ''
+
+    for file_path, report in as_sorted_dict(reports_by_file).items():
+        if lines:
+            file_lines = get_line_range_str(size=report['lines']).ljust(max_gutter)
+        else:
+            file_lines = ''
+        output.write(f"\n{file_lines}\033[1m # {file_path}\033[0m\n")
+        
+        all_top_level = ([(f, 'func') for f in sorted(report.get('functions', []), key=lambda x: x.name)] + 
+                         [(d, 'def') for d in sorted(report.get('definitions', []), key=lambda x: x.name)])
+        
+        for i, (item, kind) in enumerate(all_top_level):
+            is_last_top = (i == len(all_top_level) - 1)
+            marker = "└── " if is_last_top else "├── "
+            pipe = "    " if is_last_top else "│   "
+            
+            if lines:
+                line_range = get_line_range_str(item, default=gutter_spacing).ljust(max_gutter)
+            
+            if kind == 'func':
+                output.write(f"{line_range} {marker} {item}\n")
+                # Render Calls
+                for j, call in enumerate(sorted(item.calls)):
+                    is_last_call = (j == len(item.calls) - 1)
+                    c_marker = "└── ➜ " if is_last_call else "├── ➜ "
+                    output.write(f"{gutter_spacing} {pipe}{c_marker}{call}\n")
+
+            elif kind == 'def':
+                output.write(f"{line_range} {marker}○ {item}\n")
+                # Render Methods
+                methods = item.methods
+                for j, method in enumerate(methods):
+                    is_last_method = (j == len(methods) - 1)
+                    m_marker = "└── " if is_last_method else "├── "
+                    m_pipe = "    " if is_last_method else "│   "
+                    
+                    if lines:
+                        m_line_range = get_line_range_str(method, default=gutter_spacing).ljust(max_gutter)
+                    else:
+                        m_line_range = ''
+                    output.write(f"{m_line_range} {pipe}{m_marker}{method}\n")

radixcodemap-0.2.0/radix/scanner.py

@@ -0,0 +1,119 @@
+import os
+from pathlib import Path
+from typing import Generator, Tuple, Optional, Set
+
+import zipfile
+from dataclasses import dataclass
+from typing import Callable
+
+@dataclass
+class FileEntry:
+    full_path: Path         # The logical path within the project
+    rel_path: Path
+    size: int           # For your max_bytes check
+    reader: Callable[[], bytes] # The "make_reader" logic
+
+class DiskSource:
+    def __init__(self, root_path: Path):
+        self.path = Path(root_path)
+        self.is_single_file = self.path.is_file()
+        self.root = self.path.parent if self.is_single_file else self.path
+        
+    def walk(self) -> Generator[FileEntry, None, None]:
+        if self.is_single_file:
+            yield FileEntry(    
+                full_path=self.path,
+                rel_path=Path(self.path.name),
+                size=self.path.stat().st_size,
+                reader=self.path.read_bytes
+            )
+            return
+        
+        for root, dirs, files in os.walk(self.root):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ProjectScanner.DEFAULT_IGNORE_LIST]
+            for f in files:
+                p = Path(root) / f
+                yield FileEntry(    
+                    full_path=p,
+                    rel_path=p.relative_to(self.root),
+                    size=p.stat().st_size,
+                    reader=p.read_bytes
+                )
+
+class ZipSource:
+    def __init__(self, buffer):
+        self.zip = zipfile.ZipFile(buffer)
+
+    @classmethod
+    def from_path(cls, path):
+        # Open file is seekable
+        return cls(open(path, 'rb'))
+
+    @classmethod
+    def from_stream(cls, stream):
+        # Pipes aren't seekable, so we must read the whole thing into memory
+        # to allow ZipFile to jump to the Central Directory at the end.
+        seekable_buffer = io.BytesIO(stream.read())
+        return cls(seekable_buffer)
+
+    def walk(self) -> Generator[FileEntry, None, None]:
+        for info in self.zip.infolist():
+            if info.is_dir():
+                continue
+            
+            rel_path = Path(info.filename)
+            yield FileEntry(
+                full_path=rel_path,
+                rel_path=rel_path,
+                size=info.file_size,
+                reader=lambda name=info.filename: self.zip.read(name)
+            )
+
+
+class ProjectScanner:
+    DEFAULT_IGNORE_LIST = {
+        "node_modules", "bower_components", "vendor", 
+        "dist", "build", "out", "venv", "env", "target"
+    }
+
+    def __init__(self, registry, max_bytes: int = 200_000, extra_ignored_dirs: Optional[Set[str]] = None):
+        self.registry = registry
+        self.max_bytes = max_bytes
+        self.ignored_segments = self.DEFAULT_IGNORE_LIST
+        if extra_ignored_dirs:
+            self.ignored_segments.update(extra_ignored_dirs)
+    
+    def is_visible(self, entry: FileEntry) -> bool:
+        if entry.size > self.max_bytes:
+            return False
+        if not self.registry.has_handler(entry.rel_path.suffix):
+            return False
+        for part in entry.rel_path.parts:
+            if part.startswith(".") or part in self.ignored_segments:
+                return False
+        return True
+
+    def make_reader(self, path):
+        def reader():
+            with open(path, 'rb') as f:
+                content = f.read()
+            return content
+        return reader
+
+    def scan(self, source) -> Generator[Tuple[Path, Path, type, Callable], None, None]:
+        """
+        Yields (Full_Path, Relative_Path, Handler, Reader)
+        """
+        for entry in source.walk():
+            # Check visibility based on the relative path (to catch ignored folders)
+            if not self.is_visible(entry):
+                continue
+
+            handler_class = self.registry.get_handler_class(entry.rel_path.suffix)
+            if handler_class:
+                yield (
+                    entry.full_path,
+                    entry.rel_path,
+                    handler_class,
+                    entry.reader
+                )

radixcodemap-0.2.0/radixcodemap.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: radixcodemap
+Version: 0.2.0
+Summary: Summarize code repositories quickly and (soon) with multiple verbosity levels
+Home-page: https://github.com/jdotpy/radix-map
+Download-URL: https://github.com/jdotpy/radix-map/tarball/master
+Author: KJ
+Author-email: jdotpy@users.noreply.github.com
+Keywords: tools
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tree-sitter
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+
+
+# Radix: Configurable SourceCode summarizer
+
+Quickly summarize project structure with multiple verbosity levels (ok, so maybe there's only one option right now lol). More soon.
+
+
+## Installation
+---
+
+1. **Clone the repository:**
+   ```bash
+   git clone [https://github.com/jdotpy/radix-map.git](https://github.com/jdotpy/radix-map.git)
+   cd radix-map
+   pip install .
+   ```
+
+
+2. **Install Dependencies based on code you plan on using:**
+   ```bash
+   pip install tree-sitter-python
+   pip install tree-sitter-go
+   pip install tree-sitter-javascript
+   ```
+
+
+## Use
+---
+
+```bash
+radix map .
+```
+
+Example output:
+```bash
+#tests/test_integration.py
+└── ƒ get_test_pairs()
+
+#tests/snapshots/python_ex1.py
+├── ƒ global_helper()
+└── ○ class DataProcessor
+    ├── ƒ __init__(self, source: str)
+    ├── ƒ process(self)
+    └── ƒ _validate(self)
+
+#radix/scanner.py
+└── ○ class ProjectScanner
+    ├── ƒ __init__(self, registry, max_bytes: int = 200_000, extra_ignored_dirs: Optional[Set[str]] = None)
+    ├── ƒ is_visible(self, path: Path)
+    └── ƒ scan(self, target: str)
+```
+
+## Supported Languages
+
+
+| Language | Status | Package Requirement |
+|---|---|---|
+| Python	| ✅ functions & classes | tree-sitter-python | 
+| Go	| 🚧 | tree-sitter-go | 
+| JavaScript | 🚧 | tree-sitter-javascript | 
+
+```
+

radixcodemap-0.2.0/radixcodemap.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+setup.py
+radix/__init__.py
+radix/__main__.py
+radix/cli.py
+radix/core.py
+radix/report.py
+radix/scanner.py
+radix/handlers/__init__.py
+radix/handlers/base.py
+radix/handlers/handler_go.py
+radix/handlers/handler_js.py
+radix/handlers/handler_py.py
+radix/handlers/registry.py
+radix/handlers/tree_utils.py
+radixcodemap.egg-info/PKG-INFO
+radixcodemap.egg-info/SOURCES.txt
+radixcodemap.egg-info/dependency_links.txt
+radixcodemap.egg-info/entry_points.txt
+radixcodemap.egg-info/requires.txt
+radixcodemap.egg-info/top_level.txt
+tests/test_integration.py

radixcodemap-0.2.0/radixcodemap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

radixcodemap-0.2.0/radixcodemap.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+radix = radix.__main__:entrypoint

radixcodemap-0.2.0/radixcodemap.egg-info/requires.txt

@@ -0,0 +1,5 @@
+tree-sitter
+
+[dev]
+pytest
+twine

radixcodemap-0.2.0/radixcodemap.egg-info/top_level.txt

@@ -0,0 +1 @@
+radix

radixcodemap-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

radixcodemap-0.2.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup
+
+with open("README.md", "r") as f:
+    long_description = f.read()
+
+setup(
+    name = 'radixcodemap',
+    entry_points={
+        'console_scripts': [
+            'radix=radix.__main__:entrypoint',
+        ],
+    },
+    packages=['radix', 'radix.handlers'],
+    version = '0.2.0',
+    description = 'Summarize code repositories quickly and (soon) with multiple verbosity levels',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author = 'KJ',
+    author_email = 'jdotpy@users.noreply.github.com',
+    url = 'https://github.com/jdotpy/radix-map',
+    download_url = 'https://github.com/jdotpy/radix-map/tarball/master',
+    keywords = ['tools'],
+    install_requires=['tree-sitter'],
+    extras_require={
+        'dev': ['pytest', 'twine'],
+    },
+    classifiers = [
+        "Programming Language :: Python :: 3",
+    ],
+)

radixcodemap-0.2.0/tests/test_integration.py

@@ -0,0 +1,49 @@
+import pytest
+from pathlib import Path
+from radix.core import analyze_project
+from radix.report import display_txt
+from radix.handlers.registry import HandlerRegistry
+from .utils import MockScanner, MockSource
+
+import io
+
+# Setup paths
+TEST_DATA_DIR = Path(__file__).parent / "snapshots"
+SNAPSHOT_SUFFIX = '.snapshot'
+
+def get_test_pairs():
+    """
+    Finds all source files and pairs them with their corresponding .snapshot output.
+    Returns a list of tuples: (source_path, expected_output_path)
+    """
+    pairs = []
+    for snapshot_file in TEST_DATA_DIR.glob("*" + SNAPSHOT_SUFFIX):
+        # Matches 'python_ex1.py' with 'python_ex1.py.snapshot'
+        source_file = TEST_DATA_DIR / str(snapshot_file)[:-len(SNAPSHOT_SUFFIX)]
+        if source_file.exists():
+            pairs.append((source_file, snapshot_file))
+    return pairs
+
+@pytest.mark.parametrize("source_path, expected_path", get_test_pairs())
+def test_report_generation(source_path, expected_path):
+    source_code = source_path.read_bytes()
+    expected_output = expected_path.read_text()
+
+    virtual_path = source_path.name
+    handler = HandlerRegistry().get_handler_class(source_path.suffix)
+    
+    source = MockSource([])
+    scanner = MockScanner(None, [
+        (
+            virtual_path,
+            virtual_path,
+            handler,
+            lambda: source_code,
+        )
+    ])
+
+    test_output = io.StringIO()
+    reports_by_file = analyze_project(scanner, source)
+    display_txt(reports_by_file, test_output)
+    result = test_output.getvalue()
+    assert result == expected_output, f"Snapshot comparison failed for {source_path.name}"