codebase-brain 0.1.0__tar.gz → 0.3.0__tar.gz

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/PKG-INFO

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

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/brain_cli.py

@@ -65,6 +65,75 @@ def cmd_start(path):
         print(f"\nBrain: {answer}\n")
 
 
+def _explain_risk(staged_files, G, risk, brain):
+    from brain_parser.llm_router import call_llm
+
+    context = ""
+    for f in staged_files:
+        target_norm = os.path.abspath(f).replace('\\', '/')
+        matched = None
+        for node in G.nodes():
+            node_norm = os.path.abspath(node).replace('\\', '/')
+            if node_norm == target_norm:
+                matched = node
+                break
+        if not matched:
+            continue
+
+        file_risk = risk.get(matched, 'LOW')
+        if file_risk != 'HIGH':
+            continue
+
+        direct = list(G.predecessors(matched))
+        file_data = brain.get(matched, {})
+        functions = [fn['name'] for fn in file_data.get('functions', [])]
+
+        context += f"\nFile: {f}\n"
+        context += f"Risk: {file_risk}\n"
+        context += f"Functions in this file: {functions}\n"
+        context += f"Files that depend on it: {direct}\n"
+
+    prompt = f"""A developer is about to commit changes to a HIGH risk file.
+Given this context:
+{context}
+
+In 2-3 sentences, explain in plain English:
+1. Why this file is risky to change
+2. What could realistically break if the change is wrong
+3. What the developer should double check before committing
+
+Be direct and specific. No generic advice."""
+
+    try:
+        return call_llm(prompt, max_tokens=200)
+    except Exception as e:
+        return f"Could not generate explanation: {str(e)}"
+
+
+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 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
@@ -106,10 +175,13 @@ def cmd_impact(filepath=None, staged=False, block=False):
             print("BRAIN WARNING: HIGH RISK commit detected.")
             print("This change affects critical files.")
             print("Production incidents have originated from files like these.")
+
+            print("\nAsking Brain to explain the risk...\n")
+            explanation = _explain_risk(staged_files, G, risk, brain)
+            print(explanation)
+
             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:
@@ -134,30 +206,6 @@ def cmd_impact(filepath=None, staged=False, block=False):
         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")
@@ -200,7 +248,14 @@ def install_hook(repo_path="."):
 
 
 def cmd_init():
+    import os
     print("Initializing Codebase Brain...\n")
+
+    # global config — stored once per machine
+    config_dir = os.path.expanduser("~/.codebase-brain")
+    os.makedirs(config_dir, exist_ok=True)
+    config_path = os.path.join(config_dir, "config.env")
+
     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")
@@ -237,7 +292,7 @@ def cmd_init():
         },
         "5": {
             "name": "ollama",
-            "key_prompt": None,  # no key needed
+            "key_prompt": None,
             "models": ["llama3.2", "codellama", "deepseek-coder"],
             "default_model": "llama3.2"
         }
@@ -248,14 +303,12 @@ def cmd_init():
 
     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 ""
@@ -271,16 +324,16 @@ def cmd_init():
     else:
         model = provider["default_model"]
 
-    with open(".env", "w") as f:
+    # save globally — one time setup
+    with open(config_path, "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")
+    print(f"\nBrain initialized globally — {provider['name']} / {model}")
+    print("Run 'brain start' in any project to begin.\n")
 
 def cmd_rootcause(error_text=None):
     from brain_parser.root_cause import find_root_cause
@@ -297,6 +350,41 @@ def cmd_rootcause(error_text=None):
         error_text = "\n".join(lines)
 
     print(find_root_cause(error_text))
+def cmd_uninstall():
+    import shutil
+
+    print("Uninstalling Codebase Brain...\n")
+
+    # remove global config
+    config_dir = os.path.expanduser("~/.codebase-brain")
+    if os.path.exists(config_dir):
+        shutil.rmtree(config_dir)
+        print("Removed global config.")
+
+    # remove local brain.json
+    brain_json = os.path.join(os.getcwd(), 'brain.json')
+    if os.path.exists(brain_json):
+        os.remove(brain_json)
+        print("Removed brain.json.")
+
+    # remove local brain_map.html
+    brain_map = os.path.join(os.getcwd(), 'brain_map.html')
+    if os.path.exists(brain_map):
+        os.remove(brain_map)
+        print("Removed brain_map.html.")
+
+    # remove git hook
+    hook_path = os.path.join(os.getcwd(), '.git', 'hooks', 'pre-commit')
+    if os.path.exists(hook_path):
+        # only remove if it's a Brain hook
+        with open(hook_path, 'r') as f:
+            content = f.read()
+        if 'Codebase Brain' in content:
+            os.remove(hook_path)
+            print("Removed git hook.")
+
+    print("\nBrain removed from this project.")
+    print("To fully uninstall: pip uninstall codebase-brain")
 
 
 def main():
