codebase-brain 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

brain_parser/codebase_walker.py

@@ -103,4 +103,4 @@ if __name__ == "__main__":
     save_brain(brain)
 
     loaded = load_brain()
-    print(f"Brain loaded with {len(loaded)} files")
+    print(f"Brain loaded with {len(loaded)} files")

brain_parser/llm_router.py

@@ -8,11 +8,9 @@ def get_config():
     if os.path.exists(local_env):
         load_dotenv(local_env, override=True)
 
-    # check if local .env actually had Brain's keys
     has_key = os.getenv("LLM_API_KEY") or os.getenv("GROQ_API_KEY")
 
     if not has_key:
-        # local .env didn't have Brain's config — fall back to global
         global_config = os.path.expanduser("~/.codebase-brain/config.env")
         if os.path.exists(global_config):
             load_dotenv(global_config, override=True)
@@ -20,7 +18,7 @@ def get_config():
     return {
         'provider': os.getenv("LLM_PROVIDER", "groq").lower(),
         'api_key': os.getenv("LLM_API_KEY") or os.getenv("GROQ_API_KEY"),
-        'model': os.getenv("LLM_MODEL") or os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+        'model': os.getenv("LLM_MODEL") or os.getenv("GROQ_MODEL", "openai/gpt-oss-120b")
     }
 
 
@@ -44,53 +42,103 @@ def call_llm(prompt, max_tokens=500):
         return _call_groq(api_key, model, prompt, max_tokens)
 
 
+def _try_models(model, fallback_list, call_fn):
+    """Generic fallback runner — tries the configured model first, then known-stable alternatives."""
+    models_to_try = [model] + [m for m in fallback_list if m != model]
+    seen = set()
+    models_to_try = [m for m in models_to_try if not (m in seen or seen.add(m))]
+
+    last_error = None
+    for try_model in models_to_try:
+        try:
+            return call_fn(try_model)
+        except Exception as e:
+            last_error = e
+            continue
+
+    return f"Could not get AI response — all models unavailable: {str(last_error)}"
+
+
 def _call_groq(api_key, model, prompt, max_tokens):
     from groq import Groq
     client = Groq(api_key=api_key)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-        temperature=0
-    )
-    return response.choices[0].message.content
+
+    fallback_list = ["openai/gpt-oss-120b", "llama-3.1-8b-instant", "qwen3.6-27b"]
+
+    def call_fn(m):
+        response = client.chat.completions.create(
+            model=m,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            temperature=0
+        )
+        return response.choices[0].message.content
+
+    return _try_models(model, fallback_list, call_fn)
 
 
 def _call_openai(api_key, model, prompt, max_tokens):
     from openai import OpenAI
     client = OpenAI(api_key=api_key)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-        temperature=0
-    )
-    return response.choices[0].message.content
+
+    fallback_list = ["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"]
+
+    def call_fn(m):
+        response = client.chat.completions.create(
+            model=m,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            temperature=0
+        )
+        return response.choices[0].message.content
+
+    return _try_models(model, fallback_list, call_fn)
 
 
 def _call_anthropic(api_key, model, prompt, max_tokens):
     import anthropic
     client = anthropic.Anthropic(api_key=api_key)
-    response = client.messages.create(
-        model=model,
-        max_tokens=max_tokens,
-        messages=[{"role": "user", "content": prompt}]
-    )
-    return response.content[0].text
+
+    fallback_list = ["claude-3-5-haiku-20241022", "claude-3-5-sonnet-20241022", "claude-3-haiku-20240307"]
+
+    def call_fn(m):
+        response = client.messages.create(
+            model=m,
+            max_tokens=max_tokens,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        return response.content[0].text
+
+    return _try_models(model, fallback_list, call_fn)
 
 
 def _call_google(api_key, model, prompt, max_tokens):
     import google.generativeai as genai
     genai.configure(api_key=api_key)
-    gemini = genai.GenerativeModel(model)
-    response = gemini.generate_content(prompt)
-    return response.text
+
+    fallback_list = ["gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash"]
+
+    def call_fn(m):
+        gemini = genai.GenerativeModel(m)
+        response = gemini.generate_content(prompt)
+        return response.text
+
+    return _try_models(model, fallback_list, call_fn)
 
 
 def _call_ollama(model, prompt, max_tokens):
     import requests
-    response = requests.post(
-        "http://localhost:11434/api/generate",
-        json={"model": model, "prompt": prompt, "stream": False}
-    )
-    return response.json().get("response", "")
+
+    fallback_list = ["llama3.2", "codellama", "deepseek-coder"]
+
+    def call_fn(m):
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={"model": m, "prompt": prompt, "stream": False}
+        )
+        result = response.json().get("response", "")
+        if not result:
+            raise ValueError(f"Empty response from Ollama model {m}")
+        return result
+
+    return _try_models(model, fallback_list, call_fn)

brain_parser/root_cause.py

@@ -37,21 +37,47 @@ def extract_frames(stacktrace):
 
 
 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 = []
