srcly 0.1.8__tar.gz → 0.1.9__tar.gz

{srcly-0.1.8 → srcly-0.1.9}/PKG-INFO

@@ -1,11 +1,15 @@
 Metadata-Version: 2.4
 Name: srcly
-Version: 0.1.8
+Version: 0.1.9
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3
 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-typescript>=0.23.2
+Requires-Dist: tree-sitter>=0.25.2
 Requires-Dist: uvicorn>=0.38.0
 Description-Content-Type: text/markdown
 

{srcly-0.1.8 → srcly-0.1.9}/app/config.py

@@ -28,5 +28,5 @@ IGNORE_EXTENSIONS: Set[str] = {
     '.zip', '.tar', '.gz', '.map', '.min.js', '.min.css', '.json', '.xml', '.txt', 
     '.ttf', '.woff', '.woff2', '.eot', '.otf', '.mp4', '.mp3', '.wav', '.webm', '.ogg',
     '.exe', '.dll', '.so', '.dylib', '.bin', '.iso', '.dmg', '.pkg', '.deb', '.rpm',
-    '.csv'
+    '.csv', '.lock'
 }

{srcly-0.1.8 → srcly-0.1.9}/app/models.py

@@ -7,6 +7,10 @@ class Metrics(BaseModel):
     # so we store it as a float to match the analysis values.
     complexity: float = 0.0
     function_count: int = 0
+    last_modified: float = 0.0
+    gitignored_count: int = 0
+    file_size: int = 0
+    file_count: int = 0
 
 class Node(BaseModel):
     name: str
@@ -15,6 +19,8 @@ class Node(BaseModel):
     metrics: Metrics
     # Use default_factory to avoid sharing the same list across instances
     children: List["Node"] = Field(default_factory=list)
