fossil-code 0.2.0__py3-none-any.whl

fossil/git_miner.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+
+from fossil.models import CommitInfo, GitHistoryResult
+from fossil.repo import git_head, is_shallow, is_tracked, relpath, remote_url, run_git
+
+PR_RE = re.compile(r"(?:#|PR\s*#?|pull request\s*#?)(\d+)", re.IGNORECASE)
+
+
+def parse_commit(raw: str) -> CommitInfo:
+    h, ts, author, email, subject = raw.split("\x1f", 4)
+    date = datetime.fromtimestamp(int(ts), UTC).isoformat().replace("+00:00", "Z")
+    pr_match = PR_RE.search(subject)
+    return CommitInfo(
+        hash=h,
+        short_hash=h[:7],
+        date=date,
+        author_name=author,
+        author_email=email,
+        message=subject,
+        pr_number=int(pr_match.group(1)) if pr_match else None,
+    )
+
+
+def mine_history(
+    path: Path, repo_root: Path, depth: int, reference_terms: set[str]
+) -> GitHistoryResult:
+    rel = relpath(path, repo_root)
+    result = GitHistoryResult(
+        head=git_head(repo_root),
+        tracked=is_tracked(path, repo_root),
+        shallow=is_shallow(repo_root),
+        remote_url=remote_url(repo_root),
+    )
+    if result.shallow:
+        result.warnings.append("Shallow git clone detected. History may be incomplete.")
+    if not result.tracked:
+        return result
+
+    fmt = "%H%x1f%ct%x1f%an%x1f%ae%x1f%s"
+    file_log = run_git(
+        repo_root,
+        ["log", f"--max-count={depth}", f"--format={fmt}", "--follow", "--", rel],
+        check=False,
+    )
+    commits = [parse_commit(line) for line in file_log.stdout.splitlines() if line.strip()]
+    if commits:
+        result.last_modified = commits[0]
+        result.original_author = commits[-1]
+    if len(commits) >= depth:
+        result.warnings.append(
+            f"History truncated at {depth} commits. Increase --depth for deeper traversal."
+        )
+
+    terms = [term for term in reference_terms if term]
+    if not terms:
+        result.ambiguous_death = True
+        return result
+    grep = "|".join(re.escape(term) for term in sorted(terms, key=len, reverse=True))
+    ref_log = run_git(
+        repo_root,
+        ["log", "--all", f"--max-count={depth}", f"--format={fmt}", "-G", grep, "--", "."],
+        check=False,
+    )
+    ref_commits = [parse_commit(line) for line in ref_log.stdout.splitlines() if line.strip()]
+    candidates = [
+        commit
+        for commit in ref_commits
+        if commit.hash != (result.last_modified.hash if result.last_modified else "")
+    ]
+    if candidates:
+        result.death_commit = candidates[0]
+    else:
+        result.ambiguous_death = True
+    return result

fossil/models.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class Reference:
+    path: str
+    line: int
+    kind: str
+    text: str
+
+
+@dataclass
+class StaticAnalysisResult:
+    language: str
+    call_sites: int = 0
+    import_references: int = 0
+    dynamic_references: list[Reference] = field(default_factory=list)
+    reflection_patterns: list[Reference] = field(default_factory=list)
+    test_file_references: int = 0
+    documentation_references: int = 0
+    config_file_references: int = 0
+    references: list[Reference] = field(default_factory=list)
+    unknown_language: bool = False
+
+    @property
+    def main_code_references(self) -> int:
+        return max(0, self.call_sites + self.import_references)
+
+
+@dataclass
+class CommitInfo:
+    hash: str
+    short_hash: str
+    date: str
+    author_name: str
+    author_email: str
+    message: str
+    pr_number: int | None = None
+
+
+@dataclass
+class GitHistoryResult:
+    head: str
+    tracked: bool
+    shallow: bool = False
+    remote_url: str | None = None
+    death_commit: CommitInfo | None = None
+    original_author: CommitInfo | None = None
+    last_modified: CommitInfo | None = None
+    ambiguous_death: bool = False
+    warnings: list[str] = field(default_factory=list)
+
+
+@dataclass
+class HoldPattern:
+    text: str
+    line: int
+    condition: str | None
+    condition_type: str
+    condition_met: bool | None
+    evidence: str
+
+
+@dataclass
+class PatternResult:
+    detected: bool
+    patterns: list[HoldPattern] = field(default_factory=list)
+
+
+@dataclass
+class ConfidenceSignal:
+    name: str
+    weight: int
+    applied: bool
+    reason: str
+
+
+@dataclass
+class ConfidenceResult:
+    score: int
+    label: str
+    risk: str
+    signals: list[ConfidenceSignal]
+
+
+@dataclass
+class ForensicResult:
+    fossil_version: str
+    target: str
+    abs_path: str
+    repo_root: str
+    language: str
+    dead: bool
+    status: str
+    static_analysis: StaticAnalysisResult
+    git_history: GitHistoryResult
+    temporary_hold: PatternResult
+    confidence: ConfidenceResult | None
+    suggested_action: str | None
+    yolo_command: str | None
+    analysis_duration_ms: int
+    cached: bool = False
+    warnings: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)

