codebase-brain 0.1.0__py3-none-any.whl

brain_parser/root_cause.py

@@ -0,0 +1,162 @@
+import re
+import os
+from brain_parser.codebase_walker import load_brain
+from brain_parser.graph_builder import build_graph, calculate_risk
+
+
+# Patterns for each language stacktrace format
+TRACE_PATTERNS = [
+    # JavaScript/Node: at functionName (file.js:34:12)
+    r'at\s+(?:\S+\s+)?\((.+?\.(?:js|ts)):(\d+)',
+    # Python: File "file.py", line 34
+    r'File\s+"(.+?\.py)",\s+line\s+(\d+)',
+    # Java: at com.example.Class(File.java:34)
+    r'at\s+[\w.]+\((\w+\.java):(\d+)\)',
+]
+
+
+def extract_frames(stacktrace):
+    """Extract (filepath, line_number) pairs from any stacktrace."""
+    frames = []
+    for pattern in TRACE_PATTERNS:
+        matches = re.findall(pattern, stacktrace)
+        for filepath, line in matches:
+            frames.append({
+                'file': filepath.strip(),
+                'line': int(line)
+            })
+    # deduplicate preserving order
+    seen = set()
+    unique = []
+    for f in frames:
+        key = (f['file'], f['line'])
+        if key not in seen:
+            seen.add(key)
+            unique.append(f)
+    return unique
+
+
+def match_frame_to_graph(frame_file, G):
+    """Match a short filename from stacktrace to full path in graph."""
+    frame_norm = frame_file.replace('\\', '/')
+    candidates = []
+
+    for node in G.nodes():
+        node_norm = node.replace('\\', '/')
+        # exact suffix match — auth/middleware.js matches ./src/auth/middleware.js
+        if node_norm.endswith(frame_norm):
+            candidates.append(node)
+
+    if not candidates:
+        return None
+    # prefer shortest path — most specific match
+    return min(candidates, key=len)
+
+
+def find_root_cause(stacktrace):
+    """Main function — paste stacktrace, get root cause analysis."""
+    brain = load_brain()
+    if not brain:
+        return {"error": "No brain found. Run 'brain start' first."}
+
+    G = build_graph(brain)
+    risk = calculate_risk(G)
+
+    frames = extract_frames(stacktrace)
+    if not frames:
+        return {"error": "No file references found in stacktrace. Paste the full error including file paths."}
+
+    results = []
+    for frame in frames:
+        matched_node = match_frame_to_graph(frame['file'], G)
+        if not matched_node:
+            continue
+
+        # walk backwards — what files feed into this file
+        import networkx as nx
+        predecessors = list(G.predecessors(matched_node))
+        ancestors = list(nx.ancestors(G, matched_node))
+
+        # find functions in this file near the error line
+        file_data = brain.get(matched_node, {})
+        functions = file_data.get('functions', [])
+        nearby_functions = [
+            f for f in functions
+            if abs(f['line'] - frame['line']) <= 10
+        ]
+
+        results.append({
+            'file': matched_node,
+            'line': frame['line'],
+            'risk': risk.get(matched_node, 'LOW'),
+            'nearby_functions': nearby_functions,
+            'direct_causes': predecessors,
+            'all_causes': ancestors,
+        })
+
+    if not results:
+        return {"error": "Files in stacktrace not found in brain. Run 'brain start' to rebuild."}
+
+    return _format_result(results, risk, stacktrace)
+
+
+def _format_result(results, risk,stacktrace=""):
+    lines = []
+    lines.append("ROOT CAUSE ANALYSIS")
+    lines.append("=" * 50)
+
+    for i, r in enumerate(results, 1):
+        lines.append(f"\n[{i}] {r['file']}  line {r['line']}  [{r['risk']}]")
+
+        if r['nearby_functions']:
+            lines.append("    Functions at error site:")
+            for f in r['nearby_functions']:
+                lines.append(f"      → {f['name']}() line {f['line']}")
+
+        if r['direct_causes']:
+            lines.append("    Direct causes (files that feed this):")
+            for f in r['direct_causes']:
+                lines.append(f"      ← {f}  [{risk.get(f, 'LOW')}]")
+
+        if r['all_causes']:
+            lines.append(f"    Full cause chain: {len(r['all_causes'])} files upstream")
+
+    # Add Groq explanation
+    lines.append("\n" + "=" * 50)
+    lines.append("BRAIN DIAGNOSIS")
+    lines.append("=" * 50)
+    lines.append(_ask_groq_diagnosis(results, risk, stacktrace))
+
+    return "\n".join(lines)
+
+
+def _ask_groq_diagnosis(results, risk, stacktrace=""):
+    from brain_parser.llm_router import call_llm
+
+    context = ""
+    for r in results:
+        context += f"\nFile: {r['file']} (line {r['line']}, risk: {r['risk']})\n"
+        if r['nearby_functions']:
+            context += f"Functions: {[f['name'] for f in r['nearby_functions']]}\n"
+        if r['direct_causes']:
+            context += f"Fed by: {r['direct_causes']}\n"
+
+    prompt = f"""You are a senior developer doing root cause analysis.
+
+Original error:
+{stacktrace}
+
+Dependency chain:
+{context}
+
+In 3 sentences max:
+1. Which file is the root cause and exactly why based on the error message
+2. What the developer should check first — name the specific function
+3. What likely went wrong — be specific about the error type
+
+Name files and functions. No generic answers."""
+
+    try:
+        return call_llm(prompt, max_tokens=200)
+    except Exception as e:
+        return f"Could not get AI diagnosis: {str(e)}"

