srcly 0.1.14__tar.gz → 0.1.16__tar.gz

{srcly-0.1.14 → srcly-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srcly
-Version: 0.1.14
+Version: 0.1.16
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3
@@ -9,6 +9,9 @@ Requires-Dist: lizard>=1.19.0
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pydantic>=2.12.4
 Requires-Dist: pytest>=9.0.1
+Requires-Dist: tree-sitter-css==0.25.0
+Requires-Dist: tree-sitter-markdown<0.6.0,>=0.5.1
+Requires-Dist: tree-sitter-scss==1.0.0
 Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: tree-sitter>=0.25.2
 Requires-Dist: uvicorn>=0.38.0

{srcly-0.1.14 → srcly-0.1.16}/app/models.py

@@ -34,6 +34,8 @@ class Metrics(BaseModel):
     tsx_duplicated_string_count: int = 0
     ts_type_interface_count: int = 0
     ts_export_count: int = 0
+    # Markdown-specific metrics
+    md_data_url_count: int = 0
 
 class Node(BaseModel):
     name: str

{srcly-0.1.14 → srcly-0.1.16}/app/routers/analysis.py

@@ -570,7 +570,14 @@ async def get_analysis_context():
     load, for both the current working directory and the repository root.
     """
     current_root = ROOT_PATH
-    repo_root = current_root.parent
+    # Use the same repository root detection logic as the analysis layer so that
+    # the client sees a consistent "repo root" regardless of how the server was
+    # started (uvx, direct CLI, dev mode, etc.).
+    #
+    # This mirrors the behaviour of the CLI helper that walks upwards from the
+    # current directory to the enclosing `.git` root, falling back to the
+    # starting directory when no repository is found.
+    repo_root = analysis.find_repo_root(current_root)
 
     current_file_count, current_folder_count = _estimate_counts(current_root)
 

{srcly-0.1.14 → srcly-0.1.16}/app/services/analysis.py

@@ -6,9 +6,19 @@ from pathlib import Path
 from app.models import Node, Metrics
 from app.config import IGNORE_DIRS, IGNORE_FILES, IGNORE_EXTENSIONS
 from app.services.tree_sitter_analysis import TreeSitterAnalyzer
+from app.services.markdown_analysis import MarkdownTreeSitterAnalyzer
+from app.services.ipynb_analysis import NotebookAnalyzer
+from app.services.css_analysis import CssTreeSitterAnalyzer
 from pathspec import PathSpec
 
+# Maximum time allowed for analyzing a single file in a worker process.
+PER_FILE_ANALYSIS_TIMEOUT_SECONDS: float = 10.0
+
 _ts_analyzer = None
+_md_analyzer = None
+_ipynb_analyzer = None
+_css_analyzer = None
+
 
 def get_ts_analyzer():
     global _ts_analyzer
@@ -16,6 +26,27 @@ def get_ts_analyzer():
         _ts_analyzer = TreeSitterAnalyzer()
     return _ts_analyzer
 
+
+def get_md_analyzer():
+    global _md_analyzer
+    if _md_analyzer is None:
+        _md_analyzer = MarkdownTreeSitterAnalyzer()
+    return _md_analyzer
+
+
+def get_ipynb_analyzer():
+    global _ipynb_analyzer
+    if _ipynb_analyzer is None:
+        _ipynb_analyzer = NotebookAnalyzer()
+    return _ipynb_analyzer
+
+
+def get_css_analyzer():
+    global _css_analyzer
+    if _css_analyzer is None:
+        _css_analyzer = CssTreeSitterAnalyzer()
+    return _css_analyzer
+
 def find_repo_root(start_path: Path) -> Path:
     current = start_path.resolve()
     for parent in [current, *current.parents]:
@@ -54,6 +85,9 @@ def attach_file_metrics(node: Node, file_info) -> None:
         node.metrics.tsx_duplicated_string_count = file_info.tsx_duplicated_string_count
         node.metrics.ts_type_interface_count = file_info.ts_type_interface_count
         node.metrics.ts_export_count = file_info.ts_export_count
+    # Markdown-specific metrics
+    if hasattr(file_info, "md_data_url_count"):
+        node.metrics.md_data_url_count = file_info.md_data_url_count
     
     # New metrics
     if hasattr(file_info, 'comment_lines'):
@@ -125,6 +159,7 @@ def attach_file_metrics(node: Node, file_info) -> None:
         func_node.metrics.comment_lines = getattr(func, 'comment_lines', 0)
         func_node.metrics.todo_count = getattr(func, 'todo_count', 0)
         func_node.metrics.ts_type_interface_count = getattr(func, 'ts_type_interface_count', 0)
+        func_node.metrics.md_data_url_count = getattr(func, 'md_data_url_count', 0)
         
         # Density for function
         comment_lines = getattr(func, 'comment_lines', 0)
@@ -266,6 +301,36 @@ def _is_gitignored(path: Path, ignore_root: Path, spec: PathSpec | None) -> bool
     rel_str = rel.as_posix()
     return spec.match_file(rel_str)
 
+
+def _should_log_file_progress(completed_count: int, total_count: int) -> bool:
+    """
+    Decide whether to emit a per-file progress log.
+
+    Rules:
+    - If there are fewer than 10 files, log every file.
+    - Otherwise:
+      - Log the first 10 files.
+      - Log at 15 and 20.
+      - Log every 25th file after that (25, 50, 75, ...).
+      - Always log the final file when done.
+    """
+    if total_count < 10:
+        return True
+
+    if completed_count <= 10:
+        return True
+
+    if completed_count in (15, 20):
+        return True
+
+    if completed_count % 25 == 0:
+        return True
+
+    if completed_count == total_count:
+        return True
+
+    return False
+
 def aggregate_metrics(node: Node) -> Metrics:
     if not node.children: return node.metrics
 
@@ -281,6 +346,7 @@ def aggregate_metrics(node: Node) -> Metrics:
     total_classes_count = 0
     total_type_interface_count = 0
     total_export_count = 0
+    total_md_data_url_count = 0
     
     # For average function length, we need total function loc and total functions (already have total_funcs)
     # But we need to sum function locs from children.
@@ -301,6 +367,7 @@ def aggregate_metrics(node: Node) -> Metrics:
         total_classes_count += child_metrics.classes_count
         total_type_interface_count += child_metrics.ts_type_interface_count
         total_export_count += child_metrics.ts_export_count
+        total_md_data_url_count += child_metrics.md_data_url_count
         
         # Reconstruct total function loc from average * count
         total_function_loc += (child_metrics.average_function_length * child_metrics.function_count)
@@ -327,6 +394,7 @@ def aggregate_metrics(node: Node) -> Metrics:
         node.metrics.average_function_length = total_function_loc / total_funcs if total_funcs > 0 else 0.0
         node.metrics.ts_type_interface_count = total_type_interface_count
         node.metrics.ts_export_count = total_export_count
+        node.metrics.md_data_url_count = total_md_data_url_count
     
     return node.metrics
 
@@ -336,11 +404,19 @@ def analyze_single_file(file_path: str):
     Must be top-level for multiprocessing pickling.
     """
     try:
-        if file_path.endswith('.ts') or file_path.endswith('.tsx'):
+        if file_path.endswith(".ts") or file_path.endswith(".tsx"):
             analyzer = get_ts_analyzer()
             return analyzer.analyze_file(file_path)
-        else:
-            return lizard.analyze_file(file_path)
+        if file_path.endswith(".css") or file_path.endswith(".scss"):
+            analyzer = get_css_analyzer()
+            return analyzer.analyze_file(file_path)
+        if file_path.endswith(".md") or file_path.endswith(".markdown"):
+            analyzer = get_md_analyzer()
+            return analyzer.analyze_file(file_path)
+        if file_path.endswith(".ipynb"):
+            analyzer = get_ipynb_analyzer()
+            return analyzer.analyze_file(file_path)
+        return lizard.analyze_file(file_path)
     except Exception as e:
         # Return error info instead of crashing
         return {"error": str(e), "filename": file_path}
@@ -405,12 +481,13 @@ def scan_codebase(root_path: Path) -> Node:
             completed_count += 1
             try:
                 # Add a timeout to prevent hanging on single files
-                result = future.result(timeout=5)
+                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
-                    print(f"✅ [{completed_count}/{total_count}] Analyzed {file}", flush=True)
+                    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)
@@ -421,7 +498,15 @@ def scan_codebase(root_path: Path) -> Node:
     node_map = {str(root_path): tree_root}
 
     for file_info in analysis_results:
