codebase-brain 0.1.0__py3-none-any.whl

brain_cli.py

@@ -0,0 +1,331 @@
+import threading
+import subprocess
+import stat
+import argparse
+import os
+import sys
+from brain_parser.codebase_walker import walk_codebase, save_brain
+from brain_parser.file_watcher import start_watching
+from brain_parser.graph_builder import build_graph, visualize_interactive
+from brain_parser.query_engine import ask_brain
+import io
+
+# Force UTF-8 output regardless of parent process encoding
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+if sys.stderr.encoding != 'utf-8':
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+import argparse
+import os
+# ... rest of your existing imports
+
+def cmd_start(path):
+    print(" Codebase Brain starting...")
+    print(f" Reading codebase at: {path}")
+    brain = walk_codebase(path)
+    save_brain(brain)
+    print(f"Brain built: {len(brain)} files analyzed")
+
+    print(" Building dependency graph...")
+    G = build_graph(brain)
+    visualize_interactive(G)
+    print("Graph ready: brain_map.html")
+
+    print("\n Scanning for bugs...")
+    from brain_parser.bug_detector import run_all_detectors
+    bugs = run_all_detectors(brain, G)
+    if bugs:
+        print(f"\n Found {len(bugs)} potential bugs:\n")
+        for bug in bugs:
+            print(f"  [{bug['severity']}] {bug['type'].replace('_', ' ').upper()}")
+            print(f"  {bug['message']}")
+            print(f"  Fix: {bug['fix']}\n")
+    else:
+        print(" No bugs detected. Codebase looks clean.\n")
+
+    print("Starting live file watcher...")
+    watcher_thread = threading.Thread(
+        target=start_watching,
+        args=(path,),
+        daemon=True
+    )
+    watcher_thread.start()
+    print("Watching for changes...")
+
+    print("\n Brain is live. Ask anything.")
+    print("Type 'exit' to stop query mode.")
+    print("Press CTRL+C anytime to shut down completely.\n")
+    while True:
+        question = input("Ask your brain: ")
+        if question == "exit":
+            print("Brain shutting down.")
+            break
+        answer = ask_brain(question)
+        print(f"\nBrain: {answer}\n")
+
+
+def cmd_impact(filepath=None, staged=False, block=False):
+    from brain_parser.codebase_walker import load_brain
+    from brain_parser.graph_builder import build_graph, get_impact, calculate_risk
+
+    brain = load_brain()
+    if not brain:
+        print("No brain found. Run 'brain start' first.")
+        return
+
+    G = build_graph(brain)
+    risk = calculate_risk(G)
+
+    root = os.path.abspath('.').replace('\\', '/')
+    def clean(path):
+        return path.replace('\\', '/').replace(root + '/', '')
+
+    if staged:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "--cached"],
+            capture_output=True, text=True
+        )
+        staged_files = [f.strip() for f in result.stdout.strip().split("\n") if f.strip()]
+
+        if not staged_files:
+            print("No staged files found.")
+            return
+
+        print(f"\n Staged files: {', '.join(staged_files)}\n")
+
+        high_risk_found = False
+        for f in staged_files:
+            print(f"{'='*50}")
+            result_data = _print_impact(G, risk, f, clean)
+            if result_data and result_data.get('risk') == 'HIGH':
+                high_risk_found = True
+
+        if block and high_risk_found:
+            print("\n" + "=" * 50)
+            print("BRAIN WARNING: HIGH RISK commit detected.")
+            print("This change affects critical files.")
+            print("Production incidents have originated from files like these.")
+            print("\nType 'yes' to commit anyway, anything else to abort: ", end='', flush=True)
+            try:
+                # Windows: CON is the console device
+                # Unix: /dev/tty is the terminal
+                import platform
+                if platform.system() == 'Windows':
+                    with open('CON', 'r') as tty:
+                        confirm = tty.readline().strip().lower()
+                else:
+                    with open('/dev/tty', 'r') as tty:
+                        confirm = tty.readline().strip().lower()
+            except:
+                try:
+                    confirm = input().strip().lower()
+                except EOFError:
+                    confirm = 'yes'
+            if confirm != 'yes':
+                print("\nCommit blocked by Codebase Brain.")
+                sys.exit(1)
+            else:
+                print("Override confirmed. Committing anyway.")
+        return
+
+    if not filepath:
+        print("Provide --file or --staged.")
+        return
+
+    _print_impact(G, risk, filepath, clean)
+
+def _print_impact(G, risk, filepath, clean):
+    from brain_parser.graph_builder import get_impact
+
+    result = get_impact(G, filepath)
+
+    if not result:
+        print(f"File not found in brain: {filepath}")
+        return None
+
+    file_risk = risk.get(result['target'], 'LOW')
+
+    print(f"\n Change Impact: {filepath}")
+    print(f"   Risk Level: {file_risk}\n")
+    print(f"DIRECT IMPACT ({len(result['direct'])} files):")
+    for f in result['direct']:
+        print(f"  → {clean(f)}")
+    print(f"\nINDIRECT IMPACT ({len(result['indirect'])} files):")
+    for f in result['indirect']:
+        print(f"  → {clean(f)}")
+    print(f"\nTotal files affected: {result['total_affected']}\n")
+
+    return {'risk': file_risk, 'total': result['total_affected']}
+
+def install_hook(repo_path="."):
+    hook_dir = os.path.join(repo_path, ".git", "hooks")
+    hook_path = os.path.join(hook_dir, "pre-commit")
+
+    if not os.path.exists(hook_dir):
+        print("Not a git repository. Run this inside your project folder.")
+        return
+
+    hook_script = """#!/bin/sh
+    # Codebase Brain — Pre-commit Impact Check
+    # https://github.com/guruvarpatel-ai/codebase-brain
+
+    STAGED=$(git diff --name-only --cached)
+
+    if [ -z "$STAGED" ]; then
+      exit 0
+    fi
+
+    echo ""
+    echo "Codebase Brain — Checking blast radius..."
+    echo ""
+
+    brain impact --staged --block
+    EXIT_CODE=$?
+
+    echo ""
+    echo "Powered by Codebase Brain"
+    echo ""
+
+    exit $EXIT_CODE
+    """
+
+    with open(hook_path, "w", newline='\n') as f:  # newline='\n' fixes Windows CRLF
+        f.write(hook_script)
+
+    os.chmod(hook_path, os.stat(hook_path).st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    print(f"Brain hook installed at {hook_path}")
+    print("Every commit now shows blast radius automatically.")
+
+
+def cmd_init():
+    print("Initializing Codebase Brain...\n")
+    print("Choose your LLM provider:")
+    print("  1. Groq        — Free, fast. llama-3.3-70b (recommended to start)")
+    print("  2. OpenAI      — Reliable, trusted by enterprises. gpt-4o-mini")
+    print("  3. Anthropic   — Best reasoning. claude-3-5-haiku (your code stays private)")
+    print("  4. Google      — Free tier available. gemini-1.5-flash")
+    print("  5. Ollama      — 100% local, no API key, no data leaves your machine")
+    print("")
+    choice = input("Enter 1-5 (default 1): ").strip() or "1"
+
+    providers = {
+        "1": {
+            "name": "groq",
+            "key_prompt": "Groq API key (free at console.groq.com): ",
+            "models": ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768"],
+            "default_model": "llama-3.3-70b-versatile"
+        },
+        "2": {
+            "name": "openai",
+            "key_prompt": "OpenAI API key (platform.openai.com): ",
+            "models": ["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"],
+            "default_model": "gpt-4o-mini"
+        },
+        "3": {
+            "name": "anthropic",
+            "key_prompt": "Anthropic API key (console.anthropic.com): ",
+            "models": ["claude-3-5-haiku-20241022", "claude-3-5-sonnet-20241022"],
+            "default_model": "claude-3-5-haiku-20241022"
+        },
+        "4": {
+            "name": "google",
+            "key_prompt": "Google API key (aistudio.google.com): ",
+            "models": ["gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash"],
+            "default_model": "gemini-1.5-flash"
+        },
+        "5": {
+            "name": "ollama",
+            "key_prompt": None,  # no key needed
+            "models": ["llama3.2", "codellama", "deepseek-coder"],
+            "default_model": "llama3.2"
+        }
+    }
+
+    if choice not in providers:
+        choice = "1"
+
+    provider = providers[choice]
+
+    # get API key
+    if provider["key_prompt"]:
+        api_key = input(provider["key_prompt"]).strip()
+    else:
+        api_key = "ollama"
+        print("Ollama selected — make sure Ollama is running at http://localhost:11434")
+
+    # pick model
+    print(f"\nAvailable models for {provider['name']}:")
+    for i, m in enumerate(provider["models"], 1):
+        default_tag = " (default)" if m == provider["default_model"] else ""
+        print(f"  {i}. {m}{default_tag}")
+
+    model_choice = input("\nEnter model number (press Enter for default): ").strip()
+    if model_choice and model_choice.isdigit():
+        idx = int(model_choice) - 1
+        if 0 <= idx < len(provider["models"]):
+            model = provider["models"][idx]
+        else:
+            model = provider["default_model"]
+    else:
+        model = provider["default_model"]
+
+    with open(".env", "w") as f:
+        f.write(f"LLM_PROVIDER={provider['name']}\n")
+        f.write(f"LLM_API_KEY={api_key}\n")
+        f.write(f"LLM_MODEL={model}\n")
+        # backwards compatibility
+        f.write(f"GROQ_API_KEY={api_key}\n")
+        f.write(f"GROQ_MODEL={model}\n")
+
+    print(f"\nBrain initialized with {provider['name']} — {model}")
+    print("Run 'brain start' to begin.\n")
+
+def cmd_rootcause(error_text=None):
+    from brain_parser.root_cause import find_root_cause
+
+    if not error_text:
+        print("Paste your error/stacktrace below.")
+        print("Press Enter twice when done.\n")
+        lines = []
+        while True:
+            line = input()
+            if line == "" and lines and lines[-1] == "":
+                break
+            lines.append(line)
+        error_text = "\n".join(lines)
+
+    print(find_root_cause(error_text))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Codebase Brain - AI layer over your codebase"
+    )
+    # ← "install-hook" added here
+    parser.add_argument("--path", default=".", help="Path to codebase")
+    parser.add_argument("--file", default="", help="File to analyze impact")
+    parser.add_argument("--staged", action="store_true", help="Analyze all staged files")
+    parser.add_argument("command", choices=["start", "init", "impact", "install-hook", "rootcause"])
+    parser.add_argument("--error", default="", help="Stacktrace to analyze")
+    parser.add_argument("--block", action="store_true", help="Block HIGH risk commits")
+    # ← new
+    args = parser.parse_args()
+
+
+    if args.command == "init":
+        cmd_init()
+    elif args.command == "rootcause":
+        cmd_rootcause(args.error or None)
+    elif args.command == "start":
+        cmd_start(args.path)
+    elif args.command == "impact":
+        cmd_impact(filepath=args.file or None, staged=args.staged, block=args.block)
+    elif args.command == "install-hook":
+        install_hook()
+
+
+
+if __name__ == "__main__":
+    main()

