gitgalaxy 2.1.0__tar.gz → 2.2.0__tar.gz

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitgalaxy
-Version: 2.1.0
+Version: 2.2.0
 Summary: An AST-free, LLM-free zero-trust static analysis engine for mapping architectural risk, securing CI/CD pipelines, and modernizing legacy monoliths.
 Author: Joe Esquibel
 Project-URL: Homepage, https://gitgalaxy.io

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/core/aperture.py

@@ -16,7 +16,7 @@ from typing import Dict, Any, Set, Optional, TypedDict, Union, List, Tuple
 
 # ==============================================================================
 # GitGalaxy Phase 0.1: Ingestion & Filtering (The Solar Shield)
-# Strategy: v6.3.0 (Heuristic Optics, Intent Overrides & Stateful Caching)
+# Strategy: v6.3.1 (Monolith Ceilings, Array Shields & Intent Overrides)
 # Architecture: Lead Shield -> Path Gate -> Intent Gate -> Content Gate
 # ==============================================================================
 
@@ -148,11 +148,6 @@ class ApertureFilter:
         if path_obj.name in self.config.get("SECRETS_EXACT", set()) or \
            ext.lower() in self.config.get("SECRETS_EXTENSIONS", set()):
             reason = f"CRITICAL LEAK (Exposed Secret: '{path_obj.name}')"
-            
-            # Muted logger to prevent UI overlap; spokes now handle their own alerts
-            # self.logger.critical(f"🛡️ SECURITY BREACH: {reason} at {relative_path}")
-            
-            # THE FIX: Return False so it drops into Dark Matter for the Supernova Injection
             return False, size_bytes, reason
 
         # --- TIER 0.2: THE NEURAL AUDITOR SHUNT (Model Weights) ---
@@ -160,7 +155,6 @@ class ApertureFilter:
         if ext.lower() in AI_MODEL_EXTS:
             reason = f"AI MODEL WEIGHTS (Bypassing Standard Logic: '{ext}')"
             self.logger.info(f"🧠 NEURAL AUDITOR SHUNT: Routing {path_obj.name} away from regex engines.")
-            # Return False to drop into Dark Matter, bypassing the memory-crashing I/O read
             return False, size_bytes, reason
 
         # --- TIER 0.5: THE ABSOLUTE EXTENSION SHIELD ---
@@ -235,8 +229,6 @@ class ApertureFilter:
                 return result
 
             # --- THE SHUNT: Content Bypass for Secrets ---
-            # If the path gate tagged this as a secret, skip the hex/binary 
-            # content checks so it doesn't accidentally get dropped.
             if reason and "CRITICAL LEAK" in reason:
                 result.update({
                     "is_in_scope": True,
@@ -269,7 +261,7 @@ class ApertureFilter:
 
     def _check_artifact_integrity(self, content: str, rel_path: str, has_intent: bool = False) -> Dict[str, Any]:
         """
-        Deep-scans the content buffer for corruption, binary data, 
+        Deep-scans the content buffer for corruption, binary data, arrays,
         or documentation generator signatures.
         """
         report = {"valid": True, "band": self.bands.get("VISIBLE", "source_code"), "reason": None, "loc": 0}
@@ -286,6 +278,17 @@ class ApertureFilter:
                 "reason": "Blocked (Binary Format Detected)"
             })
             return report
+            
+        # --- TIER 3.1: THE MONOLITH AMALGAMATION SHIELD ---
+        # 30,000+ lines in a single file is an amalgamation (e.g. sqlite3.c) or massive test array.
+        # It will saturate and choke the standard regex engine. Override Intent.
+        if report["loc"] > 30000:
+            report.update({
+                "valid": False, 
+                "band": self.bands.get("INFRARED", "saturated"), 
+                "reason": f"Blocked (Monolithic Amalgamation: {report['loc']} LOC exceeds safe regex boundaries)"
+            })
+            return report
 
         # --- TIER 3.5: THE AUTO-GEN DOC SHIELD ---
         low_path = rel_path.lower()
@@ -305,9 +308,6 @@ class ApertureFilter:
                 return report
 
         # --- TIER 3.6: THE MACHINE-GENERATED SOURCE SHIELD ---
