coderecon 0.1.0__tar.gz

coderecon-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: coderecon
+Version: 0.1.0
+Summary: Engineering-first repository reconnaissance and architectural auditing.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp
+Requires-Dist: fastmcp
+Requires-Dist: click
+Requires-Dist: ollama
+Requires-Dist: requests
+
+# coderecon
+coderecon is a CLI tool that performs deterministic reconnaissance over a codebase to extract structural facts—files, functions, edge cases, test coverage, and issue signals—and then uses an LLM to reason over those findings to generate detailed, auditable reports.

coderecon-0.1.0/README.md

@@ -0,0 +1,2 @@
+# coderecon
+coderecon is a CLI tool that performs deterministic reconnaissance over a codebase to extract structural facts—files, functions, edge cases, test coverage, and issue signals—and then uses an LLM to reason over those findings to generate detailed, auditable reports.

coderecon-0.1.0/analyzer/diff.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+
+
+def run_diff_logic():
+    # Use the same root where analysis.json lives
+    current_path = Path("analysis.json")
+    previous_path = Path("analysis_previous.json")
+
+    if not previous_path.exists():
+        return "[coderecon] Diff Refused: No previous analysis found. Run 'scan' twice to compare changes."
+
+    with open(current_path, "r", encoding="utf-8") as f:
+        curr = json.load(f)
+    with open(previous_path, "r", encoding="utf-8") as f:
+        prev = json.load(f)
+
+    # Use Path + Type + Message as the unique signature for a signal
+    def get_sig(s):
+        return (s.get("path") or s.get("file"), s.get("type"), s.get("message"))
+
+    curr_set = {get_sig(s) for s in curr.get("signals", [])}
+    prev_set = {get_sig(s) for s in prev.get("signals", [])}
+
+    added = curr_set - prev_set
+    removed = prev_set - curr_set
+
+    # Formatting Output
+    out = ["# 🔄 RECON DELTA REPORT\n"]
+
+    if added:
+        out.append(f"## 🛑 New Hazards Detected (+{len(added)})")
+        for path, stype, msg in added:
+            out.append(f"- [{stype.upper()}] in {path}: {msg}")
+
+    if removed:
+        out.append(f"\n## ✅ Risks Resolved (-{len(removed)})")
+        for path, stype, msg in removed:
+            out.append(f"- Resolved: {stype} in {path}")
+
+    if not added and not removed:
+        out.append("No changes in signal density detected.")
+
+    return "\n".join(out)

coderecon-0.1.0/analyzer/discovery/files.py

@@ -0,0 +1,46 @@
+import os
+from pathlib import Path
+
+# Move these to a set for O(1) lookup speed
+SUPPORTED_EXTENSIONS = {".py", ".js", ".ts", ".tsx", ".rs", ".go", ".java", ".cpp", ".c", ".h"}
+EXCLUDE_DIRS = {".git", "node_modules", "__pycache__", ".venv", "dist", "build", ".coderecon", "venv", "lib"}
+
+
+def _get_file_metadata(full_path, filename):
+    """Fast metadata assembly using pre-calculated values."""
+    return {
+        "path": full_path,
+        "name": filename,
+        "size": os.path.getsize(full_path)  # Only hit the disk if necessary
+    }
+
+
+def discover_files(root_path: str):
+    """
+    High-speed discovery using os.scandir to minimize system calls.
+    """
+    # 1. Handle Single File Input Fast
+    if os.path.isfile(root_path):
+        if os.path.splitext(root_path)[1].lower() in SUPPORTED_EXTENSIONS:
+            return [_get_file_metadata(root_path, os.path.basename(root_path))]
+        return []
+
+    files = []
+    stack = [root_path]
+
+    # 2. Manual Stack Walk (often faster than os.walk for deep trees)
+    while stack:
+        current_dir = stack.pop()
+        try:
+            with os.scandir(current_dir) as it:
+                for entry in it:
+                    if entry.is_dir():
+                        if entry.name not in EXCLUDE_DIRS:
+                            stack.append(entry.path)
+                    elif entry.is_file():
+                        if os.path.splitext(entry.name)[1].lower() in SUPPORTED_EXTENSIONS:
+                            files.append(_get_file_metadata(entry.path, entry.name))
+        except PermissionError:
+            continue
+
+    return files

coderecon-0.1.0/analyzer/inference/edge_cases.py