@@ -307,9 +395,10 @@ def main():
     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("command", choices=["start", "init", "impact", "install-hook", "rootcause", "uninstall"])
     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()
 
@@ -324,8 +413,12 @@ def main():
         cmd_impact(filepath=args.file or None, staged=args.staged, block=args.block)
     elif args.command == "install-hook":
         install_hook()
+    elif args.command == "uninstall":
+        cmd_uninstall()
+
 
 
 
 if __name__ == "__main__":
-    main()
+    main()
+   

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/brain_parser/bug_detector.py

@@ -9,32 +9,33 @@ def detect_circular_dependencies(brain, temp_path=None):
     G = build_graph(brain)
     bugs = []
 
-    def clean(path):
+    def rel(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]
+            p = parts[1] if len(parts) > 1 else parts[0]
+        if '/src/' in p:
+            p = p[p.find('/src/') + 1:]
+        elif p.startswith('./'):
+            p = p[2:]
+        return p
 
     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]}"
+        sccs = [scc for scc in nx.strongly_connected_components(G) if len(scc) > 1]
+
+        for scc in sccs:
+            clean_files = sorted(list(set([rel(f).split('/')[-1] for f in scc])))
+            chain = '\n  '.join([f"{i+1}. {f}" for i, f in enumerate(clean_files)])
             bugs.append({
                 'type': 'circular_dependency',
                 'severity': 'HIGH',
-                'files': clean_cycle,
-                'message': f"Circular dependency ({len(cycle)} files):\n  {chain}",
+                'files': clean_files,
+                'message': f"Circular dependency group ({len(clean_files)} 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}")
 

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/brain_parser/codebase_walker.py

@@ -53,18 +53,23 @@ def walk_codebase(root_path):
 
     return brain
 
-BRAIN_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'brain.json')
+def get_brain_path():
+    """Always returns brain.json in the current working directory."""
+    return os.path.join(os.getcwd(), 'brain.json')
 
-def save_brain(brain, output_path=BRAIN_PATH):
+def save_brain(brain, output_path=None):
+    if output_path is None:
+        output_path = get_brain_path()
     with open(output_path, "w") as f:
         json.dump(brain, f, indent=4)
     print(f"Brain saved to {output_path}")
 
-def load_brain(input_path=BRAIN_PATH):
-    if not os.path.exists(input_path):
-        print("No brain found. Run walker first.")
+def load_brain(output_path=None):
+    if output_path is None:
+        output_path = get_brain_path()
+    if not os.path.exists(output_path):
         return None
-    with open(input_path, "r") as f:
+    with open(output_path, 'r') as f:
         return json.load(f)
 
 

codebase_brain-0.3.0/brain_parser/graph_builder.py