+    start_line: int = 0
+    end_line: int = 0
 
     model_config = {
         "populate_by_name": True

{srcly-0.1.8 → srcly-0.1.9}/app/routers/analysis.py

@@ -44,20 +44,18 @@ async def refresh_analysis():
     return tree
 
 
-@router.get("/context")
-async def get_analysis_context():
+def _estimate_counts(root: Path) -> tuple[int, int]:
     """
-    Return basic information about the current analysis root directory.
+    Return an estimated (file_count, folder_count) for a given root directory.
 
-    This is used by the client to offer a one-click "analyze current folder"
-    option on first load.
+    This applies the same ignore rules used during a full analysis to keep the
+    estimate reasonably fast while still informative.
     """
-    root = ROOT_PATH
     file_count = 0
     folder_count = 0
 
     try:
-        for dirpath, dirnames, filenames in os.walk(root):
+        for _, dirnames, filenames in os.walk(root):
             # Apply ignore rules for directories to keep the estimate reasonable
             dirnames[:] = [
                 d for d in dirnames
@@ -70,8 +68,32 @@ async def get_analysis_context():
         file_count = 0
         folder_count = 0
 
+    return file_count, folder_count
+
+
+@router.get("/context")
+async def get_analysis_context():
+    """
+    Return basic information about the current analysis root directory.
+
+    This is used by the client to offer one-click analysis options on first
+    load, for both the current working directory and the repository root.
+    """
+    current_root = ROOT_PATH
+    repo_root = current_root.parent
+
+    current_file_count, current_folder_count = _estimate_counts(current_root)
+
+    repo_file_count = 0
+    repo_folder_count = 0
+    if repo_root.exists():
+        repo_file_count, repo_folder_count = _estimate_counts(repo_root)
+
     return {
-        "root_path": str(root),
-        "file_count": file_count,
-        "folder_count": folder_count,
+        "root_path": str(current_root),
+        "file_count": current_file_count,
+        "folder_count": current_folder_count,
+        "repo_root_path": str(repo_root),
+        "repo_file_count": repo_file_count,
+        "repo_folder_count": repo_folder_count,
     }

{srcly-0.1.8 → srcly-0.1.9}/app/run.py

@@ -26,11 +26,34 @@ def _open_browser_later(url: str, delay: float = 1.0) -> None:
     thread.start()
 
 
+def _find_repo_root(start_path: str) -> str:
+    """
+    Walk upwards from ``start_path`` to find a Git repository root.
+
+    Returns the first directory that contains a `.git` directory or file.
+    If none is found, the original ``start_path`` is returned.
+    """
+    current = os.path.abspath(start_path)
+
+    while True:
+        git_path = os.path.join(current, ".git")
+        if os.path.exists(git_path):
+            return current
+
+        parent = os.path.dirname(current)
+        if parent == current:
+            # Reached filesystem root; fall back to the original start path.
+            return os.path.abspath(start_path)
+
+        current = parent
+
+
 def main(argv: list[str] | None = None) -> None:
     """
     Entry point for the CLI.
 
-    - Uses the current working directory (or a provided path) as the codebase root.
+    - With no path argument, uses the enclosing Git repo root as the codebase root.
+    - If a path is provided (including "."), uses that as the codebase root.
     - Starts the FastAPI server.
     - Opens the default browser to the app URL.
     """
@@ -38,14 +61,17 @@ def main(argv: list[str] | None = None) -> None:
         prog="srcly",
         description=(
             "Interactive codebase treemap and metrics viewer. "
-            "By default, analyzes the current working directory."
+            "By default, analyzes the enclosing Git repository root."
         ),
     )
     parser.add_argument(
         "path",
         nargs="?",
-        default=".",
-        help="Path to the codebase to analyze (default: current directory).",
+        help=(
+            "Path to the codebase to analyze. "
+            "If omitted, the enclosing Git repo root is used. "
+            'Use "." explicitly to analyze the current directory.'
+        ),
     )
     parser.add_argument(
         "--host",
@@ -61,7 +87,11 @@ def main(argv: list[str] | None = None) -> None:
 
     args = parser.parse_args(argv)
 
-    target_path = os.path.abspath(args.path)
+    if args.path is None:
+        target_path = _find_repo_root(os.getcwd())
+    else:
+        target_path = os.path.abspath(args.path)
+
     if not os.path.exists(target_path):
         raise SystemExit(f"Path does not exist: {target_path}")
 

srcly-0.1.9/app/services/analysis.py

@@ -0,0 +1,331 @@
+import os
+import lizard
+import concurrent.futures
+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 pathspec import PathSpec
+
+_ts_analyzer = None
+
+def get_ts_analyzer():
+    global _ts_analyzer
+    if _ts_analyzer is None:
+        _ts_analyzer = TreeSitterAnalyzer()
+    return _ts_analyzer
+
+def find_repo_root(start_path: Path) -> Path:
+    current = start_path.resolve()
+    for parent in [current, *current.parents]:
+        if (parent / ".git").exists(): return parent
+    return current
+
+def create_node(name: str, node_type: str, path: str) -> Node:
+    return Node(
+        name=name,
+        type=node_type,
+        path=path,
+        metrics=Metrics(),
+        children=[]
+    )
+
+def attach_file_metrics(node: Node, file_info) -> None:
+    total_loc = file_info.nloc
+    node.metrics.loc = total_loc
+    node.metrics.complexity = file_info.average_cyclomatic_complexity
+    node.metrics.function_count = len(file_info.function_list)
+    node.metrics.file_count = 1
+    
+    # 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.
+    
+    # Calculate sum of function LOCs
+    func_sum_loc = 0
+    
+    def convert_function(func, parent_path: str) -> Node:
+        func_node = create_node(func.name, "function", f"{parent_path}::{func.name}")
+        func_node.metrics.loc = func.nloc
+        func_node.metrics.complexity = func.cyclomatic_complexity
+        
+        if hasattr(func, 'start_line'):
+            func_node.start_line = func.start_line
+        if hasattr(func, 'end_line'):
+            func_node.end_line = func.end_line
+            
+        # Process children if they exist (for TS/TSX)
+        if hasattr(func, 'children') and func.children:
+            for child in func.children:
+                child_node = convert_function(child, func_node.path)
+                func_node.children.append(child_node)
+        
+        return func_node
+
+    for func in file_info.function_list:
+        func_node = convert_function(func, node.path)
+        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)
+
+
+def _translate_gitignore_pattern(raw_line: str, base_rel: str) -> str | None:
+    """
+    Translate a single .gitignore pattern that lives in a directory `base_rel`
+    (relative to the repo root) into a repo-root-relative gitwildmatch pattern.
+
+    This approximates Git's semantics including:
+    - patterns starting with '!' (negation)
+    - patterns starting with '/' (anchored to the .gitignore directory)
+    - patterns without '/' applying within the directory subtree
+    """
+    line = raw_line.rstrip("\n")
+    if not line or line.lstrip().startswith("#"):
+        return None
+
+    negated = line.startswith("!")
+    body = line[1:] if negated else line
+
+    # Strip leading slash: anchored to the directory containing the .gitignore
+    if body.startswith("/"):
+        body = body[1:]
+
+    # Compute prefix for this .gitignore directory
+    prefix = f"{base_rel}/" if base_rel else ""
+
+    # If the pattern contains a slash, it's relative to the directory root.
+    # Otherwise, it should match that name anywhere under the directory.
+    if "/" in body:
+        pat = prefix + body
+    else:
+        if base_rel:
+            pat = f"{base_rel}/**/{body}"
+        else:
+            pat = f"**/{body}"
+
+    return f"!{pat}" if negated else pat
+
+
+def _load_gitignore_spec(root_path: Path) -> tuple[Path, PathSpec | None]:
+    """
+    Load a PathSpec representing .gitignore rules visible from the given
+    root path, honoring nested .gitignore files similarly to Git.
+
+    We treat the *repository root* (where .git lives) as the base for all
+    ignore patterns, so that scanning a subdirectory still respects repo-level
+    .gitignore files and nested ones.
+    """
+    repo_root = find_repo_root(root_path)
+
+    all_patterns: list[str] = []
+
+    for dirpath, dirnames, filenames in os.walk(repo_root):
+        # Never look inside the .git directory for ignore rules
+        if ".git" in dirnames:
+            dirnames.remove(".git")
+
+        if ".gitignore" not in filenames:
+            continue
+
+        gitignore_file = Path(dirpath) / ".gitignore"
+        base_rel = (
+            str(Path(dirpath).relative_to(repo_root).as_posix())
+            if Path(dirpath) != repo_root
+            else ""
+        )
+
+        with open(gitignore_file, "r") as f:
+            for raw in f:
+                translated = _translate_gitignore_pattern(raw, base_rel)
+                if translated is not None:
+                    all_patterns.append(translated)
+
+    if not all_patterns:
+        return repo_root, None
+
+    spec = PathSpec.from_lines("gitwildmatch", all_patterns)
+    return repo_root, spec
+
+
+def _is_gitignored(path: Path, ignore_root: Path, spec: PathSpec | None) -> bool:
+    """
+    Return True if the given path should be ignored according to the
+    provided PathSpec and root_path.
+    """
+    if spec is None:
+        return False
+
+    try:
+        rel = path.relative_to(ignore_root)
+    except ValueError:
+        rel = path
+
+    rel_str = rel.as_posix()
+    return spec.match_file(rel_str)
+
+def aggregate_metrics(node: Node) -> Metrics:
+    if not node.children: return node.metrics
+
+    total_loc = 0
+    max_complexity = 0
+    total_funcs = 0
+
+    for child in node.children:
+        child_metrics = aggregate_metrics(child)
+        total_loc += child_metrics.loc
+        max_complexity = max(max_complexity, child_metrics.complexity)
+        total_funcs += child_metrics.function_count
+
+    # For Folders: Sum of children
+    # For Files: We trust the attach_file_metrics logic (which includes __misc__)
+    if node.type == "folder":
+        node.metrics.loc = total_loc
+        node.metrics.complexity = max_complexity
+        node.metrics.function_count = total_funcs
+        
+        # Aggregate last_modified (max of children) and gitignored_count (sum of children)
+        node.metrics.last_modified = max((child.metrics.last_modified for child in node.children), default=0.0)
+        node.metrics.gitignored_count = sum(child.metrics.gitignored_count for child in node.children)
+        node.metrics.file_size = sum(child.metrics.file_size for child in node.children)
+        node.metrics.file_count = sum(child.metrics.file_count for child in node.children)
+    
+    return node.metrics
+
+def analyze_single_file(file_path: str):
+    """
+    Wrapper to analyze a single file safely.
+    Must be top-level for multiprocessing pickling.
+    """
+    try:
+        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)
+    except Exception as e:
+        # Return error info instead of crashing
+        return {"error": str(e), "filename": file_path}
+
+def scan_codebase(root_path: Path) -> Node:
+    print(f"🔍 Scanning: {root_path}", flush=True)
+
+    # Load .gitignore spec (repo-wide, with nested .gitignore support)
+    ignore_root, gitignore_spec = _load_gitignore_spec(root_path)
+
+    files_to_scan: list[str] = []
+    ignored_counts: dict[str, int] = {}
+
+    for root_dir, dirs, files in os.walk(root_path):
+        root_dir_path = Path(root_dir)
+
+        # Apply ignore dirs from config and .gitignore
+        # We must modify dirs in-place to prune traversal
+        pruned_dirs: list[str] = []
+        for d in dirs:
+            if d in IGNORE_DIRS:
+                continue
+            dir_path = root_dir_path / d
+            if _is_gitignored(dir_path, ignore_root, gitignore_spec):
+                # Entire directory is ignored; we skip traversing into it.
+                continue
+            pruned_dirs.append(d)
+        dirs[:] = pruned_dirs
+
+        current_ignored_count = 0
+        for file in files:
+            if file in IGNORE_FILES:
+                continue
+            if Path(file).suffix in IGNORE_EXTENSIONS:
+                continue
+
+            file_path = root_dir_path / file
+
+            if _is_gitignored(file_path, ignore_root, gitignore_spec):
+                current_ignored_count += 1
+                continue
+
+            files_to_scan.append(str(file_path))
+
+        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=5)
+                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)
+                    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)
+
+    tree_root = create_node("root", "folder", str(root_path))
+    node_map = {str(root_path): tree_root}
+
+    for file_info in analysis_results:
+        path_obj = Path(file_info.filename)
+        try: rel_path = path_obj.relative_to(root_path)
+        except ValueError: continue
+
+        parts = rel_path.parts
+        current_node = tree_root
+        current_path = root_path
+
+        # Build Folder Tree
+        for part in parts[:-1]:
+            next_path = current_path / part
+            next_path_str = str(next_path)
+            if next_path_str not in node_map:
+                new_folder = create_node(part, "folder", next_path_str)
+                # Set gitignored count if we have it for this folder
+                if next_path_str in ignored_counts:
+                    new_folder.metrics.gitignored_count = ignored_counts[next_path_str]
+                current_node.children.append(new_folder)
+                node_map[next_path_str] = new_folder
+            current_node = node_map[next_path_str]
+            current_path = next_path
+
+        # Add File
+        file_node = create_node(parts[-1], "file", str(path_obj))
+        file_node = create_node(parts[-1], "file", str(path_obj))
+        attach_file_metrics(file_node, file_info)
+        # Set last_modified
+        try:
+            stat = os.stat(path_obj)
+            file_node.metrics.last_modified = stat.st_mtime
+            file_node.metrics.file_size = stat.st_size
+        except OSError:
+            file_node.metrics.last_modified = 0.0
+            file_node.metrics.file_size = 0
+            
+        current_node.children.append(file_node)
+
+    aggregate_metrics(tree_root)
+    return tree_root