-        path_obj = Path(file_info.filename)
+        # Be defensive: if we ever get back an unexpected object from the
+        # worker (e.g. a dict without "error", or something without a
+        # ``filename`` attribute), skip it instead of crashing the whole scan.
+        filename = getattr(file_info, "filename", None)
+        if not filename:
+            print(f"⚠️ Skipping unexpected analysis result without filename: {file_info!r}", flush=True)
+            continue
+
+        path_obj = Path(filename)
         try: rel_path = path_obj.relative_to(root_path)
         except ValueError: continue
 

srcly-0.1.16/app/services/css_analysis.py

@@ -0,0 +1,232 @@
+import re
+from typing import List
+
+import tree_sitter_css as tscss
+import tree_sitter_scss as tsscss
+from tree_sitter import Language, Node, Parser
+
+from app.services.tree_sitter_analysis import FileMetrics, FunctionMetrics
+
+
+CSS_LANGUAGE = Language(tscss.language())
+SCSS_LANGUAGE = Language(tsscss.language())
+
+
+class CssTreeSitterAnalyzer:
+    """
+    Analyze CSS and SCSS files using tree-sitter and emit a hierarchy of
+    "scopes" compatible with the existing FunctionMetrics / FileMetrics
+    pipeline.
+
+    Goals:
+      - For CSS: treat each rule / at-rule block as a scope.
+      - For SCSS: in addition to CSS rules, create scopes for:
+          - nested rules (selectors inside selectors / at-rules)
+          - mixin definitions
+          - function definitions
+    """
+
+    def __init__(self) -> None:
+        self.css_parser = Parser(CSS_LANGUAGE)
+        self.scss_parser = Parser(SCSS_LANGUAGE)
+
+    def analyze_file(self, file_path: str) -> FileMetrics:
+        with open(file_path, "rb") as f:
+            content = f.read()
+
+        is_scss = file_path.endswith(".scss")
+        parser = self.scss_parser if is_scss else self.css_parser
+        tree = parser.parse(content)
+
+        # Simple non-empty line count for LOC
+        lines = content.splitlines()
+        nloc = len([l for l in lines if l.strip()])
+
+        scopes = self._extract_scopes(tree.root_node, content, is_scss=is_scss)
+
+        average_complexity = (
+            sum(f.cyclomatic_complexity for f in scopes) / len(scopes)
+            if scopes
+            else 0.0
+        )
+
+        total_scope_loc = sum(f.nloc for f in scopes)
+        average_scope_length = total_scope_loc / len(scopes) if scopes else 0.0
+
+        # For now we do not compute any CSS/SCSS-specific metrics; everything
+        # other than LOC and the scope hierarchy stays at 0 so the rest of the
+        # pipeline can aggregate safely.
+        return FileMetrics(
+            nloc=nloc,
+            average_cyclomatic_complexity=average_complexity,
+            function_list=scopes,
+            filename=file_path,
+            comment_lines=0,
+            comment_density=0.0,
+            max_nesting_depth=0,
+            average_function_length=average_scope_length,
+            parameter_count=0,
+            todo_count=0,
+            classes_count=0,
+            tsx_nesting_depth=0,
+            tsx_render_branching_count=0,
+            tsx_react_use_effect_count=0,
+            tsx_anonymous_handler_count=0,
+            tsx_prop_count=0,
+            ts_any_usage_count=0,
+            ts_ignore_count=0,
+            ts_import_coupling_count=0,
+            tsx_hardcoded_string_volume=0,
+            tsx_duplicated_string_count=0,
+            ts_type_interface_count=0,
+            ts_export_count=0,
+            md_data_url_count=0,
+        )
+
+    # ---- Scope extraction ----------------------------------------------------
+
+    def _extract_scopes(
+        self, root: Node, content: bytes, is_scss: bool
+    ) -> List[FunctionMetrics]:
+        """
+        Walk the CSS / SCSS syntax tree and build a hierarchy of scopes.
+
+        We treat any node that looks like a "rule" / "block" container (rule
+        sets, at-rules, etc.) as a scope. For SCSS we also treat mixin and
+        function definitions as scopes.
+        """
+
+        def walk(node: Node) -> List[FunctionMetrics]:
+            results: List[FunctionMetrics] = []
+            for child in node.children:
+                if self._node_is_scope(child, is_scss=is_scss):
+                    scope = self._build_scope_metrics(child, content, is_scss=is_scss)
+                    scope.children = walk(child)
+                    results.append(scope)
+                else:
+                    results.extend(walk(child))
+            return results
+
+        return walk(root)
+
+    def _node_is_scope(self, node: Node, is_scss: bool) -> bool:
+        """
+        Heuristic: identify rule / at-rule / mixin / function nodes.
+
+        The exact node type names differ slightly between CSS and SCSS
+        grammars, so we rely on a mix of explicit names and substring checks.
+        """
+
+        t = node.type
+
+        # Common CSS rule / at-rule containers.
+        rule_like_types = {
+            "rule_set",
+            "ruleset",
+            "style_rule",
+            "qualified_rule",
+            "media_rule",
+            "supports_rule",
+            "keyframes_rule",
+            "font_face_rule",
+            "page_rule",
+        }
+        if t in rule_like_types:
+            return True
+
+        # Generic heuristic: anything with "rule" in the name (but not the
+        # root stylesheet) is probably a rule-like container.
+        if "rule" in t and t not in {"stylesheet"}:
+            return True
+
+        if is_scss:
+            # SCSS-specific constructs for functions / mixins and control flow
+            # that introduce nested blocks.
+            scss_scope_types = {
+                "mixin_declaration",
+                "mixin_definition",
+                "function_declaration",
+                "function_definition",
+                "if_statement",
+                "each_statement",
+                "for_statement",
+                "while_statement",
+            }
+            if t in scss_scope_types:
+                return True
+
+            if any(
+                key in t
+                for key in (
+                    "mixin",
+                    "function",
+                )
+            ):
+                return True
+
+        return False
+
+    def _build_scope_metrics(
+        self, node: Node, content: bytes, is_scss: bool
+    ) -> FunctionMetrics:
+        start_line = node.start_point.row + 1
+        end_line = node.end_point.row + 1
+        nloc = max(0, end_line - start_line + 1)
+
+        name = self._get_scope_name(node, content)
+        origin_type = "scss_scope" if is_scss else "css_scope"
+
+        return FunctionMetrics(
+            name=name,
+            cyclomatic_complexity=0,
+            nloc=nloc,
+            start_line=start_line,
+            end_line=end_line,
+            parameter_count=0,
+            max_nesting_depth=0,
+            comment_lines=0,
+            todo_count=0,
+            ts_type_interface_count=0,
+            md_data_url_count=0,
+            origin_type=origin_type,
+            is_jsx_container=False,
+        )
+
+    # ---- Helpers -------------------------------------------------------------
+
+    def _get_scope_name(self, node: Node, content: bytes, max_len: int = 80) -> str:
+        """
+        Derive a human-friendly name for a CSS / SCSS scope by taking the
+        first line of the node text up to the opening '{', if present.
+        """
+
+        # Use byte offsets so we don't depend on child layout details.
+        src = content[node.start_byte : node.end_byte].decode(
+            "utf-8", errors="ignore"
+        )
+
+        # Take the first non-empty line.
+        first_line = ""
+        for line in src.splitlines():
+            stripped = line.strip()
+            if stripped:
+                first_line = stripped
+                break
+
+        if not first_line:
+            first_line = node.type
+
+        # Trim everything after '{' so selectors / rule headers look clean.
+        brace_index = first_line.find("{")
+        if brace_index != -1:
+            first_line = first_line[:brace_index].rstrip()
+
+        # Collapse internal whitespace to keep long selectors readable.
+        first_line = re.sub(r"\s+", " ", first_line).strip()
+
+        if len(first_line) > max_len:
+            first_line = first_line[: max_len - 1] + "…"
+
+        return first_line or node.type
+
+