-        # THE FIX: We now evaluate the machine-gen shield for ALL files. 
-        # If a file has a VIP pass (has_intent) but is an unreadable monolith (>1000 lines), 
-        # we strip its VIP status and banish it to Dark Matter as procedural debris.
         head_sample = "\n".join(lines_list[:100])
         if self.machine_gen_shield.search(head_sample):
             if not has_intent or report["loc"] > 1000:
@@ -319,8 +319,6 @@ class ApertureFilter:
                 return report
 
         # --- TIER 3.7: THE LEXICAL MONOTONY SHIELD (Generated Code) ---
-        # Detects massive generated boilerplate by checking structural entropy
-        # EXEMPTION: COBOL Data Divisions and Copybooks are naturally highly repetitive.
         if report["loc"] > 2000 and not has_intent and not low_path.endswith(('.cpy', '.cbl', '.cob')):
             sample_lines = lines_list[:500]
             meaningful_lines = [l for l in sample_lines if l.strip()]
@@ -340,50 +338,52 @@ class ApertureFilter:
                     })
                     return report
 
-        # --- TIER 3.8: THE DECLARATIVE DATA SHIELD ---
-        if low_path.endswith(('.yml', '.yaml', '.json', '.xml')):
-            if report["loc"] > 1000 and not has_intent:
+        # --- TIER 3.8: THE DECLARATIVE & VECTOR DATA SHIELD ---
+        if low_path.endswith(('.yml', '.yaml', '.json', '.xml', '.svg', '.sql', '.csv', '.tsv')):
+            # If the file is massive, absolutely drop it. Even if Git tracks it.
+            if report["loc"] > 2500:
+                report.update({
+                    "valid": False, 
+                    "band": self.bands.get("RADIO", "radio_noise"), 
+                    "reason": f"Blocked (Massive Declarative/Vector Blob: {report['loc']} LOC)"
+                })
+                return report
+            elif not has_intent and report["loc"] > 1000:
                 report.update({
                     "valid": False, 
                     "band": self.bands.get("RADIO", "radio_noise"), 
-                    "reason": f"Blocked (Declarative Data Blob: {report['loc']} lines exceed 1000-line logic threshold)"
+                    "reason": f"Blocked (Declarative Data Blob without Intent: {report['loc']} LOC)"
                 })
                 return report
 
-        # --- TIER 3.9: THE EMBEDDED DATA / HEX ARRAY SHIELD ---
-        # Drops massive test vectors, crypto keys, or images compiled into C headers.
-        # THE FIX: Removed 'has_intent'. Absolute structural density overrides VIP folder status.
-        if report["loc"] > 250:
+        # --- TIER 3.9: THE TEST DATA & ARRAY SHIELD ---
+        # Drops massive test vectors, crypto keys, or arrays compiled into headers/tests.
+        if report["loc"] > 500:
+            # Check 1: Hex Arrays
             hex_count = content.count('0x') + content.count('0X')
-            
-            # Scenario A: High Absolute Hex Density. 
-            # Catches files where hex values are densely packed on single lines, 
-            # even if interleaved with verbose C-struct initializations.
             if hex_count > report["loc"]:
                 report.update({
                     "valid": False, 
                     "band": self.bands.get("MICROWAVE", "binary_debris"), 
-                    "reason": f"Blocked (Embedded Data Payload: {hex_count} hex tokens in {report['loc']} LOC)"
+                    "reason": f"Blocked (Embedded Hex Payload: {hex_count} hex tokens in {report['loc']} LOC)"
                 })
                 return report
                 
