repoglance 0.4.2__tar.gz → 0.4.3__tar.gz

{repoglance-0.4.2 → repoglance-0.4.3}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.3] - 2026-08-01
+
+### Added
+- **`--fast` mode**: counts only (languages, LOC, sizes), skipping per-function
+  complexity parsing — the expensive step. Combined with the process pool this
+  scans **20 million lines in ~4.4 s** (~4.5M LOC/s). Use it for size/inventory
+  passes on very large monorepos; drop it for full complexity/health analysis.
+
+### Changed
+- **Python complexity now uses CPython's C-accelerated `ast`** instead of the
+  pure-Python tokenizer, roughly **halving full-analysis time on Python-heavy
+  repos** (Django 415k LOC: ~10 s → ~5 s on 8 cores). Other languages still use
+  lizard. Adaptive process-pool chunk sizing reduces IPC overhead.
+
 ## [0.4.2] - 2026-08-01
 
 ### Added

{repoglance-0.4.2 → repoglance-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repoglance
-Version: 0.4.2
+Version: 0.4.3
 Summary: Instant, gorgeous insight into any code repository — languages, complexity hotspots, TODOs and git activity in one terminal command.
 Project-URL: Homepage, https://github.com/SRJ-ai/repoglance
 Project-URL: Repository, https://github.com/SRJ-ai/repoglance
@@ -302,11 +302,16 @@ millions of lines, thousands of files — not just small projects:
 
 Measured on Django (3,180 files, ~415k lines of code), single machine:
 
-| Run | Time |
-|---|--:|
-| Cold scan, threads | ~20.5 s |
-| Cold scan, process pool (auto on large repos) | ~10.1 s |
-| Re-run with `--cache` | ~1.1 s |
+| Run | Repo | Time |
+|---|---|--:|
+| Cold scan, full analysis (8 cores) | Django, 415k LOC | ~5.0 s |
+| Re-run with `--cache` | Django, 415k LOC | ~1.1 s |
+| **`--fast` (counts only), process pool** | **20,000,000 LOC** | **~4.4 s** |
+
+`--fast` skips per-function complexity parsing (the expensive step) and reports
+languages, line counts and sizes only — that's what makes a 20-million-line
+scan finish in seconds (~4.5M LOC/s here). Drop `--fast` when you want the full
+complexity/health analysis.
 
 The cold scan is dominated by real per-function complexity parsing. The process
 pool spreads that across cores (~2× here); the incremental cache (`--cache

{repoglance-0.4.2 → repoglance-0.4.3}/README.md

@@ -270,11 +270,16 @@ millions of lines, thousands of files — not just small projects:
 
 Measured on Django (3,180 files, ~415k lines of code), single machine:
 
-| Run | Time |
-|---|--:|
-| Cold scan, threads | ~20.5 s |
-| Cold scan, process pool (auto on large repos) | ~10.1 s |
-| Re-run with `--cache` | ~1.1 s |
+| Run | Repo | Time |
+|---|---|--:|
+| Cold scan, full analysis (8 cores) | Django, 415k LOC | ~5.0 s |
+| Re-run with `--cache` | Django, 415k LOC | ~1.1 s |
+| **`--fast` (counts only), process pool** | **20,000,000 LOC** | **~4.4 s** |
+
+`--fast` skips per-function complexity parsing (the expensive step) and reports
+languages, line counts and sizes only — that's what makes a 20-million-line
+scan finish in seconds (~4.5M LOC/s here). Drop `--fast` when you want the full
+complexity/health analysis.
 
 The cold scan is dominated by real per-function complexity parsing. The process
 pool spreads that across cores (~2× here); the incremental cache (`--cache

{repoglance-0.4.2 → repoglance-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "repoglance"
-version = "0.4.2"
+version = "0.4.3"
 description = "Instant, gorgeous insight into any code repository — languages, complexity hotspots, TODOs and git activity in one terminal command."
 readme = "README.md"
 requires-python = ">=3.9"

{repoglance-0.4.2 → repoglance-0.4.3}/src/repoglance/__init__.py

@@ -1,3 +1,3 @@
 """repoglance — instant, gorgeous insight into any code repository."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"

{repoglance-0.4.2 → repoglance-0.4.3}/src/repoglance/cli.py

@@ -41,6 +41,7 @@ def _resolve(cli_val, cfg, key, default):
 @click.option("--max-bytes", type=int, default=None, help="Skip files larger than this many bytes.")
 @click.option("--jobs", type=int, default=None, help="Number of parallel workers for scanning.")
 @click.option("--processes/--threads", "use_processes", default=None, help="Force process- or thread-based parallelism (default: auto by repo size).")
+@click.option("--fast", is_flag=True, help="Counts only (languages, LOC) — skip complexity parsing for maximum speed on huge repos.")
 @click.option("--duplicates", "want_dupes", is_flag=True, help="Detect duplicated code blocks.")
 @click.option("--owners", "want_owners", is_flag=True, help="Attribute top complexity hotspots to authors (git blame).")
 @click.option("--include-vendored", is_flag=True, help="Analyze vendored/generated files instead of excluding them.")
@@ -57,9 +58,9 @@ def _resolve(cli_val, cfg, key, default):
 @click.version_option(__version__, "-V", "--version", prog_name="repoglance")
 def main(path, as_json, as_md, as_csv, as_sarif, sarif_threshold, html_path, svg_path,
          badge_path, badge_json_path, baseline_out, since_rev, include, exclude, ignore,
-         no_git, max_bytes, jobs, use_processes, want_dupes, want_owners, include_vendored,
-         cache_path, watch, compare_to, fail_on_regression, ci, max_complexity, max_todos,
-         fail_under):
+         no_git, max_bytes, jobs, use_processes, fast, want_dupes, want_owners,
+         include_vendored, cache_path, watch, compare_to, fail_on_regression, ci,
+         max_complexity, max_todos, fail_under):
     """Instant, gorgeous insight into any code repository.
 
     PATH defaults to the current directory. Configuration may be supplied via
@@ -82,7 +83,7 @@ def main(path, as_json, as_md, as_csv, as_sarif, sarif_threshold, html_path, svg
         "max_bytes": max_bytes, "extra_ignores": ignores, "include": include,
         "exclude": exclude, "changed_only": changed, "jobs": jobs,
         "include_vendored": include_vendored, "keep_contents": want_dupes,
-        "processes": use_processes,
+        "processes": use_processes, "fast": fast,
     }
 
     if watch:

{repoglance-0.4.2 → repoglance-0.4.3}/src/repoglance/complexity.py

@@ -70,7 +70,7 @@ def _lizard_scores(source: str, rel_path: str) -> Optional[List[FuncScore]]:
 
 
 def python_complexity(source: str, rel_path: str) -> List[FuncScore]:
-    """AST-based fallback for Python when lizard is unavailable."""
+    """Fast AST-based complexity for Python (CPython's C parser)."""
     try:
         tree = ast.parse(source)
     except SyntaxError:
@@ -79,17 +79,24 @@ def python_complexity(source: str, rel_path: str) -> List[FuncScore]:
     scores: List[FuncScore] = []
 
     class Visitor(ast.NodeVisitor):
-        def _score(self, node) -> int:
+        def _measure(self, node):
             complexity = 1
+            nodes = 0
             for child in ast.walk(node):
+                nodes += 1
                 if isinstance(child, _BRANCH_NODES):
                     complexity += 1
                 elif isinstance(child, _BOOLOP_EXTRA):
                     complexity += len(child.values) - 1
-            return complexity
+            end = getattr(node, "end_lineno", node.lineno) or node.lineno
+            nloc = max(1, end - node.lineno + 1)
+            args = node.args
+            params = len(args.args) + len(getattr(args, "posonlyargs", [])) + len(args.kwonlyargs)
+            return complexity, nloc, nodes, params
 
         def visit_FunctionDef(self, node):
-            scores.append(FuncScore(rel_path, node.name, node.lineno, self._score(node)))
+            cx, nloc, tokens, params = self._measure(node)
+            scores.append(FuncScore(rel_path, node.name, node.lineno, cx, nloc, tokens, params))
             self.generic_visit(node)
 
         visit_AsyncFunctionDef = visit_FunctionDef
@@ -104,14 +111,22 @@ def heuristic_complexity(source: str, rel_path: str) -> int:
 
 
 def analyze_complexity(source: str, rel_path: str, language: str) -> List[FuncScore]:
-    """Return per-function complexity, preferring lizard's real analysis."""
+    """Return per-function complexity.
+
+    Python is analyzed with CPython's C-accelerated ``ast`` (much faster than a
+    pure-Python tokenizer), which matters a lot on Python-heavy monorepos. Other
+    languages use lizard; anything lizard cannot read falls back to a heuristic.
+    """
     if language in NON_CODE_LANGS:
         return []
+    if language == "Python":
+        scores = python_complexity(source, rel_path)
+        if scores:
+            return scores
+        # Empty may mean a syntax error (e.g. Python 2); let lizard try.
     scores = _lizard_scores(source, rel_path)
     if scores is not None:
         return scores
-    if language == "Python":
-        return python_complexity(source, rel_path)
     score = heuristic_complexity(source, rel_path)
     return [FuncScore(rel_path, "(file)", 1, score)] if score > 1 else []
 

{repoglance-0.4.2 → repoglance-0.4.3}/src/repoglance/scanner.py

@@ -18,7 +18,7 @@ from typing import Dict, Iterable, List, Optional
 
 from .complexity import FuncScore, analyze_complexity
 from .languages import lang_for
-from .vendored import is_vendored
+from .vendored import is_vendored, is_vendored_path
 
 # Above this many files we default to process-based parallelism: complexity
 # parsing is CPU-bound and the GIL prevents threads from using multiple cores.
@@ -204,6 +204,7 @@ def scan(
     keep_contents: bool = False,
     cache_data: Optional[dict] = None,
     processes: Optional[bool] = None,
+    fast: bool = False,
 ) -> ScanResult:
     """Walk ``root`` and gather per-file line/language/complexity stats.
 
@@ -250,7 +251,7 @@ def scan(
     else:
         to_parse = todo
 
-    processed = _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, processes)
+    processed = _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, processes, fast)
 
     for full, item in zip(to_parse, processed):
         if item is None:
@@ -303,14 +304,15 @@ def _absorb(result, stat, todos, scores, vendored, include_vendored, text, keep_
         result.contents[stat.path] = text
 
 
-def _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, processes):
+def _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, processes, fast=False):
     """Analyze files in parallel. Uses processes for large, CPU-bound scans so
     complexity parsing actually spreads across cores (threads can't, due to the
     GIL); falls back to threads for small scans or when contents must be kept."""
     if not to_parse:
         return []
     worker = functools.partial(
-        _process_file, root_path=root_path, max_bytes=max_bytes, keep_contents=keep_contents,
+        _process_file, root_path=root_path, max_bytes=max_bytes,
+        keep_contents=keep_contents, fast=fast,
     )
     use_proc = processes if processes is not None else (
         not keep_contents and len(to_parse) >= _PROCESS_THRESHOLD and (os.cpu_count() or 1) > 1
@@ -318,8 +320,10 @@ def _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, proce
     if use_proc:
         try:
             workers = jobs or min(8, os.cpu_count() or 2)
+            # Larger chunks amortize per-task IPC/pickling overhead.
+            chunk = max(16, len(to_parse) // (workers * 4))
             with ProcessPoolExecutor(max_workers=workers) as pool:
-                return list(pool.map(worker, to_parse, chunksize=16))
+                return list(pool.map(worker, to_parse, chunksize=chunk))
         except Exception:
             pass  # fall back to threads if the process pool cannot start
     workers = jobs or min(32, (os.cpu_count() or 4) * 4)
@@ -327,9 +331,15 @@ def _parallel_process(to_parse, root_path, max_bytes, keep_contents, jobs, proce
         return list(pool.map(worker, to_parse))
 
 
-def _process_file(full: Path, root_path: Path, max_bytes: int, keep_contents: bool = False):
+def _process_file(full: Path, root_path: Path, max_bytes: int,
+                  keep_contents: bool = False, fast: bool = False):
     """Read and analyze one file. Returns (FileStat, todos, scores, text, vendored)
-    or None. Top-level and picklable so it works with a process pool."""
+    or None. Top-level and picklable so it works with a process pool.
+
+    In ``fast`` mode we only count lines and detect language/vendoring — the
+    per-function complexity parse (the expensive step) is skipped, which is what
+    lets very large repositories be scanned in seconds.
+    """
     fn = full.name
     ext = fn.rsplit(".", 1)[-1] if "." in fn else ""
     language = lang_for(ext, fn)
@@ -344,10 +354,10 @@ def _process_file(full: Path, root_path: Path, max_bytes: int, keep_contents: bo
     rel = full.relative_to(root_path).as_posix()
     total, code, blank, comment = _count_lines(text, language)
     stat = FileStat(rel, language, total, code, blank, comment, size)
-    vendored = is_vendored(rel, text)
+    vendored = is_vendored_path(rel) if fast else is_vendored(rel, text)
     todos: List[Todo] = []
     scores: List[FuncScore] = []
-    if not vendored:
+    if not vendored and not fast:
         _collect_todos(text, rel, language, todos)
         _score_complexity(text, rel, language, scores)
     # Avoid shipping file text back across a process boundary unless needed.

{repoglance-0.4.2 → repoglance-0.4.3}/tests/test_v041.py

@@ -7,6 +7,20 @@ from repoglance.cli import main
 from repoglance.config import load_config
 
 
+def test_fast_mode_counts_without_complexity(tmp_path):
+    from repoglance.scanner import scan
+
+    (tmp_path / "a.py").write_text(
+        "def f(x):\n    if x:\n        return 1  # TODO\n    return 0\n", encoding="utf-8"
+    )
+    fast = scan(tmp_path, fast=True)
+    full = scan(tmp_path, fast=False)
+    assert fast.total_code == full.total_code       # counts still accurate
+    assert fast.func_scores == []                   # complexity skipped
+    assert fast.todos == []                          # todo scan skipped too
+    assert full.func_scores                          # full mode still analyzes
+
+
 def test_process_and_thread_modes_agree(tmp_path):
     from repoglance.scanner import scan