@@ -0,0 +1,304 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+from brain_parser.codebase_walker import load_brain
+from pyvis.network import Network
+
+
+def build_graph(brain):
+    G = nx.DiGraph()
+
+    for filepath, data in brain.items():
+        G.add_node(filepath)
+
+        for imp in data.get('imports', []):
+            raw = imp.get('name', '')
+
+            # extract module from "from x import y" or "import x"
+            if raw.startswith('from '):
+                module = raw.split('from ')[1].split(' import')[0].strip()
+            elif raw.startswith('import '):
+                module = raw.replace('import ', '').split(' as ')[0].strip()
+            else:
+                continue
+
+            # convert module path to file path format
+            # tests.circular_test.file_b → tests/circular_test/file_b
+            module_as_path = module.replace('.', '/').lower()
+
+            for other_file in brain.keys():
+                other_normalized = other_file.replace('\\', '/').lower()
+                # match whole filename not partial
+                filename = other_normalized.split('/')[-1].replace('.py', '').replace('.js', '').replace('.java',
+                                                                                                         '').replace(
+                    '.ts', '')
+                if module_as_path == filename or other_normalized.endswith(module_as_path + '.py'):
+                    G.add_edge(filepath, other_file)
+
+    return G
+
+
+def visualize_graph(G):
+    risk = calculate_risk(G)
+
+    color_map = {
+        "HIGH": "red",
+        "MEDIUM": "orange",
+        "LOW": "lightgreen"
+    }
+
+    node_colors = [color_map[risk[node]] for node in G.nodes()]
+
+    plt.figure(figsize=(10, 7))
+    pos = nx.spring_layout(G)
+
+    nx.draw(G, pos,
+            with_labels=True,
+            node_color=node_colors,
+            node_size=2000,
+            font_size=8,
+            arrows=True,
+            edge_color='gray',
+            font_weight='bold'
+            )
+
+    plt.title("Live Codebase Brain - Risk Map")
+    plt.savefig("brain_graph.png")
+    plt.show()
+
+
+def calculate_risk(G):
+    risk = {}
+
+    for node in G.nodes():
+        in_degree = G.in_degree(node)
+
+        if in_degree >= 2:
+            risk[node] = "HIGH"
+        elif in_degree == 1:
+            risk[node] = "MEDIUM"
+        else:
+            risk[node] = "LOW"
+
+    return risk
+
+def visualize_interactive(G):
+    from pyvis.network import Network
+    import os
+
+    risk = calculate_risk(G)
+
+    net = Network(
+        height="100vh",
+        width="100%",
+        bgcolor="#0d0d0d",
+        font_color="#ffffff",
+        directed=True,
+        cdn_resources='in_line'
+    )
+
+    color_map = {
+        "HIGH": "#ff3860",
+        "MEDIUM": "#ffdd57",
+        "LOW": "#23d160"
+    }
+
+    # build node map first — ensures consistent keys for edges
+    node_map = {}
+    for node in G.nodes():
+        node_map[node] = str(node)
+# demo test
+    for node, node_id in node_map.items():
+        risk_level = risk.get(node, 'LOW')
+        color = color_map[risk_level]
+        label = node.replace('\\', '/').split('/')[-1]
+        size = 18 + (G.in_degree(node) * 5)
+
+        net.add_node(
+            node_id,
+            label=label,
+            color={
+                'background': color,
+                'border': color,
+                'highlight': {'background': '#ffffff', 'border': color}
+            },
+            size=size,
+            font={'size': 14, 'color': '#ffffff', 'face': 'monospace'},
+            borderWidth=2,
+            shadow=True,
+             title=f"File: {label}\nRisk: {risk_level}\nConnections: {G.in_degree(node)}"
+        )
+
+    for edge in G.edges():
+        src = node_map.get(edge[0], str(edge[0]))
+        dst = node_map.get(edge[1], str(edge[1]))
+        if src in net.get_nodes() and dst in net.get_nodes():
+            net.add_edge(
+                src, dst,
+                color={'color': '#ffffff33'},
+                width=1.5,
+                arrows={'to': {'enabled': True, 'scaleFactor': 0.6}}
+            )
+
+    net.set_options("""
+    {
+      "nodes": {
+        "borderWidth": 2,
+        "shadow": {
+          "enabled": true,
+          "color": "rgba(0,0,0,0.8)",
+          "size": 15,
+          "x": 0,
+          "y": 0
+        }
+      },
+      "edges": {
+        "smooth": {
+          "type": "curvedCW",
+          "roundness": 0.2
+        },
+        "shadow": false
+      },
+      "interaction": {
+        "hover": true,
+        "navigationButtons": false,
+        "hideEdgesOnDrag": true,
+        "tooltipDelay": 100
+      },
+      "physics": {
+        "stabilization": {
+          "enabled": true,
+          "iterations": 200
+        },
+        "barnesHut": {
+          "gravitationalConstant": -12000,
+          "centralGravity": 0.1,
+          "springLength": 250,
+          "springConstant": 0.02,
+          "damping": 0.09
+        }
+      }
+    }
+    """)
+
+    output_path = os.path.join(os.getcwd(), 'brain_map.html')
+
+    html_content = net.generate_html()
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+
+    with open(output_path, 'r', encoding='utf-8') as f:
+        html = f.read()
+
+    custom_style = """
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { background: #0d0d0d; font-family: 'Courier New', monospace; }
+#mynetwork {
+    background: radial-gradient(ellipse at center, #1a1a2e 0%, #0d0d0d 100%);
+    border: none !important;
+}
+.legend {
+    position: fixed;
+    top: 20px;
+    left: 20px;
+    background: rgba(13,13,13,0.9);
+    border: 1px solid #333;
+    border-radius: 12px;
+    padding: 16px 20px;
+    color: #fff;
+    font-family: monospace;
+    font-size: 13px;
+    z-index: 1000;
+    backdrop-filter: blur(10px);
+}
+.legend-title {
+    color: #888;
+    font-size: 11px;
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 12px;
+}
+.legend-item { display: flex; align-items: center; gap: 10px; margin: 8px 0; }
+.dot { width: 12px; height: 12px; border-radius: 50%; box-shadow: 0 0 8px currentColor; }
+.high { background: #ff3860; color: #ff3860; }
+.medium { background: #ffdd57; color: #ffdd57; }
+.low { background: #23d160; color: #23d160; }
+.brain-title {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    color: #444;
+    font-family: monospace;
+    font-size: 12px;
+    letter-spacing: 3px;
+    text-transform: uppercase;
+    z-index: 1000;
+}
+div.vis-tooltip {
+    background: #1a1a2e !important;
+    border: 1px solid #ff3860 !important;
+    border-radius: 8px !important;
+    color: #fff !important;
+    font-family: monospace !important;
+    font-size: 12px !important;
+    padding: 10px 14px !important;
+}
+</style>
+<div class="legend">
+    <div class="legend-title">Risk Level</div>
+    <div class="legend-item"><div class="dot high"></div><span>High Risk</span></div>
+    <div class="legend-item"><div class="dot medium"></div><span>Medium Risk</span></div>
+    <div class="legend-item"><div class="dot low"></div><span>Low Risk</span></div>
+</div>
+<div class="brain-title">Codebase Brain</div>
+"""
+
+    html = html.replace('<body>', '<body>' + custom_style)
+
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(html)
+
+    print(f"Nodes in graph: {len(G.nodes())}")
+    print(f"Edges in graph: {len(G.edges())}")
+    print(f"Graph saved to {output_path}")
+
+
+def get_impact(G, filepath):
+    import networkx as nx
+    import os
+
+    # Normalize incoming path
+    target_norm = os.path.abspath(filepath).replace('\\', '/')
+    target_rel = filepath.replace('\\', '/').lstrip('./')
+
+    # Find matching node — handles both absolute and relative keys
+    matched = None
+
+    for node in G.nodes():
+        node_norm = os.path.abspath(node).replace('\\', '/')
+        if node_norm == target_norm:
+            matched = node
+            break
+
+    if not matched:
+        return None
+
+    direct = list(G.predecessors(matched))
+    all_affected = nx.ancestors(G, matched)
+    indirect = [f for f in all_affected if f not in direct]
+
+    return {
+        'target': matched,
+        'direct': direct,
+        'indirect': indirect,
+        'total_affected': len(direct) + len(indirect)
+    }
+
+if __name__ == "__main__":
+    brain = load_brain()
+    G = build_graph(brain)
+    visualize_interactive(G)
+
+    print("\nRisk Report:")
+    for node, level in calculate_risk(G).items():
+        print(f"  {node.split(chr(92))[-1]}: {level}")

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/brain_parser/llm_router.py