-            # Scenario B: Vertical Array formatting.
-            # Catches files where hex values are spread out 1-per-line.
-            if hex_count > (report["loc"] * 0.2):
-                hex_lines = sum(1 for l in lines_list if ('0x' in l or '0X' in l) and ',' in l)
-                if (hex_lines / report["loc"]) > 0.25:
-                    report.update({
-                        "valid": False, 
-                        "band": self.bands.get("MICROWAVE", "binary_debris"), 
-                        "reason": f"Blocked (Embedded Data Payload: >25% of {report['loc']} LOC is hex arrays)"
-                    })
-                    return report
+            # Check 2: Massive Data Arrays (Comma Density)
+            # If there are more than 3 commas per line on average in a massive file, it's a data array/matrix.
+            comma_count = content.count(',')
+            if comma_count > (report["loc"] * 3):
+                report.update({
+                    "valid": False, 
+                    "band": self.bands.get("MICROWAVE", "binary_debris"), 
+                    "reason": f"Blocked (Embedded Array/Matrix Payload: {comma_count} commas in {report['loc']} LOC)"
+                })
+                return report
 
         # --- TIER 4: INFRARED GATE (Minification & Saturation) ---
         max_line = self.config.get("MAX_LINE_LENGTH", 500)
         
-        # Prose and documentation often have long unbroken strings (URLs, paragraphs)
-        is_prose = low_path.endswith(('.md', '.markdown', '.txt', '.json', '.csv', '.rst'))
+        is_prose = low_path.endswith(('.md', '.markdown', '.txt', '.json', '.csv', '.rst', '.sql', '.svg'))
 
         for i, line in enumerate(lines_list[:100]): 
             if len(line) > max_line and not is_prose:
@@ -432,7 +432,6 @@ class ApertureFilter:
                 return False
         
         # 4. Standard Iterative Gitignore Logic (The Fix)
-        # Bypasses the massive OR Regex bottleneck 
         for pattern in self.ignore_patterns:
             if pattern.endswith('/'):
                 if any(fnmatch.fnmatch(p + '/', pattern) for p in parts):
@@ -453,11 +452,9 @@ class ApertureFilter:
                 with ignore_file.open('r', encoding='utf-8') as f:
                     for line in f:
                         l = line.strip()
-                        # Ignore comments and empty lines
                         if l and not l.startswith('#'):
                             patterns.append(l)
             except Exception as e: 
                 self.logger.warning(f"Failed to parse .gitignore: {e}")
                 
-        return patterns
-      
+        return patterns

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/core/detector.py

@@ -348,7 +348,9 @@ class LogicSplicer:
         safe_lines = []
         for line in code_stream.split('\n'):
             if len(line) > 1500:
-                safe_lines.append(' ' * len(line))
+                # Preserve indentation and inject a single safe char so it isn't counted as a blank line
+                indent = len(line) - len(line.lstrip())
+                safe_lines.append(' ' * indent + 'x' + ' ' * (len(line) - indent - 1))
             else:
                 safe_lines.append(line)
         code_stream = '\n'.join(safe_lines)
@@ -478,6 +480,9 @@ class LogicSplicer:
                 result_payload["regex_telemetry"] = regex_telemetry
             return result_payload
 
+        except TimeoutError:
+            # Let the Hardware Guillotine drop cleanly to the Worker thread!
+            raise
         except Exception as e:
             self.logger.error(f"Catastrophic failure during structural splicing: {e}", exc_info=True)
             return {

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/core/network_risk_sensor.py

@@ -92,14 +92,16 @@ class NetworkRiskSensor:
         # PageRank determines the absolute "Load-Bearing" gravity of a file
         try:
             pagerank = nx.pagerank(G, weight='weight')
-            # NEW: Calculate Choke Points (Betweenness) and Ripple Effect (Closeness)
-            # Note: We limit betweenness to a sample (k=50) if the graph is massive (>5k nodes) to keep it O(N) fast.
-            k_val = min(len(G.nodes()), 50) if len(G.nodes()) > 5000 else None
+            
+            # THE FIX: Drop the exact threshold from 5000 down to 500. 
+            # Force a maximum sample size of 100 nodes for anything larger.
+            k_val = min(len(G.nodes()), 100) if len(G.nodes()) > 500 else None
             betweenness = nx.betweenness_centrality(G, k=k_val, weight='weight')
             
-            # Put a hard ceiling on Closeness Centrality to prevent the O(N^2) trap
-            if len(G.nodes()) > 5000:
-                self.logger.warning("Graph too massive for Closeness Centrality. Bypassing.")
+            # THE FIX: Closeness Centrality has no built-in sampling. 
+            # Drop the bypass threshold from 5000 to 1500 to prevent minute-long hangs.
+            if len(G.nodes()) > 1500:
+                self.logger.warning("Graph too massive for exact Closeness Centrality. Bypassing.")
                 closeness = {n: 0.0 for n in G.nodes()}
             else:
                 closeness = nx.closeness_centrality(G)
@@ -194,7 +196,12 @@ class NetworkRiskSensor:
                         self.logger.warning("Graph too massive for Modularity. Bypassing.")
                         macro_metrics["modularity"] = 0.0
                     else:
-                        communities = community.greedy_modularity_communities(U)
+                        # THE FIX: Attempt Louvain (blazing fast), fallback to Greedy (slow)
+                        try:
+                            communities = community.louvain_communities(U)
+                        except AttributeError:
+                            communities = community.greedy_modularity_communities(U)
+                            
                         macro_metrics["modularity"] = round(community.modularity(U, communities), 4)
                 except Exception: pass
 

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/galaxyscope.py

@@ -679,11 +679,11 @@ class Orchestrator:
                 "zero_dependency_mode": (not HAS_NETWORKX or not HAS_TIKTOKEN or not ML_AVAILABLE)
             }
             