brain_parser/ast_parser.py

@@ -0,0 +1,62 @@
+import ast
+import os
+
+def parse_file(filepath):
+    #hello world
+    with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+        source=f.read()
+    try:
+       tree=ast.parse(source)
+       return tree
+    except SyntaxError as e:
+        print(f"Syntax error in {filepath}: {e}")
+        return None
+
+def extract_imports(tree):
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({
+                    "name": alias.name,
+                    "type": "direct"
+                })
+        if isinstance(node, ast.ImportFrom):
+            imports.append({
+                "module": node.module or "unknown",
+                "type": "from"
+            })
+    return imports
+
+def extract_classes_and_functions(tree):
+    classes = []
+    functions = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            classes.append({
+                "name": node.name,
+                "line": node.lineno
+            })
+        if isinstance(node, ast.FunctionDef):
+            functions.append({
+                "name": node.name,
+                "args": [arg.id if hasattr(arg, 'id') else arg.arg
+                         for arg in node.args.args],
+                "line": node.lineno
+            })
+    return {"classes": classes, "functions": functions}
+
+
+def analyze_file(filepath):
+    tree = parse_file(filepath)
+    if tree is None:
+        return None
+
+    return {
+        "file":filepath ,
+        "imports":extract_imports(tree),
+        "classes_and_functions":extract_classes_and_functions(tree)
+    }
+if __name__ == "__main__":
+    result = analyze_file("utils.py")
+    print(result)

