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

ai_dev_tools/runners/baseline.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from ai_dev_tools.models.report import Artifact, Report
+
+BASELINE_SCHEMA_VERSION = "1"
+_SAFE_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
+
+
+def run_baseline(project_root: Path, action: str, name: str | None = None) -> Report:
+    root = project_root.resolve()
+    report = Report(command=f"baseline {action}" + (f" {name}" if name else ""), project_root=root)
+    directory = root / ".ai" / "cache" / "baselines"
+    if action == "list":
+        names = sorted(path.stem for path in directory.glob("*.json"))
+        report.summary = {"baselines": names, "count": len(names)}
+        return report
+    if not name or not _SAFE_NAME.fullmatch(name):
+        report.status = "failed"
+        report.exit_code = 2
+        report.summary = {
+            "message": "Baseline name must use 1-64 letters, digits, dots, dashes, or underscores.",
+            "reason_code": "INVALID_BASELINE_NAME",
+        }
+        return report
+    path = directory / f"{name}.json"
+    if action == "create":
+        snapshot = _snapshot(root, name)
+        directory.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(snapshot, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        report.summary = {
+            "name": name,
+            "reports": len(snapshot["reports"]),
+            "failures": len(_all_failures(snapshot)),
+            "created_at": snapshot["created_at"],
+        }
+        report.artifacts.append(Artifact(str(path), "baseline", "Local report baseline"))
+        return report
+    if action == "compare":
+        baseline = _load_baseline(path)
+        if baseline is None:
+            report.status = "failed"
+            report.exit_code = 1
+            report.summary = {
+                "message": f"Baseline does not exist or is invalid: {name}",
+                "reason_code": "BASELINE_NOT_FOUND",
+            }
+            return report
+        current = _snapshot(root, name)
+        report.summary = _compare(baseline, current)
+        report.summary["name"] = name
+        report.summary["baseline_created_at"] = baseline.get("created_at")
+        report.summary["ready"] = not (
+            report.summary["new_failures"] or report.summary["status_regressions"]
+        )
+        report.status = "success" if report.summary["ready"] else "failed"
+        return report
+    raise ValueError(f"Unsupported baseline action: {action}")
+
+
+def _snapshot(root: Path, name: str) -> dict[str, Any]:
+    reports: dict[str, dict[str, object]] = {}
+    paths = [
+        *sorted((root / ".ai" / "reports").glob("*latest.json")),
+        *sorted((root / ".ai" / "context").glob("*latest.json")),
+    ]
+    for path in paths:
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        command = payload.get("command")
+        if not isinstance(command, str):
+            continue
+        reports[command] = {
+            "status": payload.get("status"),
+            "failures": sorted(_failure_signatures(payload)),
+            "issue_codes": sorted(_issue_codes(payload)),
+            "source": str(path.relative_to(root)),
+        }
+    return {
+        "schema_version": BASELINE_SCHEMA_VERSION,
+        "name": name,
+        "created_at": datetime.now(UTC).isoformat(),
+        "reports": reports,
+    }
+
+
+def _compare(baseline: dict[str, Any], current: dict[str, Any]) -> dict[str, object]:
+    old_reports = _report_map(baseline)
+    new_reports = _report_map(current)
+    old_failures = _all_failures(baseline)
+    new_failures = _all_failures(current)
+    changed_statuses = [
+        {
+            "command": command,
+            "baseline": old_reports[command].get("status"),
+            "current": new_reports[command].get("status"),
+        }
+        for command in sorted(old_reports.keys() & new_reports.keys())
+        if old_reports[command].get("status") != new_reports[command].get("status")
+    ]
+    old_issues = _all_report_values(baseline, "issue_codes")
+    new_issues = _all_report_values(current, "issue_codes")
+    status_regressions = [
+        item
+        for item in changed_statuses
+        if item["current"] in {"failed", "blocked", "environment_error"}
+    ]
+    unchanged = sum(
+        old_reports[command] == new_reports[command]
+        for command in old_reports.keys() & new_reports.keys()
+    )
+    return {
+        "new_failures": sorted(new_failures - old_failures),
+        "resolved_failures": sorted(old_failures - new_failures),
+        "new_issue_codes": sorted(new_issues - old_issues),
+        "resolved_issue_codes": sorted(old_issues - new_issues),
+        "changed_statuses": changed_statuses,
+        "status_regressions": status_regressions,
+        "new_reports": sorted(new_reports.keys() - old_reports.keys()),
+        "missing_reports": sorted(old_reports.keys() - new_reports.keys()),
+        "unchanged_reports": unchanged,
+        "baseline_report_count": len(old_reports),
+        "current_report_count": len(new_reports),
+    }
+
+
+def _load_baseline(path: Path) -> dict[str, Any] | None:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict) or payload.get("schema_version") != BASELINE_SCHEMA_VERSION:
+        return None
+    return payload
+
+
+def _report_map(snapshot: dict[str, Any]) -> dict[str, dict[str, object]]:
+    reports = snapshot.get("reports")
+    if not isinstance(reports, dict):
+        return {}
+    return {str(command): value for command, value in reports.items() if isinstance(value, dict)}
+
+
+def _all_report_values(snapshot: dict[str, Any], key: str) -> set[str]:
+    values: set[str] = set()
+    for command, report in _report_map(snapshot).items():
+        entries = report.get(key)
+        if isinstance(entries, list):
+            values.update(f"{command}:{entry}" for entry in entries if isinstance(entry, str))
+    return values
+
+
+def _all_failures(snapshot: dict[str, Any]) -> set[str]:
+    failures: set[str] = set()
+    for command, report in _report_map(snapshot).items():
+        values = report.get("failures")
+        if isinstance(values, list):
+            failures.update(f"{command}:{value}" for value in values if isinstance(value, str))
+    return failures
+
+
+def _failure_signatures(value: object) -> set[str]:
+    result: set[str] = set()
+    if isinstance(value, dict):
+        for key, child in value.items():
+            if key in {"failure_signature", "signature"} and isinstance(child, str) and child:
+                result.add(child)
+            else:
+                result.update(_failure_signatures(child))
+    elif isinstance(value, list):
+        for child in value:
+            result.update(_failure_signatures(child))
+    return result
+
+
+def _issue_codes(payload: dict[str, object]) -> set[str]:
+    result: set[str] = set()
+    issues = payload.get("issues")
+    if isinstance(issues, list):
+        for issue in issues:
+            if isinstance(issue, dict) and isinstance(issue.get("code"), str):
+                result.add(str(issue["code"]))
+    return result