+    """Match any path format from stacktrace to full path in graph — universal matching."""
+
+    def normalize(path):
+        p = path.replace('\\', '/').lower()
+        if len(p) > 1 and p[1] == ':':
+            p = p[2:]
+        return p.lstrip('/')
+
+    frame_norm = normalize(frame_file)
+    frame_parts = frame_norm.split('/')
 
+    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):
+        node_norm = normalize(node)
+        node_parts = node_norm.split('/')
+
+        min_len = min(len(frame_parts), len(node_parts))
+        if min_len == 0:
+            continue
+
+        if frame_parts[-min_len:] == node_parts[-min_len:]:
+            candidates.append(node)
+            continue
+
+        if frame_parts[-1] == node_parts[-1]:
             candidates.append(node)
 
     if not candidates:
         return None
-    # prefer shortest path — most specific match
-    return min(candidates, key=len)
 
+    def match_score(node):
+        node_parts = normalize(node).split('/')
+        score = 0
+        for a, b in zip(reversed(frame_parts), reversed(node_parts)):
+            if a == b:
+                score += 1
+            else:
+                break
+        return score
+
+    return max(candidates, key=match_score)
 
 def find_root_cause(stacktrace):
     """Main function — paste stacktrace, get root cause analysis."""

{codebase_brain-0.3.2.dist-info → codebase_brain-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebase-brain
-Version: 0.3.2
+Version: 0.3.4
 Summary: An AI brain that lives inside your codebase
 Requires-Python: >=3.8
 Requires-Dist: watchdog

{codebase_brain-0.3.2.dist-info → codebase_brain-0.3.4.dist-info}/RECORD

@@ -2,15 +2,15 @@ brain_cli.py,sha256=uYpVxWpM7_fVM-Z4JSgWj0fqU9TGc4Zhc9uu6ritbZA,14576
 brain_parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 brain_parser/ast_parser.py,sha256=3Vy1XXyInjgA2xn6IBYv4K1juEdtFwAo58upqukCHXI,1799
 brain_parser/bug_detector.py,sha256=IbEpyXfatL0r1cjaIZ7LXzYPg7z0molyRjg2ULu4828,7653
-brain_parser/codebase_walker.py,sha256=rWAHtHWurpZ7HhHAXLSuySMn07TIfg20LrRJ8wyCxKQ,3714
+brain_parser/codebase_walker.py,sha256=VqzHcVerp-CEnSsGvHf_13RjT1YBne9iMeAc8kHVLuY,3716
 brain_parser/file_watcher.py,sha256=cXsXxrSPvVhSzVmbGsLu5u-jd98VUHvTs8-W0QkhHf4,2582
 brain_parser/graph_builder.py,sha256=gOXII_SwEs_sJfVFBk81ftedT3fxYN2gz1_aopbpTUU,8741
-brain_parser/llm_router.py,sha256=wJP1piBEFqeIMDrHUcGbVpLsJP-aGbn7rKLFYSCcJmc,3224
+brain_parser/llm_router.py,sha256=D0RD71xVNqy9PCPuDUsSCYmlSaWtczDkERUnLslHGQ8,4733
 brain_parser/query_engine.py,sha256=Lunb_-9z1Lk2VYOE7f_-jF8X2AQtby1tPFXgFUjqnpA,3671
-brain_parser/root_cause.py,sha256=jvRB9OzFREU0oguGhfoU8wV2mCJ7A85y2BohybzIQ-0,5326
+brain_parser/root_cause.py,sha256=bgBVjP6rlDlcOUrjM5mUi4Fa-ERQvrhgFRqbMfgWZpw,5974
 brain_parser/universal_parser.py,sha256=47StXj-GPGJb4g0WzM5VYgM3tIc1tOzwEa8mcL_q9AY,6694
-codebase_brain-0.3.2.dist-info/METADATA,sha256=7S_PQcUGheuzOMBkWV3ITr9y5HXzcmOm1kJg4Un4Ds0,531
-codebase_brain-0.3.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-codebase_brain-0.3.2.dist-info/entry_points.txt,sha256=O9yHP4zy_uoVPxmewGbdNjNksmxRYUv34MQJDRXXodc,41
-codebase_brain-0.3.2.dist-info/top_level.txt,sha256=RmSvznU63-vmm5zLSKAlYYsFzQ8X3RyPrB-m0q0uQfI,23
-codebase_brain-0.3.2.dist-info/RECORD,,
+codebase_brain-0.3.4.dist-info/METADATA,sha256=UrO6il1XfJ_OeEw8uoO6qM7h2XIOC9jmZsdcG8lKkAM,531
+codebase_brain-0.3.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+codebase_brain-0.3.4.dist-info/entry_points.txt,sha256=O9yHP4zy_uoVPxmewGbdNjNksmxRYUv34MQJDRXXodc,41
+codebase_brain-0.3.4.dist-info/top_level.txt,sha256=RmSvznU63-vmm5zLSKAlYYsFzQ8X3RyPrB-m0q0uQfI,23
+codebase_brain-0.3.4.dist-info/RECORD,,

{codebase_brain-0.3.2.dist-info → codebase_brain-0.3.4.dist-info}/WHEEL

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