-            if "singularity" not in summary: 
-                summary["singularity"] = {}
+            if "unparsable_files" not in summary: 
+                summary["unparsable_files"] = {}
                 
             # Pass the array into the function, and merge the results directly
-            summary["singularity"].update(self._summarize_anomalies(total_unparsable))
+            summary["unparsable_files"].update(self._summarize_anomalies(total_unparsable))
 
             # --- PURE OUTPUT ROUTER ---
             # Respect the exact path provided, just ensure the parent folder exists

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/physics/neural_auditor.py

@@ -57,7 +57,7 @@ class NeuralAuditor:
 
             # 3. Extract Metadata
             metadata = header.get('__metadata__', {})
-            architecture = metadata.get('format', metadata.get('architecture', 'Unknown Transformer'))
+            architecture = metadata.get('architecture', metadata.get('format', 'Unknown Transformer'))
             
             # 4. Calculate Parameters (Sum of the product of all tensor shapes)
             total_params = 0

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/recorders/llm_recorder.py

@@ -86,8 +86,10 @@ class LLMRecorder:
             if name: resolution_map[name] = path
             if stem: resolution_map[stem] = path
 
-        inbound_map = {s.get("path", ""): [] for s in parsed_files}
-        outbound_map = {s.get("path", ""): [] for s in parsed_files}
+
+        from collections import defaultdict
+        inbound_set_map = defaultdict(set)
+        outbound_set_map = defaultdict(set)
         
         for s in parsed_files:
             curr = s.get("path", "")
@@ -95,8 +97,12 @@ class LLMRecorder:
                 if imp in resolution_map:
                     target_path = resolution_map[imp]
                     if target_path != curr:
-                        if curr not in inbound_map[target_path]: inbound_map[target_path].append(curr)
-                        if target_path not in outbound_map[curr]: outbound_map[curr].append(target_path)
+                        inbound_set_map[target_path].add(curr)
+                        outbound_set_map[curr].add(target_path)
+                        
+        # Cast back to standard dictionaries of lists for downstream compatibility
+        inbound_map = {k: list(v) for k, v in inbound_set_map.items()}
+        outbound_map = {k: list(v) for k, v in outbound_set_map.items()}
 
         # 1. Build the Relational Knowledge Graph
         self._generate_sqlite_graph(parsed_files, unparsable_files, summary, session_meta, output_path_db, inbound_map)
@@ -128,8 +134,7 @@ class LLMRecorder:
         comp = summary.get("composition", {})
         git_audit = session_meta.get("git_audit", {})
         
-        bypassed_count = summary.get("unparsable_files", {}).get("ambig_file_count", 0)
-        total_excluded = len(unparsable_files) + bypassed_count
+        total_excluded = len(unparsable_files)
         visible_count = sum_data.get("verified_files", len(parsed_files))
         
         lines = []
@@ -403,22 +408,24 @@ class LLMRecorder:
             lines.append(f"{rank}. **{name}** (`{path}`) — {count} outbound dependencies")
         lines.append("")
 