@@ -1,13 +1,31 @@
 import os
-from dotenv import load_dotenv
 
-load_dotenv()
+def get_config():
+    """Load from local .env first, then global ~/.codebase-brain/config.env"""
+    from dotenv import load_dotenv
+
+    # try local .env first
+    local_env = os.path.join(os.getcwd(), '.env')
+    if os.path.exists(local_env):
+        load_dotenv(local_env)
+    else:
+        # fallback to global config
+        global_config = os.path.expanduser("~/.codebase-brain/config.env")
+        if os.path.exists(global_config):
+            load_dotenv(global_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")
+    }
 
 
 def call_llm(prompt, max_tokens=500):
-    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")
+    config = get_config()
+    provider = config['provider']
+    api_key = config['api_key']
+    model = config['model']
 
     if provider == "groq":
         return _call_groq(api_key, model, prompt, max_tokens)

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/codebase_brain.egg-info/PKG-INFO

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

{codebase_brain-0.1.0 → codebase_brain-0.3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="codebase-brain",
-    version="0.1.0",
+    version="0.3.0",
     description="An AI brain that lives inside your codebase",
     package_dir={"": "."},
     packages=find_packages(where="."),

codebase_brain-0.1.0/brain_parser/graph_builder.py

@@ -1,190 +0,0 @@
-import networkx as nx
-import matplotlib.pyplot as plt
-from brain_parser.codebase_walker import load_brain
-from pyvis.network import Network
-
-
-def build_graph(brain):
-    G = nx.DiGraph()
-
-    for filepath, data in brain.items():
-        G.add_node(filepath)
-
-        for imp in data.get('imports', []):
-            raw = imp.get('name', '')
-
-            # extract module from "from x import y" or "import x"
-            if raw.startswith('from '):
-                module = raw.split('from ')[1].split(' import')[0].strip()
-            elif raw.startswith('import '):
-                module = raw.replace('import ', '').split(' as ')[0].strip()
-            else:
-                continue
-
-            # convert module path to file path format
-            # tests.circular_test.file_b → tests/circular_test/file_b
-            module_as_path = module.replace('.', '/').lower()
-
-            for other_file in brain.keys():
-                other_normalized = other_file.replace('\\', '/').lower()
-                # match whole filename not partial
-                filename = other_normalized.split('/')[-1].replace('.py', '').replace('.js', '').replace('.java',
-                                                                                                         '').replace(
-                    '.ts', '')
-                if module_as_path == filename or other_normalized.endswith(module_as_path + '.py'):
-                    G.add_edge(filepath, other_file)
-
-    return G
-
-
-def visualize_graph(G):
-    risk = calculate_risk(G)
-
-    color_map = {
-        "HIGH": "red",
-        "MEDIUM": "orange",
-        "LOW": "lightgreen"
-    }
-
-    node_colors = [color_map[risk[node]] for node in G.nodes()]
-
-    plt.figure(figsize=(10, 7))
-    pos = nx.spring_layout(G)
-
-    nx.draw(G, pos,
-            with_labels=True,
-            node_color=node_colors,
-            node_size=2000,
-            font_size=8,
-            arrows=True,
-            edge_color='gray',
-            font_weight='bold'
-            )
-
-    plt.title("Live Codebase Brain - Risk Map")
-    plt.savefig("brain_graph.png")
-    plt.show()
-
-
-def calculate_risk(G):
-    risk = {}
-
-    for node in G.nodes():
-        in_degree = G.in_degree(node)
-
-        if in_degree >= 2:
-            risk[node] = "HIGH"
-        elif in_degree == 1:
-            risk[node] = "MEDIUM"
-        else:
-            risk[node] = "LOW"
-
-    return risk
-
-def visualize_interactive(G):
-    risk = calculate_risk(G)\
-
-    color_map = {
-        "HIGH": "#ff4444",
-        "MEDIUM": "#ffa500",
-        "LOW": "#44cc44"
-    }
-
-    net = Network(
-        height="750px",
-        width="100%",
-        bgcolor="#1a1a2e",
-        font_color="white",
-        directed=True
-    )
-
-    for node in G.nodes():
-        risk_level = risk[node]
-        color = color_map[risk_level]
-        label = node.split("\\")[-1].split("/")[-1]
-
-        net.add_node(
-            node,
-            label=label,
-            color=color,
-            size=20 + (G.in_degree(node) * 3),
-            title=f"File: {label}\nRisk: {risk_level}\nConnections: {G.in_degree(node)}"
-        )
-
-    for edge in G.edges():
-        net.add_edge(edge[0], edge[1])
-
-    net.set_options("""
-    {
-      "nodes": {
-        "borderWidth": 2,
-        "shadow": true
-      },
-      "edges": {
-        "smooth": {
-          "type": "dynamic"
-        },
-        "shadow": true
-      },
-      "interaction": {
-        "hover": true,
-        "navigationButtons": true,
-        "hideEdgesOnDrag": true
-      },
-      "physics": {
-        "stabilization": true,
-        "barnesHut": {
-          "gravitationalConstant": -8000,
-          "springLength": 200,
-          "springConstant": 0.02
-        }
-      }
-    }
-    """)
-    net.save_graph("brain_map.html")
-    print(f"Nodes in graph: {len(G.nodes())}")
-    print(f"Edges in graph: {len(G.edges())}")
-    import webbrowser
-    webbrowser.open("brain_map.html")
-    print("Interactive graph saved to brain_map.html")
-
-
-def get_impact(G, filepath):
-    import networkx as nx
-    import os
-
-    # Normalize incoming path
-    target_norm = os.path.abspath(filepath).replace('\\', '/')
-    target_rel = filepath.replace('\\', '/').lstrip('./')
-
-    # Find matching node — handles both absolute and relative keys
-    matched = None
-
-    for node in G.nodes():
-        node_norm = os.path.abspath(node).replace('\\', '/')
-        if node_norm == target_norm:
-            matched = node
-            break
-
-    if not matched:
-        return None
-
-    direct = list(G.predecessors(matched))
-    all_affected = nx.ancestors(G, matched)
-    indirect = [f for f in all_affected if f not in direct]
-
-    return {
-        'target': matched,
-        'direct': direct,
-        'indirect': indirect,
-        'total_affected': len(direct) + len(indirect)
-    }
-
-if __name__ == "__main__":
-    brain = load_brain()
-    G = build_graph(brain)
-    visualize_interactive(G)
-
-    print("\nRisk Report:")
-    for node, level in calculate_risk(G).items():
-        print(f"  {node.split(chr(92))[-1]}: {level}")