agentic-devtools 0.2.596__py3-none-any.whl → 0.2.598__py3-none-any.whl

agentic_devtools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.596'
-__version_tuple__ = version_tuple = (0, 2, 596)
+__version__ = version = '0.2.598'
+__version_tuple__ = version_tuple = (0, 2, 598)
 
 __commit_id__ = commit_id = None

agentic_devtools/cli/ci/windows_specific.py

@@ -13,6 +13,9 @@ from collections.abc import Collection, Mapping, Sequence
 from pathlib import Path, PurePosixPath, PureWindowsPath
 from typing import Literal, NamedTuple, cast
 
+from agentic_devtools.cli.ci import windows_specific_cli
+from agentic_devtools.cli.ci.windows_specific_cli import _check_bindings, _run_cli, _unique_object
+
 __all__ = [
     "ProductGroup",
     "SelectorPolicy",
@@ -23,6 +26,7 @@ __all__ = [
     "run_selected_tests",
     "audit_test_results",
     "evaluate_gate",
+    "main",
 ]
 
 ProductGroup = Literal["setup-check", "portability", "benchmark"]
@@ -107,9 +111,14 @@ _CONTRACT_PATHS = {
     ".github/workflows/pr-smart-module-tests.yml",
     "tests/workflows/test_windows_specific_ci.py",
     "agentic_devtools/cli/ci/windows_specific.py",
+    "agentic_devtools/cli/ci/windows_specific_cli.py",
     "agentic_devtools/cli/ci/windows_fixture_bytes.py",
 }
-_CONTRACT_PREFIXES = ("tests/unit/cli/ci/windows_specific/", "tests/unit/cli/ci/windows_fixture_bytes/")
+_CONTRACT_PREFIXES = (
+    "tests/unit/cli/ci/windows_specific/",
+    "tests/unit/cli/ci/windows_specific_cli/",
+    "tests/unit/cli/ci/windows_fixture_bytes/",
+)
 _EXPECTATION_NAMES = {"EXPECTED_SELECTORS", "EXPECTED_EXPANSIONS"}
 _NODE_ID_PATTERN = re.compile(
     r"(?:(?!\.{1,2}(?:/|$))[^/\\:\s]+/)*(?!\.{1,2}(?:/|$))[^/\\:\s]+\.py"
@@ -153,7 +162,7 @@ def _parse_source(source: str) -> SelectorPolicy:
     if assignments.keys() != _EXPECTATION_NAMES:
         raise ValueError("Missing simple top-level expectation assignments")
 
-    _check_bindings(tree, {id(statement.targets[0]) for statement in assignments.values()})
+    _check_bindings(tree, {id(statement.targets[0]) for statement in assignments.values()}, _EXPECTATION_NAMES)
 
     values = {}
     for name, statement in assignments.items():
@@ -171,38 +180,6 @@ def _parse_source(source: str) -> SelectorPolicy:
     return _validate_policy(values["EXPECTED_SELECTORS"], values["EXPECTED_EXPANSIONS"])
 
 
-def _check_bindings(tree: ast.Module, allowed_targets: set[int]) -> None:
-    """Reject expectation bindings other than the two approved literal targets."""
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
-            if node.id in _EXPECTATION_NAMES and id(node) not in allowed_targets:
-                raise ValueError("Additional expectation binding or deletion")
-        # Some Python bindings are string fields rather than Name(Store) nodes.
-        names: Sequence[str | None]
-        if isinstance(node, ast.alias):
-            if node.name == "*":
-                raise ValueError("Wildcard imports may rebind policy expectations")
-            names = [node.asname or node.name.split(".")[0]]
-        elif isinstance(node, ast.arg):
-            names = [node.arg]
-        elif isinstance(node, (ast.Global, ast.Nonlocal)):
-            names = node.names
-        else:
-            names = [getattr(node, "name", None), getattr(node, "rest", None)]
-        if any(name in _EXPECTATION_NAMES for name in names):
-            raise ValueError("Additional expectation binding")
-
-
-def _unique_object(pairs: list[tuple[str, object]]) -> dict[str, object]:
-    """Reject duplicate JSON keys at every nesting level."""
-    result: dict[str, object] = {}
-    for key, value in pairs:
-        if key in result:
-            raise ValueError(f"Duplicate JSON object key: {key}")
-        result[key] = value
-    return result
-
-
 def load_policy(
     manifest_path: str | Path,
     base_policy_path: str | Path,
@@ -498,3 +475,24 @@ def evaluate_gate(
     ):
         return {"ok": False, "error_code": "required_evidence_missing"}
     return {"ok": True, "classification": "native-evidence" if groups else "not-applicable"}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the focused Windows CI command dispatcher with trusted APIs."""
+    policy_loader: windows_specific_cli._LoadPolicy[SelectorPolicy, ProductGroup] = load_policy
+    group_selector: windows_specific_cli._SelectGroups[ProductGroup] = select_groups
+    test_runner: windows_specific_cli._RunSelectedTests[SelectorPolicy, ProductGroup] = run_selected_tests
+    gate_evaluator: windows_specific_cli._EvaluateGate[Literal["success", "failure", "cancelled", "skipped"]] = (
+        evaluate_gate
+    )
+    return _run_cli(
+        argv,
+        load_policy=policy_loader,
+        select_groups=group_selector,
+        run_selected_tests=test_runner,
+        evaluate_gate=gate_evaluator,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agentic_devtools/cli/ci/windows_specific_cli.py

@@ -0,0 +1,362 @@
+"""Private command dispatch for trusted Windows-specific CI orchestration."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Collection, Mapping, Sequence
+from pathlib import Path
+from typing import Literal, Never, Protocol, TypeVar, cast
+
+from agentic_devtools.cli.ci.windows_fixture_bytes import verify_fixture_bytes
+
+POut = TypeVar("POut", covariant=True)
+PIn = TypeVar("PIn", contravariant=True)
+GOut = TypeVar("GOut", bound=Literal["setup-check", "portability", "benchmark"], covariant=True)
+GIn = TypeVar("GIn", bound=Literal["setup-check", "portability", "benchmark"], contravariant=True)
+RIn = TypeVar("RIn", bound=Literal["success", "failure", "cancelled", "skipped"], contravariant=True)
+_P = str | Path
+type _G[T] = Collection[T]
+_R = dict[str, bool | list[str] | int]
+_S = Mapping[str, object]
+_E = dict[str, bool | str]
+
+
+class _LoadPolicy(Protocol[POut, GIn]):
+    def __call__(self, m: _P, b: _P, h: _P, /, *, applicable_groups: _G[GIn], bootstrap: bool) -> POut: ...
+
+
+class _SelectGroups(Protocol[GOut]):
+    def __call__(self, changed_paths: Sequence[str]) -> tuple[frozenset[GOut], bool]: ...
+
+
+class _RunSelectedTests(Protocol[PIn, GIn]):
+    def __call__(self, root: _P, policy: PIn, groups: _G[GIn], /, *, junit_path: _P) -> _R: ...
+
+
+class _EvaluateGate(Protocol[RIn]):
+    def __call__(self, selection: _S, linux: RIn | None, windows: RIn | None, /) -> _E: ...
+
+
+def _check_bindings(tree: ast.Module, allowed_targets: set[int], expectation_names: set[str]) -> None:
+    """Reject expectation bindings other than the approved literal targets."""
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            if node.id in expectation_names and id(node) not in allowed_targets:
+                raise ValueError("Additional expectation binding or deletion")
+        # Some Python bindings are string fields rather than Name(Store) nodes.
+        names: Sequence[str | None]
+        if isinstance(node, ast.alias):
+            if node.name == "*":
+                raise ValueError("Wildcard imports may rebind policy expectations")
+            names = [node.asname or node.name.split(".")[0]]
+        elif isinstance(node, ast.arg):
+            names = [node.arg]
+        elif isinstance(node, (ast.Global, ast.Nonlocal)):
+            names = node.names
+        else:
+            names = [getattr(node, "name", None), getattr(node, "rest", None)]
+        if any(name in expectation_names for name in names):
+            raise ValueError("Additional expectation binding")
+
+
+def _unique_object(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    """Reject duplicate JSON keys at every nesting level."""
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"Duplicate JSON object key: {key}")
+        result[key] = value
+    return result
+
+
+class _Dispatcher[
+    PolicyT,
+    GroupT: Literal["setup-check", "portability", "benchmark"],
+    ResultT: Literal["success", "failure", "cancelled", "skipped"],
+]:
+    def __init__(
+        self,
+        load_policy: _LoadPolicy[PolicyT, GroupT],
+        select_groups: _SelectGroups[GroupT],
+        run_selected_tests: _RunSelectedTests[PolicyT, GroupT],
+        evaluate_gate: _EvaluateGate[ResultT],
+    ) -> None:
+        self._load_policy = load_policy
+        self._select_groups = select_groups
+        self._run_selected_tests = run_selected_tests
+        self._evaluate_gate = evaluate_gate
+        self._product_group_order = ("setup-check", "portability", "benchmark")
+
+    def _emit(self, payload: Mapping[str, object], status: int = 0) -> int:
+        print(json.dumps(payload, separators=(",", ":")))
+        return status
+
+    def _fail(self, error_code: str, detail: object, status: int = 1) -> int:
+        print(str(detail), file=sys.stderr)
+        return self._emit({"ok": False, "error_code": error_code}, status)
+
+    def _missing_file_code(self, exc: FileNotFoundError, base_policy: str, manifest: str, head_policy: str) -> str:
+        if not isinstance(exc.filename, str):
+            return "policy_io_failed"
+        path = Path(exc.filename)
+        if path == Path(base_policy):
+            return "base_policy_missing"
+        if path == Path(manifest):
+            return "manifest_missing"
+        if path == Path(head_policy):
+            return "head_policy_missing"
+        return "policy_io_failed"
+
+    def _decode_json(self, raw: str, error_code: str) -> tuple[object | None, int | None]:
+        try:
+            return json.loads(raw, object_pairs_hook=_unique_object), None
+        except ValueError as exc:
+            return None, self._fail(error_code, exc)
+
+    def _retry_select_policy(
+        self, manifest: str, base_policy: str, head_policy: str, groups: frozenset[GroupT]
+    ) -> tuple[int, bool]:
+        try:
+            self._load_policy(
+                manifest,
+                base_policy,
+                head_policy,
+                applicable_groups=groups,
+                bootstrap=True,
+            )
+        except FileNotFoundError as exc:
+            return self._fail(self._missing_file_code(exc, base_policy, manifest, head_policy), exc), False
+        except ValueError as exc:
+            return self._fail("bootstrap_not_allowed", exc), False
+        except OSError as exc:
+            return self._fail("policy_io_failed", exc), False
+        return 0, True
+
+    def _select_policy(
+        self, manifest: str, base_policy: str, head_policy: str, groups: frozenset[GroupT], bootstrap: bool
+    ) -> tuple[int, bool]:
+        try:
+            self._load_policy(
+                manifest,
+                base_policy,
+                head_policy,
+                applicable_groups=groups,
+                bootstrap=False,
+            )
+        except FileNotFoundError as exc:
+            code = self._missing_file_code(exc, base_policy, manifest, head_policy)
+            if code == "base_policy_missing" and bootstrap and not groups:
+                return self._retry_select_policy(manifest, base_policy, head_policy, groups)
+            return self._fail(code, exc), False
+        except ValueError as exc:
+            return self._fail("policy_invalid", exc), False
+        except OSError as exc:
+            return self._fail("policy_io_failed", exc), False
+        if bootstrap:
+            return self._fail(
+                "bootstrap_not_allowed", "--bootstrap is not allowed when the trusted base policy exists"
+            ), False
+        return 0, False
+
+    def _select(self, args: argparse.Namespace) -> int:
+        changed_paths, status = self._decode_json(args.changed_paths_json, "changed_paths_failed")
+        if status is not None:
+            return status
+        if not isinstance(changed_paths, list) or any(not isinstance(path, str) for path in changed_paths):
+            return self._fail("changed_paths_failed", "Changed paths must be a JSON array of strings")
+        try:
+            applicable_groups, contract_required = self._select_groups(changed_paths)
+        except ValueError as exc:
+            return self._fail("changed_paths_failed", exc)
+        base_policy = os.environ.get("WINDOWS_CI_BASE_POLICY")
+        if not base_policy:
+            return self._fail("base_policy_unset", "WINDOWS_CI_BASE_POLICY must name the trusted base policy")
+        status, bootstrap_allowed = self._select_policy(
+            args.manifest, base_policy, args.head_policy, applicable_groups, args.bootstrap
+        )
+        if status:
+            return status
+        return self._emit(
+            {
+                "ok": True,
+                "product_groups": [group for group in self._product_group_order if group in applicable_groups],
+                "contract_required": contract_required,
+                "windows_required": bool(applicable_groups),
+                "bootstrap_allowed": bootstrap_allowed,
+            }
+        )
+
+    def _validate_groups(self, groups: object) -> list[GroupT] | None:
+        if not isinstance(groups, list):
+            return None
+        for group in groups:
+            if not isinstance(group, str) or group not in self._product_group_order:
+                return None
+        if len(set(groups)) != len(groups):
+            return None
+        if groups != [group for group in self._product_group_order if group in groups]:
+            return None
+        return cast(list[GroupT], groups)
+
+    def _validate_run_selection(self, selection: object) -> list[GroupT] | None:
+        keys = {"ok", "product_groups", "contract_required", "windows_required", "bootstrap_allowed"}
+        if not isinstance(selection, dict) or set(selection) != keys or selection.get("ok") is not True:
+            return None
+        groups = self._validate_groups(selection.get("product_groups"))
+        if groups is None:
+            return None
+        if any(
+            not isinstance(selection.get(key), bool)
+            for key in ("contract_required", "windows_required", "bootstrap_allowed")
+        ):
+            return None
+        if selection["windows_required"] != bool(groups):
+            return None
+        if groups and selection["bootstrap_allowed"]:
+            return None
+        return groups
+
+    def _load_run_policy(
+        self, manifest: str, base_policy: str, head_policy: str, groups: list[GroupT]
+    ) -> tuple[int, PolicyT | None]:
+        try:
+            policy = self._load_policy(
+                manifest,
+                base_policy,
+                head_policy,
+                applicable_groups=groups,
+                bootstrap=False,
+            )
+        except FileNotFoundError as exc:
+            return self._fail(self._missing_file_code(exc, base_policy, manifest, head_policy), exc), None
+        except ValueError as exc:
+            return self._fail("policy_invalid", exc), None
+        except OSError as exc:
+            return self._fail("policy_io_failed", exc), None
+        return 0, policy
+
+    def _execute_tests(self, args: argparse.Namespace, policy: PolicyT, groups: list[GroupT]) -> int:
+        try:
+            result = self._run_selected_tests(args.root, policy, groups, junit_path=args.junit)
+        except subprocess.CalledProcessError as exc:
+            detail = f"Test subprocess failed with exit status {exc.returncode}: {exc}"
+            if exc.output:
+                detail += f"\nstdout:\n{exc.output}"
+            if exc.stderr:
+                detail += f"\nstderr:\n{exc.stderr}"
+            return self._fail("test_process_failed", detail, exc.returncode)
+        except ValueError as exc:
+            return self._fail("test_validation_failed", exc)
+        except OSError as exc:
+            return self._fail("test_io_failed", exc)
+        return self._emit(
+            {
+                "ok": True,
+                "collected_ids": result["collected_ids"],
+                "executed_ids": result["executed_ids"],
+                "skipped": result["skipped"],
+            }
+        )
+
+    def _run(self, args: argparse.Namespace) -> int:
+        selection, status = self._decode_json(args.selection_json, "selection_failed")
+        if status is not None:
+            return status
+        groups = self._validate_run_selection(selection)
+        if groups is None:
+            return self._fail("selection_failed", "Run requires a successful select result")
+        if not groups:
+            return self._fail("no_product_groups", "No Windows product groups apply")
+        base_policy = os.environ.get("WINDOWS_CI_BASE_POLICY")
+        if not base_policy:
+            return self._fail("base_policy_unset", "WINDOWS_CI_BASE_POLICY must name the trusted base policy")
+        status, policy = self._load_run_policy(args.manifest, base_policy, args.head_policy, groups)
+        if status:
+            return status
+        return self._execute_tests(args, cast(PolicyT, policy), groups)
+
+    def _gate(self, args: argparse.Namespace) -> int:
+        selection, status = self._decode_json(args.selection_json, "selection_failed")
+        if status is not None:
+            return status
+        result = self._evaluate_gate(
+            cast(_S, selection),
+            cast(ResultT | None, args.linux_result),
+            cast(ResultT | None, args.windows_result),
+        )
+        return self._emit(result, 0 if result.get("ok") is True else 1)
+
+    def _verify_fixtures(self, args: argparse.Namespace) -> int:
+        try:
+            files_checked = verify_fixture_bytes(args.commit, Path(args.root))
+        except subprocess.CalledProcessError as exc:
+            detail = str(exc)
+            for label, output in (("stdout", exc.stdout), ("stderr", exc.stderr)):
+                if output:
+                    detail += f"\n{label}:\n{os.fsdecode(output)}"
+            return self._fail("fixture_audit_failed", detail)
+        except (ValueError, FileNotFoundError, NotADirectoryError, OSError) as exc:
+            return self._fail("fixture_audit_failed", exc)
+        return self._emit({"ok": True, "files_checked": files_checked})
+
+    def run(self, argv: Sequence[str] | None) -> int:
+        class _JsonArgumentParser(argparse.ArgumentParser):
+            def error(self, message: str) -> Never:
+                self.print_usage(sys.stderr)
+                print(f"{self.prog}: error: {message}", file=sys.stderr)
+                print(json.dumps({"ok": False, "error_code": "invalid_arguments"}, separators=(",", ":")))
+                self.exit(2)
+
+        parser = _JsonArgumentParser(description="Run focused trusted Windows CI commands")
+        commands = parser.add_subparsers(dest="command", required=True)
+
+        select_parser = commands.add_parser("select")
+        select_parser.add_argument("--changed-paths-json", required=True)
+        select_parser.add_argument("--manifest", required=True)
+        select_parser.add_argument("--head-policy", required=True)
+        select_parser.add_argument("--bootstrap", action="store_true")
+
+        run_parser = commands.add_parser("run")
+        run_parser.add_argument("--selection-json", required=True)
+        run_parser.add_argument("--manifest", required=True)
+        run_parser.add_argument("--head-policy", required=True)
+        run_parser.add_argument("--root", required=True)
+        run_parser.add_argument("--junit", required=True)
+
+        gate_parser = commands.add_parser("gate")
+        gate_parser.add_argument("--selection-json", required=True)
+        gate_parser.add_argument("--linux-result")
+        gate_parser.add_argument("--windows-result")
+
+        fixture_parser = commands.add_parser("verify-fixtures")
+        fixture_parser.add_argument("--commit", required=True)
+        fixture_parser.add_argument("--root", required=True)
+
+        args = parser.parse_args(argv)
+        return {
+            "select": self._select,
+            "run": self._run,
+            "gate": self._gate,
+            "verify-fixtures": self._verify_fixtures,
+        }[args.command](args)
+
+
+def _run_cli[
+    PolicyT,
+    GroupT: Literal["setup-check", "portability", "benchmark"],
+    ResultT: Literal["success", "failure", "cancelled", "skipped"],
+](
+    argv: Sequence[str] | None,
+    *,
+    load_policy: _LoadPolicy[PolicyT, GroupT],
+    select_groups: _SelectGroups[GroupT],
+    run_selected_tests: _RunSelectedTests[PolicyT, GroupT],
+    evaluate_gate: _EvaluateGate[ResultT],
+) -> int:
+    """Dispatch through the private typed command handler."""
+    return _Dispatcher(load_policy, select_groups, run_selected_tests, evaluate_gate).run(argv)

agentic_devtools/cli/setup/dependency_checker.py

@@ -5,13 +5,19 @@ Checks all external CLI tools that ``agentic-devtools`` depends on and
 reports their availability, version, and install path in a formatted table.
 """
 
+import json
+import os
 import re
+import shlex
 import shutil
 import subprocess
 import sys
 from dataclasses import dataclass, field
+from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlsplit
+from urllib.request import url2pathname
 
 from ..subprocess_utils import run_safe
 from .git_hooks_policy import is_git_hooks_management_enabled
@@ -128,23 +134,11 @@ def _find_binary(name: str) -> str | None:
     return shutil.which(name)
 
 
-def _check_dependency(
-    name: str,
-    *,
-    required: bool,
-    install_hint: str,
-    category: str,
-) -> DependencyStatus:
+def _check_dependency(name: str, *, required: bool, install_hint: str, category: str) -> DependencyStatus:
     """Check a single dependency and return its :class:`DependencyStatus`."""
     path = _find_binary(name)
     if not path:
-        return DependencyStatus(
-            name=name,
-            found=False,
-            required=required,
-            install_hint=install_hint,
-            category=category,
-        )
+        return DependencyStatus(name=name, found=False, required=required, install_hint=install_hint, category=category)
     version = _get_version(name, path)
     return DependencyStatus(
         name=name,
@@ -162,6 +156,50 @@ def _check_dependency(
 # ---------------------------------------------------------------------------
 
 
+def _check_editable_install() -> DependencyStatus:
+    """Report stale editable sources for this interpreter without repairing them."""
+    status = DependencyStatus(name="editable-install", found=True, category="Warning")
+    status.install_hint = "pip install -e <current-worktree-root>"
+    try:
+        cwd = Path.cwd().resolve()
+        root = next((p for p in (cwd, *cwd.parents) if (p / "pyproject.toml").is_file()), None)
+        root_path = ("<current-worktree-root>", str(root))[root is not None]
+        powershell_path = "'" + root_path.replace("'", "''") + "'"
+        quote = (shlex.quote(root_path), powershell_path)[sys.platform == "win32"]
+        status.install_hint = (f"pip install -e {root_path}", f"pip install -e {quote}")[root is not None]
+        raw = (installed_distribution := distribution("agentic-devtools")).read_text("direct_url.json")
+        if raw is None:  # PathDistribution.read_text suppresses PermissionError by returning None.
+            try:
+                raw = getattr(installed_distribution, "_path").joinpath("direct_url.json").read_text(encoding="utf-8")
+            except AttributeError, FileNotFoundError, KeyError, NotADirectoryError:
+                return status
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            raise ValueError("Invalid direct_url.json object")
+        info = data.get("dir_info", {})
+        if not isinstance(info, dict) or not isinstance(info.get("editable", False), bool):
+            raise ValueError("Invalid editable metadata")
+        if not info.get("editable", False):
+            return status
+        url = data.get("url")
+        if not isinstance(url, str):
+            raise ValueError("Missing editable source URL")
+        parsed = urlsplit(url)
+        source = Path(url2pathname(url, require_scheme=True))
+        if parsed.query or parsed.fragment or not source.is_absolute():
+            raise ValueError("Invalid editable source URL")
+        source = source.resolve()
+        status.path = str(source)
+        status.found = source.is_dir() and (
+            root is None or os.path.normcase(str(source)) == os.path.normcase(str(root))
+        )
+    except PackageNotFoundError:
+        return status
+    except OSError, TypeError, ValueError, UnicodeError, RuntimeError:
+        status.found = False
+    return status
+
+
 def _check_path_profile() -> DependencyStatus:
     """Check whether ``~/.agdt/bin`` is present as a PATH component.
 
@@ -281,12 +319,7 @@ def _check_git_hooks_config() -> DependencyStatus:
             category=_GIT_HOOKS_OPTIONAL_CATEGORY,
         )
     except subprocess.TimeoutExpired:
-        return DependencyStatus(
-            name="git-hooks",
-            found=False,
-            required=False,
-            category=_GIT_HOOKS_OPTIONAL_CATEGORY,
-        )
+        return DependencyStatus(name="git-hooks", found=False, required=False, category=_GIT_HOOKS_OPTIONAL_CATEGORY)
 
     if in_repo.returncode != 0:
         # Not in a git repo — non-blocking
@@ -308,22 +341,12 @@ def _check_git_hooks_config() -> DependencyStatus:
         )
     except FileNotFoundError, subprocess.TimeoutExpired:
         # git disappeared or timed out — treat as non-blocking (same as git-missing)
-        return DependencyStatus(
-            name="git-hooks",
-            found=False,
-            required=False,
-            category=_GIT_HOOKS_OPTIONAL_CATEGORY,
-        )
+        return DependencyStatus(name="git-hooks", found=False, required=False, category=_GIT_HOOKS_OPTIONAL_CATEGORY)
 
     if toplevel.returncode != 0:
         # show-toplevel failed (e.g. detached HEAD, bare repo, or unexpected error)
         # — cannot validate .githooks dir; treat as non-blocking
-        return DependencyStatus(
-            name="git-hooks",
-            found=False,
-            required=False,
-            category=_GIT_HOOKS_OPTIONAL_CATEGORY,
-        )
+        return DependencyStatus(name="git-hooks", found=False, required=False, category=_GIT_HOOKS_OPTIONAL_CATEGORY)
 
     repo_root = Path(toplevel.stdout.strip())
 
@@ -337,12 +360,7 @@ def _check_git_hooks_config() -> DependencyStatus:
         )
     except FileNotFoundError, subprocess.TimeoutExpired:
         # git disappeared or timed out — treat as non-blocking
