delegate-agent-cli 0.11.0__py3-none-any.whl

delegate_agent/config_commands.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TextIO
+
+from delegate_agent import config as delegate_config
+from delegate_agent import rendering as delegate_rendering
+from delegate_agent import wsl
+from delegate_agent.errors import EXIT_OK, DelegateError
+from delegate_agent.json_types import JsonObject
+from delegate_agent.private_io import ensure_private_file
+
+
+@dataclass(frozen=True)
+class ConfigCommand:
+    action: str
+    force: bool = False
+    json_mode: bool = False
+
+
+PROFILE_CONFIG_NAMES = delegate_config.PROFILE_CONFIG_NAMES
+
+
+def _target_path() -> Path:
+    raw = delegate_config.config_path()
+    if wsl.should_reject_windows_path(str(raw)):
+        raise DelegateError("windows_path", wsl.windows_path_message("DELEGATE_CONFIG", str(raw)))
+    return raw
+
+
+def _profile_overlay(config: JsonObject, profile: str) -> JsonObject | None:
+    profiles = config.get("profiles")
+    if not isinstance(profiles, dict):
+        return None
+    definitions = profiles.get("definitions")
+    if not isinstance(definitions, dict):
+        return None
+    definition = definitions.get(profile)
+    if not isinstance(definition, dict):
+        return None
+    detect_from = profiles.get("detectFrom", [])
+    overlay_profiles: JsonObject = {
+        "default": profile,
+        "definitions": {profile: definition},
+    }
+    if isinstance(detect_from, list):
+        overlay_profiles["detectFrom"] = [
+            item for item in detect_from if isinstance(item, str) and item.strip()
+        ]
+    return {"profiles": overlay_profiles}
+
+
+def _write_missing_profile_configs(base_path: Path, config: JsonObject) -> JsonObject:
+    created: list[str] = []
+    existing: list[str] = []
+    skipped: list[str] = []
+    for profile in PROFILE_CONFIG_NAMES:
+        path = delegate_config.profile_config_path(base_path, profile)
+        if path.exists():
+            existing.append(str(path))
+            continue
+        overlay = _profile_overlay(config, profile)
+        if overlay is None:
+            skipped.append(profile)
+            continue
+        path.write_text(json.dumps(overlay, indent=2) + "\n", encoding="utf-8")
+        ensure_private_file(path)
+        created.append(str(path))
+    return {
+        "created": created,
+        "existing": existing,
+        "skipped": skipped,
+    }
+
+
+def _read_config(path: Path) -> JsonObject:
+    try:
+        return delegate_config.read_config_file(path)
+    except delegate_config.ConfigError as exc:
+        raise DelegateError(exc.error, exc.message) from exc
+
+
+def _validated_effective_config(config: JsonObject) -> JsonObject:
+    merged = delegate_config.merge_config_layer(delegate_config.embedded_default_config(), config)
+    try:
+        delegate_config.validate_config(merged)
+    except delegate_config.ConfigError as exc:
+        raise DelegateError(exc.error, exc.message) from exc
+    return merged
+
+
+def emit(command: ConfigCommand, stdout: TextIO) -> int:
+    if command.action not in {"init", "sync-profiles"}:
+        raise DelegateError("invalid_config_command", f"Unknown config action: {command.action}")
+    path = _target_path()
+    if command.action == "sync-profiles":
+        if not path.exists():
+            raise DelegateError(
+                "config_not_found",
+                f"Config does not exist at {path}; run delegate config init first.",
+            )
+        payload = _validated_effective_config(_read_config(path))
+        profile_configs = _write_missing_profile_configs(path, payload)
+        result: JsonObject = {
+            "ok": True,
+            "path": str(path),
+            "action": "sync-profiles",
+            "profileConfigs": profile_configs,
+        }
+        if command.json_mode:
+            delegate_rendering.print_json(result, stdout)
+        else:
+            for created in profile_configs["created"]:
+                print(f"wrote profile config: {created}", file=stdout)
+            if not profile_configs["created"]:
+                print("profile configs already present", file=stdout)
+        return EXIT_OK
+    if path.exists() and not command.force:
+        raise DelegateError(
+            "config_exists",
+            f"Config already exists at {path}; pass --force to overwrite it.",
+        )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = delegate_config.example_config()
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    ensure_private_file(path)
+    profile_configs = _write_missing_profile_configs(path, payload)
+    result: JsonObject = {
+        "ok": True,
+        "path": str(path),
+        "action": "init",
+        "force": command.force,
+        "profileConfigs": profile_configs,
+    }
+    if command.json_mode:
+        delegate_rendering.print_json(result, stdout)
+    else:
+        print(f"wrote config: {path}", file=stdout)
+        for created in profile_configs["created"]:
+            print(f"wrote profile config: {created}", file=stdout)
+    return EXIT_OK

delegate_agent/constants.py

@@ -0,0 +1,50 @@
+"""Cross-cutting CLI mode vocabulary and validation.
+
+A dependency leaf shared by the parser, request builder, argv builders, and
+execution layers so they agree on the launch mode vocabulary without
+importing ``cli``.
+"""
+
+from __future__ import annotations
+
+from delegate_agent.errors import DelegateError
+
+MODE_SAFE = "safe"
+MODE_WORK = "work"
+MODE_CALL = "call"
+VALID_MODES = {MODE_SAFE, MODE_WORK, MODE_CALL}
+
+# Canonical engine/harness vocabulary. This tuple's order is the registry order
+# reused wherever engines are enumerated (the describe payload, help prose, the
+# runs/worktree --harness filters). Membership checks and the prose enumeration
+# both derive from it so the list can never drift out of sync.
+KNOWN_ENGINES = ("cursor", "droid", "codex", "kimi", "claude", "grok")
+# "cursor, droid, codex, kimi, claude, or grok" — for error messages and help text.
+ENGINES_PROSE = f"{', '.join(KNOWN_ENGINES[:-1])}, or {KNOWN_ENGINES[-1]}"
+
+# Engines launched without a model-alias positional argument.
+MODELESS_ENGINES = tuple(engine for engine in KNOWN_ENGINES if engine != "droid")
+# Engines whose binary is a simple <engine>.binary config key.
+BINARY_CONFIG_ENGINES = tuple(engine for engine in KNOWN_ENGINES if engine != "cursor")
+# Modeless engines accepted by input JSON's optional model field.
+MODELESS_NONCURSOR_ENGINES = tuple(
+    engine for engine in KNOWN_ENGINES if engine not in {"cursor", "droid"}
+)
+# Engines whose safe-review prompt prefix is injected by request_build.effective_prompt.
+SAFE_REVIEW_PREFIX_INJECTED_HERE_ENGINES = tuple(
+    engine for engine in KNOWN_ENGINES if engine in {"codex", "droid", "claude", "grok"}
+)
+# Stable public summary order; membership is still derived from the modeless engine set.
+MODEL_SUMMARY_ENGINES = tuple(
+    engine for engine in ("cursor", "codex", "claude", "grok", "kimi") if engine in MODELESS_ENGINES
+)
+
+
+def validate_mode(mode: str) -> None:
+    if mode not in VALID_MODES:
+        raise DelegateError(
+            "invalid_mode",
+            "Mode must be safe, work, or call. Valid forms: "
+            "delegate <harness> safe|work <prompt>; "
+            "delegate droid <model-alias> safe|work <prompt>.",
+        )