srcly-0.1.16/app/services/ipynb_analysis.py

@@ -0,0 +1,89 @@
+import json
+from typing import List
+
+from app.services.tree_sitter_analysis import FileMetrics, FunctionMetrics
+
+
+class NotebookAnalyzer:
+    """
+    Lightweight analysis pipeline for Jupyter notebooks.
+
+    The goal is to:
+    - Treat each cell as a "scope" so it can appear as a child in the treemap.
+    - Count LOC **only** from the `source` field of each cell (code/markdown/raw).
+      We explicitly ignore any `outputs`/execution metadata so that large output-
+      heavy notebooks don't dominate the treemap.
+    """
+
+    def analyze_file(self, file_path: str) -> FileMetrics:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        cells = data.get("cells") or []
+
+        function_list: List[FunctionMetrics] = []
+        current_line = 1
+        total_nloc = 0
+
+        for idx, cell in enumerate(cells):
+            cell_type = cell.get("cell_type", "cell")
+            source = cell.get("source", "")
+
+            # `source` can be a list of lines or a single string.
+            if isinstance(source, list):
+                text = "".join(source)
+            else:
+                text = str(source)
+
+            lines = text.splitlines()
+            # Count only non-empty lines of actual content.
+            non_empty_lines = [ln for ln in lines if ln.strip()]
+            loc = len(non_empty_lines)
+
+            if loc <= 0:
+                # Skip zero-LOC cells entirely for treemap sizing purposes.
+                continue
+
+            start_line = current_line
+            end_line = current_line + loc - 1
+            current_line = end_line + 1
+            total_nloc += loc
+
+            name = f"[{cell_type}] cell {idx + 1}"
+
+            cell_metrics = FunctionMetrics(
+                name=name,
+                cyclomatic_complexity=0,
+                nloc=loc,
+                start_line=start_line,
+                end_line=end_line,
+            )
+            function_list.append(cell_metrics)
+
+        # Aggregate simple file-level metrics.
+        average_complexity = (
+            sum(f.cyclomatic_complexity for f in function_list) / len(function_list)
+            if function_list
+            else 0.0
+        )
+
+        average_function_length = (
+            total_nloc / len(function_list) if function_list else 0.0
+        )
+
+        return FileMetrics(
+            nloc=total_nloc,
+            average_cyclomatic_complexity=average_complexity,
+            function_list=function_list,
+            filename=file_path,
+            comment_lines=0,
+            comment_density=0.0,
+            max_nesting_depth=0,
+            average_function_length=average_function_length,
+            parameter_count=0,
+            todo_count=0,
+            classes_count=0,
+            # TS/TSX-specific metrics remain at their defaults (all zeros) for notebooks.
+        )
+
+