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

ai_dev_tools/runners/check_scheduler.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from time import monotonic
+
+from ai_dev_tools.runners.check_models import CheckTask
+from ai_dev_tools.utils.subprocess import CommandResult
+
+
+@dataclass(frozen=True, slots=True)
+class ScheduleResult:
+    tasks: list[CheckTask]
+    results: list[CommandResult]
+    cancelled: list[CheckTask]
+    wall_seconds: float
+    aggregate_seconds: float
+    time_to_first_failure_seconds: float | None
+
+
+def schedule_checks(
+    tasks: list[CheckTask],
+    jobs: int,
+    policy: str,
+    execute: Callable[[CheckTask], CommandResult],
+) -> ScheduleResult:
+    started = monotonic()
+    completed_tasks: list[CheckTask] = []
+    results: list[CommandResult] = []
+    cancelled: list[CheckTask] = []
+    first_failure_at: float | None = None
+    groups = [tasks] if policy == "complete" else _feedback_groups(tasks)
+    for group_index, group in enumerate(groups):
+        group_results = _execute_group(group, jobs, execute)
+        completed_tasks.extend(group)
+        results.extend(group_results)
+        if first_failure_at is None and any(result.exit_code != 0 for result in group_results):
+            first_failure_at = monotonic() - started
+        blocking = any(
+            task.required and result.exit_code != 0
+            for task, result in zip(group, group_results, strict=True)
+        )
+        if policy == "feedback-first" and blocking:
+            cancelled = [task for remaining in groups[group_index + 1 :] for task in remaining]
+            break
+    wall = monotonic() - started
+    return ScheduleResult(
+        completed_tasks,
+        results,
+        cancelled,
+        round(wall, 3),
+        round(sum(result.duration_seconds for result in results), 3),
+        round(first_failure_at, 3) if first_failure_at is not None else None,
+    )
+
+
+def schedule_graph(tasks: list[CheckTask], policy: str) -> dict[str, object]:
+    waves = _feedback_groups(tasks) if policy == "feedback-first" else [tasks]
+    return {
+        "policy": policy,
+        "waves": [
+            {
+                "index": index,
+                "cost": wave[0].cost if wave else "none",
+                "checks": [task.name for task in wave],
+                "workspaces": sorted({task.workspace for task in wave}),
+            }
+            for index, wave in enumerate(waves)
+        ],
+        "fail_fast": policy == "feedback-first",
+        "deterministic_order": True,
+    }
+
+
+def _feedback_groups(tasks: list[CheckTask]) -> list[list[CheckTask]]:
+    costs = ("fast", "medium", "slow")
+    return [
+        [task for task in tasks if task.cost == cost]
+        for cost in costs
+        if any(task.cost == cost for task in tasks)
+    ]
+
+
+def _execute_group(
+    tasks: list[CheckTask],
+    jobs: int,
+    execute: Callable[[CheckTask], CommandResult],
+) -> list[CommandResult]:
+    workers = max(1, min(jobs, len(tasks)))
+    if workers == 1:
+        return [execute(task) for task in tasks]
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        return list(executor.map(execute, tasks))

