devarch 0.2.0__py3-none-any.whl

devarch/__init__.py

@@ -0,0 +1,4 @@
+"""Dev Archaeologist package."""
+
+from .version import __version__
+

devarch/__main__.py

@@ -0,0 +1,4 @@
+from .cli.main import app
+
+app()
+

devarch/analyzers/__init__.py

@@ -0,0 +1,2 @@
+"""Static analyzers used by Dev Archaeologist."""
+

devarch/analyzers/ancient.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ..models import Artifact
+from ..utils.fs import path_kind, safe_stat
+
+
+@dataclass(slots=True)
+class AncientStats:
+    total: int
+    unreferenced: int
+
+
+def file_age_days(path: Path) -> int:
+    modified = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc)
+    return max((datetime.now(timezone.utc) - modified).days, 0)
+
+
+def find_ancient_files(
+    files: list[Path],
+    references: dict[Path, set[Path]],
+    threshold_days: int = 365,
+) -> list[Artifact]:
+    artifacts: list[Artifact] = []
+    for path in files:
+        if path_kind(path) == "binary":
+            continue
+        age = file_age_days(path)
+        referenced = path in references and bool(references[path])
+        if age >= threshold_days or (age >= 180 and not referenced):
+            risk = "High" if age >= 730 or not referenced else "Medium"
+            status = "Unreferenced" if not referenced else "Referenced"
+            artifacts.append(
+                Artifact(
+                    path=path,
+                    kind="ancient_file",
+                    risk=risk,
+                    age_days=age,
+                    size_bytes=safe_stat(path),
+                    detail=status,
+                    confidence=0.84 if not referenced else 0.7,
+                )
+            )
+    return artifacts
+

