kctl-claw 0.2.0__py3-none-any.whl

kctl_claw/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-claw: Kodemeio OpenClaw CLI."""
+
+__version__ = "0.2.0"

kctl_claw/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_claw."""
+
+from kctl_claw.cli import _run
+
+_run()

kctl_claw/cli.py

@@ -0,0 +1,173 @@
+"""Main CLI entry point for kctl-claw."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+
+from kctl_claw import __version__
+from kctl_claw.commands.agents import app as agents_app
+from kctl_claw.commands.agents_test import app as agents_test_app
+from kctl_claw.commands.ai import app as ai_app
+from kctl_claw.commands.aliases import register_aliases
+from kctl_claw.commands.backup import app as backup_app
+from kctl_claw.commands.config_cmd import app as config_app
+from kctl_claw.commands.config_drift import app as config_drift_app
+from kctl_claw.commands.cron import app as cron_app
+from kctl_claw.commands.cron_debug import app as cron_debug_app
+from kctl_claw.commands.deploy import app as deploy_app
+from kctl_claw.commands.docker_cmd import app as docker_app
+from kctl_claw.commands.doctor_cmd import app as doctor_app
+from kctl_claw.commands.env import app as env_app
+from kctl_claw.commands.health import app as health_app
+from kctl_claw.commands.lint_cmd import app as lint_app
+from kctl_claw.commands.logs import app as logs_app
+from kctl_claw.commands.mcp import app as mcp_app
+from kctl_claw.commands.mcp_test import app as mcp_test_app
+from kctl_claw.commands.memory import app as memory_app
+from kctl_claw.commands.monitor_cmd import app as monitor_app
+from kctl_claw.commands.pipeline import app as pipeline_app
+from kctl_claw.commands.prompts import app as prompts_app
+from kctl_claw.commands.security import app as security_app
+from kctl_claw.commands.skill_cmd import app as skill_app
+from kctl_claw.commands.skills import app as skills_app
+from kctl_claw.commands.skills_test import app as skills_test_app
+from kctl_claw.commands.status import app as status_app
+from kctl_claw.commands.telegram import app as telegram_app
+from kctl_claw.commands.test_cmd import app as test_app
+from kctl_claw.commands.trading import app as trading_app
+from kctl_claw.core.callbacks import AppContext
+from kctl_lib.self_update import notify_if_outdated
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-claw {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-claw",
+    help="Kodemeio OpenClaw CLI — manage AI agent gateway instances.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    output_format: Annotated[
+        str, typer.Option("--format", "-f", help="Output format (pretty/json/csv/yaml)")
+    ] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit table headers")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    root: Annotated[str | None, typer.Option("--root", help="Project root override")] = None,
+    live: Annotated[bool, typer.Option("--live", help="Push config changes and trigger reload")] = False,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio OpenClaw CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        format=output_format,
+        no_header=no_header,
+        profile=profile,
+        root_override=root,
+        live=live,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-claw", __version__)
+
+
+# Existing command groups
+app.add_typer(agents_app, name="agents")
+app.add_typer(ai_app, name="ai")
+app.add_typer(backup_app, name="backup")
+app.add_typer(config_app, name="config")
+app.add_typer(cron_app, name="cron")
+app.add_typer(deploy_app, name="deploy")
+app.add_typer(env_app, name="env")
+app.add_typer(health_app, name="health")
+app.add_typer(logs_app, name="logs")
+app.add_typer(memory_app, name="memory")
+app.add_typer(mcp_app, name="mcp")
+app.add_typer(security_app, name="security")
+app.add_typer(skills_app, name="skills")
+app.add_typer(status_app, name="status")
+app.add_typer(telegram_app, name="telegram")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(trading_app, name="trading")
+
+# New command groups (SP6)
+app.add_typer(agents_test_app, name="agents-test")
+app.add_typer(config_drift_app, name="config-drift")
+app.add_typer(cron_debug_app, name="cron-debug")
+app.add_typer(docker_app, name="docker")
+app.add_typer(doctor_app, name="doctor")
+app.add_typer(lint_app, name="lint")
+app.add_typer(mcp_test_app, name="mcp-test")
+app.add_typer(monitor_app, name="monitor")
+app.add_typer(pipeline_app, name="pipeline")
+app.add_typer(prompts_app, name="prompts")
+app.add_typer(skills_test_app, name="skills-test")
+app.add_typer(test_app, name="test")
+
+register_aliases(app)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-claw."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-claw", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-claw")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-claw", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-claw", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_claw/commands/agents.py

@@ -0,0 +1,323 @@
+"""Agent management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_claw.core.callbacks import AppContext
+from kctl_claw.core.exceptions import GatewayError
+from kctl_claw.core.resolve import get_all_agents, resolve_agent
+
+_GATEWAY_HINT = "Start the gateway first: kctl-claw deploy up"
+
+app = typer.Typer(help="Manage OpenClaw agents.")
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List all configured agents."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    agents = get_all_agents(actx.config_mgr)
+
+    rows = []
+    json_data = []
+    for a in agents:
+        name = a["name"]
+        model = a.get("model", "default")
+        profile = a.get("profile", "default")
+        thinking = a.get("thinking", "adaptive")
+        rows.append([name, model, profile, thinking])
+        json_data.append({"name": name, "model": model, "profile": profile, "thinking": thinking})
+
+    out.table(
+        f"Agents ({len(agents)})",
+        [("Name", "cyan"), ("Model", ""), ("Profile", ""), ("Thinking", "dim")],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+) -> None:
+    """Get detailed agent info."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    agent = resolve_agent(actx.config_mgr, name)
+
+    sections = [
+        (
+            "Config",
+            [
+                ("Name", agent["name"]),
+                ("Model", agent.get("model", "default")),
+                ("Profile", agent.get("profile", "default")),
+                ("Thinking", agent.get("thinking", "adaptive")),
+                ("Sandbox", str(agent.get("sandbox", True))),
+            ],
+        ),
+    ]
+    if agent.get("workspace"):
+        sections[0][1].append(("Workspace", agent["workspace"]))
+
+    out.detail(f"Agent: {name}", sections, data_for_json=agent)
+
+
+@app.command("set-model")
+def set_model(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+    model: Annotated[str, typer.Argument(help="Model ID (e.g. claude-opus-4-6)")],
+) -> None:
+    """Change an agent's primary model."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    mgr = actx.config_mgr
+
+    from kctl_claw.core.config_manager import ConfigFile
+
+    agent = resolve_agent(mgr, name)
+    old_model = agent.get("model", "default")
+
+    mgr.backup_before_modify(ConfigFile.OPENCLAW)
+    data = mgr.read(ConfigFile.OPENCLAW)
+    for a in data["agents"]["list"]:
+        if a["name"] == name:
+            a["model"] = model
+            break
+    mgr.write(ConfigFile.OPENCLAW, data)
+    out.success(f"{name}: {old_model} -> {model}")
+
+    if actx.live:
+        out.info("Reloading gateway...")
+        # DockerClient.restart() would go here when available
+
+
+@app.command("set-profile")
+def set_profile(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+    profile: Annotated[str, typer.Argument(help="Tool profile name")],
+) -> None:
+    """Change an agent's tool profile."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    mgr = actx.config_mgr
+
+    from kctl_claw.core.config_manager import ConfigFile
+
+    agent = resolve_agent(mgr, name)
+    old_profile = agent.get("profile", "default")
+
+    mgr.backup_before_modify(ConfigFile.OPENCLAW)
+    data = mgr.read(ConfigFile.OPENCLAW)
+    for a in data["agents"]["list"]:
+        if a["name"] == name:
+            a["profile"] = profile
+            break
+    mgr.write(ConfigFile.OPENCLAW, data)
+    out.success(f"{name}: profile {old_profile} -> {profile}")
+
+
+@app.command("set-thinking")
+def set_thinking(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+    mode: Annotated[str, typer.Argument(help="Thinking mode (adaptive/medium/high/off)")],
+) -> None:
+    """Change an agent's thinking mode."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    mgr = actx.config_mgr
+
+    valid_modes = ["adaptive", "medium", "high", "off"]
+    if mode not in valid_modes:
+        out.error(f"Invalid mode: {mode} (valid: {', '.join(valid_modes)})")
+        raise typer.Exit(1)
+
+    from kctl_claw.core.config_manager import ConfigFile
+
+    resolve_agent(mgr, name)
+
+    mgr.backup_before_modify(ConfigFile.OPENCLAW)
+    data = mgr.read(ConfigFile.OPENCLAW)
+    for a in data["agents"]["list"]:
+        if a["name"] == name:
+            a["thinking"] = mode
+            break
+    mgr.write(ConfigFile.OPENCLAW, data)
+    out.success(f"{name}: thinking -> {mode}")
+
+
+@app.command()
+def workspace(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+) -> None:
+    """Show agent workspace structure."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    resolve_agent(actx.config_mgr, name)
+
+    root = actx.project_root
+    # Main agent uses config/workspace/, others use config/agents/<name>/workspace/
+    ws_dir = root / "config" / "workspace" if name == "kodemeiodev" else root / "config" / "agents" / name / "workspace"
+
+    if not ws_dir.exists():
+        out.warn(f"Workspace not found: {ws_dir}")
+        return
+
+    nodes = []
+    for item in sorted(ws_dir.iterdir()):
+        if item.is_dir():
+            children = [{"name": f.name} for f in sorted(item.iterdir()) if not f.name.startswith(".")]
+            nodes.append({"name": f"{item.name}/", "children": children})
+        else:
+            size = f"{item.stat().st_size:,} bytes"
+            nodes.append({"name": item.name, "info": size})
+
+    out.tree(f"Workspace: {name}", nodes)
+
+
+@app.command()
+def test(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+    prompt: Annotated[str, typer.Argument(help="Test prompt to send")],
+) -> None:
+    """Quick test — send a prompt to an agent and show the response."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    resolve_agent(actx.config_mgr, name)
+    out.info(f"Testing agent {name!r} with: {prompt[:80]!r}")
+
+    try:
+        data = actx.gateway.post(f"/api/agents/{name}/message", {"content": prompt, "test": True})
+        if isinstance(data, dict):
+            sections = [
+                (
+                    "Response",
+                    [
+                        ("Agent", name),
+                        ("Status", str(data.get("status", ""))),
+                        ("Content", str(data.get("content", ""))[:300]),
+                        ("Model", str(data.get("model", ""))),
+                        ("Tokens", str(data.get("tokens", ""))),
+                    ],
+                )
+            ]
+            out.detail(f"Agent Test: {name}", sections, data_for_json=data)
+        else:
+            out.text(str(data))
+    except GatewayError as e:
+        out.warn(f"Gateway not available: {e}")
+        out.info(_GATEWAY_HINT)
+
+
+@app.command()
+def replay(
+    ctx: typer.Context,
+    conversation_id: Annotated[str, typer.Argument(help="Conversation ID to replay")],
+) -> None:
+    """Quick replay — replay a conversation and diff the output."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    out.info(f"Replaying conversation: {conversation_id!r}...")
+    try:
+        data = actx.gateway.post(f"/api/conversations/{conversation_id}/replay", {})
+        if isinstance(data, dict):
+            diffs = data.get("diffs", [])
+            rows = [[str(d.get("turn", "")), str(d.get("field", "")), str(d.get("delta", ""))] for d in diffs]
+            out.table(
+                f"Replay Diff ({len(diffs)} differences)",
+                [("Turn", "cyan"), ("Field", ""), ("Delta", "dim")],
+                rows,
+                data_for_json=data,
+            )
+        else:
+            out.text(str(data))
+    except GatewayError as e:
+        out.warn(f"Gateway not available: {e}")
+        out.info(_GATEWAY_HINT)
+
+
+@app.command()
+def stats(ctx: typer.Context) -> None:
+    """Show per-agent stats: message count, token usage."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    out.info("Fetching agent stats from gateway...")
+    try:
+        data = actx.gateway.get("/api/agents/stats")
+        if isinstance(data, list):
+            rows = [
+                [
+                    str(s.get("agent", "")),
+                    str(s.get("messages", "")),
+                    str(s.get("tokens_in", "")),
+                    str(s.get("tokens_out", "")),
+                    str(s.get("cost_usd", "")),
+                ]
+                for s in data
+            ]
+            out.table(
+                f"Agent Stats ({len(data)} agents)",
+                [("Agent", "cyan"), ("Messages", ""), ("Tokens In", ""), ("Tokens Out", ""), ("Cost USD", "dim")],
+                rows,
+                data_for_json=data,
+            )
+        elif isinstance(data, dict):
+            rows = [[k, str(v)] for k, v in data.items()]
+            out.table("Agent Stats", [("Key", "cyan"), ("Value", "")], rows)
+        else:
+            out.text(str(data))
+    except GatewayError as e:
+        out.warn(f"Gateway not available: {e}")
+        out.info(_GATEWAY_HINT)
+
+
+@app.command("compare-models")
+def compare_models(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Agent name")],
+) -> None:
+    """Compare model performance for a given agent."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    agent = resolve_agent(actx.config_mgr, name)
+    current_model = agent.get("model", "default")
+
+    out.info(f"Model performance comparison for agent {name!r} (current: {current_model!r})")
+    try:
+        data = actx.gateway.get(f"/api/agents/{name}/model-comparison")
+        if isinstance(data, list):
+            rows = [
+                [
+                    str(m.get("model", "")),
+                    str(m.get("avg_latency_ms", "")),
+                    str(m.get("avg_tokens", "")),
+                    str(m.get("avg_cost_usd", "")),
+                    str(m.get("success_rate", "")),
+                ]
+                for m in data
+            ]
+            out.table(
+                f"Model Comparison: {name}",
+                [("Model", "cyan"), ("Avg Latency", ""), ("Avg Tokens", ""), ("Avg Cost", ""), ("Success %", "dim")],
+                rows,
+                data_for_json=data,
+            )
+        else:
+            out.text(str(data))
+    except GatewayError as e:
+        out.warn(f"Gateway not available: {e}")
+        out.info(_GATEWAY_HINT)