aisc-cli 0.1.0__py3-none-any.whl

aisc/cli/commands/agents.py

@@ -0,0 +1,117 @@
+"""F2-C (fix2-design.md): `aisc claude` / `aisc codex` — agent entry sugar.
+
+One command opens the AGENT inside the ACTIVE workspace's container (the
+registry's default pointer = last `aisc run`); `--workspace` retargets
+without switching the default. Args after `--` pass through verbatim
+(`aisc claude -- -c` → container-side `claude -c`).
+
+Text mode streams the TTY (docker exec -it); JSON mode runs captured and
+returns the exit code in the envelope — scripting-friendly.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from aisc.adapters.docker_ import DockerExecutor, RealDockerExecutor
+from aisc.domain.models import CliError, ProcessResult
+
+AGENTS = ("claude", "codex")
+
+
+def _resolve_by_workspace(workspace: str, explicit_root: Optional[str]) -> str:
+    """Find the registered container bound to this workspace path.
+
+    The registry lives in the workspace's state dir (data-root
+    ``workspaces/<hash>/runtime``). ``list_containers`` returns a
+    ``name → meta`` map — the earlier list-shaped traversal here was wrong
+    and crashed every ``aisc claude --workspace <path>``.
+    """
+    from aisc.adapters.container_registry import list_containers
+    from aisc.application.data_root import workspace_state_dir
+
+    target = Path(workspace).resolve()
+    try:
+        state_dir = workspace_state_dir(target)
+    except Exception as exc:
+        if not explicit_root:
+            raise CliError(
+                message=f"cannot resolve the workspace state dir: {exc}",
+                exit_code=1, error_code="AISC_ERR_GENERAL") from exc
+        state_dir = Path(explicit_root).resolve()
+
+    matches = [
+        name for name, meta in list_containers(state_dir).items()
+        if Path(str(meta.get("workspace", ""))).resolve() == target
+    ]
+    if not matches:
+        raise CliError(
+            message=f"no active container is registered for {target} — "
+                    f"start one first: aisc run {target}",
+            exit_code=4, error_code="AISC_ERR_NOT_FOUND",
+        )
+    return str(matches[0])
+
+
+def cmd_agent(
+    agent: str,
+    agent_args: List[str],
+    workspace: Optional[str] = None,
+    name_override: Optional[str] = None,
+    explicit_root: Optional[str] = None,
+    capture: bool = False,
+    executor: Optional[DockerExecutor] = None,
+) -> ProcessResult | Dict[str, Any]:
+    """Open one agent in the active (or --workspace) container.
+
+    Returns the streaming ProcessResult in text mode; in capture mode a
+    JSON-serializable dict for the envelope.
+    """
+    exec_ = executor or RealDockerExecutor()
+
+    if agent not in AGENTS:
+        raise CliError(message=f"unknown agent {agent!r}", exit_code=2,
+                       error_code="AISC_ERR_USAGE")
+
+    if workspace:
+        name = _resolve_by_workspace(workspace, explicit_root)
+    else:
+        from aisc.cli.commands import runs as cli_runs
+        from aisc.cli.commands.container import discover_container
+
+        # Default leg: the machine-global ACTIVE workspace (never cwd — the
+        # cwd anchor trips the data-root overlap gate from $HOME and reads
+        # the wrong registry).
+        active = cli_runs.get_active()
+        if active:
+            from aisc.application.data_root import workspace_state_dir
+
+            try:
+                root = str(workspace_state_dir(Path(active)))
+            except Exception:
+                root = explicit_root
+        else:
+            root = explicit_root
+        name = discover_container(name_override=name_override,
+                                  explicit_root=root,
+                                  executor=exec_)
+
+    # -it only when a real TTY rides along — capture mode pipes stdio, and
+    # docker exec -t without a TTY dies with "the input device is not a TTY".
+    argv = ["exec", *(["-it"] if not capture else []), name, agent, *agent_args]
+    if capture:
+        proc = exec_.run_captured(argv)
+        return {
+            "container": name,
+            "agent": agent,
+            "agent_args": list(agent_args),
+            "exit_code": proc.exit_code,
+            "stdout": proc.stdout,
+            "stderr": proc.stderr,
+        }
+    proc = exec_.run_streaming(argv)
+    if proc.command_not_found:
+        raise CliError(message="Docker CLI not found", exit_code=3,
+                       error_code="AISC_ERR_DOCKER_UNAVAILABLE")
+    return proc

aisc/cli/commands/artifact.py

@@ -0,0 +1,210 @@
+"""`aisc artifact` commands — Agent Artifact fact protocol (Stage 3, ART-02).
+
+record/list/inspect/clear-session all return JSON-serializable dicts under the
+``aisc.cli/v1`` envelope. The authoritative fact layer writes session-scoped
+registries in the host data dir; the workspace is never touched (A-ART04-1).
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from aisc.domain.artifacts import (
+    ArtifactAction,
+    ArtifactKind,
+    ArtifactOpenWith,
+    ArtifactProvenance,
+    ArtifactRecord,
+    normalize_media_type,
+)
+from aisc.domain.models import CliError, RuntimeErrorCode
+
+
+def _iso_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _resolve_workspace(workspace: Optional[str]) -> Path:
+    return Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+
+def _record_to_dict(rec: ArtifactRecord) -> Dict[str, Any]:
+    return rec.to_dict()
+
+def _normalize_record_path(raw: str, workspace: Path) -> str:
+    """Accept a container/host absolute path when it is inside the workspace.
+
+    Agents sometimes ignore the Skill instruction and pass `/root/app/...`
+    (the container mount). The host cannot resolve that path, but it maps
+    directly to a workspace-relative path, which is what the registry stores.
+    Anything outside the workspace is still rejected by ``validate_relative_path``.
+    """
+    path = Path(raw)
+    if not path.is_absolute():
+        return raw
+    try:
+        rel = os.path.relpath(raw, workspace)
+    except ValueError:
+        return raw
+    if rel == "." or rel.startswith("..") or Path(rel).is_absolute():
+        return raw
+    return rel.replace("\\", "/")
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+def cmd_artifact_record(
+    *,
+    runtime_id: str,
+    session_id: str,
+    agent: str,
+    path: str,
+    action: str = ArtifactAction.CREATED,
+    kind: str = ArtifactKind.DELIVERABLE,
+    media_type: Optional[str] = None,
+    label: str = "",
+    open_with: str = ArtifactOpenWith.PREVIEW,
+    previous_path: Optional[str] = None,
+    workspace: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc artifact record``."""
+    from aisc.application.artifact import record as _record
+
+    ws = _resolve_workspace(workspace)
+    try:
+        mt = normalize_media_type(media_type)
+        normalized_path = _normalize_record_path(path, ws)
+        normalized_previous_path = (
+            _normalize_record_path(previous_path, ws) if previous_path else None
+        )
+        rec = ArtifactRecord(
+            schema_version=1,
+            artifact_id=str(uuid.uuid4()),
+            workspace_relative_path=normalized_path,
+            action=action,
+            kind=kind,
+            media_type=mt,
+            label=label,
+            open_with=open_with,
+            producer={
+                "agent": agent,
+                "session_id": session_id,
+                "runtime_id": runtime_id,
+            },
+            state="present",
+            provenance=ArtifactProvenance.MANIFEST,
+            recorded_at=_iso_now(),
+            previous_path=normalized_previous_path,
+            extra={},
+        ).validate()
+        saved = _record(ws, rec, session_id=session_id)
+    except ValueError as exc:
+        raise CliError(
+            message=str(exc),
+            exit_code=2,
+            error_code="AISC_ERR_ARTIFACT_INVALID",
+        ) from exc
+    return {"artifact": _record_to_dict(saved)}
+
+
+def cmd_artifact_list(
+    *,
+    workspace: Optional[str] = None,
+    session_id: Optional[str] = None,
+    kind: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc artifact list``."""
+    from aisc.application.artifact import list_records
+
+    ws = _resolve_workspace(workspace)
+    if kind is not None and kind not in ArtifactKind.ALL:
+        raise CliError(
+            message=f"invalid kind: {kind!r}",
+            exit_code=2,
+            error_code="AISC_ERR_ARTIFACT_INVALID",
+        )
+    records = list_records(ws, session_id=session_id, kind=kind)
+    return {
+        "schema_version": 1,
+        "artifacts": [_record_to_dict(r) for r in records],
+    }
+
+
+def cmd_artifact_inspect(
+    *,
+    artifact_id: str,
+    workspace: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc artifact inspect``."""
+    from aisc.application.artifact import inspect_record
+
+    ws = _resolve_workspace(workspace)
+    rec = inspect_record(ws, artifact_id)
+    if rec is None:
+        raise CliError(
+            message=f"artifact not found: {artifact_id}",
+            exit_code=1,
+            error_code="AISC_ERR_ARTIFACT_NOT_FOUND",
+        )
+    return {"artifact": _record_to_dict(rec)}
+
+
+def cmd_artifact_clear_session(
+    *,
+    runtime_id: str,
+    session_id: str,
+    workspace: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc artifact clear-session``."""
+    from aisc.application.artifact import clear_session
+
+    ws = _resolve_workspace(workspace)
+    clear_session(ws, session_id)
+    return {
+        "runtime_id": runtime_id,
+        "session_id": session_id,
+        "cleared": True,
+    }
+
+
+def print_artifact_text(
+    sub: str,
+    data: Optional[Dict[str, Any]],
+    errors: List[Dict[str, Any]],
+) -> None:
+    """Human-readable output for `aisc artifact` (text mode)."""
+    if errors:
+        for err in errors:
+            print(f"Error: {err.get('message', '')}", file=__import__("sys").stderr)
+        return
+    if sub == "record" and isinstance(data, dict) and data.get("artifact"):
+        a = data["artifact"]
+        print(f"recorded {a['artifact_id']}  {a['workspace_relative_path']}  "
+              f"({a['kind']}, {a['action']})")
+    elif sub == "list" and isinstance(data, dict):
+        arts = data.get("artifacts", [])
+        if not arts:
+            print("(no artifacts)")
+            return
+        for a in arts:
+            print(f"{a['artifact_id']}  {a['workspace_relative_path']}  "
+                  f"({a['kind']}, {a['action']}, {a['state']})")
+    elif sub == "inspect" and isinstance(data, dict) and data.get("artifact"):
+        a = data["artifact"]
+        print(f"artifact: {a['artifact_id']}")
+        print(f"  path:     {a['workspace_relative_path']}")
+        print(f"  kind:     {a['kind']}")
+        print(f"  action:   {a['action']}")
+        print(f"  state:    {a['state']}")
+        print(f"  media:    {a.get('media_type') or '-'}")
+        print(f"  label:    {a.get('label') or '-'}")
+        print(f"  producer: {a.get('producer', {}).get('agent', '-')} "
+              f"session={a.get('producer', {}).get('session_id', '-')}")
+    elif sub == "clear-session":
+        print("cleared")