devarch/analyzers/dead_code.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import ast
+import re
+from pathlib import Path
+
+from ..models import Artifact
+from ..utils.fs import path_kind, read_text
+
+
+PY_IMPORT_RE = re.compile(r"^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))", re.MULTILINE)
+CODE_EXTENSIONS = {".py", ".pyi", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+def _module_name(path: Path, root: Path) -> str:
+    rel = path.relative_to(root).with_suffix("")
+    return ".".join(rel.parts)
+
+
+def _has_unreachable_code(content: str) -> bool:
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return False
+
+    terminal_types = (ast.Return, ast.Raise, ast.Break, ast.Continue)
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            terminated = False
+            for stmt in node.body:
+                if terminated:
+                    return True
+                terminated = isinstance(stmt, terminal_types)
+    return False
+
+
+def find_dead_code(root: Path, files: list[Path], text_cache: dict[Path, str]) -> list[Artifact]:
+    artifacts: list[Artifact] = []
+    text_files = [path for path in files if path_kind(path) == "text"]
+
+    imported_modules: set[str] = set()
+    for path in text_files:
+        content = text_cache.get(path, "")
+        for match in PY_IMPORT_RE.finditer(content):
+            target = match.group(1) or match.group(2)
+            if target:
+                imported_modules.add(target.lstrip(".").replace(".", "/"))
+
+    for path in text_files:
+        content = text_cache.get(path, "")
+        module = _module_name(path, root)
+        module_path = module.replace(".", "/")
+        if path.suffix.lower() == ".py":
+            if "tests" in path.parts or path.name.startswith("test_") or path.name == "conftest.py":
+                continue
+            if path.name in {"__init__.py", "__main__.py"}:
+                continue
+            if not any(module_path.endswith(name) or name.endswith(module_path) for name in imported_modules):
+                if "if __name__ == \"__main__\"" not in content and "if __name__ == '__main__'" not in content:
+                    artifacts.append(
+                        Artifact(
+                            path=path,
+                            kind="dead_code_candidate",
+                            risk="Medium",
+                            detail="Module is not referenced by obvious imports",
+                            confidence=0.62,
+                        )
+                    )
+
+            if _has_unreachable_code(content):
+                artifacts.append(
+                    Artifact(
+                        path=path,
+                        kind="unreachable_code",
+                        risk="Low",
+                        detail="Function body contains statements after a terminal statement",
+                        confidence=0.72,
+                        )
+                    )
+        else:
+            if path.suffix.lower() not in CODE_EXTENSIONS:
+                continue
+            if not any(module_path.endswith(name) or name.endswith(module_path) for name in imported_modules):
+                artifacts.append(
+                    Artifact(
+                        path=path,
+                        kind="dead_code_candidate",
+                        risk="Low",
+                        detail="File is not referenced by obvious imports",
+                        confidence=0.5,
+                    )
+                )
+
+    return artifacts

devarch/analyzers/duplicates.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+from ..models import Artifact
+from ..utils.fs import path_kind, read_text
+
+
+def normalize_text(text: str) -> str:
+    text = re.sub(r"\"\"\".*?\"\"\"|'''.*?'''", "", text, flags=re.S)
+    text = re.sub(r"#.*$", "", text, flags=re.M)
+    text = re.sub(r"//.*$", "", text, flags=re.M)
+    text = re.sub(r"/\*.*?\*/", "", text, flags=re.S)
+    text = re.sub(r"\s+", " ", text)
+    text = re.sub(r"\b\d+\b", "0", text)
+    return text.strip().lower()
+
+
+def tokenize_blocks(text: str, block_size: int = 12) -> list[str]:
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if len(lines) <= block_size:
+        return ["\n".join(lines)] if lines else []
+    blocks: list[str] = []
+    for index in range(0, len(lines) - block_size + 1):
+        blocks.append("\n".join(lines[index : index + block_size]))
+    return blocks
+
+
+def find_duplicates(files: list[Path], text_cache: dict[Path, str]) -> list[Artifact]:
+    signatures: dict[str, list[Path]] = defaultdict(list)
+    for path in files:
+        if path_kind(path) != "text":
+            continue
+        content = normalize_text(text_cache.get(path, ""))
+        if not content:
+            continue
+        for block in tokenize_blocks(content):
+            if len(block.split()) < 10:
+                continue
+            signatures[block].append(path)
+
+    artifacts: list[Artifact] = []
+    seen: set[tuple[Path, Path, str]] = set()
+    for block, paths in signatures.items():
+        if len(paths) < 2:
+            continue
+        for idx, left in enumerate(paths):
+            for right in paths[idx + 1 :]:
+                pair = tuple(sorted((left, right))) + (block,)
+                if pair in seen:
+                    continue
+                seen.add(pair)
+                artifacts.append(
+                    Artifact(
+                        path=left,
+                        kind="duplicate_block",
+                        risk="Medium",
+                        detail=f"Similar to {right}",
+                        score=0.85,
+                        confidence=0.85,
+                        metadata={"match_path": str(right)},
+                    )
+                )
+    return artifacts
+
+
+def similarity_report(files: list[Path], text_cache: dict[Path, str]) -> list[dict[str, object]]:
+    normalized: dict[Path, set[str]] = {}
+    for path in files:
+        if path_kind(path) != "text":
+            continue
+        tokens = set(re.findall(r"[a-zA-Z_][a-zA-Z0-9_]+", normalize_text(text_cache.get(path, ""))))
+        if tokens:
+            normalized[path] = tokens
+
+    report: list[dict[str, object]] = []
+    paths = list(normalized)
+    for idx, left in enumerate(paths):
+        for right in paths[idx + 1 :]:
+            a = normalized[left]
+            b = normalized[right]
+            if not a or not b:
+                continue
+            intersection = len(a & b)
+            union = len(a | b)
+            if not union:
+                continue
+            similarity = round((intersection / union) * 100, 1)
+            if similarity >= 65:
+                report.append(
+                    {
+                        "left": str(left),
+                        "right": str(right),
+                        "similarity": similarity,
+                    }
+                )
+    return sorted(report, key=lambda item: item["similarity"], reverse=True)
+

devarch/analyzers/health.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class HealthMetrics:
+    score: int
+    status: str
+    warnings: list[str]
+    debt_estimate: float
+
+
+def calculate_health(
+    *,
+    total_files: int,
+    dead_code_count: int,
+    duplicate_count: int,
+    ancient_count: int,
+    todo_count: int,
+    monster_count: int,
+    ruin_count: int,
+    suspicious_count: int,
+) -> HealthMetrics:
+    debt = (
+        dead_code_count * 2.0
+        + duplicate_count * 1.5
+        + ancient_count * 1.2
+        + todo_count * 0.35
+        + monster_count * 2.5
+        + ruin_count * 0.8
+        + suspicious_count * 0.6
+    )
+    if total_files:
+        debt += min(total_files / 250.0, 10.0)
+    score = max(0, min(100, int(round(100 - debt))))
+    if score >= 85:
+        status = "Healthy"
+    elif score >= 65:
+        status = "Moderate debt"
+    elif score >= 45:
+        status = "Debt detected"
+    else:
+        status = "Critical"
+
+    warnings: list[str] = []
+    if dead_code_count:
+        warnings.append("Dead code candidates detected")
+    if duplicate_count:
+        warnings.append("Duplicate implementations found")
+    if ancient_count:
+        warnings.append("Ancient files appear abandoned")
+    if monster_count:
+        warnings.append("Monster files need review")
+    if ruin_count:
+        warnings.append("Empty structures or unused assets found")
+    if suspicious_count:
+        warnings.append("Suspicious filenames found")
+    return HealthMetrics(score=score, status=status, warnings=warnings, debt_estimate=debt)
+