ai-dev-cli-tools 0.5.0a1__py3-none-any.whl

ai_dev_tools/detectors/workspaces.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+import tomllib
+from pathlib import Path
+
+from ai_dev_tools.detectors.runtime import detect_runtime_requirements
+from ai_dev_tools.models.workspace import Workspace
+
+_IGNORED = {".git", ".ai", ".venv", "node_modules", "dist", "build", "target", "vendor"}
+
+
+def detect_workspaces(root: Path) -> list[Workspace]:
+    candidates: dict[Path, set[str]] = {root.resolve(): set()}
+    _add_manifest_roots(root, candidates)
+    _add_declared_workspaces(root, candidates)
+    workspaces = [_workspace(root, path, sources) for path, sources in candidates.items()]
+    result = [workspace for workspace in workspaces if workspace is not None]
+    return sorted(result, key=lambda item: (item.root.count("/"), item.root, item.workspace_id))
+
+
+def owning_workspace(workspaces: list[Workspace], relative_path: str) -> Workspace | None:
+    owners = [workspace for workspace in workspaces if workspace.owns(relative_path)]
+    return max(owners, key=lambda item: len(item.root), default=None)
+
+
+def _add_manifest_roots(root: Path, candidates: dict[Path, set[str]]) -> None:
+    manifests = {
+        "pyproject.toml",
+        "package.json",
+        "Cargo.toml",
+        "pom.xml",
+        "build.gradle",
+        "build.gradle.kts",
+        "composer.json",
+    }
+    for current, directories, files in os.walk(root):
+        current_path = Path(current)
+        directories[:] = sorted(
+            name
+            for name in directories
+            if name not in _IGNORED
+            and not (current_path.name in {"test", "tests"} and name == "fixtures")
+        )
+        for name in sorted(manifests & set(files)):
+            path = current_path / name
+            resolved = path.parent.resolve()
+            candidates.setdefault(resolved, set()).add(_rel(root, path))
+
+
+def _add_declared_workspaces(root: Path, candidates: dict[Path, set[str]]) -> None:
+    package = _json(root / "package.json")
+    raw_workspaces = package.get("workspaces", [])
+    if isinstance(raw_workspaces, dict):
+        raw_workspaces = raw_workspaces.get("packages", [])
+    if isinstance(raw_workspaces, list):
+        for pattern in raw_workspaces:
+            if isinstance(pattern, str):
+                _add_glob(root, pattern, "package.json#workspaces", candidates)
+
+    pnpm = _text(root / "pnpm-workspace.yaml")
+    for pattern in re.findall(r"^\s*-\s*['\"]?([^'\"#]+)", pnpm, re.MULTILINE):
+        _add_glob(root, pattern.strip(), "pnpm-workspace.yaml", candidates)
+
+    cargo = _toml(root / "Cargo.toml")
+    cargo_workspace = cargo.get("workspace", {})
+    if isinstance(cargo_workspace, dict) and isinstance(cargo_workspace.get("members"), list):
+        for pattern in cargo_workspace["members"]:
+            if isinstance(pattern, str):
+                _add_glob(root, pattern, "Cargo.toml#workspace", candidates)
+
+    pom = _text(root / "pom.xml")
+    for module in re.findall(r"<module>\s*([^<]+)\s*</module>", pom):
+        _add_root(root, module.strip(), "pom.xml#modules", candidates)
+
+    gradle = _text(root / "settings.gradle") + "\n" + _text(root / "settings.gradle.kts")
+    for declaration in re.findall(r"\binclude\s*\(?\s*([^\n\r\)]+)", gradle):
+        for module in re.findall(r"['\"]:([^'\"]+)['\"]", declaration):
+            _add_root(root, module.replace(":", "/"), "Gradle settings", candidates)
+
+
+def _add_glob(root: Path, pattern: str, source: str, candidates: dict[Path, set[str]]) -> None:
+    normalized = pattern.replace("\\", "/").rstrip("/")
+    for value in glob.glob(str(root / normalized)):
+        path = Path(value)
+        if path.is_dir() and not _ignored(root, path):
+            candidates.setdefault(path.resolve(), set()).add(source)
+
+
+def _add_root(root: Path, relative: str, source: str, candidates: dict[Path, set[str]]) -> None:
+    path = (root / relative).resolve()
+    try:
+        path.relative_to(root.resolve())
+    except ValueError:
+        return
+    if path.is_dir() and not _ignored(root, path):
+        candidates.setdefault(path, set()).add(source)
+
+
+def _workspace(root: Path, path: Path, sources: set[str]) -> Workspace | None:
+    configs = [
+        name
+        for name in (
+            "pyproject.toml",
+            "requirements.txt",
+            "package.json",
+            "pnpm-lock.yaml",
+            "yarn.lock",
+            "package-lock.json",
+            "Cargo.toml",
+            "pom.xml",
+            "build.gradle",
+            "build.gradle.kts",
+            "composer.json",
+        )
+        if (path / name).exists()
+    ]
+    if not configs and path != root.resolve():
+        return None
+    technologies: list[str] = []
+    if any(name in configs for name in ("pyproject.toml", "requirements.txt")):
+        technologies.append("python")
+    if "package.json" in configs:
+        technologies.append("node")
+    if "Cargo.toml" in configs:
+        technologies.append("rust")
+    if any(name in configs for name in ("pom.xml", "build.gradle", "build.gradle.kts")):
+        technologies.append("java")
+    if "composer.json" in configs:
+        technologies.append("php")
+    kind = "mixed" if len(technologies) > 1 else technologies[0] if technologies else "root"
+    relative = _rel(root, path)
+    package_manager = _package_manager(configs, path)
+    commands = _commands(path, technologies, package_manager)
+    config_files = tuple(sorted({*configs, *sources}))
+    workspace_id = relative.replace("/", ":") if relative else "root"
+    return Workspace(
+        workspace_id=workspace_id,
+        root=relative,
+        kind=kind,
+        technologies=tuple(technologies),
+        package_manager=package_manager,
+        config_files=config_files,
+        commands=commands,
+        runtime_requirements=tuple(detect_runtime_requirements(path)),
+    )
+
+
+def _commands(path: Path, technologies: list[str], package_manager: str | None) -> dict[str, str]:
+    commands: dict[str, str] = {}
+    if "python" in technologies:
+        commands["test"] = "python -m pytest"
+    if "node" in technologies and package_manager:
+        package = _json(path / "package.json")
+        scripts = package.get("scripts", {})
+        if isinstance(scripts, dict):
+            for name in ("test", "lint", "typecheck", "build"):
+                if isinstance(scripts.get(name), str):
+                    commands[name] = f"{package_manager} run {name}"
+    if package_manager == "cargo":
+        commands["test"] = "cargo test"
+    if package_manager == "maven":
+        commands["test"] = "mvn test"
+    if package_manager == "gradle":
+        commands["test"] = "gradle test"
+    if package_manager == "composer":
+        commands.setdefault("install", "composer install --no-interaction")
+    return commands
+
+
+def _package_manager(configs: list[str], path: Path) -> str | None:
+    if "pnpm-lock.yaml" in configs:
+        return "pnpm"
+    if "yarn.lock" in configs:
+        return "yarn"
+    if "package-lock.json" in configs or "package.json" in configs:
+        return "npm"
+    if "Cargo.toml" in configs:
+        return "cargo"
+    if "pom.xml" in configs:
+        return "maven"
+    if "build.gradle" in configs or "build.gradle.kts" in configs:
+        return "gradle"
+    if "composer.json" in configs:
+        return "composer"
+    if "pyproject.toml" in configs or "requirements.txt" in configs:
+        return "python"
+    return None
+
+
+def _ignored(root: Path, path: Path) -> bool:
+    try:
+        relative = path.resolve().relative_to(root.resolve())
+    except ValueError:
+        return True
+    return any(part in _IGNORED for part in relative.parts)
+
+
+def _rel(root: Path, path: Path) -> str:
+    value = path.resolve().relative_to(root.resolve()).as_posix()
+    return "" if value == "." else value
+
+
+def _text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _json(path: Path) -> dict[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _toml(path: Path) -> dict[str, object]:
+    try:
+        with path.open("rb") as handle:
+            value = tomllib.load(handle)
+            return value if isinstance(value, dict) else {}
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}