ai_dev_tools/runners/bootstrap.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Literal
+
+from ai_dev_tools.config import Settings, load_settings
+from ai_dev_tools.detectors.environment import run_doctor
+from ai_dev_tools.detectors.project import scan_project
+from ai_dev_tools.models.report import Artifact, Issue, Report
+from ai_dev_tools.reporters.writer import write_json, write_markdown
+from ai_dev_tools.runners.bootstrap_models import (
+    BootstrapOptions as BootstrapOptions,
+)
+from ai_dev_tools.runners.bootstrap_models import (
+    BootstrapPlan as BootstrapPlan,
+)
+from ai_dev_tools.runners.bootstrap_models import (
+    BootstrapStep as BootstrapStep,
+)
+from ai_dev_tools.runners.bootstrap_strategies import (
+    build_bootstrap_plan as build_bootstrap_plan,
+)
+from ai_dev_tools.security.secrets import mask_text
+from ai_dev_tools.utils.subprocess import CommandResult, run_command
+
+BootstrapStatus = Literal["planned", "executed", "skipped", "failed"]
+
+
+def run_bootstrap(project_root: Path, options: BootstrapOptions) -> Report:
+    settings = load_settings(project_root)
+    report = Report(command="bootstrap", project_root=settings.project_root)
+    scan = scan_project(settings.project_root)
+    doctor = run_doctor(settings.project_root)
+    plan = build_bootstrap_plan(settings, options)
+    missing_tools = _missing_required_tools(plan, doctor)
+    incompatible_runtimes = list(doctor.summary.get("incompatible_runtimes", []))
+    log_path = _log_path(settings.logs_directory)
+
+    if settings.warnings:
+        report.issues.extend(
+            Issue("warning", warning, code="CONFIG_WARNING") for warning in settings.warnings
+        )
+    if incompatible_runtimes:
+        report.status = "blocked"
+        report.issues.extend(
+            Issue(
+                "error",
+                (
+                    f"Incompatible {item.get('runtime')} runtime: "
+                    f"requires {item.get('constraint')}, detected {item.get('detected')}."
+                ),
+                code="INCOMPATIBLE_RUNTIME",
+            )
+            for item in incompatible_runtimes
+            if isinstance(item, dict)
+        )
+    elif not plan.steps and plan.project_type == "unknown":
+        report.status = "blocked"
+        report.issues.append(
+            Issue("error", "No supported project bootstrap strategy detected.", code="NO_STRATEGY")
+        )
+    elif missing_tools:
+        report.status = "blocked"
+        report.issues.extend(
+            Issue("error", f"Missing required bootstrap tool: {tool}", code="MISSING_RUNTIME")
+            for tool in missing_tools
+        )
+    else:
+        report.status = "success"
+
+    executed: list[dict[str, object]] = []
+    created_venv = False
+    created_env = False
+    smoke_check = "skipped"
+
+    should_execute = report.status == "success" and not options.explain and not options.dry_run
+    if should_execute:
+        for step in plan.steps:
+            result = _execute_step(step, settings, log_path)
+            executed.append(_step_result(step, result))
+            if step.action == "create_venv" and result.exit_code == 0:
+                created_venv = True
+            if step.action == "copy_env" and result.exit_code == 0:
+                created_env = True
+            if result.exit_code != 0:
+                report.status = "failed"
+                report.exit_code = result.exit_code
+                report.issues.append(
+                    Issue("error", f"Bootstrap command failed: {step.name}", code="COMMAND_FAILED")
+                )
+                break
+        if report.status == "success" and settings.bootstrap.run_smoke_check:
+            smoke_results = [_execute_step(step, settings, log_path) for step in plan.smoke_steps]
+            executed.extend(
+                _step_result(step, result)
+                for step, result in zip(plan.smoke_steps, smoke_results, strict=True)
+            )
+            smoke_check = (
+                "passed" if all(result.exit_code == 0 for result in smoke_results) else "failed"
+            )
+            if smoke_check == "failed":
+                report.status = "partial"
+                report.issues.append(
+                    Issue("warning", "Bootstrap smoke check failed.", code="SMOKE_FAILED")
+                )
+    elif options.explain or options.dry_run:
+        smoke_check = "planned" if plan.smoke_steps else "skipped"
+
+    summary: dict[str, object] = {
+        "project_type": plan.project_type,
+        "package_manager": plan.package_manager,
+        "dry_run": options.dry_run,
+        "explain": options.explain,
+        "planned_commands": len(plan.steps),
+        "executed_commands": len([item for item in executed if item["exit_code"] == 0]),
+        "created_venv": created_venv,
+        "created_env": created_env,
+        "smoke_check": smoke_check,
+        "plan": plan.to_dict(),
+        "executed": executed,
+        "missing_tools": missing_tools,
+        "runtime_compatibility": doctor.summary.get("runtime_compatibility", []),
+        "scan": scan.summary,
+        "modifications": "NONE" if options.explain or options.dry_run else "PLANNED",
+    }
+    if log_path.exists():
+        summary["full_log"] = str(log_path)
+        report.artifacts.append(Artifact(str(log_path), "log", "Full bootstrap command output"))
+    report.summary = summary
+    report.finish()
+    write_markdown(report, settings.reports_directory / "bootstrap-latest.md")
+    write_json(report, settings.reports_directory / "bootstrap-latest.json")
+    return report
+
+
+def _execute_step(step: BootstrapStep, settings: Settings, log_path: Path) -> CommandResult:
+    working_directory = (
+        settings.project_root / step.workspace if step.workspace else settings.project_root
+    )
+    if step.action == "copy_env":
+        source = working_directory / ".env.example"
+        target = working_directory / ".env"
+        if target.exists():
+            result = CommandResult(step.command, 0, "Skipped existing .env", "", 0.0)
+        else:
+            shutil.copyfile(source, target)
+            result = CommandResult(step.command, 0, "Created .env from .env.example", "", 0.0)
+    else:
+        result = run_command(step.command, working_directory, settings.bootstrap.timeout_seconds)
+    result.stdout = mask_text(result.stdout)
+    result.stderr = mask_text(result.stderr)
+    _append_log(log_path, step, result)
+    return result
+
+
+def _append_log(log_path: Path, step: BootstrapStep, result: CommandResult) -> None:
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    with log_path.open("a", encoding="utf-8") as handle:
+        handle.write(f"$ {' '.join(step.command)}\n")
+        handle.write(result.combined_output + "\n")
+        handle.write(f"EXIT_CODE={result.exit_code} DURATION={result.duration_seconds}s\n\n")
+
+
+def _step_result(step: BootstrapStep, result: CommandResult) -> dict[str, object]:
+    return {
+        "name": step.name,
+        "command": step.command,
+        "exit_code": result.exit_code,
+        "duration_seconds": result.duration_seconds,
+        "timed_out": result.timed_out,
+    }
+
+
+def _missing_required_tools(plan: BootstrapPlan, doctor: Report) -> list[str]:
+    tools = doctor.summary.get("tools", {})
+    if not isinstance(tools, dict):
+        return plan.required_tools
+    missing: list[str] = []
+    for tool in plan.required_tools:
+        if tool == "python":
+            continue
+        tool_info = tools.get(tool)
+        if not isinstance(tool_info, dict) or tool_info.get("status") != "ok":
+            missing.append(tool)
+    return sorted(set(missing))
+
+
+def _log_path(logs_dir: Path) -> Path:
+    return logs_dir / f"bootstrap-{datetime.now().strftime('%Y%m%d-%H%M%S-%f')}.log"