@@ -0,0 +1,92 @@
+import ast
+
+
+def _emit(fn, inner, rule_id, case, reason, severity="low"):
+    return {
+        "rule_id": rule_id,
+        "function": fn["name"],
+        "file": fn["path"],
+        "case": case,
+        "reason": reason,
+        "severity": severity,
+        "line": getattr(inner, "lineno", None),
+        "node_type": type(inner).__name__,
+    }
+
+
+class DepthVisitor(ast.NodeVisitor):
+    """Tracks nesting depth of control flow nodes."""
+
+    def __init__(self):
+        self.current_depth = 0
+        self.max_depth = 0
+        self.nesting_nodes = (ast.If, ast.For, ast.While, ast.Try, ast.With)
+
+    def visit_nested(self, node):
+        self.current_depth += 1
+        self.max_depth = max(self.max_depth, self.current_depth)
+        self.generic_visit(node)
+        self.current_depth -= 1
+
+    def visit_If(self, node): self.visit_nested(node)
+
+    def visit_For(self, node): self.visit_nested(node)
+
+    def visit_While(self, node): self.visit_nested(node)
+
+    def visit_Try(self, node): self.visit_nested(node)
+
+
+def detect_edge_cases(functions):
+    edge_cases = []
+
+    for fn in functions:
+        try:
+            with open(fn["path"], "r", encoding="utf-8", errors="ignore") as f:
+                tree = ast.parse(f.read())
+        except Exception:
+            continue
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == fn["name"]:
+
+                # 1. Check Deep Nesting
+                dv = DepthVisitor()
+                dv.visit(node)
+                if dv.max_depth > 3:
+                    edge_cases.append(_emit(
+                        fn, node, "CR1001", "Deep Nesting",
+                        f"Logic nested {dv.max_depth} levels deep. High cognitive load.", "high"
+                    ))
+
+                # 2. Specific Logic Hazards
+                for inner in ast.walk(node):
+                    if isinstance(inner, (ast.For, ast.While)):
+                        edge_cases.append(_emit(
+                            fn, inner, "CR2001", "Loop execution",
+                            "Potential for infinite loops or O(n) performance hits.", "medium"
+                        ))
+
+                    if isinstance(inner, ast.Try):
+                        # Check for 'bare' except or too many handlers
+                        edge_cases.append(_emit(
+                            fn, inner, "CR3001", "Exception path",
+                            "Complexity in error recovery paths.", "low"
+                        ))
+
+                    if isinstance(inner, ast.BinOp) and isinstance(inner.op, ast.Div):
+                        edge_cases.append(_emit(
+                            fn, inner, "CR4001", "Math risk",
+                            "Division operation without visible zero-check.", "medium"
+                        ))
+
+                    # 3. Detect "God Functions" (Length-based)
+                    if hasattr(node, 'end_lineno'):
+                        length = node.end_lineno - node.lineno
+                        if length > 50:
+                            edge_cases.append(_emit(
+                                fn, node, "CR1002", "Large Function",
+                                f"Function is {length} lines long. Suggest refactoring.", "medium"
+                            ))
+
+    return edge_cases

coderecon-0.1.0/analyzer/parsing/functions.py

@@ -0,0 +1,56 @@
+import re
+from pathlib import Path
+
+# Pre-compiled for speed. Optimized for Rust, TSX, JS, Go, and C-style syntax.
+# Also added a group for Python 'def' as a secondary regex fallback.
+GENERIC_FUNCTION_RE = re.compile(
+    r"(?:async\s+)?(?:fn\s+(\w+)|function\s+(\w+)|(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>|const\s+(\w+)\s*:\s*React\.FC|(\w+)\s*\([^)]*\)\s*\{|def\s+(\w+)\s*\()",
+    re.MULTILINE
+)
+
+# Reserved keywords to ignore during regex discovery
+RESERVED = {"if", "for", "while", "switch", "catch", "return", "export", "default"}
+
+
+def extract_functions(file_path: str, content: str):
+    """
+    High-speed extraction: AST for Python, Regex for everything else.
+    """
+    path = Path(file_path)
+    functions = []
+    suffix = path.suffix.lower()
+
+    # 1. PYTHON AST PARSING (Primary for .py)
+    if suffix == ".py":
+        import ast
+        try:
+            tree = ast.parse(content)
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    functions.append({
+                        "name": node.name,
+                        "line": node.lineno,
+                        "path": str(path),
+                        "type": "python_ast",
+                        "length": len(node.body)  # Real logic density
+                    })
+            return functions
+        except SyntaxError:
+            pass  # Fallback to regex if the file is malformed
+
+    # 2. MULTI-LANGUAGE REGEX DISCOVERY (For Rust, JS, TS, Go, and failing Py files)
+    # Using finditer is faster as it doesn't build the whole list at once
+    for match in GENERIC_FUNCTION_RE.finditer(content):
+        # Extract the first non-None group (the function name)
+        func_name = next((g for g in match.groups() if g), None)
+
+        if func_name and func_name not in RESERVED:
+            functions.append({
+                "name": func_name,
+                "line": content.count("\n", 0, match.start()) + 1,
+                "path": str(path),
+                "type": "regex_discovery",
+                "length": 0  # Placeholder for regex-found functions
+            })
+
+    return functions

