aisc-cli 0.1.0__py3-none-any.whl

aisc/cli/commands/conversation.py

@@ -0,0 +1,72 @@
+"""Conversation commands implementation (v2.1.8 T3).
+
+Implements ``aisc conversation`` subcommands: list, preflight.
+Per docs/plans/2.1.8-dev-plans/01-design.md §1b. Both are captured,
+read-only commands — ``conversation resume`` deliberately does NOT exist
+as a CLI command (方案 B 冻结): resume is the Workbench two-call
+orchestration (preflight IPC + open_session --resume-id).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from aisc.application.conversation import (
+    delete_conversation,
+    list_conversations,
+    preflight_conversation,
+    rename_conversation,
+)
+
+
+def cmd_conversation_list(workspace: str) -> Dict[str, Any]:
+    """Execute ``aisc conversation list`` per design §1b."""
+    return list_conversations(workspace)
+
+
+def cmd_conversation_preflight(workspace: str, conversation_id: str,
+                               agent: str) -> Dict[str, Any]:
+    """Execute ``aisc conversation preflight`` per design §2."""
+    return preflight_conversation(workspace, conversation_id, agent)
+
+
+def cmd_conversation_delete(workspace: str, conversation_id: str,
+                            agent: str) -> Dict[str, Any]:
+    """Execute ``aisc conversation delete`` (v2.1.8 T4 手测反馈 #4)."""
+    return delete_conversation(workspace, conversation_id, agent)
+
+
+def cmd_conversation_rename(workspace: str, conversation_id: str, agent: str,
+                            title: str) -> Dict[str, Any]:
+    """Execute ``aisc conversation rename`` (v2.1.8 T4 手测反馈 #2)."""
+    return rename_conversation(workspace, conversation_id, agent, title)
+
+
+def print_conversation_text(subcommand: str, data: Any, errors: list) -> None:
+    """Minimal human-readable output for ``aisc conversation`` text mode."""
+    if errors:
+        for e in errors:
+            print(f"Error: {e.get('message', '')}")
+        return
+    if not isinstance(data, dict):
+        return
+    if subcommand == "list":
+        conversations = data.get("conversations", [])
+        if not conversations:
+            print("(no conversations)")
+            return
+        for c in conversations:
+            line = (f"{c.get('conversation_id', '')}  agent={c.get('agent', '')}  "
+                    f"{c.get('last_at') or '-'}  {c.get('title', '')}")
+            if not c.get("resumable", True):
+                line += f"  [unresumable: {c.get('unavailable_reason', '')}]"
+            print(line)
+    elif subcommand == "preflight":
+        print(f"preflight ok: {data.get('conversation_id', '')} "
+              f"agent={data.get('agent', '')}")
+    elif subcommand == "delete":
+        print(f"deleted: {data.get('conversation_id', '')} "
+              f"agent={data.get('agent', '')}")
+    elif subcommand == "rename":
+        print(f"renamed: {data.get('conversation_id', '')} "
+              f"agent={data.get('agent', '')} title={data.get('title', '')}")

aisc/cli/commands/data_root.py

@@ -0,0 +1,84 @@
+"""``aisc data-root`` commands (Stage 7, 7d) — doctor / migrate / rollback.
+
+Non-interactive by contract (03-ux-flow): conflicts and unconsented unknowns
+exit non-zero via CliError instead of guessing. All output is
+JSON-serializable for the aisc.cli/v1 envelope; text mode prints a short
+summary.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from aisc.adapters.data_root_store import DataRootStore
+from aisc.application.data_migration import MigrationExecutor
+from aisc.application.data_root import DataRootResolver
+
+
+def _executor(workspace: Optional[str]) -> MigrationExecutor:
+    ws = Path(workspace).resolve() if workspace else Path.cwd()
+    resolved = DataRootResolver().resolve(ws)
+    return MigrationExecutor(ws, resolved, store=DataRootStore(resolved))
+
+
+def cmd_data_root_doctor(workspace: Optional[str] = None) -> Dict[str, Any]:
+    return _executor(workspace).doctor()
+
+
+def cmd_data_root_migrate(
+    workspace: Optional[str] = None,
+    *,
+    dry_run: bool = False,
+    quarantine_unknown: bool = False,
+) -> Dict[str, Any]:
+    executor = _executor(workspace)
+    if dry_run:
+        return executor.dry_run()
+    return executor.migrate(quarantine_unknown=quarantine_unknown).to_dict()
+
+
+def cmd_data_root_rollback(
+    workspace: Optional[str] = None,
+    manifest: Optional[str] = None,
+) -> Dict[str, Any]:
+    return _executor(workspace).rollback(
+        manifest_path=Path(manifest) if manifest else None
+    ).to_dict()
+
+
+def print_data_root_text(data: Any) -> None:
+    """Minimal human-readable output for text mode."""
+    if not isinstance(data, dict):
+        return
+    if "legacy" in data and "data_root" in data:
+        root = data["data_root"]
+        print(f"data root : {root.get('root', '')} ({root.get('origin')})")
+        print(f"writable  : {root.get('writable')}")
+        print(f"ws hash   : {root.get('workspace_hash', '')}")
+        legacy = data.get("legacy") or {}
+        counts = legacy.get("counts") or {}
+        print("legacy    : "
+              f"owned={counts.get('owned', 0)} transient={counts.get('transient', 0)} "
+              f"unknown={counts.get('unknown', 0)} conflict={counts.get('conflict', 0)}")
+        pending = data.get("pending_manifest")
+        if pending:
+            print(f"manifest  : {pending}")
+        return
+    if "plan" in data:
+        print(f"dry-run   : {data['plan'].get('copy_count', 0)} file(s) to copy, "
+              f"~{data['plan'].get('owned_bytes', 0)} bytes")
+        for conflict in data.get("conflicts", []):
+            print(f"CONFLICT  : {conflict}")
+        for unknown in data.get("unknowns", []):
+            print(f"UNKNOWN   : {unknown}")
+        return
+    outcome = data.get("outcome")
+    if outcome == "rolled_back":
+        print(f"rolled back: removed={data.get('removed', 0)} "
+              f"kept={data.get('kept', 0)} restored={data.get('restored', 0)}")
+    else:
+        print(f"migration {outcome}: copied={data.get('copied', 0)} "
+              f"skipped={data.get('skipped', 0)} quarantined={data.get('quarantined', 0)}")
+    if data.get("markers"):
+        print(f"markers   : {', '.join(data['markers'])}")

aisc/cli/commands/logs.py

@@ -0,0 +1,89 @@
+"""``aisc logs`` command layer (lifecycle-logging P2).
+
+Read-only views over the shared JSONL timeline
+(``<data root>/logs/aisc.log``): `show` returns the recent event tail
+(filtered by writer), `path` prints the file location. Lines are secret-free
+by construction (P1's allowlisted schema) — this layer adds no redaction
+because there is nothing sensitive to redact.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+from aisc.applog import log_file_path
+
+
+def cmd_logs_show(args: Any) -> Dict[str, Any]:
+    lines = int(getattr(args, "lines", 200) or 200)
+    source = getattr(args, "source", "all") or "all"
+    path = log_file_path()
+    events: List[Dict[str, Any]] = []
+    if path is not None and path.exists():
+        # Current file only — rotated (.1/.2) stay cold history. The file is
+        # size-capped (≤2MB) so a full read is cheap.
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        for line in raw.splitlines():
+            if not line.strip():
+                continue
+            try:
+                rec = json.loads(line)
+            except ValueError:
+                continue  # a torn line (crash mid-append) never breaks the view
+            if not isinstance(rec, dict):
+                continue
+            if source != "all" and rec.get("source") != source:
+                continue
+            events.append(rec)
+    return {
+        "path": str(path) if path is not None else None,
+        "source": source,
+        "returned": len(events[-lines:]),
+        "total_matched": len(events),
+        "lines": events[-lines:],
+    }
+
+
+def cmd_logs_path(args: Any) -> Dict[str, Any]:
+    path = log_file_path()
+    return {
+        "path": str(path) if path is not None else None,
+        "exists": bool(path is not None and path.exists()),
+    }
+
+
+def print_logs_text(data: Dict[str, Any], is_show: bool) -> None:
+    """Human-readable output."""
+    if not isinstance(data, dict):
+        return
+    path = data.get("path")
+    if not is_show:
+        print(path or "(log location unresolvable — data root error)")
+        return
+    if path is None:
+        print("(log location unresolvable — data root error)")
+        return
+    lines = data.get("lines") or []
+    if not lines:
+        print(f"No events recorded yet ({path})")
+        return
+    for rec in lines:
+        ts = str(rec.get("ts", ""))[:19]
+        level = str(rec.get("level", "?")).upper()
+        src = rec.get("source", "?")
+        event = rec.get("event", "?")
+        extras = []
+        if rec.get("run_id"):
+            extras.append(f"run={str(rec['run_id'])[:13]}")
+        for key in ("action", "command", "phase", "container", "outcome",
+                    "exit_code", "duration_ms", "error_code", "state",
+                    "detail"):
+            if key in rec and rec[key] is not None:
+                extras.append(f"{key}={rec[key]}")
+        suffix = " ".join(extras)
+        print(f"{ts} {level:<5} {src:<3} {event}  {suffix}".rstrip())
+    shown = data.get("returned", len(lines))
+    total = data.get("total_matched", len(lines))
+    if shown < total:
+        print(f"-- showing {shown} of {total} matched events ({path})")

aisc/cli/commands/network.py

@@ -0,0 +1,132 @@
+"""``aisc network subscription`` command layer (IDEA-2, 2b).
+
+Thin wrappers over ``aisc.application.network_subscription``. The
+subscription URL is a credential: it rides stdin (``import`` reads one URL
+line; ``import-file`` reads the full subscription content), never argv.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Dict
+
+from aisc.domain.models import CliError
+
+
+def _read_stdin_text(*, what: str) -> str:
+    raw = sys.stdin.read()
+    if not raw.strip():
+        raise CliError(
+            message=f"{what} on stdin is required (secrets never ride argv)",
+            exit_code=2,
+            error_code="AISC_ERR_USAGE",
+        )
+    return raw
+
+
+def cmd_network_subscription_import(args: Any) -> Dict[str, Any]:
+    from aisc.application.network_subscription import import_subscription
+
+    url = _read_stdin_text(what="a subscription URL").strip()
+    return import_subscription(url)
+
+
+def cmd_network_subscription_import_file(args: Any) -> Dict[str, Any]:
+    from aisc.application.network_subscription import import_subscription_content
+
+    content = sys.stdin.buffer.read()
+    return import_subscription_content(content)
+
+
+def cmd_network_subscription_store_downloaded(args: Any) -> Dict[str, Any]:
+    """挂账①: stdin carries a JSON document {url, content_b64, userinfo} —
+    the body of a Rust-side (reqwest) download. b64 keeps the payload
+    byte-exact through the text stdin channel."""
+    import base64
+    import json
+
+    from aisc.application.network_subscription import store_downloaded
+
+    raw = sys.stdin.read()
+    try:
+        request = json.loads(raw) if raw.strip() else {}
+    except json.JSONDecodeError as exc:
+        raise CliError(
+            message=f"store-downloaded request is not valid JSON: {exc}",
+            exit_code=2,
+            error_code="AISC_ERR_USAGE",
+        ) from exc
+    if not isinstance(request, dict):
+        raise CliError(
+            message="store-downloaded request must be a JSON object",
+            exit_code=2,
+            error_code="AISC_ERR_USAGE",
+        )
+    b64 = str(request.get("content_b64") or "")
+    try:
+        content = base64.b64decode(b64, validate=True) if b64 else b""
+    except Exception as exc:
+        raise CliError(
+            message=f"content_b64 is not valid base64: {exc}",
+            exit_code=2,
+            error_code="AISC_ERR_USAGE",
+        ) from exc
+    url = request.get("url")
+    userinfo = request.get("userinfo")
+    return store_downloaded(
+        str(url) if isinstance(url, str) and url else None,
+        content,
+        str(userinfo) if isinstance(userinfo, str) else "",
+    )
+
+
+def cmd_network_subscription_refresh(args: Any) -> Dict[str, Any]:
+    from aisc.application.network_subscription import refresh_subscription
+
+    return refresh_subscription()
+
+
+def cmd_network_subscription_show(args: Any) -> Dict[str, Any]:
+    from aisc.application.network_subscription import show_subscription
+
+    return show_subscription()
+
+
+def cmd_network_subscription_clear(args: Any) -> Dict[str, Any]:
+    from aisc.application.network_subscription import clear_subscription
+
+    if not getattr(args, "confirm", False):
+        raise CliError(
+            message="clear requires --confirm",
+            exit_code=2,
+            error_code="AISC_ERR_USAGE",
+        )
+    return clear_subscription()
+
+
+def print_network_subscription_text(data: Dict[str, Any]) -> None:
+    """Human-readable output (secret-free: masked URL only)."""
+    if not isinstance(data, dict):
+        return
+    if not data.get("configured"):
+        print("No subscription configured.")
+        print("Import one:  aisc network subscription import   (URL on stdin)")
+        print("       or:    aisc network subscription import-file (content on stdin)")
+        return
+    print(f"Source:      {data.get('source') or 'manual'}")
+    print(f"URL:         {data.get('url_masked') or '(manually imported)'}")
+    print(f"Updated:     {data.get('fetched_at') or '(unknown)'}")
+    print(f"Config:      {data.get('config_path') or ''} ({data.get('config_sha256') or '?'})")
+    userinfo = data.get("userinfo")
+    if isinstance(userinfo, dict) and userinfo:
+        total = userinfo.get("total")
+        used = userinfo.get("upload", 0) + userinfo.get("download", 0)
+        if total:
+            pct = min(100.0, used * 100.0 / total)
+            print(f"Usage:       {used} / {total} bytes ({pct:.1f}%)")
+        else:
+            print(f"Usage:       {used} bytes (unlimited plan)")
+        if "expire" in userinfo:
+            print(f"Expires:     epoch {userinfo['expire']}")
+    else:
+        print("Usage:       (subscription provided no usage header)")

aisc/cli/commands/profile.py

@@ -0,0 +1,52 @@
+"""CLI command implementations for ``aisc profile list`` and ``aisc profile show``.
+
+Read-only — returns built-in safe/unsafe profiles only.
+No user-defined profiles, no confirmation flow, no run integration.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from aisc.application.profile_service import (
+    run_profile_list, ProfileListResult,
+    run_profile_show, ProfileShowResult,
+)
+
+
+def cmd_profile_list() -> ProfileListResult:
+    """Execute ``profile list``."""
+    return run_profile_list()
+
+
+def cmd_profile_show(name: str) -> ProfileShowResult:
+    """Execute ``profile show NAME``."""
+    return run_profile_show(name)
+
+
+def print_profile_list_text(data: Dict[str, Any]) -> None:
+    """Print profile list in human-readable format."""
+    profiles = data.get("profiles", [])
+    print("=== Profile List ===")
+    print()
+    if not profiles:
+        print("No profiles found.")
+    else:
+        for p in profiles:
+            print(f"  {p['name']:12s} dangerously_skip_permissions={p['dangerously_skip_permissions']}")
+            print(f"              {p['description']}")
+            print()
+    print()
+
+
+def print_profile_show_text(data: Dict[str, Any]) -> None:
+    """Print a single profile in human-readable format."""
+    if not data:
+        print("Profile not found.")
+        return
+    print("=== Profile Detail ===")
+    print()
+    for key in ("name", "description"):
+        print(f"  {key:30s} {data.get(key, '')}")
+    print(f"  dangerously_skip_permissions  {data.get('dangerously_skip_permissions', False)}")
+    print()

aisc/cli/commands/provider.py

@@ -0,0 +1,49 @@
+"""Provider command implementation (Workbench Phase 0 S0.4).
+
+Implements ``aisc provider current``. The legacy interactive ``set-key``
+subcommand stays in ``aisc.cli.commands.container`` / ``main.py``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from aisc.adapters.docker_ import DockerExecutor
+from aisc.adapters.docker_sdk_backed import default_executor
+from aisc.application.provider import current_provider
+
+
+def _resolve_workspace_and_registry(workspace: Optional[str]):
+    from aisc.application.data_root import workspace_state_dir
+
+    ws_path = Path(workspace).resolve() if workspace else Path.cwd()
+    return str(ws_path), workspace_state_dir(ws_path)
+
+
+def cmd_provider_current(
+    runtime_id: str,
+    agent: str,
+    workspace: Optional[str] = None,
+    executor: Optional[DockerExecutor] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc provider current`` per contract §七."""
+    exec_ = executor or default_executor()
+    _ws, reg_root = _resolve_workspace_and_registry(workspace)
+    status = current_provider(
+        runtime_id=runtime_id,
+        agent=agent,
+        executor=exec_,
+        registry_root=reg_root,
+    )
+    return status.to_dict()
+
+
+def print_provider_current_text(data: Any) -> None:
+    """Minimal human-readable output for ``aisc provider current`` text mode."""
+    if not isinstance(data, dict):
+        return
+    print(f"{data.get('agent', '')}: {data.get('provider_name', '')} "
+          f"({data.get('provider_id', '')})")
+    print(f"  route_mode : {data.get('route_mode', '')}")
+    print(f"  auth_status: {data.get('auth_status', '')}")