ai_dev_tools/runners/bootstrap_models.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Literal
+
+BootstrapStatus = Literal["planned", "executed", "skipped", "failed"]
+
+
+@dataclass(frozen=True, slots=True)
+class BootstrapOptions:
+    dry_run: bool = False
+    explain: bool = False
+    create_env: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class BootstrapStep:
+    name: str
+    command: list[str]
+    reason: str
+    source: str
+    modifies_project: bool = True
+    required_tool: str | None = None
+    action: str = "command"
+    workspace: str = ""
+
+    def to_dict(self) -> dict[str, object]:
+        return {**asdict(self), "reason_code": _bootstrap_reason_code(self)}
+
+
+def _bootstrap_reason_code(step: BootstrapStep) -> str:
+    if step.action == "create_venv":
+        return "CREATE_VIRTUAL_ENVIRONMENT"
+    if step.action == "copy_env":
+        return "CREATE_ENVIRONMENT_FILE"
+    if step.workspace:
+        return "WORKSPACE_BOOTSTRAP"
+    if "smoke" in step.name.lower() or "verify" in step.reason.lower():
+        return "SMOKE_VALIDATION"
+    return "PROJECT_BOOTSTRAP"
+
+
+@dataclass(frozen=True, slots=True)
+class BootstrapPlan:
+    project_type: str
+    package_manager: str | None
+    steps: list[BootstrapStep]
+    smoke_steps: list[BootstrapStep]
+    required_tools: list[str]
+    env_available: bool = False
+    env_will_create: bool = False
+    monorepo_subprojects: list[str] | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "project_type": self.project_type,
+            "package_manager": self.package_manager,
+            "steps": [step.to_dict() for step in self.steps],
+            "smoke_steps": [step.to_dict() for step in self.smoke_steps],
+            "required_tools": self.required_tools,
+            "env_available": self.env_available,
+            "env_will_create": self.env_will_create,
+            "monorepo_subprojects": self.monorepo_subprojects or [],
+        }