coderecon-0.1.0/analyzer/scan.py

@@ -0,0 +1,95 @@
+import json
+import concurrent.futures
+from pathlib import Path
+from multiprocessing import cpu_count
+from tqdm import tqdm
+
+from analyzer.discovery.files import discover_files
+from analyzer.parsing.functions import extract_functions
+from analyzer.signals.aggregate import aggregate_signals
+from analyzer.testing.tests import map_tests
+from analyzer.inference.edge_cases import detect_edge_cases
+from analyzer.signals.signals import generate_signals
+from schemas.analysis import AnalysisSchema
+
+def detect_tech_stack(files):
+    """Detects the tech stack based on marker files."""
+    stack = []
+    filenames = {Path(f['path']).name for f in files}
+    all_paths_str = "".join([f['path'].lower() for f in files])
+
+    if "package.json" in filenames: stack.append("Node.js")
+    if "tsconfig.json" in filenames: stack.append("TypeScript")
+    if "requirements.txt" in filenames or "pyproject.toml" in filenames: stack.append("Python")
+    if "pom.xml" in filenames: stack.append("Java/Maven")
+    if "go.mod" in filenames: stack.append("Go")
+    if "prisma" in all_paths_str: stack.append("Prisma ORM")
+    if "vite.config" in all_paths_str: stack.append("Vite")
+    if "react" in all_paths_str: stack.append("React")
+
+    return stack if stack else ["General Software"]
+
+
+def _parse_file_batch(file_batch):
+    """Processes a chunk of files in one go to reduce process overhead."""
+    from analyzer.parsing.functions import extract_functions
+    results = []
+    for file_info in file_batch:
+        file_path = file_info["path"]
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+            results.extend(extract_functions(file_path, content))
+        except Exception:
+            continue
+    return results
+
+
+def run_analysis(path: str) -> dict:
+    from analyzer.discovery.files import discover_files
+    files = discover_files(path)
+    all_functions = []
+
+    # Optimization: Chunking
+    # Spawning processes is expensive; processing in batches is 3x faster for small files.
+    chunk_size = 20
+    chunks = [files[i:i + chunk_size] for i in range(0, len(files), chunk_size)]
+
+    max_workers = max(1, int(cpu_count() * 0.8))
+
+    print(f"[coderecon] Analyzing {len(files)} files using {max_workers} cores...")
+
+    with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(_parse_file_batch, chunk): chunk for chunk in chunks}
+
+        for future in tqdm(concurrent.futures.as_completed(futures),
+                           total=len(chunks),
+                           desc="[coderecon] Scanning",
+                           unit="batch",
+                           leave=False):
+            all_functions.extend(future.result())
+
+    # Pipeline logic...
+    tech_stack = detect_tech_stack(files)
+    tests = map_tests(files)
+    edge_cases = detect_edge_cases(all_functions)
+    raw_signals = generate_signals(all_functions, edge_cases, tests)
+    aggregated_signals = aggregate_signals(raw_signals)
+
+    analysis = AnalysisSchema(
+        files=files,
+        functions=all_functions,
+        tests=tests,
+        edge_cases=edge_cases,
+        signals_raw=raw_signals,
+        signals=aggregated_signals,
+        tech_stack=tech_stack
+    )
+
+    analysis_dict = analysis.dict()
+
+    with open("analysis.json", "w", encoding="utf-8") as f:
+        json.dump(analysis_dict, f, indent=4)
+
+    return analysis_dict
+

