srcly 0.1.19__tar.gz → 0.1.20__tar.gz

{srcly-0.1.19 → srcly-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srcly
-Version: 0.1.19
+Version: 0.1.20
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3

{srcly-0.1.19 → srcly-0.1.20}/app/routers/files.py

@@ -24,6 +24,9 @@ async def get_file_content(path: str = Query(..., description="Absolute path to
     # For this local tool, we'll allow reading any file as requested, but maybe warn?
     
     try:
+        # Log every file read request before processing so hangs/crashes are attributable.
+        print(f"📄 Reading file content: {file_path}", flush=True)
+
         if file_path.suffix == ".ipynb":
             return get_ipynb_analyzer().get_virtual_content(str(file_path))
         

{srcly-0.1.19 → srcly-0.1.20}/app/services/analysis.py

@@ -1,6 +1,7 @@
 import os
 import lizard
-import concurrent.futures
+import multiprocessing
+import time
 from pathlib import Path
 
 from app.models import Node, Metrics
@@ -14,6 +15,20 @@ from pathspec import PathSpec
 # Maximum time allowed for analyzing a single file in a worker process.
 PER_FILE_ANALYSIS_TIMEOUT_SECONDS: float = 10.0
 
+# Max parallel workers for per-file analysis. Each file is analyzed in its own
+# subprocess so we can enforce a *hard* timeout and terminate hung analysis.
+def _default_max_workers() -> int:
+    """
+    Pick a reasonable default worker count close to available CPU cores.
+
+    We keep 1 core of headroom so the main process / OS remains responsive.
+    """
+    cpu = os.cpu_count() or 4
+    return max(1, cpu - 1)
+
+
+MAX_ANALYSIS_WORKERS: int = _default_max_workers()
+
 _ts_analyzer = None
 _md_analyzer = None
 _ipynb_analyzer = None
@@ -209,13 +224,9 @@ def attach_file_metrics(node: Node, file_info) -> None:
         node.children.append(func_node)
         func_sum_loc += func.nloc
 
-    # CRITICAL FIX: Add a virtual node for the "Glue Code" (Imports, Exports, Global Vars)
-    remainder = total_loc - func_sum_loc
-    if remainder > 0:
-        misc_node = create_node("(misc/imports)", "code_fragment", f"{node.path}::__misc__")
-        misc_node.metrics.loc = remainder
-        misc_node.metrics.complexity = 0 # Glue code is usually simple
-        node.children.append(misc_node)
+    # NOTE: We no longer create a synthetic child node for module-level "glue".
+    # Any top-level/module lines should be represented as the (body) of the
+    # file/module scope (handled by the newer scope-body attribution logic).
 
 
 def _translate_gitignore_pattern(raw_line: str, base_rel: str) -> str | None:
@@ -390,7 +401,7 @@ def aggregate_metrics(node: Node) -> Metrics:
         total_function_loc += (child_metrics.average_function_length * child_metrics.function_count)
 
     # For Folders: Sum of children
-    # For Files: We trust the attach_file_metrics logic (which includes __misc__)
+    # For Files: We trust the attach_file_metrics logic.
     if node.type == "folder":
         node.metrics.loc = total_loc
         node.metrics.complexity = max_complexity
@@ -446,6 +457,147 @@ def analyze_single_file(file_path: str):
         # Return error info instead of crashing
         return {"error": str(e), "filename": file_path}
 
+
+def _analyze_file_in_subprocess(file_path: str, send_conn) -> None:
+    """
+    Child-process entry point. Runs analysis and sends the result back over a pipe.
+    Must be top-level for multiprocessing pickling.
+    """
+    try:
+        result = analyze_single_file(file_path)
+    except Exception as e:
+        result = {"error": str(e), "filename": file_path}
+    try:
+        send_conn.send(result)
+    except Exception:
+        # If sending fails, there's nothing useful we can do here.
+        pass
+    finally:
+        try:
+            send_conn.close()
+        except Exception:
+            pass
+
+
+def _run_file_analyses_with_hard_timeouts(
+    files_to_scan: list[str],
+    timeout_seconds: float,
+    max_workers: int,
+) -> list:
+    """
+    Analyze files with a *hard* per-file timeout by running each file in its own
+    subprocess. This avoids the common pitfall where a ProcessPoolExecutor can
+    hang forever if a worker gets stuck, because individual tasks cannot be
+    force-killed reliably.
+    """
+    if not files_to_scan:
+        return []
+
+    ctx = multiprocessing.get_context("spawn")
+    total_count = len(files_to_scan)
+    completed_count = 0
+
+    # Active entries: (process, file_path, start_time, recv_conn)
+    active: list[tuple[multiprocessing.Process, str, float, object]] = []
+    results: list = []
+
+    next_index = 0
+    while next_index < total_count or active:
+        # Fill up worker slots.
+        while next_index < total_count and len(active) < max_workers:
+            file_path = files_to_scan[next_index]
+            next_index += 1
+
+            # Log every file *before* it is processed so we can identify the
+            # last-started file if analysis hangs or crashes.
+            print(f"➡️ [{next_index}/{total_count}] Starting analysis: {file_path}", flush=True)
+
+            recv_conn, send_conn = ctx.Pipe(duplex=False)
+            proc = ctx.Process(
+                target=_analyze_file_in_subprocess,
+                args=(file_path, send_conn),
+                daemon=True,
+            )
+            start_time = time.time()
+            proc.start()
+            # Close the child end in the parent process to avoid leaks.
+            try:
+                send_conn.close()
+            except Exception:
+                pass
+
+            active.append((proc, file_path, start_time, recv_conn))
+
+        # Check running workers for completion or timeout.
+        still_active: list[tuple[multiprocessing.Process, str, float, object]] = []
+        now = time.time()
+
+        for proc, file_path, start_time, recv_conn in active:
+            elapsed = now - start_time
+
+            if proc.is_alive() and elapsed <= timeout_seconds:
+                still_active.append((proc, file_path, start_time, recv_conn))
+                continue
+
+            # Either finished, or timed out.
+            if proc.is_alive() and elapsed > timeout_seconds:
+                completed_count += 1
+                print(
+                    f"❌ [{completed_count}/{total_count}] Timeout analyzing {file_path} after {elapsed:.2f}s (terminated)",
+                    flush=True,
+                )
+                try:
+                    proc.terminate()
+                except Exception:
+                    pass
+                try:
+                    proc.join(timeout=1.0)
+                except Exception:
+                    pass
+                try:
+                    recv_conn.close()
+                except Exception:
+                    pass
+                continue
+
+            # Process finished; collect result if possible.
+            try:
+                proc.join(timeout=0.0)
+            except Exception:
+                pass
+
+            completed_count += 1
+            result = None
+            try:
+                # If the child crashed before sending anything, recv may raise EOFError.
+                result = recv_conn.recv()
+            except Exception as exc:
+                result = {"error": str(exc), "filename": file_path}
+            finally:
+                try:
+                    recv_conn.close()
+                except Exception:
+                    pass
+
+            if isinstance(result, dict) and "error" in result:
+                print(
+                    f"❌ [{completed_count}/{total_count}] Error analyzing {file_path}: {result.get('error')}",
+                    flush=True,
+                )
+            else:
+                if _should_log_file_progress(completed_count, total_count):
+                    print(f"✅ [{completed_count}/{total_count}] Analyzed {file_path}", flush=True)
+                results.append(result)
+
+        active = still_active
+
+        # Avoid busy-looping when workers are running.
+        if active and (next_index < total_count or active):
+            time.sleep(0.02)
+
+    return results
+
+
 def scan_codebase(root_path: Path) -> Node:
     print(f"🔍 Scanning: {root_path}", flush=True)
 
@@ -489,35 +641,16 @@ def scan_codebase(root_path: Path) -> Node:
         if current_ignored_count > 0:
             ignored_counts[str(root_dir_path)] = current_ignored_count
 
-    print(f"📂 Analyzing {len(files_to_scan)} source files...", flush=True)
-    
-    analysis_results = []
-    
-    # Use ProcessPoolExecutor for better control and per-file error handling
-    # lizard.analyze_files was opaque and crashing the whole pool on one error
-    with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
-        future_to_file = {executor.submit(analyze_single_file, f): f for f in files_to_scan}
-        
-        completed_count = 0
-        total_count = len(files_to_scan)
-        
-        for future in concurrent.futures.as_completed(future_to_file):
-            file = future_to_file[future]
-            completed_count += 1
-            try:
-                # Add a timeout to prevent hanging on single files
-                result = future.result(timeout=PER_FILE_ANALYSIS_TIMEOUT_SECONDS)
-                if isinstance(result, dict) and "error" in result:
-                    print(f"❌ [{completed_count}/{total_count}] Error analyzing {file}: {result['error']}", flush=True)
-                else:
-                    # Success
-                    if _should_log_file_progress(completed_count, total_count):
-                        print(f"✅ [{completed_count}/{total_count}] Analyzed {file}", flush=True)
-                    analysis_results.append(result)
-            except concurrent.futures.TimeoutError:
-                print(f"❌ [{completed_count}/{total_count}] Timeout analyzing {file} (skipped)", flush=True)
-            except Exception as exc:
-                print(f"❌ [{completed_count}/{total_count}] Exception analyzing {file}: {exc}", flush=True)
+    print(
+        f"📂 Analyzing {len(files_to_scan)} source files... (workers={MAX_ANALYSIS_WORKERS}, timeout={PER_FILE_ANALYSIS_TIMEOUT_SECONDS}s)",
+        flush=True,
+    )
+
+    analysis_results = _run_file_analyses_with_hard_timeouts(
+        files_to_scan=files_to_scan,
+        timeout_seconds=PER_FILE_ANALYSIS_TIMEOUT_SECONDS,
+        max_workers=MAX_ANALYSIS_WORKERS,
+    )
 
     tree_root = create_node("root", "folder", str(root_path))
     node_map = {str(root_path): tree_root}

{srcly-0.1.19 → srcly-0.1.20}/app/services/python/python_analysis.py

@@ -22,6 +22,9 @@ class PythonTreeSitterAnalyzer:
 
         # Extract functions, classes, and other scopes
         functions = self._extract_scopes(tree.root_node)
+        import_scope = self._compute_import_scope(tree.root_node, content)
+        if import_scope is not None:
+            functions.insert(0, import_scope)
 
         avg_complexity = 0.0
         if functions:
@@ -71,6 +74,71 @@ class PythonTreeSitterAnalyzer:
             md_data_url_count=0
         )
 
+    def _compute_import_scope(self, root_node: Node, content: bytes) -> FunctionMetrics | None:
+        """
+        Create a synthetic top-level scope representing import statements.
+
+        - nloc: total LOC occupied by *all* import statements in the file
+        - start/end_line: span of the largest contiguous block of imports
+        """
+        import_spans: List[tuple[int, int]] = []
+        lines = content.splitlines()
+
+        def only_blank_lines_between(end_line: int, start_line: int) -> bool:
+            if start_line <= end_line + 1:
+                return True
+            for line_no in range(end_line + 1, start_line):
+                idx = line_no - 1
+                if 0 <= idx < len(lines):
+                    if lines[idx].strip():
+                        return False
+            return True
+
+        def traverse(n: Node) -> None:
+            if n.type in {"import_statement", "import_from_statement"}:
+                start_line = n.start_point.row + 1
+                end_line = n.end_point.row + 1
+                import_spans.append((start_line, end_line))
+            for child in n.children:
+                traverse(child)
+
+        traverse(root_node)
+
+        if not import_spans:
+            return None
+
+        import_spans.sort(key=lambda s: (s[0], s[1]))
+        total_import_loc = sum(e - s + 1 for s, e in import_spans)
+
+        blocks: List[tuple[int, int, int]] = []  # (block_start, block_end, block_loc_sum)
+        cur_s, cur_e = import_spans[0]
+        cur_loc = cur_e - cur_s + 1
+        for s, e in import_spans[1:]:
+            # Allow blank lines between imports to still count as one contiguous block.
+            if only_blank_lines_between(cur_e, s):
+                cur_e = max(cur_e, e)
+                cur_loc += (e - s + 1)
+            else:
+                blocks.append((cur_s, cur_e, cur_loc))
+                cur_s, cur_e = s, e
+                cur_loc = e - s + 1
+        blocks.append((cur_s, cur_e, cur_loc))
+
+        block_s, block_e, _ = max(blocks, key=lambda b: (b[2], -b[0]))
+
+        return FunctionMetrics(
+            name="(imports)",
+            cyclomatic_complexity=0,
+            nloc=total_import_loc,
+            start_line=block_s,
+            end_line=block_e,
+            parameter_count=0,
+            max_nesting_depth=0,
+            comment_lines=0,
+            todo_count=0,
+            origin_type="imports",
+        )
+
     def _extract_scopes(self, root_node: Node) -> List[FunctionMetrics]:
         # We want to capture:
         # - Functions (def)

{srcly-0.1.19 → srcly-0.1.20}/app/services/typescript/typescript_analysis.py

@@ -27,6 +27,11 @@ class TreeSitterAnalyzer:
         nloc = len([l for l in lines if l.strip()])
         
         functions = self._extract_functions(tree.root_node, content)
+        import_scope = self._compute_import_scope(tree.root_node, content)
+        if import_scope is not None:
+            # Make imports visible as a top-level "scope" in treemap/scopes views.
+            functions.insert(0, import_scope)
+
         # Post-process TSX scopes so that each function containing TSX gets a
         # single virtual root "<fragment>" node that groups all JSX container
         # scopes beneath it. This keeps TSX scopes together without changing
@@ -97,6 +102,79 @@ class TreeSitterAnalyzer:
             ts_export_count=ts_export_count,
         )
 
+    def _compute_import_scope(self, root_node: Node, content: bytes) -> FunctionMetrics | None:
+        """
+        Create a synthetic top-level scope representing import statements.
+
+        - nloc: total LOC occupied by *all* import statements in the file
+        - start/end_line: span of the largest contiguous block of imports
+        """
+        import_spans: List[tuple[int, int]] = []
+        lines = content.splitlines()
+
+        def only_blank_lines_between(end_line: int, start_line: int) -> bool:
+            """
+            Returns True if every line strictly between end_line and start_line
+            is blank/whitespace-only. Lines are 1-based.
+            """
+            if start_line <= end_line + 1:
+                return True
+            # Between (end_line+1) and (start_line-1), inclusive.
+            for line_no in range(end_line + 1, start_line):
+                idx = line_no - 1
+                if 0 <= idx < len(lines):
+                    if lines[idx].strip():
+                        return False
+            return True
+
+        def traverse(n: Node) -> None:
+            if n.type == "import_statement":
+                start_line = n.start_point.row + 1
+                end_line = n.end_point.row + 1
+                import_spans.append((start_line, end_line))
+            for child in n.children:
+                traverse(child)
+
+        traverse(root_node)
+
+        if not import_spans:
+            return None
+
+        import_spans.sort(key=lambda s: (s[0], s[1]))
+        total_import_loc = sum(e - s + 1 for s, e in import_spans)
+
+        # Merge adjacent import statements into contiguous blocks.
+        blocks: List[tuple[int, int, int]] = []  # (block_start, block_end, block_loc_sum)
+        cur_s, cur_e = import_spans[0]
+        cur_loc = cur_e - cur_s + 1
+        for s, e in import_spans[1:]:
+            # Allow blank lines between imports to still count as one contiguous block.
+            if only_blank_lines_between(cur_e, s):
+                cur_e = max(cur_e, e)
+                cur_loc += (e - s + 1)
+            else:
+                blocks.append((cur_s, cur_e, cur_loc))
+                cur_s, cur_e = s, e
+                cur_loc = e - s + 1
+        blocks.append((cur_s, cur_e, cur_loc))
+
+        # Pick the largest block (by LOC, then by earliest start line for stability).
+        block_s, block_e, _ = max(blocks, key=lambda b: (b[2], -b[0]))
+
+        return FunctionMetrics(
+            name="(imports)",
+            cyclomatic_complexity=0,
+            nloc=total_import_loc,
+            start_line=block_s,
+            end_line=block_e,
+            parameter_count=0,
+            max_nesting_depth=0,
+            comment_lines=0,
+            todo_count=0,
+            ts_type_interface_count=0,
+            origin_type="imports",
+        )
+
     def _extract_functions(self, root_node: Node, content: bytes) -> List[FunctionMetrics]:
         function_types = {
             'function_declaration',
@@ -213,7 +291,41 @@ class TreeSitterAnalyzer:
                 return f"{name_node.text.decode('utf-8')} (type)"
             return "type"
         elif node.type == 'object':
-             # Try to find the name from the parent assignment or property
+            # TSX / JSX: object literal used inside a JSX attribute expression, e.g.
+            #   <TapestryNode class={classy(..., { wireframe: () => ... })} />
+            # Prefer naming after the owning attribute: "class (obj)".
+            current = node
+            hops = 0
+            function_boundary_types = {
+                'function_declaration',
+                'method_definition',
+                'arrow_function',
+                'function_expression',
+                'generator_function',
+                'generator_function_declaration',
+            }
+            while current is not None and hops < 12:
+                if current.type == 'jsx_attribute':
+                    name_node = current.child_by_field_name('name')
+                    if name_node is None:
+                        for c in current.children:
+                            if c.type in {"property_identifier", "identifier", "jsx_identifier"}:
+                                name_node = c
+                                break
+                    if name_node:
+                        return f"{name_node.text.decode('utf-8')} (obj)"
+                    break
+
+                # Don't cross into a nested function/container; if the object literal
+                # is inside a callback, it should be named by its local context instead.
+                if current is not node and current.type in function_boundary_types:
+                    break
+                if current.type in {'program', 'statement_block'}:
+                    break
+                current = current.parent
+                hops += 1
+
+            # Try to find the name from the parent assignment or property
             parent = node.parent
             if parent:
                 # const obj = { ... }
@@ -410,21 +522,19 @@ class TreeSitterAnalyzer:
 
     def _expression_defines_function(self, expr_node: Node) -> bool:
         # Check if the expression contains an inline function definition
-        # It might be wrapped in parenthesized_expression
+        # It might be wrapped in parenthesized_expression, and it may be nested
+        # inside other expressions (e.g. call arguments, object literals) like:
+        #   class={classy(..., { wireframe: () => ... })}
         
-        def has_func(n: Node):
-            if n.type in {'arrow_function', 'function_expression'}:
+        def has_func(n: Node) -> bool:
+            if n.type in {"arrow_function", "function_expression"}:
                 return True
-            if n.type == 'parenthesized_expression':
-                for c in n.children:
-                    if has_func(c):
-                        return True
+            for c in n.children:
+                if has_func(c):
+                    return True
             return False
 
-        for child in expr_node.children:
-            if has_func(child):
-                return True
-        return False
+        return has_func(expr_node)
 
     def _calculate_complexity(self, node: Node) -> int:
         complexity = 1