ai_dev_tools/git/__init__.py

@@ -0,0 +1 @@
+"""Git inspection helpers."""

ai_dev_tools/git/inspect.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ai_dev_tools.config import load_settings
+from ai_dev_tools.models.report import Report
+from ai_dev_tools.reporters.writer import write_json, write_markdown
+from ai_dev_tools.security.secrets import scan_paths_for_secrets
+from ai_dev_tools.utils.subprocess import run_command
+
+CONFLICT_CODES = {"UU", "AA", "DD", "AU", "UA", "DU", "UD"}
+
+
+def inspect_git(project_root: Path, detailed: bool = False) -> Report:
+    settings = load_settings(project_root)
+    report = Report(
+        command="git inspect" if detailed else "git status", project_root=settings.project_root
+    )
+    inside = run_command(["git", "rev-parse", "--is-inside-work-tree"], settings.project_root, 20)
+    if inside.exit_code != 0:
+        report.status = "warning"
+        report.summary = {"state": "NOT_A_GIT_REPOSITORY"}
+        return report
+
+    branch = _text(["git", "branch", "--show-current"], settings.project_root) or None
+    upstream = _upstream(settings.project_root)
+    porcelain = _text(["git", "status", "--porcelain=v1", "--branch"], settings.project_root)
+    ahead_count, behind_count = _ahead_behind_counts(porcelain)
+    staged_entries = _name_status(
+        ["git", "diff", "--cached", "--name-status", "-z"], settings.project_root
+    )
+    unstaged_entries = _name_status(["git", "diff", "--name-status", "-z"], settings.project_root)
+    untracked_files = _nul_output(
+        ["git", "ls-files", "--others", "--exclude-standard", "-z"], settings.project_root
+    )
+    conflicted_files = _conflicted_files(porcelain)
+    staged_files = _entry_paths(staged_entries)
+    unstaged_files = _entry_paths(unstaged_entries)
+    changed = sorted({*staged_files, *unstaged_files, *untracked_files, *conflicted_files})
+    states = _states(
+        porcelain=porcelain,
+        upstream=upstream,
+        detached=branch is None,
+        has_changes=bool(changed),
+        has_conflicts=bool(conflicted_files),
+    )
+    summary: dict[str, object] = {
+        "state": states[0],
+        "states": states,
+        "branch": branch,
+        "upstream": upstream,
+        "ahead": ahead_count,
+        "behind": behind_count,
+        "diverged": ahead_count > 0 and behind_count > 0,
+        "detached_head": branch is None,
+        "changed_files": changed,
+        "staged_files": staged_files,
+        "unstaged_files": unstaged_files,
+        "untracked_files": untracked_files,
+        "conflicted_files": conflicted_files,
+        "conflicts": conflicted_files,
+        "renamed_files": [
+            entry
+            for entry in [*staged_entries, *unstaged_entries]
+            if entry["status"].startswith("R")
+        ],
+        "deleted_files": [
+            entry["path"]
+            for entry in [*staged_entries, *unstaged_entries]
+            if entry["status"].startswith("D")
+        ],
+        "stash_count": len(
+            [
+                line
+                for line in _text(["git", "stash", "list"], settings.project_root).splitlines()
+                if line
+            ]
+        ),
+    }
+    if detailed:
+        upstream_diff_bytes = (
+            _diff_bytes(settings.project_root, ["git", "diff", upstream + "...HEAD"])
+            if upstream
+            else 0
+        )
+        scan_paths = [settings.project_root / item for item in changed]
+        summary.update(
+            {
+                "recent_commits": _text(
+                    ["git", "log", "--oneline", "-5"], settings.project_root
+                ).splitlines(),
+                "diff_stat": _text(["git", "diff", "--stat"], settings.project_root),
+                "diff_size_bytes": _diff_bytes(settings.project_root, ["git", "diff"]),
+                "unstaged_diff_bytes": _diff_bytes(settings.project_root, ["git", "diff"]),
+                "staged_diff_bytes": _diff_bytes(
+                    settings.project_root, ["git", "diff", "--cached"]
+                ),
+                "upstream_diff_bytes": upstream_diff_bytes,
+                "large_changed_files": _large_files(settings.project_root, changed),
+                "secret_findings": [
+                    finding.masked_dict()
+                    for finding in scan_paths_for_secrets(settings.project_root, scan_paths)
+                ],
+            }
+        )
+    report.summary = summary
+    report.status = (
+        "warning"
+        if any(s in states for s in ("DIRTY", "CONFLICT", "DIVERGED", "DETACHED_HEAD"))
+        else "success"
+    )
+    report.finish()
+    suffix = "inspect" if detailed else "status"
+    write_markdown(report, settings.reports_directory / f"git-{suffix}.md")
+    write_json(report, settings.reports_directory / f"git-{suffix}.json")
+    return report
+
+
+def _upstream(root: Path) -> str | None:
+    value = _text(["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root)
+    return value or None
+
+
+def _text(command: list[str], root: Path) -> str:
+    result = run_command(command, root, 30)
+    return result.stdout.strip() if result.exit_code == 0 else ""
+
+
+def _nul_output(command: list[str], root: Path) -> list[str]:
+    result = run_command(command, root, 30)
+    if result.exit_code != 0:
+        return []
+    return [item for item in result.stdout.split("\0") if item]
+
+
+def _name_status(command: list[str], root: Path) -> list[dict[str, str]]:
+    items = _nul_output(command, root)
+    entries: list[dict[str, str]] = []
+    index = 0
+    while index < len(items):
+        status = items[index]
+        index += 1
+        if status.startswith("R") or status.startswith("C"):
+            if index + 1 > len(items):
+                break
+            old_path = items[index]
+            new_path = items[index + 1]
+            index += 2
+            entries.append({"status": status, "path": new_path, "old_path": old_path})
+            continue
+        if index > len(items):
+            break
+        path = items[index]
+        index += 1
+        entries.append({"status": status, "path": path})
+    return entries
+
+
+def _entry_paths(entries: list[dict[str, str]]) -> list[str]:
+    return sorted({entry["path"] for entry in entries})
+
+
+def _ahead_behind_counts(porcelain: str) -> tuple[int, int]:
+    header = porcelain.splitlines()[0] if porcelain else ""
+    ahead = re.search(r"ahead (\d+)", header)
+    behind = re.search(r"behind (\d+)", header)
+    return (int(ahead.group(1)) if ahead else 0, int(behind.group(1)) if behind else 0)
+
+
+def _states(
+    porcelain: str,
+    upstream: str | None,
+    detached: bool,
+    has_changes: bool,
+    has_conflicts: bool,
+) -> list[str]:
+    states: list[str] = []
+    if detached:
+        states.append("DETACHED_HEAD")
+    if upstream is None:
+        states.append("NO_UPSTREAM")
+    ahead_count, behind_count = _ahead_behind_counts(porcelain)
+    if ahead_count and behind_count:
+        states.append("DIVERGED")
+    elif ahead_count:
+        states.append("AHEAD")
+    elif behind_count:
+        states.append("BEHIND")
+    if has_conflicts:
+        states.append("CONFLICT")
+    if has_changes:
+        states.append("DIRTY")
+    if not states:
+        states.append("UP_TO_DATE")
+    return states
+
+
+def _conflicted_files(porcelain: str) -> list[str]:
+    return sorted(
+        line[3:]
+        for line in porcelain.splitlines()[1:]
+        if len(line) > 3 and line[:2] in CONFLICT_CODES
+    )
+
+
+def _diff_bytes(root: Path, command: list[str]) -> int:
+    result = run_command(command, root, 60)
+    return len(result.stdout.encode("utf-8")) if result.exit_code == 0 else 0
+
+
+def _large_files(root: Path, files: list[str]) -> list[str]:
+    return [
+        item
+        for item in files
+        if (root / item).exists()
+        and (root / item).is_file()
+        and (root / item).stat().st_size > 1_000_000
+    ]

ai_dev_tools/models/__init__.py

@@ -0,0 +1 @@
+"""Shared data models."""

ai_dev_tools/models/report.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Literal
+
+from ai_dev_tools import __version__
+
+Status = Literal[
+    "success",
+    "failed",
+    "partial",
+    "warning",
+    "not_implemented",
+    "invalid_configuration",
+    "environment_error",
+    "blocked",
+]
+Severity = Literal["info", "warning", "error", "critical"]
+
+
+def utc_now() -> datetime:
+    return datetime.now(UTC)
+
+
+@dataclass(slots=True)
+class Artifact:
+    path: str
+    kind: str
+    description: str
+
+
+@dataclass(slots=True)
+class Issue:
+    severity: Severity | str
+    message: str
+    location: str | None = None
+    code: str | None = None
+    tool: str | None = None
+    file: str | None = None
+    line: int | None = None
+    column: int | None = None
+    masked: bool = False
+
+
+@dataclass(slots=True)
+class Report:
+    command: str
+    project_root: Path
+    status: Status = "success"
+    started_at: datetime = field(default_factory=utc_now)
+    finished_at: datetime | None = None
+    summary: dict[str, Any] = field(default_factory=dict)
+    issues: list[Issue] = field(default_factory=list)
+    artifacts: list[Artifact] = field(default_factory=list)
+    schema_version: str = "1.1"
+    tool_version: str = __version__
+    exit_code: int = 0
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def finish(self, status: Status | None = None) -> Report:
+        if status is not None:
+            self.status = status
+        self.finished_at = utc_now()
+        if self.exit_code == 0 and self.status not in {"success", "partial", "warning"}:
+            self.exit_code = 1
+        return self
+
+    @property
+    def duration_seconds(self) -> float:
+        finished = self.finished_at or utc_now()
+        return round((finished - self.started_at).total_seconds(), 3)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ai_dev_tools.reporters.progressive import add_progressive_metadata
+
+        finished = self.finished_at or utc_now()
+        status = "partial" if self.status == "warning" else self.status
+        payload = {
+            "schema_version": self.schema_version,
+            "tool_version": self.tool_version,
+            "command": self.command,
+            "status": status,
+            "exit_code": self.exit_code,
+            "started_at": self.started_at.isoformat(),
+            "finished_at": finished.isoformat(),
+            "duration_seconds": self.duration_seconds,
+            "project_root": str(self.project_root),
+            "summary": self.summary,
+            "issues": [asdict(issue) for issue in self.issues],
+            "artifacts": [asdict(artifact) for artifact in self.artifacts],
+            "metadata": dict(self.metadata),
+        }
+        return add_progressive_metadata(payload)

ai_dev_tools/models/workspace.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeRequirement:
+    runtime: str
+    constraint: str
+    source: str
+
+    def to_dict(self) -> dict[str, str]:
+        return asdict(self)
+
+
+@dataclass(frozen=True, slots=True)
+class Workspace:
+    workspace_id: str
+    root: str
+    kind: str
+    technologies: tuple[str, ...]
+    package_manager: str | None = None
+    config_files: tuple[str, ...] = ()
+    commands: dict[str, str] = field(default_factory=dict)
+    runtime_requirements: tuple[RuntimeRequirement, ...] = ()
+
+    def owns(self, relative_path: str) -> bool:
+        normalized = relative_path.replace("\\", "/").strip("/")
+        workspace_root = self.root.replace("\\", "/").strip("/")
+        return (
+            not workspace_root
+            or normalized == workspace_root
+            or normalized.startswith(workspace_root + "/")
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.workspace_id,
+            "root": self.root,
+            "kind": self.kind,
+            "technologies": list(self.technologies),
+            "package_manager": self.package_manager,
+            "config_files": list(self.config_files),
+            "commands": dict(self.commands),
+            "runtime_requirements": [
+                requirement.to_dict() for requirement in self.runtime_requirements
+            ],
+        }

ai_dev_tools/parsers/__init__.py

@@ -0,0 +1 @@
+"""Output parsers."""