ai_dev_tools/runners/check_selection.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import fnmatch
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+from ai_dev_tools.cache.graph import related_tests as graph_related_tests
+from ai_dev_tools.cache.repository import read_repository_index
+from ai_dev_tools.config import Settings
+from ai_dev_tools.runners.check_models import ChangedSelection, ChangedStrategy, CheckTask
+from ai_dev_tools.utils.subprocess import CommandResult, run_command
+
+
+def select_changed_checks(
+    settings: Settings,
+    plan: list[CheckTask],
+    collector: Callable[[Path], list[str]] | None = None,
+) -> ChangedSelection:
+    changed_files = (collector or collect_changed_files)(settings.project_root)
+    if not changed_files:
+        return ChangedSelection("no_changes", "high", [], [], [], "No changed files detected.")
+    config_reason = _configuration_change_reason(changed_files)
+    if config_reason:
+        return ChangedSelection(
+            "configuration_change",
+            "low",
+            changed_files,
+            [],
+            [],
+            config_reason,
+        )
+    direct_changed_tests = [path for path in changed_files if _is_test_path(Path(path))]
+    if direct_changed_tests:
+        return ChangedSelection(
+            "changed_test_direct",
+            "high",
+            changed_files,
+            sorted(direct_changed_tests),
+            _commands_for_selected_tests(plan, sorted(direct_changed_tests)),
+            None,
+        )
+    configured_tests = _configured_changed_tests(settings, changed_files)
+    if configured_tests:
+        return ChangedSelection(
+            "configured_mapping",
+            "high",
+            changed_files,
+            configured_tests,
+            _commands_for_selected_tests(plan, configured_tests),
+            None,
+        )
+    selected_tests = infer_tests_for_changed_files(settings.project_root, changed_files)
+    if selected_tests:
+        strategy: ChangedStrategy = "direct_test_match"
+        return ChangedSelection(
+            strategy,
+            "medium",
+            changed_files,
+            selected_tests,
+            _commands_for_selected_tests(plan, selected_tests),
+            None,
+        )
+    return ChangedSelection(
+        "broad_fallback",
+        "low",
+        changed_files,
+        [],
+        [],
+        "Changed files were detected, but no reliable test dependency map is available yet.",
+    )
+
+
+def collect_changed_files(
+    root: Path,
+    command_runner: Callable[[list[str], Path, int], CommandResult] = run_command,
+) -> list[str]:
+    seen: dict[str, None] = {}
+    commands = [
+        ["git", "diff", "--name-only", "-z"],
+        ["git", "diff", "--cached", "--name-only", "-z"],
+        ["git", "ls-files", "--others", "--exclude-standard", "-z"],
+    ]
+    upstream = command_runner(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root, 30
+    )
+    if upstream.exit_code == 0 and upstream.stdout.strip():
+        commands.append(["git", "diff", "--name-only", "-z", upstream.stdout.strip() + "...HEAD"])
+    for command in commands:
+        result = command_runner(command, root, 30)
+        if result.exit_code != 0:
+            continue
+        for item in _split_nul(result.stdout):
+            if item:
+                seen[item] = None
+    return sorted(seen)
+
+
+def infer_tests_for_changed_files(root: Path, changed_files: list[str]) -> list[str]:
+    selected: dict[str, None] = {}
+    index = read_repository_index(root)
+    for rel in graph_related_tests(index.get("graph"), changed_files):
+        _add_existing(root, selected, rel)
+    for rel in changed_files:
+        path = Path(rel)
+        if _is_test_path(path):
+            _add_existing(root, selected, rel)
+            continue
+        candidates = _candidate_tests_for_source(path)
+        for candidate in candidates:
+            _add_existing(root, selected, candidate)
+        for importer in _python_importing_tests(root, path):
+            selected[importer] = None
+    return sorted(selected)
+
+
+def _configuration_change_reason(changed_files: list[str]) -> str | None:
+    broad_files = {
+        "pyproject.toml",
+        "pytest.ini",
+        "tox.ini",
+        "noxfile.py",
+        "package.json",
+        "pnpm-workspace.yaml",
+        "jest.config.js",
+        "jest.config.ts",
+        "vitest.config.js",
+        "vitest.config.ts",
+        "pom.xml",
+        "build.gradle",
+        "build.gradle.kts",
+        "settings.gradle",
+        "settings.gradle.kts",
+        "Cargo.toml",
+        "Cargo.lock",
+        "composer.json",
+        "phpunit.xml",
+    }
+    for rel in changed_files:
+        path = Path(rel)
+        normalized = path.as_posix()
+        if path.name == "conftest.py" or "fixtures" in path.parts:
+            return f"Shared test fixture changed: {rel}"
+        if normalized in broad_files or path.name in broad_files:
+            return f"Project or test configuration changed: {rel}"
+    return None
+
+
+def _candidate_tests_for_source(path: Path) -> list[str]:
+    stem = path.stem
+    suffix = path.suffix.lower()
+    parts = list(path.parts)
+    candidates: list[str] = []
+    if suffix == ".py":
+        relative_parts = parts[1:] if parts and parts[0] in {"src", "lib"} else parts
+        if relative_parts:
+            relative_parts[-1] = f"test_{stem}.py"
+            candidates.append(str(Path("tests", *relative_parts)))
+        candidates.append(str(Path("tests", f"test_{stem}.py")))
+    if suffix in {".js", ".jsx", ".ts", ".tsx"}:
+        candidates.extend(
+            [
+                str(path.with_name(f"{stem}.test{suffix}")),
+                str(path.with_name(f"{stem}.spec{suffix}")),
+                str(Path("tests", f"{stem}.test{suffix}")),
+                str(Path("tests", f"{stem}.spec{suffix}")),
+            ]
+        )
+    if suffix == ".java" and parts[:3] == ["src", "main", "java"]:
+        test_parts = ["src", "test", "java", *parts[3:]]
+        test_parts[-1] = f"{stem}Test.java"
+        candidates.append(str(Path(*test_parts)))
+    if suffix == ".php":
+        rel_parts = parts[1:] if parts and parts[0] == "src" else parts
+        if rel_parts:
+            rel_parts[-1] = f"{stem}Test.php"
+            candidates.append(str(Path("tests", *rel_parts)))
+    return candidates
+
+
+def _python_importing_tests(root: Path, source_path: Path) -> list[str]:
+    if source_path.suffix.lower() != ".py" or not (root / "tests").exists():
+        return []
+    module = ".".join(source_path.with_suffix("").parts)
+    if module.startswith("src."):
+        module = module[4:]
+    needle_options = {
+        f"import {module}",
+        f"from {module} import",
+        f"from {module.rsplit('.', 1)[0]} import" if "." in module else "",
+    }
+    matches: list[str] = []
+    for test_path in (root / "tests").rglob("test_*.py"):
+        text = test_path.read_text(encoding="utf-8", errors="replace")
+        if any(needle and needle in text for needle in needle_options):
+            matches.append(str(test_path.relative_to(root)))
+    return matches
+
+
+def _configured_changed_tests(settings: Settings, changed_files: list[str]) -> list[str]:
+    selected: dict[str, None] = {}
+    for source_pattern, test_patterns in settings.changed_tests.items():
+        if not any(
+            fnmatch.fnmatch(path.replace("\\", "/"), source_pattern) for path in changed_files
+        ):
+            continue
+        for pattern in test_patterns:
+            for match in _matching_test_files(settings.project_root, pattern):
+                selected[str(match.relative_to(settings.project_root))] = None
+    return sorted(selected)
+
+
+def _matching_test_files(root: Path, pattern: str) -> list[Path]:
+    files: dict[Path, None] = {}
+    for match in root.glob(pattern):
+        if match.is_file():
+            files[match] = None
+        elif match.is_dir():
+            for child in match.rglob("*"):
+                if child.is_file():
+                    files[child] = None
+    return sorted(files)
+
+
+def _commands_for_selected_tests(
+    plan: list[CheckTask], selected_tests: list[str]
+) -> list[list[str]]:
+    commands: list[list[str]] = []
+    if not selected_tests:
+        return commands
+    if any(path.endswith(".py") for path in selected_tests):
+        commands.append([sys.executable, "-m", "pytest", *selected_tests])
+    if any(path.endswith((".js", ".jsx", ".ts", ".tsx")) for path in selected_tests):
+        npm_test = next((task.command for task in plan if task.name == "npm test"), ["npm", "test"])
+        commands.append(npm_test)
+    if any(path.endswith(".java") for path in selected_tests):
+        maven = next((task.command for task in plan if task.name == "maven test"), None)
+        gradle = next((task.command for task in plan if task.name == "gradle test"), None)
+        commands.append(maven or gradle or ["mvn", "test"])
+    if any(path.endswith(".php") for path in selected_tests):
+        commands.append(
+            next(
+                (task.command for task in plan if task.name == "composer test"),
+                ["composer", "test"],
+            )
+        )
+    return commands
+
+
+def _is_test_path(path: Path) -> bool:
+    text = path.as_posix().lower()
+    return (
+        "/tests/" in f"/{text}"
+        or ".test." in text
+        or ".spec." in text
+        or path.name.startswith("test_")
+    )
+
+
+def _add_existing(root: Path, selected: dict[str, None], rel: str) -> None:
+    path = root / rel
+    if path.exists() and path.is_file():
+        selected[str(path.relative_to(root))] = None
+
+
+def _split_nul(output: str) -> list[str]:
+    return [item for item in output.split("\0") if item]