fossil/patterns.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import re
+from datetime import date, datetime
+from pathlib import Path
+
+from fossil.models import HoldPattern, PatternResult
+from fossil.repo import run_git
+
+PATTERNS = [
+    re.compile(r"TODO:\s*remove after\s+(?P<condition>.+)", re.IGNORECASE),
+    re.compile(r"FIXME:\s*delete when\s+(?P<condition>.+)", re.IGNORECASE),
+    re.compile(
+        r"keep(?:ing)? (?:this )?(?:around )?(?:for now|until\s+(?P<condition>.+))", re.IGNORECASE
+    ),
+    re.compile(r"\btemporary\b|\btemp code\b|\btemp fix\b", re.IGNORECASE),
+    re.compile(r"\bDEPRECATED\b|@deprecated", re.IGNORECASE),
+    re.compile(r"will be removed in\s+(?P<condition>.+)", re.IGNORECASE),
+]
+
+
+def detect_patterns(path: Path, repo_root: Path) -> PatternResult:
+    result = PatternResult(detected=False)
+    text = path.read_text(encoding="utf-8", errors="replace")
+    for line_no, line in enumerate(text.splitlines(), 1):
+        for regex in PATTERNS:
+            match = regex.search(line)
+            if not match:
+                continue
+            condition = (match.groupdict().get("condition") or "").strip(" .#")
+            kind, met, evidence = verify_condition(condition, repo_root)
+            result.patterns.append(
+                HoldPattern(
+                    text=line.strip(),
+                    line=line_no,
+                    condition=condition or None,
+                    condition_type=kind,
+                    condition_met=met,
+                    evidence=evidence,
+                )
+            )
+    result.detected = bool(result.patterns)
+    return result
+
+
+def verify_condition(condition: str, repo_root: Path) -> tuple[str, bool | None, str]:
+    if not condition:
+        return "unverifiable", None, "No explicit condition found."
+    pr = re.search(r"(?:PR|#)\s*(\d+)", condition, re.IGNORECASE)
+    if pr:
+        number = pr.group(1)
+        log = run_git(
+            repo_root, ["log", "--all", "--grep", f"#{number}", "--format=%H %s"], check=False
+        )
+        if log.stdout.strip():
+            return "pr", True, f"Found commit message referencing #{number}."
+        return "pr", None, f"PR #{number} requires remote API verification."
+    version = re.search(r"\bv?(\d+\.\d+(?:\.\d+)?)\b", condition)
+    if version:
+        tags = run_git(repo_root, ["tag", "--list", f"*{version.group(1)}*"], check=False)
+        if tags.stdout.strip():
+            return "version", True, f"Matching git tag found: {tags.stdout.splitlines()[0]}."
+        return "version", False, f"No git tag matched version {version.group(1)}."
+    parsed = _parse_date(condition)
+    if parsed:
+        if parsed <= date.today():
+            return "date", True, f"Date {parsed.isoformat()} has passed."
+        return "date", False, f"Date {parsed.isoformat()} has not passed."
+    return "unverifiable", None, f'Condition: UNVERIFIABLE — "{condition}"'
+
+
+def _parse_date(value: str) -> date | None:
+    for token in re.findall(r"\d{4}-\d{2}-\d{2}|\d{4}/\d{2}/\d{2}", value):
+        for fmt in ("%Y-%m-%d", "%Y/%m/%d"):
+            try:
+                return datetime.strptime(token, fmt).date()
+            except ValueError:
+                pass
+    return None

fossil/py.typed

@@ -0,0 +1 @@
+