+        import heapq
         # --- 8. GOD FUNCTIONS (THE FUNCTIONS) ---
         lines.append("## 8. FUNCTION HITLIST (Heaviest Functions)")
         lines.append("> *Note: The 'Impact' metric below represents Structural Magnitude (complexity, arguments, and length), NOT operational risk. These are the load-bearing pillars of the logic.*\n")
         
-        # Flatten all functions to sort them globally
+        # Flatten without deep-copying memory using a lightweight Tuple 
         all_sats = []
         for s in parsed_files:
+            file_path = s.get("path", "Unknown")
             for sat in s.get("functions", []):
-                sat_copy = sat.copy()
-                sat_copy["file"] = s.get("path", "Unknown")
-                all_sats.append(sat_copy)
+                all_sats.append((sat, file_path))
                 
-        sorted_by_impact = sorted(all_sats, key=lambda x: x.get("impact", 0), reverse=True)
-        if sorted_by_impact:
-            for f in sorted_by_impact[:10]:
-                lines.append(f"- `{f.get('name')}` (@ `{f.get('file')}`) -> Impact: **{f.get('impact')}** | LOC: {f.get('loc')}")
+        # O(N) extraction of the Top 10 (Faster than sorting the entire array)
+        top_impact = heapq.nlargest(10, all_sats, key=lambda x: x[0].get("impact", 0))
+        
+        if top_impact:
+            for f, file_path in top_impact:
+                lines.append(f"- `{f.get('name')}` (@ `{file_path}`) -> Impact: **{f.get('impact')}** | LOC: {f.get('loc')}")
                 doc = f.get('docstring', '').strip()
                 if doc:
                     clean_doc = " ".join(doc.split())[:150] + ("..." if len(doc) > 150 else "")
@@ -431,28 +438,28 @@ class LLMRecorder:
         lines.append("## 8.5 ALGORITHMIC & DATABASE BOTTLENECKS")
         lines.append("> Highlights the most computationally expensive and database-heavy functions across the repository.\n")
         
-        # Sort by recursion first, then big-o depth
-        sorted_by_big_o = sorted(all_sats, key=lambda x: (x.get("is_recursive", False), x.get("big_o_depth", 1)), reverse=True)
-        complex_sats = [s for s in sorted_by_big_o if s.get("is_recursive", False) or s.get("big_o_depth", 1) > 2]
+        # THE FIX: x[0] accesses the dictionary inside the new (sat, file_path) tuple
+        sorted_by_big_o = sorted(all_sats, key=lambda x: (x[0].get("is_recursive", False), x[0].get("big_o_depth", 1)), reverse=True)
+        complex_sats = [s for s in sorted_by_big_o if s[0].get("is_recursive", False) or s[0].get("big_o_depth", 1) > 2]
         
         if complex_sats:
             lines.append("### Highest Time Complexity (Big-O)")
-            for f in complex_sats[:10]:
+            for f, file_path in complex_sats[:10]:
                 o_str = "O(2^N) [Recursive]" if f.get("is_recursive", False) else f"O(N^{f.get('big_o_depth', 1)})"
-                lines.append(f"- `{f.get('name')}` (@ `{f.get('file')}`) -> **{o_str}**")
+                lines.append(f"- `{f.get('name')}` (@ `{file_path}`) -> **{o_str}**")
                 doc = f.get('docstring', '').strip()
                 if doc:
                     clean_doc = " ".join(doc.split())[:150] + ("..." if len(doc) > 150 else "")
                     lines.append(f"  * *Intent:* {clean_doc}")
             lines.append("")
             
-        sorted_by_db = sorted(all_sats, key=lambda x: x.get("db_complexity", 0), reverse=True)
-        db_sats = [s for s in sorted_by_db if s.get("db_complexity", 0) > 0]
+        sorted_by_db = sorted(all_sats, key=lambda x: x[0].get("db_complexity", 0), reverse=True)
+        db_sats = [s for s in sorted_by_db if s[0].get("db_complexity", 0) > 0]
         
         if db_sats:
             lines.append("### Highest Data Gravity (Database Complexity)")