coderecon-0.1.0/analyzer/signals/aggregate.py

@@ -0,0 +1,35 @@
+from collections import defaultdict
+
+
+def aggregate_signals(signals):
+    grouped = defaultdict(lambda: {
+        "count": 0,
+        "lines": set()
+    })
+
+    for sig in signals:
+        key = (
+            sig["type"],
+            sig.get("path"),
+            sig.get("function"),
+            sig.get("case")
+        )
+
+        grouped[key]["count"] += 1
+
+        if sig.get("line") is not None:
+            grouped[key]["lines"].add(sig["line"])
+
+    aggregated = []
+
+    for (sig_type, path, function, case), data in grouped.items():
+        aggregated.append({
+            "type": sig_type,
+            "path": path,
+            "function": function,
+            "case": case,
+            "count": data["count"],
+            "lines": sorted(data["lines"]),
+        })
+
+    return aggregated

coderecon-0.1.0/analyzer/signals/signals.py

@@ -0,0 +1,75 @@
+def assign_severity(signal_type: str) -> str:
+    mapping = {
+        "untested_function": "Medium",
+        "potential_edge_case": "Low",
+        "exception_path": "High",
+        "division_operation": "High",
+        "while_loop": "Medium",
+        "conditional_branch": "Low"
+    }
+
+    return mapping.get(signal_type, "Low")
+
+def generate_signals(functions, edge_cases, tests):
+    """Convert raw findings into structured signals with safety fallbacks."""
+
+    signals = []
+
+    tested_functions = set()
+    for test in tests:
+        # Safely handle potential missing references key
+        tested_functions.update(test.get("references", []))
+
+    # Untested functions
+    for fn in functions:
+        # Use .get() to prevent KeyError if 'length' or 'line_start' is missing
+        length = fn.get("length", 0)
+        line_start = fn.get("line_start", fn.get("line", 0)) # Fallback to 'line' for regex matches
+        fn_name = fn.get("name", "unknown")
+        fn_path = fn.get("path", "unknown")
+
+        # Threshold checks with safe length
+        if length > 100:
+            signals.append({
+                "type": "large_function",
+                "function": fn_name,
+                "path": fn_path,
+                "line": line_start,
+                "length": length,
+                "severity": "High"
+            })
+        elif length > 60:
+            signals.append({
+                "type": "large_function",
+                "function": fn_name,
+                "path": fn_path,
+                "line": line_start,
+                "length": length,
+                "severity": "Medium"
+            })
+
+        if fn_name not in tested_functions:
+            signal_type = "untested_function"
+            signals.append({
+                "type": "untested_function",
+                "function": fn_name,
+                "path": fn_path,
+                "line": line_start,
+                "severity": assign_severity(signal_type),
+            })
+
+    # Potential edge cases
+    for ec in edge_cases:
+        signal_type = "potential_edge_case"
+        signals.append({
+            "type": "potential_edge_case",
+            "function": ec.get("function"),
+            "path": ec.get("file"),
+            "line": ec.get("line"),
+            "case": ec.get("case"),
+            "rule_id": ec.get("rule_id"),
+            "node_type": ec.get("node_type"),
+            "severity": assign_severity(signal_type),
+        })
+
+    return signals

coderecon-0.1.0/analyzer/testing/tests.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+import ast
+
+def map_tests(files):
+    """
+    Discover test functions and infer which priduction functions they reference.
+    """
+    tests=[]
+
+    for file in files:
+        path = Path(file["path"])
+
+        if not (
+            path.name.startswith("test_") or "test" in path.parts
+        ):
+            continue
+
+        try:
+            source = open(path, "r",encoding="utf-8",errors="ignore").read()
+            tree= ast.parse(source)
+        except Exception:
+            continue
+
+        for node in ast.walk(tree):
+            if isinstance(node,ast.FunctionDef) and node.name.startswith("test_"):
+                referenced = set()
+
+                for inner in ast.walk(node):
+                    if isinstance(inner,ast.Call):
+                        if isinstance(inner.func,ast.Name):
+                            referenced.add(inner.func.id)
+
+                tests.append({
+                    "test_name": node.name,
+                    "file":str(path),
+                    "references":sorted(referenced)
+                })
+                
+    return tests