-        return DependencyStatus(
-            name="git-hooks",
-            found=False,
-            required=False,
-            category=_GIT_HOOKS_OPTIONAL_CATEGORY,
-        )
+        return DependencyStatus(name="git-hooks", found=False, required=False, category=_GIT_HOOKS_OPTIONAL_CATEGORY)
 
     hooks_path_set = config_result.returncode == 0
     current = config_result.stdout.strip() if hooks_path_set else ""
@@ -395,40 +413,21 @@ def check_all_dependencies() -> list[DependencyStatus]:
         A list of :class:`DependencyStatus` objects, one per tool.
     """
     results = [
-        _check_dependency(
-            "copilot",
-            required=False,
-            install_hint="run: agdt-setup-copilot-cli",
-            category="Recommended",
-        ),
-        _check_dependency(
-            "gh",
-            required=False,
-            install_hint="run: agdt-setup-gh-cli  (or https://cli.github.com/)",
-            category="Recommended",
-        ),
-        _check_dependency(
-            "git",
-            required=True,
-            install_hint="https://git-scm.com/downloads",
-            category="Required",
-        ),
-        _check_dependency(
-            "az",
-            required=False,
-            install_hint="https://docs.microsoft.com/cli/azure/install-azure-cli",
-            category="Optional — needed for Azure DevOps",
-        ),
-        _check_dependency(
-            "code",
-            required=False,
-            install_hint="https://code.visualstudio.com/",
-            category="Optional — needed for VS Code integration",
-        ),
+        _check_dependency(name, required=required, install_hint=hint, category=category)
+        for name, required, hint, category in (
+            ("copilot", False, "run: agdt-setup-copilot-cli", "Recommended"),
+            ("gh", False, "run: agdt-setup-gh-cli  (or https://cli.github.com/)", "Recommended"),
+            ("git", True, "https://git-scm.com/downloads", "Required"),
+            (
+                "az",
+                False,
+                "https://docs.microsoft.com/cli/azure/install-azure-cli",
+                "Optional — needed for Azure DevOps",
+            ),
+            ("code", False, "https://code.visualstudio.com/", "Optional — needed for VS Code integration"),
+        )
     ]
-    results.append(_check_path_profile())
-    results.append(_check_git_hooks_config())
-    return results
+    return [*results, _check_path_profile(), _check_git_hooks_config(), _check_editable_install()]
 
 
 def print_dependency_report(statuses: list[DependencyStatus]) -> None:

agentic_devtools/cli/setup/doctor.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Callable
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from dataclasses import replace as _replace
 from typing import Any
 
@@ -250,7 +250,7 @@ def run_doctor(
     classified_problems: list[tuple[ErrorClass, DependencyStatus]] = []
     repair_outcomes: list[RepairOutcome] = []
     phases: list[PhaseResult] = []
-    extra_details: dict[str, Any] = {}
+    extra_details: dict[str, Any] = {"dependencies": [asdict(status) for status in statuses]}
 
     # ── Phase 1: check ────────────────────────────────────────────────────────
     check_start = time.monotonic()

{agentic_devtools-0.2.596.dist-info → agentic_devtools-0.2.598.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-devtools
-Version: 0.2.596
+Version: 0.2.598
 Summary: Agentic devtools integrate Jira, DevOps & more
 Author: ayaiayorg
 License-Expression: MIT

{agentic_devtools-0.2.596.dist-info → agentic_devtools-0.2.598.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentic_devtools/__init__.py,sha256=gvLzsZ6L3Abr4sPHr4OJ_rdZDD8cFzXacaV0LGs8dVc,539
-agentic_devtools/_version.py,sha256=AvrHmM1z84QxURku5GjpXs4ePlchTMmZCz-bqWtaQkM,524
+agentic_devtools/_version.py,sha256=J38w9gRM5zrffQfl71XdldHwa7TCV6jmj0Fcjq-GZc8,524
 agentic_devtools/agdt_gitignore.py,sha256=vVVqTjBZ_ijn6U3Lnh_JGrARLschYVN-fFal9jDk0Ak,2694
 agentic_devtools/background_tasks.py,sha256=sFgmqOnCdCjclABJ8V__yDwBXDyi45b1Z-MVv3G2zB8,17664
 agentic_devtools/config.py,sha256=DEVxTVZhsQbVQwO9qdB_1h19aBpjMzF6xJY_ePYLGLs,15629
@@ -290,7 +290,8 @@ agentic_devtools/cli/ci/suppressed_reaper.py,sha256=hitRKUr3BhxB5fCJvEDvxMU0_9c6
 agentic_devtools/cli/ci/suppressed_reaper_command.py,sha256=Dl-T5haMCyaAo1fnCnLoKsJw4aRwqwLiB2v1o8XWx_8,2247
 agentic_devtools/cli/ci/watchdog_command.py,sha256=8I_emQPPU1wx37DcJUgNz-PRl1zsKBv88pWHIFGXw3s,54494
 agentic_devtools/cli/ci/windows_fixture_bytes.py,sha256=19rXUSdokwWel5N3ngOkdelQVv-dGjAWyZCaVHQNpWI,6188
-agentic_devtools/cli/ci/windows_specific.py,sha256=e6ZNu6rlEdx9X7fmUPB64zH_ANaR-_T9aqe50AHNNLE,23538
+agentic_devtools/cli/ci/windows_specific.py,sha256=7xzmQp2A0wAGe3H-qmfWwqESt9E-GKA4Fu_6rAIIjms,23159
+agentic_devtools/cli/ci/windows_specific_cli.py,sha256=g0CtGsvdN-RW4FdHO_l86KPosC532npXG3nrBy38CRM,15653
 agentic_devtools/cli/ci/evaluator/__init__.py,sha256=59IKUIYDwZQCbLwBoMgwlr_kHYkdWOXIONnRlICnySk,1079
 agentic_devtools/cli/ci/evaluator/actions.py,sha256=ofZpNDtBtLMH_Ka4h3JKEnhxaR1nrDGIrpzhHB1vW34,30274
 agentic_devtools/cli/ci/evaluator/classifier.py,sha256=5o_LguIbS8jMScsIs-HPNObzeMtHdcd4X1IPOP8rrSM,5867
@@ -555,8 +556,8 @@ agentic_devtools/cli/setup/commit_template_setup.py,sha256=3xojqN7o8uF12PfnSdtaG
 agentic_devtools/cli/setup/copilot_cli_installer.py,sha256=LoBWSfuHlyzrDMyUb8h5gOe77JLW5XSyaif_XE7PLXY,10040
 agentic_devtools/cli/setup/copilot_settings.py,sha256=hLpU4MA3dHVa0Pq19bzoSsVbF8zPaTs-He4T_uDgYpM,9854
 agentic_devtools/cli/setup/decision_log.py,sha256=KAqxWyPJLcRg2bFT2-pbx6faobo9dZktMlyuE9Qxaz4,12396
-agentic_devtools/cli/setup/dependency_checker.py,sha256=F8XZEAt0TtOwj50IpHxUDU7QB-9FUiZUdy-BFUY54FE,15374
-agentic_devtools/cli/setup/doctor.py,sha256=cDCNEaHifmJtx6qHvnqa3qRe9FuF7zb-zHxlGGTw9oE,18391
+agentic_devtools/cli/setup/dependency_checker.py,sha256=ytDKcq6QepYAhGt2obHriOuOrCDgO8YzsGqt2kDJj8E,17272
+agentic_devtools/cli/setup/doctor.py,sha256=z1vEDQKI4jSMu2pYLObAxiZv4c5-5SnTNWCf4ipsVJc,18454
 agentic_devtools/cli/setup/doctor_repair.py,sha256=JmlQZi6dIqke7Rzq19EfIgkbtYbE-a0DdqLYg1iyP4A,6230
 agentic_devtools/cli/setup/doctor_repairs.py,sha256=_iuruXUB9vrrhP2YcRz-dZfpIKEqWoyQ-WxtQ11YD9M,9809
 agentic_devtools/cli/setup/exit_codes.py,sha256=56ej8g1n8K5cmsuyE0eEwoITqkJLWONRsNI6DfunuVQ,2553
@@ -1305,8 +1306,8 @@ agentic_devtools/_bundled_skills/skills/speckit-plan/SKILL.md,sha256=qYLpzgLCIZ6
 agentic_devtools/_bundled_skills/skills/speckit-specify/SKILL.md,sha256=HbHRbdphMqbtNw6fL6NcYCj6sSFmUyk2S4U0bZ9p_l4,13681
 agentic_devtools/_bundled_skills/skills/write-github-commit-message/SKILL.md,sha256=Ep1lR8NDN117Iytj172VZgqazFiLpJ56Z7RXgaTnxR8,2626
 agentic_devtools/_bundled_skills/skills/write-github-commit-message/commit-types.md,sha256=bTy_t68ZD6R87rFIzq9wybTu8Wudoahb7nB9IWC4bFo,1839
-agentic_devtools-0.2.596.dist-info/METADATA,sha256=LpdqiT1tbaT8eB4vtvWOdBDdCX5ZY7TdRs7odTvahHs,35589
-agentic_devtools-0.2.596.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-agentic_devtools-0.2.596.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
-agentic_devtools-0.2.596.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.596.dist-info/RECORD,,
+agentic_devtools-0.2.598.dist-info/METADATA,sha256=NQlxxZMvekaRdXpTDU1tKYAqPvYURKqbkk3qUDhZDXE,35589
+agentic_devtools-0.2.598.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+agentic_devtools-0.2.598.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
+agentic_devtools-0.2.598.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.598.dist-info/RECORD,,