ai_dev_tools/runners/diagnostics.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+
+from ai_dev_tools.cache.repository import read_repository_index
+from ai_dev_tools.cache.validation import validation_cache_stats
+from ai_dev_tools.config import load_settings
+from ai_dev_tools.models.report import Report
+
+
+def run_diagnostics(project_root: Path) -> Report:
+    settings = load_settings(project_root)
+    root = settings.project_root
+    report = Report(command="diagnostics", project_root=root)
+    config_path = root / ".ai-dev-tools.toml"
+    report.summary = {
+        "cache": validation_cache_stats(root),
+        "repository_index": _index_summary(read_repository_index(root)),
+        "reports": _directory_stats(settings.reports_directory),
+        "logs": _directory_stats(settings.logs_directory),
+        "configuration": {
+            "source": str(config_path) if config_path.exists() else "built-in defaults",
+            "warnings": settings.warnings,
+            "reports_directory": str(settings.reports_directory),
+            "logs_directory": str(settings.logs_directory),
+        },
+        "efficiency_metrics": _efficiency_metrics(root),
+        "privacy": "local-only; no repository contents or metrics are transmitted",
+    }
+    return report
+
+
+def _directory_stats(directory: Path) -> dict[str, object]:
+    files = [path for path in directory.rglob("*") if path.is_file()] if directory.exists() else []
+    sizes = [_size(path) for path in files]
+    ordered = sorted(files, key=_mtime)
+    return {
+        "files": len(files),
+        "bytes": sum(sizes),
+        "oldest": str(ordered[0]) if ordered else None,
+        "newest": str(ordered[-1]) if ordered else None,
+    }
+
+
+def _index_summary(index: dict[str, object]) -> dict[str, object]:
+    summary = index.get("summary")
+    return {
+        "available": bool(index),
+        "schema_version": index.get("schema_version"),
+        **(summary if isinstance(summary, dict) else {}),
+    }
+
+
+def _efficiency_metrics(root: Path) -> dict[str, int]:
+    context_path = root / ".ai" / "context" / "context-latest.json"
+    try:
+        context = json.loads(context_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        context = {}
+    summary = context.get("summary", {}) if isinstance(context, dict) else {}
+    incremental = summary.get("incremental", {}) if isinstance(summary, dict) else {}
+    reused = incremental.get("reused_files", []) if isinstance(incremental, dict) else []
+    reused_paths = {str(item) for item in reused} if isinstance(reused, list) else set()
+    index = read_repository_index(root)
+    entries = index.get("entries", [])
+    reused_bytes = 0
+    if isinstance(entries, list):
+        for entry in entries:
+            if isinstance(entry, dict) and entry.get("path") in reused_paths:
+                size = entry.get("size")
+                reused_bytes += size if isinstance(size, int) else 0
+    budget = summary.get("budget", {}) if isinstance(summary, dict) else {}
+    used_chars = budget.get("used_chars", 0) if isinstance(budget, dict) else 0
+    chars = used_chars if isinstance(used_chars, int) else 0
+    return {
+        "latest_context_chars": chars,
+        "latest_context_token_estimate": math.ceil(chars / 4),
+        "reused_context_bytes": reused_bytes,
+        "estimated_tokens_avoided": math.ceil(reused_bytes / 4),
+    }
+
+
+def _size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _mtime(path: Path) -> int:
+    try:
+        return path.stat().st_mtime_ns
+    except OSError:
+        return 0

ai_dev_tools/runners/feedback.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from ai_dev_tools.config import load_settings
+from ai_dev_tools.context import ContextOptions, build_context
+from ai_dev_tools.git.inspect import inspect_git
+from ai_dev_tools.models.report import Artifact, Report
+from ai_dev_tools.runners.check import run_check
+from ai_dev_tools.security.secrets import mask_text
+
+SESSION_SCHEMA_VERSION = "1"
+
+
+@dataclass(frozen=True, slots=True)
+class FeedbackOptions:
+    task: str = ""
+    explain: bool = False
+    jobs: int = 4
+
+
+def run_feedback(project_root: Path, options: FeedbackOptions) -> Report:
+    settings = load_settings(project_root)
+    root = settings.project_root
+    report = Report(command="feedback", project_root=root)
+    timings: dict[str, float] = {}
+
+    started = time.monotonic()
+    git_report = inspect_git(root, detailed=True)
+    timings["git_inspect"] = _elapsed(started)
+
+    started = time.monotonic()
+    check_report = run_check(
+        root,
+        mode="changed",
+        explain=options.explain,
+        jobs=options.jobs,
+        policy="feedback-first",
+        resume=True,
+    )
+    timings["validation"] = _elapsed(started)
+
+    started = time.monotonic()
+    context_report = build_context(
+        root,
+        ContextOptions(
+            task=options.task,
+            profile="minimal",
+            incremental=not options.explain,
+            explain=options.explain,
+        ),
+    )
+    timings["context"] = _elapsed(started)
+
+    changed = [str(item) for item in git_report.summary.get("changed_files", [])]
+    failures = _failure_signatures(check_report)
+    blocking_codes = [
+        str(issue.code or "VALIDATION_FAILED")
+        for issue in check_report.issues
+        if issue.severity in {"error", "critical"}
+    ]
+    if check_report.status == "failed" and not blocking_codes:
+        blocking_codes.append("VALIDATION_FAILED")
+    ready = check_report.status in {"success", "partial"} and not blocking_codes
+    report.status = "success" if ready else "failed"
+    report.summary = {
+        "agent_protocol_version": "1",
+        "decision": {
+            "ready": ready,
+            "status": report.status,
+            "confidence": _confidence(check_report),
+            "blocking_reason_codes": sorted(set(blocking_codes)),
+        },
+        "changes": {
+            "files": changed,
+            "count": len(changed),
+            "git_states": git_report.summary.get("states", []),
+        },
+        "validation": {
+            "status": check_report.status,
+            "checks_total": check_report.summary.get("checks_total", 0),
+            "checks_failed": check_report.summary.get("checks_failed", 0),
+            "first_failure": check_report.summary.get("first_failure"),
+            "failure_signatures": failures,
+            "results": check_report.summary.get("results", []),
+            "execution": check_report.summary.get("execution", {}),
+        },
+        "context": {
+            "status": context_report.status,
+            "selected_files": context_report.summary.get("selected_files", []),
+            "incremental": context_report.summary.get("incremental", {}),
+            "budget": context_report.summary.get("budget", {}),
+        },
+        "performance": {
+            "stages_seconds": timings,
+            "total_seconds": round(sum(timings.values()), 3),
+        },
+        "expand": [
+            {"kind": artifact.kind, "path": artifact.path}
+            for artifact in [*check_report.artifacts, *context_report.artifacts]
+        ],
+    }
+    session_path = _write_session(
+        root,
+        {
+            "schema_version": SESSION_SCHEMA_VERSION,
+            "task": options.task,
+            "changed_files": changed,
+            "validation_status": check_report.status,
+            "failure_signatures": failures,
+            "context_incremental": context_report.summary.get("incremental", {}),
+            "performance": timings,
+        },
+    )
+    report.artifacts.append(Artifact(str(session_path), "session", "Local agent session state"))
+    report.artifacts.extend(_unique_artifacts([*check_report.artifacts, *context_report.artifacts]))
+    return report
+
+
+def run_session_status(project_root: Path) -> Report:
+    root = project_root.resolve()
+    report = Report(command="session status", project_root=root)
+    try:
+        payload = json.loads(_session_path(root).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        report.status = "partial"
+        report.summary = {
+            "message": "No valid local session state exists.",
+            "reason_code": "SESSION_MISSING",
+        }
+        return report
+    if not isinstance(payload, dict) or payload.get("schema_version") != SESSION_SCHEMA_VERSION:
+        report.status = "partial"
+        report.summary = {
+            "message": "Local session state uses an unsupported schema.",
+            "reason_code": "SESSION_SCHEMA_UNSUPPORTED",
+        }
+        return report
+    report.summary = payload
+    report.artifacts.append(
+        Artifact(str(_session_path(root)), "session", "Local agent session state")
+    )
+    return report
+
+
+def _failure_signatures(report: Report) -> list[str]:
+    results = report.summary.get("results")
+    if not isinstance(results, list):
+        return []
+    return sorted(
+        {
+            str(item["failure_signature"])
+            for item in results
+            if isinstance(item, dict) and item.get("failure_signature")
+        }
+    )
+
+
+def _confidence(report: Report) -> str:
+    changed = report.summary.get("changed_analysis")
+    if isinstance(changed, dict) and isinstance(changed.get("confidence"), str):
+        return str(changed["confidence"])
+    return "medium" if report.status == "partial" else "high"
+
+
+def _write_session(root: Path, payload: dict[str, object]) -> Path:
+    path = _session_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(
+        mask_text(json.dumps(payload, indent=2, sort_keys=True) + "\n"), encoding="utf-8"
+    )
+    os.replace(temporary, path)
+    return path
+
+
+def _session_path(root: Path) -> Path:
+    return root / ".ai" / "cache" / "session.json"
+
+
+def _elapsed(started: float) -> float:
+    return round(time.monotonic() - started, 3)
+
+
+def _unique_artifacts(artifacts: list[Artifact]) -> list[Artifact]:
+    unique: dict[tuple[str, str], Artifact] = {}
+    for artifact in artifacts:
+        unique[(artifact.path, artifact.kind)] = artifact
+    return list(unique.values())