-            for f in db_sats[:10]:
-                lines.append(f"- `{f.get('name')}` (@ `{f.get('file')}`) -> DB Complexity: **{f.get('db_complexity', 0)}**")
+            for f, file_path in db_sats[:10]:
+                lines.append(f"- `{f.get('name')}` (@ `{file_path}`) -> DB Complexity: **{f.get('db_complexity', 0)}**")
                 doc = f.get('docstring', '').strip()
                 if doc:
                     clean_doc = " ".join(doc.split())[:150] + ("..." if len(doc) > 150 else "")
@@ -1115,6 +1122,13 @@ class LLMRecorder:
                     exps.get("verification", 0.0)
                 ))
 
+            # Master arrays for batching child records (Massive speed boost)
+            all_dna_data = []
+            all_satellites = []
+            all_outbound = []
+            all_inbound = []
+            
+            import json
             for file_data in parsed_files:
                 p = file_data.get("path")
                 c_name = file_data.get("directory_group", "__monolith__")
@@ -1123,13 +1137,11 @@ class LLMRecorder:
                 rv = file_data.get("risk_vector", [0.0] * len(self.RISK_SCHEMA))
                 pop_count = len(inbound_map.get(p, []))
                 
-                # Extract repo-level metadata (can be injected via ML pass)
                 repo_macro = tel.get("repo_macro_species", "Unknown")
                 repo_z = tel.get("repo_z_score", 0.0)
-                
-                # --- INJECT ALL RAW DNA METRICS ---
                 parent_entity = tel.get("domain_context", {}).get("parent_entity", "")
                 
