srcly 0.1.14__tar.gz → 0.1.17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srcly
-Version: 0.1.14
+Version: 0.1.17
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3
@@ -9,6 +9,10 @@ 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-python==0.25.0
+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.17}/app/models.py

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

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

@@ -5,7 +5,8 @@ import os
 from typing import Dict, List, Optional, Tuple
 
 from app.models import Node, DependencyGraph, DependencyNode, DependencyEdge
-from app.services import analysis, cache, tree_sitter_analysis
+from app.services import analysis, cache
+from app.services.typescript import typescript_analysis
 from app.config import IGNORE_DIRS
 
 router = APIRouter(prefix="/api/analysis", tags=["analysis"])
@@ -333,7 +334,7 @@ async def get_dependencies(path: str = None):
     if not target_path.exists():
         raise HTTPException(status_code=404, detail="Path not found")
 
-    analyzer = tree_sitter_analysis.TreeSitterAnalyzer()
+    analyzer = typescript_analysis.TreeSitterAnalyzer()
     nodes = []
     edges = []
     
@@ -570,7 +571,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.17}/app/routers/files.py

@@ -2,6 +2,8 @@ from fastapi import APIRouter, HTTPException, Query
 from pathlib import Path
 from fastapi.responses import PlainTextResponse
 
+from app.services.analysis import get_ipynb_analyzer
+
 router = APIRouter(prefix="/api/files", tags=["files"])
 
 @router.get("/content", response_class=PlainTextResponse)
@@ -21,6 +23,8 @@ 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:
+        if file_path.suffix == ".ipynb":
+            return get_ipynb_analyzer().get_virtual_content(str(file_path))
         return file_path.read_text(encoding="utf-8")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Failed to read file: {str(e)}")

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

@@ -5,10 +5,20 @@ 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.typescript.typescript_analysis import TreeSitterAnalyzer
+from app.services.markdown.markdown_analysis import MarkdownTreeSitterAnalyzer
+from app.services.ipynb.ipynb_analysis import NotebookAnalyzer
+from app.services.css.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,35 @@ 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
+
+_python_analyzer = None
+def get_python_analyzer():
+    global _python_analyzer
+    if _python_analyzer is None:
+        from app.services.python.python_analysis import PythonTreeSitterAnalyzer
+        _python_analyzer = PythonTreeSitterAnalyzer()
+    return _python_analyzer
+
 def find_repo_root(start_path: Path) -> Path:
     current = start_path.resolve()
     for parent in [current, *current.parents]:
@@ -54,6 +93,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'):
@@ -65,6 +107,9 @@ def attach_file_metrics(node: Node, file_info) -> None:
         node.metrics.todo_count = file_info.todo_count
         node.metrics.classes_count = file_info.classes_count
     
+    if hasattr(file_info, 'python_import_count'):
+        node.metrics.python_import_count = file_info.python_import_count
+    
     # Set start/end line for the file (approximate, 1 to total lines)
     # We don't strictly have this from lizard always, but we can infer or leave 0.
     # For now, let's leave file start/end as 0 unless we want to read the file.
@@ -125,6 +170,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 +312,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 +357,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 +378,13 @@ 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
+        if hasattr(child_metrics, 'python_import_count'):
+             # Metric model has it, but child_metrics is a Metrics object so it should have it
+             total_python_import_count = getattr(child_metrics, 'python_import_count', 0)
+             # Should we add a local var for this? Yes
+             pass
+        
         
         # Reconstruct total function loc from average * count
         total_function_loc += (child_metrics.average_function_length * child_metrics.function_count)
@@ -326,7 +410,10 @@ def aggregate_metrics(node: Node) -> Metrics:
         node.metrics.classes_count = total_classes_count
         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_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
+        node.metrics.python_import_count = total_python_import_count
     
     return node.metrics
 
@@ -336,11 +423,25 @@ 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)
+        if file_path.endswith(".py"):
+             # We can cache it similarly if we want, or just instantiate. 
+             # For consistency let's add a getter or just instantiate for now to avoid circular imports / global clutter
+             # actually lets follow pattern
+             return get_python_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 +506,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 +523,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.17/app/services/analysis_types.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import List
+
+@dataclass
+class FunctionMetrics:
+    name: str
+    cyclomatic_complexity: int
+    nloc: int
+    start_line: int
+    end_line: int
+    parameter_count: int = 0
+    max_nesting_depth: int = 0
+    comment_lines: int = 0
+    todo_count: int = 0
+    # TS/TSX Specific Metrics (per-function)
+    ts_type_interface_count: int = 0
+    # Markdown-specific metrics
+    md_data_url_count: int = 0
+    # TSX structure helpers
+    contains_tsx: bool = False
+    tsx_start_line: int = 0
+    tsx_end_line: int = 0
+    tsx_root_name: str = ""
+    tsx_root_is_fragment: bool = False
+    origin_type: str = ""
+    is_jsx_container: bool = False
+    children: List["FunctionMetrics"] = field(default_factory=list)
+    # We store children to represent nested functions.
+
+@dataclass
+class FileMetrics:
+    nloc: int
+    average_cyclomatic_complexity: float
+    function_list: List[FunctionMetrics] = field(default_factory=list)
+    filename: str = ""
+    comment_lines: int = 0
+    comment_density: float = 0.0
+    max_nesting_depth: int = 0
+    average_function_length: float = 0.0
+    parameter_count: int = 0
+    todo_count: int = 0
+    classes_count: int = 0
+    
+    # TS/TSX Specific Metrics
+    tsx_nesting_depth: int = 0
+    tsx_render_branching_count: int = 0
+    tsx_react_use_effect_count: int = 0
+    tsx_anonymous_handler_count: int = 0
+    tsx_prop_count: int = 0
+    ts_any_usage_count: int = 0
+    ts_ignore_count: int = 0
+    ts_import_coupling_count: int = 0
+    tsx_hardcoded_string_volume: int = 0
+    tsx_duplicated_string_count: int = 0
+    ts_type_interface_count: int = 0
+    ts_type_interface_count: int = 0
+    ts_export_count: int = 0
+    # Python-specific metrics
+    python_import_count: int = 0
+    # Markdown-specific metrics (per-file)
+    md_data_url_count: int = 0

srcly-0.1.17/app/services/css/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.analysis_types 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.14 → srcly-0.1.17}/app/services/data_flow_analysis.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import List, Dict, Optional, Any
 import uuid
 
-from app.services.tree_sitter_analysis import TreeSitterAnalyzer
+from app.services.typescript.typescript_analysis import TreeSitterAnalyzer
 
 # Load TypeScript and TSX grammars
 TYPESCRIPT_LANGUAGE = Language(tstypescript.language_typescript())