agent-devkit 0.1.6 → 0.2.0

package/runtime/cli/aikit/extensions.py

@@ -0,0 +1,140 @@
+"""Local extension registry for Agent DevKit MVP."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+from cli.aikit.app_home import ensure_app_home, app_home
+from cli.aikit.errors import DevKitError
+
+
+EXTENSIONS_SCHEMA_VERSION = "agent-devkit.local-extensions/v1"
+
+
+def local_extensions_list() -> dict[str, Any]:
+    data = load_extensions()
+    return {
+        "kind": "local-extensions",
+        "schema_version": EXTENSIONS_SCHEMA_VERSION,
+        "status": "ok",
+        "items": public_extensions(data["extensions"]),
+        "scopes": extension_scopes(),
+    }
+
+
+def local_extension_add(path: str | None) -> dict[str, Any]:
+    if not path:
+        raise DevKitError("local add requires --path")
+    source = Path(path).expanduser().resolve()
+    if not source.exists():
+        raise DevKitError(f"local extension path not found: {source}")
+    data = load_extensions()
+    extension_id = source.name
+    if any(item["id"] == extension_id for item in data["extensions"]):
+        raise DevKitError(f"local extension already registered: {extension_id}")
+    item = {"id": extension_id, "path": str(source), "enabled": True, "scope": "user"}
+    data["extensions"].append(item)
+    save_extensions(data)
+    return {"kind": "local-extension", "status": "added", "item": item}
+
+
+def local_extension_enable(extension_id: str, enabled: bool) -> dict[str, Any]:
+    data = load_extensions()
+    item = find_extension(data, extension_id)
+    item["enabled"] = enabled
+    save_extensions(data)
+    return {"kind": "local-extension", "status": "enabled" if enabled else "disabled", "item": item}
+
+
+def local_extension_remove(extension_id: str) -> dict[str, Any]:
+    data = load_extensions()
+    before = len(data["extensions"])
+    data["extensions"] = [item for item in data["extensions"] if item.get("id") != extension_id]
+    save_extensions(data)
+    return {"kind": "local-extension-remove", "status": "removed" if len(data["extensions"]) < before else "not-found"}
+
+
+def local_extension_validate(extension_id: str) -> dict[str, Any]:
+    data = load_extensions()
+    item = find_extension(data, extension_id)
+    path = Path(str(item.get("path") or ""))
+    checks = [
+        {"id": "path-exists", "status": "passed" if path.exists() else "failed"},
+        {"id": "has-known-content", "status": "passed" if has_known_extension_content(path) else "failed"},
+    ]
+    return {
+        "kind": "local-extension-validation",
+        "status": "passed" if all(check["status"] == "passed" for check in checks) else "failed",
+        "item": item,
+        "checks": checks,
+    }
+
+
+def extension_scopes() -> dict[str, str]:
+    return {"user": str(app_home() / "local"), "project": str(Path.cwd() / ".agent-devkit")}
+
+
+def extensions_path() -> Path:
+    ensure_app_home()
+    path = app_home() / "local" / "extensions.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def load_extensions() -> dict[str, Any]:
+    path = extensions_path()
+    if not path.exists():
+        return {"version": 1, "extensions": []}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {"version": 1, "extensions": []}
+    if not isinstance(data, dict) or not isinstance(data.get("extensions"), list):
+        return {"version": 1, "extensions": []}
+    return {"version": 1, "extensions": [item for item in data["extensions"] if isinstance(item, dict)]}
+
+
+def save_extensions(data: dict[str, Any]) -> Path:
+    path = extensions_path()
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path
+
+
+def public_extensions(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        {
+            "id": item.get("id"),
+            "path": item.get("path"),
+            "enabled": item.get("enabled") is True,
+            "scope": item.get("scope") or "user",
+        }
+        for item in items
+    ]
+
+
+def find_extension(data: dict[str, Any], extension_id: str) -> dict[str, Any]:
+    for item in data["extensions"]:
+        if item.get("id") == extension_id:
+            return item
+    raise DevKitError(f"local extension not found: {extension_id}")
+
+
+def has_known_extension_content(path: Path) -> bool:
+    if not path.exists():
+        return False
+    if path.is_file():
+        return path.suffix in {".md", ".yaml", ".yml", ".json", ".py", ".sh"}
+    return any((path / name).exists() for name in ("agent.yaml", "capability.yaml", "workflow.yaml", "skill.md", "SKILL.md")) or any(
+        path.glob("**/agent.yaml")
+    )
+
+
+def copy_extension_fixture(source: Path, destination: Path) -> None:
+    if source.is_dir():
+        shutil.copytree(source, destination)
+    else:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)

package/runtime/cli/aikit/fallback.py

@@ -130,6 +130,7 @@ def provider_detail(requirement: dict[str, Any], status_item: dict[str, Any]) ->
         "status": status_item.get("status") or "missing",
         "configured": bool(status_item.get("configured")),
         "purpose": requirement.get("purpose"),
+        "inferred": bool(requirement.get("inferred")),
     }
 
 

package/runtime/cli/aikit/github_pr.py

@@ -188,6 +188,29 @@ def pr_create_automation(*, task_id: str | None = None, title: str | None = None
     return task
 
 
+def summarize_pr_list(payload: dict[str, Any]) -> str:
+    if payload.get("status") != "ok":
+        return str(payload.get("message") or "Nao foi possivel listar PRs.")
+    items = payload.get("items") or []
+    if not items:
+        return "Nenhuma PR aguardando sua revisao foi encontrada."
+    lines = []
+    for item in items:
+        number = item.get("number")
+        title = item.get("title") or "-"
+        url = item.get("url") or ""
+        lines.append(f"- #{number} {title} {url}".strip())
+    return "\n".join(lines)
+
+
+def planned_pr_commands(action: str, *, pr_ref: str | None = None) -> list[list[str]]:
+    if action == "list-review-requests":
+        return [["gh", "pr", "list", "--review-requested", "@me", "--json", "number,title,url,author,headRefName,baseRefName,isDraft"]]
+    if action == "inspect":
+        return [["gh", "pr", "view", str(pr_ref), "--json", "number,title,url,author,body,headRefName,baseRefName,state,isDraft,reviewDecision,mergeable"]]
+    return []
+
+
 def gh_check() -> dict[str, Any]:
     binary = shutil.which("gh")
     if not binary:

package/runtime/cli/aikit/guardrails.py

@@ -4,6 +4,13 @@ from __future__ import annotations
 
 from typing import Any
 
+from cli.aikit.write_policy import (
+    is_blocked_by_default,
+    is_known_write_policy,
+    normalize_write_policy,
+    requires_runtime_confirmation,
+)
+
 
 RUNTIME_CONFIRM_FLAG = "--confirm-execute"
 RUNTIME_DANGEROUS_FLAG = "--allow-dangerous"
@@ -13,13 +20,6 @@ EXECUTE_INTENT_FLAGS = {
     "--yes-confirm",
     "--yes-save",
 }
-DANGEROUS_POLICIES = {"blocked_by_default"}
-WRITE_POLICIES_REQUIRING_CONFIRMATION = {
-    "confirm",
-    "ask_before_write",
-    "template_version_write",
-    "create_new_version",
-}
 
 
 def evaluate_execution_guardrails(
@@ -29,12 +29,27 @@ def evaluate_execution_guardrails(
     """Return sanitized args and an optional blocked guardrail result."""
 
     sanitized_args = strip_runtime_flags(capability_args)
-    write_policy = str(capability.get("write_policy") or "")
+    raw_write_policy = capability.get("write_policy")
+    write_policy = normalize_write_policy(raw_write_policy or "")
     execute_requested = any(flag in capability_args for flag in EXECUTE_INTENT_FLAGS)
     confirmed = RUNTIME_CONFIRM_FLAG in capability_args
     dangerous_allowed = RUNTIME_DANGEROUS_FLAG in capability_args
 
-    if execute_requested and write_policy in DANGEROUS_POLICIES and not dangerous_allowed:
+    if raw_write_policy and not is_known_write_policy(raw_write_policy):
+        return {
+            "ready": False,
+            "args": sanitized_args,
+            "reason": "unknown_write_policy",
+            "write_policy": write_policy,
+            "risks": [
+                "Capability declares an unsupported write policy, so runtime safety semantics are ambiguous.",
+            ],
+            "next_steps": [
+                "Fix the capability manifest to use a canonical write_policy before requesting execution.",
+            ],
+        }
+
+    if execute_requested and is_blocked_by_default(write_policy) and not dangerous_allowed:
         return {
             "ready": False,
             "args": sanitized_args,
@@ -48,7 +63,7 @@ def evaluate_execution_guardrails(
             ],
         }
 
-    if execute_requested and write_policy in WRITE_POLICIES_REQUIRING_CONFIRMATION and not confirmed:
+    if execute_requested and requires_runtime_confirmation(write_policy) and not confirmed:
         return {
             "ready": False,
             "args": sanitized_args,