chattermate-cli 0.2.0__py3-none-any.whl

chattermate_cli/commands/knowledge.py

@@ -0,0 +1,104 @@
+"""
+ChatterMate - CLI Knowledge Commands
+Copyright (C) 2024 ChatterMate
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>
+"""
+
+from typing import List, Optional
+
+import typer
+from rich.table import Table
+
+from .. import config
+from ..context import console, get_client, output, print_error, run
+
+knowledge_app = typer.Typer(no_args_is_help=True, help="Manage agent knowledge sources.")
+
+
+@knowledge_app.command("add-url")
+def add_url(
+    website: List[str] = typer.Option([], "--website", "-w", help="Website URL (repeatable)."),
+    pdf_url: List[str] = typer.Option([], "--pdf-url", help="PDF URL (repeatable)."),
+    agent_id: Optional[str] = typer.Option(None, "--agent-id", help="Attach to this agent."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Add website and/or PDF URLs to the knowledge base."""
+    if not website and not pdf_url:
+        print_error("Provide at least one --website or --pdf-url.")
+        raise typer.Exit(code=1)
+    org_id = config.load_config().get("organization_id")
+    if not org_id:
+        print_error("No organization in session. Run 'chattermate login' or 'whoami' first.")
+        raise typer.Exit(code=1)
+    client = get_client()
+    data = run(lambda: client.add_knowledge(
+        org_id=org_id, pdf_urls=list(pdf_url), websites=list(website), agent_id=agent_id,
+    ))
+    if not as_json:
+        console.print("[green]Queued knowledge ingestion.[/green]")
+    output(data, as_json)
+
+
+@knowledge_app.command("list")
+def list_knowledge(
+    agent_id: str = typer.Argument(..., help="Agent id."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """List knowledge sources linked to an agent."""
+    client = get_client()
+    data = run(lambda: client.list_knowledge_for_agent(agent_id))
+
+    def render(payload):
+        rows = payload.get("items", payload) if isinstance(payload, dict) else payload
+        table = Table(title="Knowledge sources")
+        for col in ("id", "source_type", "source"):
+            table.add_column(col)
+        for r in rows or []:
+            table.add_row(str(r.get("id")), str(r.get("source_type", "")), str(r.get("source", "")))
+        console.print(table)
+
+    output(data, as_json, render)
+
+
+@knowledge_app.command("link")
+def link(
+    knowledge_id: int = typer.Argument(..., help="Knowledge id."),
+    agent_id: str = typer.Argument(..., help="Agent id."),
+):
+    """Link a knowledge source to an agent."""
+    client = get_client()
+    run(lambda: client.link_knowledge(knowledge_id, agent_id))
+    console.print(f"[green]Linked[/green] knowledge {knowledge_id} -> agent {agent_id}")
+
+
+@knowledge_app.command("unlink")
+def unlink(
+    knowledge_id: int = typer.Argument(..., help="Knowledge id."),
+    agent_id: str = typer.Argument(..., help="Agent id."),
+):
+    """Unlink a knowledge source from an agent."""
+    client = get_client()
+    run(lambda: client.unlink_knowledge(knowledge_id, agent_id))
+    console.print(f"[green]Unlinked[/green] knowledge {knowledge_id} from agent {agent_id}")
+
+
+@knowledge_app.command("status")
+def status(
+    queue_id: int = typer.Argument(..., help="Ingestion queue id."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Check the status of a knowledge ingestion queue item."""
+    client = get_client()
+    output(run(lambda: client.knowledge_queue_status(queue_id)), as_json)

chattermate_cli/commands/workflow.py

@@ -0,0 +1,129 @@
+"""
+ChatterMate - CLI Workflow Commands
+Copyright (C) 2024 ChatterMate
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ..context import console, get_client, output, print_error, run
+
+workflow_app = typer.Typer(no_args_is_help=True, help="Create and manage agent workflows.")
+
+
+def _load_json_arg(data: Optional[str], file: Optional[Path]) -> dict:
+    if file is not None:
+        try:
+            raw = file.read_text()
+        except OSError as e:
+            print_error(f"Could not read {file}: {e}")
+            raise typer.Exit(code=1)
+    elif data is not None:
+        raw = data
+    else:
+        print_error("Provide --data '<json>' or --file <path>.")
+        raise typer.Exit(code=1)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as e:
+        print_error(f"Invalid JSON: {e}")
+        raise typer.Exit(code=1)
+
+
+@workflow_app.command("get")
+def get_workflow(
+    agent_id: str = typer.Argument(..., help="Agent id whose workflow to fetch."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Get the workflow attached to an agent."""
+    client = get_client()
+    output(run(lambda: client.get_workflow_for_agent(agent_id)), as_json)
+
+
+@workflow_app.command("create")
+def create_workflow(
+    agent_id: str = typer.Option(..., "--agent-id", help="Agent the workflow belongs to."),
+    name: str = typer.Option(..., "--name", help="Workflow name."),
+    description: Optional[str] = typer.Option(None, "--description"),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Create a workflow for an agent."""
+    payload = {"name": name, "agent_id": agent_id}
+    if description is not None:
+        payload["description"] = description
+    client = get_client()
+    data = run(lambda: client.create_workflow(payload))
+    if not as_json:
+        console.print(f"[green]Created workflow[/green] {data.get('id')} ({name})")
+    output(data, as_json)
+
+
+@workflow_app.command("update")
+def update_workflow(
+    workflow_id: str = typer.Argument(..., help="Workflow id."),
+    name: Optional[str] = typer.Option(None, "--name"),
+    description: Optional[str] = typer.Option(None, "--description"),
+    status: Optional[str] = typer.Option(
+        None, "--status", help="draft, published or archived (case-insensitive)."
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Update a workflow's metadata."""
+    payload: dict = {}
+    if name is not None:
+        payload["name"] = name
+    if description is not None:
+        payload["description"] = description
+    if status is not None:
+        # API enum values are lowercase (draft, published, archived); normalize.
+        payload["status"] = status.lower()
+    if not payload:
+        print_error("Nothing to update. Pass --name, --description or --status.")
+        raise typer.Exit(code=1)
+    client = get_client()
+    data = run(lambda: client.update_workflow(workflow_id, payload))
+    if not as_json:
+        console.print(f"[green]Updated workflow[/green] {workflow_id}")
+    output(data, as_json)
+
+
+@workflow_app.command("nodes")
+def get_nodes(
+    workflow_id: str = typer.Argument(..., help="Workflow id."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Get all nodes and connections for a workflow."""
+    client = get_client()
+    output(run(lambda: client.get_workflow_nodes(workflow_id)), as_json)
+
+
+@workflow_app.command("set-nodes")
+def set_nodes(
+    workflow_id: str = typer.Argument(..., help="Workflow id."),
+    data: Optional[str] = typer.Option(None, "--data", help="Nodes/connections JSON payload."),
+    file: Optional[Path] = typer.Option(None, "--file", help="Path to a JSON payload file."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON."),
+):
+    """Replace a workflow's nodes/connections from a JSON payload."""
+    payload = _load_json_arg(data, file)
+    client = get_client()
+    result = run(lambda: client.update_workflow_nodes(workflow_id, payload))
+    if not as_json:
+        console.print(f"[green]Updated nodes[/green] for workflow {workflow_id}")
+    output(result, as_json)

chattermate_cli/config.py

@@ -0,0 +1,101 @@
+"""
+ChatterMate - CLI Configuration
+Copyright (C) 2024 ChatterMate
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# Hosted ChatterMate API. For a local/self-hosted backend, set
+# CHATTERMATE_API_URL=http://localhost:8000 (or pass --api-url).
+DEFAULT_API_URL = "https://api.chattermate.chat"
+ENV_API_URL = "CHATTERMATE_API_URL"
+ENV_TOKEN = "CHATTERMATE_TOKEN"
+ENV_CONFIG_DIR = "CHATTERMATE_CONFIG_DIR"
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get(ENV_CONFIG_DIR, str(Path.home() / ".chattermate")))
+
+
+def config_file() -> Path:
+    return config_dir() / "config.json"
+
+
+def load_config() -> Dict[str, Any]:
+    """Load the on-disk config, or an empty dict if none exists / is unreadable."""
+    path = config_file()
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return json.load(fh)
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(cfg: Dict[str, Any]) -> None:
+    """Persist config to ~/.chattermate/config.json atomically with 0600 permissions.
+
+    The file holds tokens, so it is created 0600 from the start (no world-readable
+    window) and written via a temp file + atomic replace (no truncated config on crash).
+    """
+    d = config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    path = config_file()
+    tmp = path.with_suffix(".json.tmp")
+    # os.open with mode 0600 ensures the secret-bearing file is never world-readable.
+    fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump(cfg, fh, indent=2)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        finally:
+            raise
+    os.replace(tmp, path)
+
+
+def update_config(**values: Any) -> Dict[str, Any]:
+    cfg = load_config()
+    cfg.update({k: v for k, v in values.items() if v is not None})
+    save_config(cfg)
+    return cfg
+
+
+def clear_auth() -> None:
+    """Remove stored credentials (keeps api_url)."""
+    cfg = load_config()
+    for key in ("access_token", "refresh_token", "user_id", "organization_id", "email"):
+        cfg.pop(key, None)
+    save_config(cfg)
+
+
+def resolve_api_url(override: Optional[str] = None) -> str:
+    if override:
+        return override
+    return os.environ.get(ENV_API_URL) or load_config().get("api_url") or DEFAULT_API_URL
+
+
+def resolve_token(override: Optional[str] = None) -> Optional[str]:
+    """Resolve the bearer token: explicit override > env PAT > stored access token."""
+    if override:
+        return override
+    env_token = os.environ.get(ENV_TOKEN)
+    if env_token:
+        return env_token
+    return load_config().get("access_token")

chattermate_cli/context.py

@@ -0,0 +1,78 @@
+"""
+ChatterMate - CLI Shared Context
+Copyright (C) 2024 ChatterMate
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>
+"""
+
+import json as _json
+from typing import Any, Optional
+
+import typer
+from rich.console import Console
+
+from . import config
+from .client import ChatterMateError, Client
+
+console = Console()
+err_console = Console(stderr=True)
+
+# Set by the root callback so every command can honour a global --api-url.
+_api_url_override: Optional[str] = None
+
+
+def set_api_url_override(value: Optional[str]) -> None:
+    global _api_url_override
+    _api_url_override = value
+
+
+def _persist_tokens(access: str, refresh: Optional[str]) -> None:
+    config.update_config(access_token=access, refresh_token=refresh)
+
+
+def get_client(require_auth: bool = True) -> Client:
+    """Build a Client from --api-url / env / stored config."""
+    api_url = config.resolve_api_url(_api_url_override)
+    token = config.resolve_token()
+    cfg = config.load_config()
+    if require_auth and not token:
+        print_error("Not authenticated. Run 'chattermate login' or set CHATTERMATE_TOKEN.")
+        raise typer.Exit(code=1)
+    return Client(
+        api_url=api_url,
+        token=token,
+        refresh_token=cfg.get("refresh_token"),
+        on_tokens=_persist_tokens,
+    )
+
+
+def output(data: Any, as_json: bool, table_renderer=None) -> None:
+    """Print ``data`` as JSON when ``as_json`` is set, else via ``table_renderer``."""
+    if as_json or table_renderer is None:
+        console.print_json(_json.dumps(data, default=str))
+    else:
+        table_renderer(data)
+
+
+def print_error(message: str) -> None:
+    err_console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def run(fn):
+    """Execute an API call, turning ChatterMateError into a clean non-zero exit."""
+    try:
+        return fn()
+    except ChatterMateError as e:
+        print_error(str(e))
+        raise typer.Exit(code=1)

chattermate_cli/main.py

@@ -0,0 +1,74 @@
+"""
+ChatterMate - CLI Entry Point
+Copyright (C) 2024 ChatterMate
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>
+"""
+
+from typing import Optional
+
+import typer
+
+from . import __version__, context
+from .commands import auth as auth_cmd
+from .commands.agent import agent_app
+from .commands.knowledge import knowledge_app
+from .commands.workflow import workflow_app
+
+app = typer.Typer(
+    no_args_is_help=True,
+    add_completion=True,
+    help="ChatterMate CLI — sign up, log in, and configure agents, workflows and knowledge.",
+)
+
+
+def _version_callback(value: bool):
+    if value:
+        typer.echo(f"chattermate-cli {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    api_url: Optional[str] = typer.Option(
+        None, "--api-url",
+        help="ChatterMate API base URL (overrides CHATTERMATE_API_URL and stored config).",
+    ),
+    version: bool = typer.Option(
+        False, "--version", callback=_version_callback, is_eager=True, help="Show version."
+    ),
+):
+    """Global options."""
+    context.set_api_url_override(api_url)
+
+
+# Top-level auth commands
+app.command("login")(auth_cmd.login)
+app.command("signup")(auth_cmd.signup)
+app.command("logout")(auth_cmd.logout)
+app.command("whoami")(auth_cmd.whoami)
+
+# Sub-command groups
+app.add_typer(auth_cmd.token_app, name="token")
+app.add_typer(agent_app, name="agent")
+app.add_typer(workflow_app, name="workflow")
+app.add_typer(knowledge_app, name="knowledge")
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()