brain_parser/universal_parser.py

@@ -0,0 +1,215 @@
+import os
+import tree_sitter_python as tspython
+import tree_sitter_javascript as tsjavascript
+import tree_sitter_java as tsjava
+import tree_sitter_typescript as tstypescript
+import hashlib
+from tree_sitter import Language, Parser
+
+
+UNKNOWN_FILES = []
+
+PY_LANGUAGE = Language(tspython.language())
+JS_LANGUAGE = Language(tsjavascript.language())
+JAVA_LANGUAGE=Language(tsjava.language())
+TS_LANGUAGE = Language(tstypescript.language_typescript())
+
+LANGUAGE_MAP = {
+    'python': PY_LANGUAGE,
+    'javascript': JS_LANGUAGE,
+    'java': JAVA_LANGUAGE,
+    'typescript':TS_LANGUAGE
+}
+FUNCTION_NODES = {
+    'python': ['function_definition'],
+    'javascript': ['function_declaration', 'arrow_function', 'function_expression'],
+    'java': ['method_declaration'],
+'typescript': ['function_declaration', 'arrow_function', 'function_expression'],
+}
+CLASS_NODES = {
+    'python': ['class_definition'],
+    'javascript': ['class_declaration'],
+    'java': ['class_declaration'],
+    'typescript': ['class_declaration'],
+
+}
+IMPORT_NODES = {
+    'python': ['import_statement', 'import_from_statement'],
+    'javascript': ['import_statement'],
+    'java': ['import_declaration'],
+    'typescript': ['import_statement'],
+
+}
+
+def detect_language(filepath):
+    filepath = os.path.abspath(filepath).replace("\\", "/")
+
+    ext_map = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.java': 'java',
+        '.go': 'go',
+        '.rb': 'ruby',
+        '.cpp': 'cpp',
+        '.cs': 'csharp',
+        '.html': 'html',
+        '.css': 'css',
+        '.json': 'json',
+        '.yaml': 'yaml',
+        '.yml': 'yaml',
+        '.md': 'markdown',
+        '.sql': 'sql',
+        '.php': 'php',
+        '.swift': 'swift',
+        '.kt': 'kotlin',
+        '.rs': 'rust',
+        '.c': 'c',
+        '.sh': 'shell',
+        '.env': 'env',
+        '.xml': 'xml',
+        '.toml': 'toml',
+    }
+
+    ext = os.path.splitext(filepath)[1].lower()
+    language = ext_map.get(ext, 'unknown')
+
+    if language == 'unknown':
+        UNKNOWN_FILES.append(filepath)
+
+    return language
+
+
+def get_file_hash(content):
+    # generate md5 hash of file content
+    return hashlib.md5(content.encode('utf-8')).hexdigest()
+
+
+def extract_functions(tree, code_bytes, node_types):
+    functions = []
+
+    def walk(node):
+        if node.type in node_types:
+            name_node = node.child_by_field_name('name')
+            if name_node:
+                functions.append({
+                    'name': code_bytes[name_node.start_byte:name_node.end_byte].decode('utf-8'),
+                    'line': node.start_point[0] + 1
+                })
+            elif node.parent and node.parent.type == 'variable_declarator':
+                name_node = node.parent.child_by_field_name('name')
+                if name_node:
+                    functions.append({
+                        'name': code_bytes[name_node.start_byte:name_node.end_byte].decode('utf-8'),
+                        'line': node.start_point[0] + 1
+                    })
+        for child in node.children:
+            walk(child)
+
+    walk(tree.root_node)
+    return functions
+
+def extract_classes(tree, code_bytes,node_types):
+    # loop tree → find class_definition nodes → extract name and line number
+    classes = []
+
+    def walk(node):
+        if node.type in node_types:
+            name_node = node.child_by_field_name('name')
+            if name_node:
+                classes.append({
+                    'name': code_bytes[name_node.start_byte:name_node.end_byte].decode('utf-8'),
+                    'line': node.start_point[0] + 1
+                })
+        for child in node.children:
+            walk(child)
+
+    walk(tree.root_node)
+    return classes
+
+def extract_imports(tree, code_bytes,node_types):
+    # loop tree → find import nodes → extract module name and line number
+    imports = []
+
+    def walk(node):
+        if node.type in node_types:
+            imports.append({
+                'name': code_bytes[node.start_byte:node.end_byte].decode('utf-8').strip(),
+                'line': node.start_point[0] + 1
+            })
+        for child in node.children:
+            walk(child)
+
+    walk(tree.root_node)
+    return imports
+
+
+def summarize_file(filepath, content, language):
+    # call Groq → get 3 line summary → store instead of raw content
+    try:
+        from groq import Groq
+        from dotenv import load_dotenv
+        load_dotenv()
+
+        client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+        filename = filepath.split('/')[-1]
+        prompt = f"""Summarize this {language} file in exactly 3 sentences.
+        Focus on: what it does, what functions matter, what it connects to.
+        File: {filename}
+        Code:
+        {content[:3000]}"""
+
+        response = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=150
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Could not summarize: {str(e)}"
+
+
+def parse_file(filepath):
+    filepath = os.path.abspath(filepath).replace("\\", "/")
+    language = detect_language(filepath)
+
+    # unknown files → log and return empty structure
+    if language == 'unknown':
+        return {
+            'filepath': filepath,
+            'language': 'unknown',
+            'imports': [],
+            'functions': [],
+            'classes': [],
+            'summary': 'unknown file - could not parse'
+        }
+
+    # read raw file content
+    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+        content = f.read()
+
+    code_bytes = content.encode('utf-8')
+    functions = []
+    classes = []
+    imports = []
+
+    # if language supported by tree-sitter → parse and extract functions
+    if language in LANGUAGE_MAP:
+        parser = Parser(LANGUAGE_MAP[language])
+        tree = parser.parse(code_bytes)
+        functions = extract_functions(tree, code_bytes, FUNCTION_NODES.get(language, []))
+        classes = extract_classes(tree, code_bytes,CLASS_NODES.get(language,[]))
+        imports = extract_imports(tree, code_bytes, IMPORT_NODES.get(language, []))
+
+
+    return {
+        'filepath': filepath,
+        'language': language,
+        'imports': imports,
+        'functions': functions,
+        'classes': classes,
+        'summary': '',
+        'content': content        ,
+        'hash': get_file_hash(content)
+    }