brain_parser/bug_detector.py

@@ -0,0 +1,212 @@
+import networkx as nx
+import os
+from brain_parser.codebase_walker import load_brain
+from brain_parser.graph_builder import build_graph
+
+
+
+def detect_circular_dependencies(brain, temp_path=None):
+    G = build_graph(brain)
+    bugs = []
+
+    def clean(path):
+        p = path.replace('\\', '/')
+        idx = p.find('/temp/')
+        if idx != -1:
+            after_temp = p[idx + 6:]
+            parts = after_temp.split('/', 1)
+            if len(parts) > 1:
+                return parts[1]
+            return parts[0]
+        # fallback — just filename
+        return p.split('/')[-1]
+
+    try:
+        cycles = list(nx.simple_cycles(G))
+        for cycle in cycles:
+            clean_cycle = [clean(f) for f in cycle]
+            # format as numbered list not one long line
+            chain = '\n  '.join([f"{i+1}. {f}" for i, f in enumerate(clean_cycle)])
+            chain += f"\n  → back to {clean_cycle[0]}"
+            bugs.append({
+                'type': 'circular_dependency',
+                'severity': 'HIGH',
+                'files': clean_cycle,
+                'message': f"Circular dependency ({len(cycle)} files):\n  {chain}",
+                'fix': 'Extract shared logic into a separate file that both can import from.'
+            })
+    except Exception as e:
+        print(f"Cycle detection error: {e}")
+
+    return bugs
+def detect_unused_imports(brain):
+    # compare imports list against function/class names used in file
+    bugs = []
+
+    for filepath, data in brain.items():
+        # skip non-python files until we support body reading
+        if data.get('language') != 'python':
+            continue
+        imports = data.get('imports', [])
+        functions = [f['name'].lower() for f in data.get('functions', [])]
+        classes = [c['name'].lower() for c in data.get('classes', [])]
+        summary = data.get('summary', '').lower()
+
+        for imp in imports:
+            imp_name = imp.get('name', '').lower()
+            # extract just the module name
+            imp_name = imp.get('name', '').lower()
+
+            # handle "from x import y" → extract x
+            if imp_name.startswith('from '):
+                module = imp_name.split('from ')[1].split(' import')[0].strip()
+            # handle "import x" → extract x
+            elif imp_name.startswith('import '):
+                module = imp_name.replace('import ', '').split(' as ')[0].strip()
+            else:
+                continue
+
+            if not module:
+                continue
+
+            # check if module appears anywhere in file context
+            used = (
+                    any(module in f for f in functions) or
+                    any(module in c for c in classes) or
+                    module in summary
+            )
+
+            if not used:
+                bugs.append({
+                    'type': 'unused_import',
+                    'severity': 'LOW',
+                    'file': filepath,
+                    'import': imp.get('name', ''),
+                    'line': imp.get('line', 0),
+                    'message': f"Possibly unused import '{module}' in {filepath}",
+                    'fix': f"Remove 'import {module}' if not needed."
+                })
+
+    return bugs
+
+def detect_bugs_with_llm(brain, G):
+    # calculate risk → filter HIGH risk files → send to Groq → find bugs
+    from brain_parser.graph_builder import calculate_risk
+    from groq import Groq
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    risk = calculate_risk(G)
+    high_risk_files = [f for f, r in risk.items() if r == "HIGH"]
+
+    if not high_risk_files:
+        return []
+
+    client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+    bugs = []
+
+    for filepath in high_risk_files:
+        data = brain.get(filepath)
+        if not data:
+            continue
+
+        summary = data.get('summary', '')
+        functions = [f['name'] for f in data.get('functions', [])]
+        imports = [i['name'] for i in data.get('imports', [])]
+
+        prompt = f"""You are a senior code reviewer. Analyze this file for bugs.
+
+        File: {filepath}
+        Summary: {summary}
+        Functions: {functions}
+        Imports: {imports}
+
+        Rules:
+        - Only report bugs you can prove from the information given
+        - Every bug must reference a specific function name from the functions list
+        - Do not invent bugs that are not evident from the summary
+        - If no provable bugs exist respond with exactly: NO BUGS
+
+        Format each bug exactly like this:
+        BUG: [function_name] description of specific problem
+        FIX: specific code change needed"""
+
+        try:
+            response = client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=300,
+                temperature = 0
+            )
+            result = response.choices[0].message.content.strip()
+
+            if "NO BUGS" not in result:
+                bugs.append({
+                    'type': 'llm_detected_bug',
+                    'severity': 'HIGH',
+                    'file': filepath,
+                    'message': result,
+                    'fix': 'See details above'
+                })
+        except Exception as e:
+            print(f"LLM bug detection error for {filepath}: {e}")
+
+    return bugs
+
+
+DANGEROUS_IMPORTS = {
+    'pickle': 'Deserialization vulnerability - pickle can execute arbitrary code',
+    'subprocess': 'Potential command injection if user input is passed to subprocess',
+    'eval': 'Code injection risk - eval executes arbitrary Python code',
+    'exec': 'Code injection risk - exec executes arbitrary Python code',
+    'hashlib.md5': 'Weak hashing - MD5 is cryptographically broken for security use',
+    'tempfile': 'Insecure temporary file handling possible',
+    'yaml.load': 'Use yaml.safe_load instead - yaml.load can execute arbitrary code',
+}
+
+
+def detect_security_antipatterns(brain):
+    # check imports against known dangerous patterns
+    bugs = []
+
+    for filepath, data in brain.items():
+        if data.get('language') != 'python':
+            continue
+
+        for imp in data.get('imports', []):
+            imp_name = imp.get('name', '').lower()
+
+            for dangerous, reason in DANGEROUS_IMPORTS.items():
+                if dangerous in imp_name:
+                    bugs.append({
+                        'type': 'security_antipattern',
+                        'severity': 'HIGH',
+                        'file': filepath,
+                        'import': imp.get('name', ''),
+                        'line': imp.get('line', 0),
+                        'message': f"Security risk in {filepath} line {imp.get('line', 0)}: {reason}",
+                        'fix': f"Review usage of '{dangerous}' and ensure it never processes untrusted input."
+                    })
+
+    return bugs
+
+
+def run_all_detectors(brain=None, G=None, temp_path=None):
+    if not brain:
+        brain = load_brain()
+    if not brain:
+        return []
+
+    bugs = []
+    bugs.extend(detect_circular_dependencies(brain, temp_path))
+    bugs.extend(detect_security_antipatterns(brain))
+
+    return bugs
+
+if __name__ == "__main__":
+    bugs = run_all_detectors()
+    print(f"\nFound {len(bugs)} potential bugs:\n")
+    for bug in bugs:
+        print(f"[{bug['severity']}] {bug['type']}")
+        print(f"  {bug['message']}")
+        print(f"  Fix: {bug['fix']}\n")