+                # 1. Insert star individually to safely retrieve its exact database ID (sid)
                 cursor.execute(f'''
                     INSERT INTO stars (
                         path, filename, parent_entity, constellation, language, lock_tier, 
@@ -1153,30 +1165,32 @@ class LLMRecorder:
                 
                 sid = cursor.lastrowid
                 
-                # Dynamic Hit Insertion (Automatically includes all sec_ signatures)
+                # 2. Accumulate DNA Hits
                 hv = file_data.get("hit_vector", [])
-                dna_data = [(sid, self.SIGNAL_SCHEMA[i], hv[i]) for i in range(len(hv)) if hv[i] > 0]
-                cursor.executemany('INSERT INTO dna_hits VALUES (?, ?, ?)', dna_data)
+                all_dna_data.extend([(sid, self.SIGNAL_SCHEMA[i], hv[i]) for i in range(len(hv)) if hv[i] > 0])
                 
-                import json
+                # 3. Accumulate Satellites
                 for func in file_data.get("functions", []):
                     calls_json = json.dumps(func.get("calls_out_to", []))
-                    cursor.execute('INSERT INTO satellites (star_id, name, type_id, loc, impact, big_o_depth, is_recursive, db_complexity, docstring, calls_out_to) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', (
+                    all_satellites.append((
                         sid, func.get("name"), func.get("type_id"), func.get("loc"), func.get("impact"),
                         func.get("big_o_depth", 1), func.get("is_recursive", False), func.get("db_complexity", 0), func.get("docstring", ""), calls_json
                     ))
 
-                raw_imports = file_data.get("raw_imports", [])
-
+                # 4. Accumulate Dependencies
                 raw_imports = file_data.get("raw_imports", [])
                 if raw_imports:
-                    out_data = [(sid, imp) for imp in raw_imports]
-                    cursor.executemany('INSERT INTO outbound_dependencies VALUES (?, ?)', out_data)
+                    all_outbound.extend([(sid, imp) for imp in raw_imports])
 
                 inbound = inbound_map.get(p, [])
                 if inbound:
-                    in_data = [(sid, imp_by) for imp_by in inbound]
-                    cursor.executemany('INSERT INTO inbound_dependencies VALUES (?, ?)', in_data)
+                    all_inbound.extend([(sid, imp_by) for imp_by in inbound])
+
+            # 5. Push all accumulated child records to C-backend SQLite at once
+            cursor.executemany('INSERT INTO dna_hits VALUES (?, ?, ?)', all_dna_data)
+            cursor.executemany('INSERT INTO satellites (star_id, name, type_id, loc, impact, big_o_depth, is_recursive, db_complexity, docstring, calls_out_to) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', all_satellites)
+            cursor.executemany('INSERT INTO outbound_dependencies VALUES (?, ?)', all_outbound)
+            cursor.executemany('INSERT INTO inbound_dependencies VALUES (?, ?)', all_inbound)
 
             conn.commit()
             conn.close()

{gitgalaxy-2.1.0 → gitgalaxy-2.2.0}/gitgalaxy/recorders/record_keeper.py

@@ -44,6 +44,9 @@ class RecordKeeper:
         self.logger.debug(f"Record Keeper: Forging native SQLite database -> {db_file.name}")
 
         conn = sqlite3.connect(db_file)
+        # ---> THE SPEED FIX: Write-Ahead Logging & Relaxed Disk Sync
+        conn.execute("PRAGMA journal_mode = WAL;")
+        conn.execute("PRAGMA synchronous = NORMAL;")
         # Enforce foreign keys so cascading deletes work perfectly
         conn.execute("PRAGMA foreign_keys = ON;")
         cursor = conn.cursor()
@@ -248,6 +251,9 @@ class RecordKeeper:
         agg_build_files = 0
         agg_config_files = 0
         agg_test_files = 0
+        
+        # ---> THE SPEED FIX: Global array for all functions in the repo
+        all_func_rows = []
 
         for file_data in parsed_files:
             tel = file_data.get("telemetry", {})
@@ -437,8 +443,7 @@ class RecordKeeper:
                 ))
                 class_id_map[cls.get("name")] = cursor.lastrowid
 
-            # ---> UPDATED: 2. Extract and Insert the Functions <---
-            func_rows = []
+            # ---> UPDATED: 2. Extract and Accumulate the Functions <---
             for func in functions:
                 raw_hv = func.get("hit_vector", {})
                 func_hits = [int(raw_hv.get(h, 0)) for h in self.SIGNAL_SCHEMA]
@@ -446,7 +451,7 @@ class RecordKeeper:
                 parent_class_name = func.get("parent_class_name")
                 parent_class_id = class_id_map.get(parent_class_name) if parent_class_name else None
                 
-                func_row_data = [
+                all_func_rows.append([
                     file_id, 
                     parent_class_id,
                     str(func.get("name", "unknown_function"))[:255],
@@ -463,17 +468,16 @@ class RecordKeeper:
                     str(func.get("docstring", ""))[:2000],
                     json.dumps(func.get("calls_out_to", [])),
                     int(func.get("token_mass")) if func.get("token_mass") is not None else None
-                ] + func_hits
-                
-                func_rows.append(func_row_data)
-
-            if func_rows:
-                func_placeholders = ",".join(["?"] * len(func_rows[0]))
-                cursor.executemany(f'''
-                    INSERT INTO function_data 
-                    (file_id, parent_class_id, func_name, complexity, loc, args, usage_status, keyword_density, func_archetype, func_z_score, big_o_depth, is_recursive, db_complexity, docstring, calls_out_to, token_mass, {", ".join([self.SHORT_KEY_MAP.get(h, h) for h in self.SIGNAL_SCHEMA])})
-                    VALUES ({func_placeholders})
-                ''', func_rows)
+                ] + func_hits)
+
+        # ---> THE SPEED FIX: Push all functions to SQLite at once (OUTSIDE THE FILE LOOP) <---
+        if all_func_rows:
+            func_placeholders = ",".join(["?"] * len(all_func_rows[0]))
+            cursor.executemany(f'''
+                INSERT INTO function_data 
+                (file_id, parent_class_id, func_name, complexity, loc, args, usage_status, keyword_density, func_archetype, func_z_score, big_o_depth, is_recursive, db_complexity, docstring, calls_out_to, token_mass, {", ".join([self.SHORT_KEY_MAP.get(h, h) for h in self.SIGNAL_SCHEMA])})
+                VALUES ({func_placeholders})
+            ''', all_func_rows)
 
         # 3. REPO DATA INSERTION
         class_start_idx = self.SIGNAL_SCHEMA.index("class_start") if "class_start" in self.SIGNAL_SCHEMA else -1