codebase_brain-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: codebase-brain
+Version: 0.1.0
+Summary: An AI brain that lives inside your codebase
+Requires-Python: >=3.8
+Requires-Dist: watchdog
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+Requires-Dist: pyvis
+Requires-Dist: groq
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

codebase_brain-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+brain_cli.py,sha256=sdJ5r60B4ELMruWR8B9azejpnizFkhdDDv0IrPhMLvE,11580
+brain_parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brain_parser/ast_parser.py,sha256=3Vy1XXyInjgA2xn6IBYv4K1juEdtFwAo58upqukCHXI,1799
+brain_parser/bug_detector.py,sha256=gvXBUFFk3RYoNQC-mToo80ytR7VZr_t1TfFEiSStmvo,7652
+brain_parser/codebase_walker.py,sha256=6uU1yJ6leqmHcdlSm-xcq1DOG1mdv4F0-JupSMZrSwE,3582
+brain_parser/file_watcher.py,sha256=cuok95kDJy6uKfsz_HByKWLBvRIPUAz7djAaXQ-2T3Q,2565
+brain_parser/graph_builder.py,sha256=fpQqY46oq4uqTzysPyhbUAaAwwJGV_yH5kQBW4xtuSs,5218
+brain_parser/llm_router.py,sha256=f86O4tUw3MV1s2dq6axEzwJHEQfyboaqPr_QDR8CtK0,2447
+brain_parser/query_engine.py,sha256=Lunb_-9z1Lk2VYOE7f_-jF8X2AQtby1tPFXgFUjqnpA,3671
+brain_parser/root_cause.py,sha256=jvRB9OzFREU0oguGhfoU8wV2mCJ7A85y2BohybzIQ-0,5326
+brain_parser/universal_parser.py,sha256=47StXj-GPGJb4g0WzM5VYgM3tIc1tOzwEa8mcL_q9AY,6694
+codebase_brain-0.1.0.dist-info/METADATA,sha256=Eep4Qd7cPOarafSDhm6aysPe6lbhMk1fcPWJGqd3UVg,327
+codebase_brain-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codebase_brain-0.1.0.dist-info/entry_points.txt,sha256=O9yHP4zy_uoVPxmewGbdNjNksmxRYUv34MQJDRXXodc,41
+codebase_brain-0.1.0.dist-info/top_level.txt,sha256=RmSvznU63-vmm5zLSKAlYYsFzQ8X3RyPrB-m0q0uQfI,23
+codebase_brain-0.1.0.dist-info/RECORD,,

codebase_brain-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codebase_brain-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+brain = brain_cli:main

codebase_brain-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+brain_cli
+brain_parser