agent-data-cli 0.1.0__py3-none-any.whl

agent_data_cli/dashboard/adapters/config.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from agent_data_cli.cli.commands.config import CONFIG_CHECK_ACTION_IDS
+from agent_data_cli.core.config import validate_config_value
+
+
+def list_cli_configs(registry, store) -> list[dict[str, object]]:
+    defaults_by_key = {
+        spec.key: registry.get_cli_config_default(spec.key)
+        for spec in registry.get_cli_config_specs()
+    }
+    explicit_by_key = {entry.key: entry for entry in store.list_cli_configs()}
+    rows: list[dict[str, object]] = []
+    for spec in registry.get_cli_config_specs():
+        entry = explicit_by_key.get(spec.key)
+        if entry is not None:
+            rows.append(
+                {
+                    "scope": entry.source,
+                    "key": entry.key,
+                    "value": "***" if entry.is_secret else entry.value,
+                    "type": entry.value_type,
+                    "secret": entry.is_secret,
+                    "origin": "explicit",
+                    "updated_at": entry.updated_at,
+                }
+            )
+            continue
+        default_value = defaults_by_key.get(spec.key)
+        rows.append(
+            {
+                "scope": "cli",
+                "key": spec.key,
+                "value": default_value if default_value is not None else "unset",
+                "type": spec.type,
+                "secret": spec.secret,
+                "origin": "default" if default_value is not None else "unset",
+                "updated_at": "",
+            }
+        )
+    return rows
+
+
+def set_cli_config(registry, store, key: str, value: str) -> list[dict[str, object]]:
+    spec = registry.get_cli_config_field_spec(key)
+    validate_config_value(spec, value, owner="cli")
+    store.set_cli_config(key, value, spec.type, spec.secret)
+    return list_cli_configs(registry, store)
+
+
+def unset_cli_config(registry, store, key: str) -> list[dict[str, object]]:
+    _ = registry
+    store.unset_cli_config(key)
+    return list_cli_configs(registry, store)
+
+
+def explain_cli_config(registry, key: str) -> dict[str, object]:
+    spec = registry.get_cli_config_field_spec(key)
+    return _config_field_details("cli", spec)
+
+
+def list_source_configs(registry, store, source_name: str) -> list[dict[str, object]]:
+    source = registry.build(source_name)
+    resolved = source.config
+    resolved_entries = resolved.entries()
+    rows: list[dict[str, object]] = []
+    for spec in registry.get_source_config_specs(source_name):
+        entry = resolved_entries.get(spec.key)
+        if entry is None:
+            rows.append(
+                {
+                    "scope": source_name,
+                    "key": spec.key,
+                    "value": "unset",
+                    "type": spec.type,
+                    "secret": spec.secret,
+                    "origin": "unset",
+                    "updated_at": "",
+                }
+            )
+            continue
+        origin = "explicit" if resolved.is_explicit(spec.key) else "inherited"
+        rows.append(
+            {
+                "scope": source_name,
+                "key": spec.key,
+                "value": "***" if entry.is_secret else entry.value,
+                "type": entry.value_type,
+                "secret": entry.is_secret,
+                "origin": origin,
+                "updated_at": entry.updated_at,
+            }
+        )
+    return rows
+
+
+def set_source_config(registry, store, source_name: str, key: str, value: str) -> list[dict[str, object]]:
+    spec = registry.get_source_config_field_spec(source_name, key)
+    validate_config_value(spec, value, owner=source_name)
+    store.set_source_config(source_name, key, value, spec.type, spec.secret)
+    return list_source_configs(registry, store, source_name)
+
+
+def unset_source_config(registry, store, source_name: str, key: str) -> list[dict[str, object]]:
+    store.unset_source_config(source_name, key)
+    return list_source_configs(registry, store, source_name)
+
+
+def explain_source_config(registry, source_name: str, key: str) -> dict[str, object]:
+    spec = registry.get_source_config_field_spec(source_name, key)
+    return _config_field_details(source_name, spec)
+
+
+def check_source_config(registry, source_name: str, *, action_id: str | None = None, verb: str | None = None) -> dict[str, object]:
+    if action_id is not None and action_id not in CONFIG_CHECK_ACTION_IDS:
+        raise RuntimeError(f"unknown action id: {action_id}")
+    if action_id == "content.interact" and not verb:
+        raise RuntimeError("config source check --for content.interact requires --verb")
+    check = registry.config_check(source_name, action_id=action_id, verb=verb)
+    return {
+        "source": check.source,
+        "effective_mode": check.effective_mode,
+        "action_status": None if check.action_status is None else check.action_status.status,
+        "verb_status": None if check.verb_status is None else check.verb_status.status,
+        "items": [
+            {
+                "key": item.key,
+                "configured": item.configured,
+                "inherited": item.inherited,
+                "type": item.value_type,
+                "secret": item.secret,
+                "description": item.description,
+                "obtain_hint": item.obtain_hint,
+                "example": item.example,
+                "choices": list(item.choices),
+            }
+            for item in check.items
+        ],
+    }
+
+
+def _config_field_details(owner: str, spec) -> dict[str, object]:
+    return {
+        "scope": owner,
+        "key": spec.key,
+        "type": spec.type,
+        "secret": spec.secret,
+        "description": spec.description,
+        "inherits_from_cli": spec.inherits_from_cli,
+        "choices": list(spec.choices),
+        "obtain_hint": spec.obtain_hint,
+        "example": spec.example,
+    }

agent_data_cli/dashboard/adapters/content.py

@@ -0,0 +1,350 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from agent_data_cli.cli.commands.common import parse_since, require_action, require_option, resolve_limit, summarize_update_params, write_audit
+from agent_data_cli.cli.commands.content.common import (
+    build_query_rows,
+    group_targets_by_source,
+    require_update_options,
+    resolve_query_sources,
+    validate_search_results,
+)
+from agent_data_cli.utils.time import since_datetime_to_iso
+
+
+def search_content(
+    registry,
+    source_name: str,
+    *,
+    channel: str | None = None,
+    query: str | None = None,
+    since: str | None = None,
+    limit: int | None = None,
+) -> list[dict[str, object]]:
+    if channel is None and query is None:
+        raise RuntimeError("content search requires --channel or --query")
+    source = registry.build(source_name)
+    require_action(registry, source_name, "content.search")
+    if channel is not None:
+        require_option(registry, source_name, "content.search", "channel")
+    if query is not None:
+        require_option(registry, source_name, "content.search", "query")
+    since_value = parse_since(since) if since is not None else None
+    if since_value is not None:
+        require_option(registry, source_name, "content.search", "since")
+    if limit is not None:
+        require_option(registry, source_name, "content.search", "limit")
+    results = source.search_content(
+        channel_key=channel,
+        query=query,
+        since=since_value,
+        limit=resolve_limit(limit),
+    )
+    validate_search_results(source_name, results, registry)
+    view = source.get_content_search_view(channel)
+    rows: list[dict[str, object]] = []
+    for item in results:
+        if view is None:
+            row = {
+                "title": item.title,
+                "url": item.url,
+                "snippet": item.snippet,
+                "source": item.source,
+            }
+            if item.channel_key is not None:
+                row["channel_key"] = item.channel_key
+        else:
+            row = {column.header: column.getter(item) for column in view.columns}
+        if item.content_ref is not None:
+            row["content_ref"] = item.content_ref
+        rows.append(row)
+    return rows
+
+
+def query_content(
+    registry,
+    store,
+    *,
+    source_name: str | None = None,
+    channel_key: str | None = None,
+    group_name: str | None = None,
+    keywords: str | None = None,
+    content_type: str | None = None,
+    parent_ref: str | None = None,
+    children_ref: str | None = None,
+    depth: int | None = None,
+    since: str | None = None,
+    limit: int | None = None,
+    fetch_all: bool = False,
+) -> dict[str, object]:
+    if channel_key is not None and source_name is None:
+        raise RuntimeError("--channel requires --source")
+    if parent_ref is not None and source_name is None:
+        raise RuntimeError("--parent requires --source")
+    if children_ref is not None and source_name is None:
+        raise RuntimeError("--children requires --source")
+    if parent_ref is not None and children_ref is not None:
+        raise RuntimeError("content query does not allow --parent with --children")
+    if depth is not None and parent_ref is None and children_ref is None:
+        raise RuntimeError("--depth requires --parent or --children")
+    if (parent_ref is not None or children_ref is not None) and channel_key is not None:
+        raise RuntimeError("content query does not allow --parent or --children with --channel")
+    if channel_key is not None and group_name is not None:
+        raise RuntimeError("content query does not allow --channel with --group")
+    if source_name is not None and group_name is not None:
+        raise RuntimeError("content query does not allow --source with --group")
+    if fetch_all and limit is not None:
+        raise RuntimeError("content query does not allow --all with --limit")
+    if depth is not None and depth != -1 and depth <= 0:
+        raise RuntimeError("--depth must be a positive integer or -1")
+
+    since_value = parse_since(since) if since is not None else None
+    target_sources = resolve_query_sources(registry, store, source=source_name, group=group_name)
+    if keywords is not None:
+        for target_source in target_sources:
+            if not registry.get_storage_spec(target_source).supports_keywords:
+                raise RuntimeError(f"{target_source} does not support --keywords")
+    if since_value is not None:
+        for target_source in target_sources:
+            if registry.get_storage_spec(target_source).time_field is None:
+                raise RuntimeError(f"{target_source} does not support --since")
+
+    rows = store.query_content(
+        source=source_name,
+        channel_key=channel_key,
+        group_name=group_name,
+        record_type=content_type,
+        parent_ref=parent_ref,
+        children_ref=children_ref,
+        depth=1 if depth is None else depth,
+        since=None if since_value is None else since_datetime_to_iso(since_value),
+        keywords=keywords,
+        limit=-1 if fetch_all else resolve_limit(limit),
+        fetch_all=fetch_all,
+    )
+    rendered_rows, column_options, native_view_headers = build_query_rows(rows, registry, store)
+    return {
+        "rows": rendered_rows,
+        "column_options": column_options,
+        "native_view_headers": sorted(native_view_headers),
+    }
+
+
+def update_content(
+    registry,
+    store,
+    *,
+    source_name: str | None = None,
+    group_name: str | None = None,
+    channel_key: str | None = None,
+    since: str | None = None,
+    limit: int | None = None,
+    fetch_all: bool = False,
+    dry_run: bool = False,
+) -> dict[str, object]:
+    if bool(source_name) == bool(group_name):
+        raise RuntimeError("content update requires exactly one of --source or --group")
+    if channel_key is not None and source_name is None:
+        raise RuntimeError("--channel requires --source")
+    if fetch_all and since is not None:
+        raise RuntimeError("content update does not allow --all with --since")
+    if fetch_all and limit is not None:
+        raise RuntimeError("content update does not allow --all with --limit")
+    if dry_run and group_name is None:
+        raise RuntimeError("--dry-run only works with content update --group")
+
+    since_value = parse_since(since) if since is not None else None
+    resolved_limit = None if fetch_all else resolve_limit(limit)
+
+    if group_name is not None:
+        return _update_group(
+            registry,
+            store,
+            group_name=group_name,
+            since=since_value,
+            since_arg=since,
+            limit=resolved_limit,
+            limit_arg=limit,
+            fetch_all=fetch_all,
+            dry_run=dry_run,
+        )
+    return _update_source(
+        registry,
+        store,
+        source_name=source_name,
+        channel_key=channel_key,
+        since=since_value,
+        since_arg=since,
+        limit=resolved_limit,
+        limit_arg=limit,
+        fetch_all=fetch_all,
+    )
+
+
+def _update_group(
+    registry,
+    store,
+    *,
+    group_name: str,
+    since: datetime | None,
+    since_arg: str | None,
+    limit: int | None,
+    limit_arg: int | None,
+    fetch_all: bool,
+    dry_run: bool,
+) -> dict[str, object]:
+    targets = store.expand_group_update_targets(group_name)
+    if not targets:
+        raise RuntimeError(f"group has no subscribed update targets: {group_name}")
+    for source_name, channel_key in targets:
+        if not store.is_subscribed(source_name, channel_key):
+            raise RuntimeError(f"group target is not subscribed: {source_name}:{channel_key}")
+    grouped = group_targets_by_source(targets)
+    for source_name in grouped:
+        require_update_options(
+            registry,
+            source_name,
+            channel=False,
+            since=since_arg is not None,
+            limit=limit_arg is not None,
+            fetch_all=fetch_all,
+        )
+    if dry_run:
+        for source_name, grouped_targets in grouped.items():
+            write_audit(
+                store,
+                registry.build(source_name),
+                action="content.update",
+                target_kind="channel",
+                targets=grouped_targets,
+                dry_run=True,
+                params_summary=summarize_update_params(limit=limit, since=since, fetch_all=fetch_all),
+                status="ok",
+                error=None,
+            )
+        return {
+            "dry_run": True,
+            "targets": [{"source": source_name, "channel_key": channel_key} for source_name, channel_key in targets],
+        }
+
+    summaries: list[dict[str, object]] = []
+    saved_count = 0
+    skipped_count = 0
+    for source_name, grouped_targets in grouped.items():
+        source = registry.build(source_name)
+        try:
+            for target_channel in grouped_targets:
+                summary = source.update(
+                    channel_key=target_channel,
+                    limit=limit,
+                    since=since,
+                    fetch_all=fetch_all,
+                )
+                summaries.append(_summary_row(summary))
+                saved_count += summary.saved_count
+                skipped_count += summary.skipped_count
+            write_audit(
+                store,
+                source,
+                action="content.update",
+                target_kind="channel",
+                targets=grouped_targets,
+                dry_run=False,
+                params_summary=summarize_update_params(limit=limit, since=since, fetch_all=fetch_all),
+                status="ok",
+                error=None,
+            )
+        except Exception as exc:  # noqa: BLE001
+            write_audit(
+                store,
+                source,
+                action="content.update",
+                target_kind="channel",
+                targets=grouped_targets,
+                dry_run=False,
+                params_summary=summarize_update_params(limit=limit, since=since, fetch_all=fetch_all),
+                status="error",
+                error=str(exc),
+            )
+            raise
+    return {
+        "dry_run": False,
+        "saved_count": saved_count,
+        "skipped_count": skipped_count,
+        "summaries": summaries,
+    }
+
+
+def _update_source(
+    registry,
+    store,
+    *,
+    source_name: str,
+    channel_key: str | None,
+    since: datetime | None,
+    since_arg: str | None,
+    limit: int | None,
+    limit_arg: int | None,
+    fetch_all: bool,
+) -> dict[str, object]:
+    require_update_options(
+        registry,
+        source_name,
+        channel=channel_key is not None,
+        since=since_arg is not None,
+        limit=limit_arg is not None,
+        fetch_all=fetch_all,
+    )
+    source = registry.build(source_name)
+    audit_targets = (
+        (channel_key,)
+        if channel_key is not None
+        else tuple(sorted(subscription.channel_key for subscription in source.list_subscriptions()))
+    )
+    try:
+        summary = source.update(
+            channel_key=channel_key,
+            limit=limit,
+            since=since,
+            fetch_all=fetch_all,
+        )
+        write_audit(
+            store,
+            source,
+            action="content.update",
+            target_kind="channel",
+            targets=audit_targets,
+            dry_run=False,
+            params_summary=summarize_update_params(limit=limit, since=since, fetch_all=fetch_all),
+            status="ok",
+            error=None,
+        )
+    except Exception as exc:  # noqa: BLE001
+        write_audit(
+            store,
+            source,
+            action="content.update",
+            target_kind="channel",
+            targets=audit_targets,
+            dry_run=False,
+            params_summary=summarize_update_params(limit=limit, since=since, fetch_all=fetch_all),
+            status="error",
+            error=str(exc),
+        )
+        raise
+    return {
+        "dry_run": False,
+        "saved_count": summary.saved_count,
+        "skipped_count": summary.skipped_count,
+        "summaries": [_summary_row(summary)],
+    }
+
+
+def _summary_row(summary) -> dict[str, object]:
+    return {
+        "source": summary.source,
+        "channel_key": summary.channel_key or "",
+        "saved_count": summary.saved_count,
+        "skipped_count": summary.skipped_count,
+    }

agent_data_cli/dashboard/adapters/group.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+
+def list_groups(store) -> list[dict[str, object]]:
+    return [{"group": item.group_name, "created_at": item.created_at} for item in store.list_groups()]
+
+
+def create_group(store, group_name: str) -> list[dict[str, object]]:
+    store.create_group(group_name)
+    return list_groups(store)
+
+
+def delete_group(store, group_name: str) -> list[dict[str, object]]:
+    store.delete_group(group_name)
+    return list_groups(store)
+
+
+def list_group_members(store, group_name: str) -> list[dict[str, object]]:
+    return [
+        {
+            "group": item.group_name,
+            "member_type": item.member_type,
+            "source": item.source,
+            "channel": item.channel_key or "",
+        }
+        for item in store.list_group_members(group_name)
+    ]
+
+
+def add_source_to_group(store, group_name: str, source_name: str) -> list[dict[str, object]]:
+    store.add_group_source(group_name, source_name)
+    return list_group_members(store, group_name)
+
+
+def add_channel_to_group(store, group_name: str, source_name: str, channel_key: str) -> list[dict[str, object]]:
+    store.add_group_channel(group_name, source_name, channel_key)
+    return list_group_members(store, group_name)
+
+
+def remove_source_from_group(store, group_name: str, source_name: str) -> list[dict[str, object]]:
+    store.remove_group_source(group_name, source_name)
+    return list_group_members(store, group_name)
+
+
+def remove_channel_from_group(store, group_name: str, source_name: str, channel_key: str) -> list[dict[str, object]]:
+    store.remove_group_channel(group_name, source_name, channel_key)
+    return list_group_members(store, group_name)

agent_data_cli/dashboard/adapters/help.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from agent_data_cli.cli.commands import ROOT_COMMANDS, build_command_help_doc, build_global_help_doc
+from agent_data_cli.cli.help import build_source_help_doc
+from agent_data_cli.cli.commands.specs import CommandNodeSpec
+from agent_data_cli.core.help import HelpDoc
+
+
+def list_help_topics(registry) -> dict[str, list[str]]:
+    return {
+        "commands": sorted(_collect_topics(ROOT_COMMANDS)),
+        "sources": registry.list_names(),
+    }
+
+
+def build_help_doc_for_topic(registry, topic: str | None) -> HelpDoc:
+    normalized = "" if topic is None else topic.strip()
+    if not normalized or normalized == "global":
+        return build_global_help_doc()
+    if normalized in registry.list_names():
+        return build_source_help_doc(registry, normalized)
+    return build_command_help_doc(normalized)
+
+
+def _collect_topics(commands: tuple[CommandNodeSpec, ...], parent: tuple[str, ...] = ()) -> list[str]:
+    topics: list[str] = []
+    for command in commands:
+        current = parent + (command.name,)
+        topics.append(" ".join(current))
+        if command.children:
+            topics.extend(_collect_topics(command.children, current))
+    return topics

agent_data_cli/dashboard/adapters/source.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from agent_data_cli.cli.commands.common import require_action
+
+
+def list_sources(registry) -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+    for descriptor in registry.list_descriptors():
+        rows.append(
+            {
+                "source": descriptor.name,
+                "display_name": descriptor.display_name,
+                "summary": descriptor.summary,
+                "mode": descriptor.effective_mode or "",
+                "channel_search": descriptor.action_statuses["channel.search"].status,
+                "content_search": descriptor.action_statuses["content.search"].status,
+                "update": descriptor.action_statuses["content.update"].status,
+                "query": descriptor.action_statuses["content.query"].status,
+                "interact": descriptor.action_statuses["content.interact"].status,
+            }
+        )
+    return rows
+
+
+def check_source_health(registry, store, source_name: str) -> dict[str, object]:
+    require_action(registry, source_name, "source.health")
+    source = registry.build(source_name)
+    health = source.health()
+    store.save_health(health)
+    return {
+        "source": health.source,
+        "status": health.status,
+        "checked_at": health.checked_at,
+        "latency_ms": health.latency_ms,
+        "error": health.error,
+        "details": health.details,
+    }
+
+
+def check_source_config(registry, source_name: str, *, action_id: str | None = None, verb: str | None = None) -> dict[str, object]:
+    check = registry.config_check(source_name, action_id=action_id, verb=verb)
+    return {
+        "source": check.source,
+        "effective_mode": check.effective_mode,
+        "action_status": None if check.action_status is None else check.action_status.status,
+        "verb_status": None if check.verb_status is None else check.verb_status.status,
+        "items": [
+            {
+                "key": item.key,
+                "configured": item.configured,
+                "inherited": item.inherited,
+                "type": item.value_type,
+                "secret": item.secret,
+                "description": item.description,
+                "obtain_hint": item.obtain_hint,
+                "example": item.example,
+                "choices": list(item.choices),
+            }
+            for item in check.items
+        ],
+    }

agent_data_cli/dashboard/adapters/sub.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+
+def list_subscriptions(store, *, source_name: str | None = None) -> list[dict[str, object]]:
+    return [
+        {
+            "subscription_id": item.subscription_id,
+            "source": item.source,
+            "channel_key": item.channel_key,
+            "display_name": item.display_name,
+            "created_at": item.created_at,
+            "last_updated_at": item.last_updated_at,
+            "enabled": item.enabled,
+        }
+        for item in store.list_subscriptions(source_name)
+    ]
+
+
+def add_subscription(registry, source_name: str, channel_key: str, display_name: str | None = None) -> list[dict[str, object]]:
+    source = registry.build(source_name)
+    source.subscribe(channel_key, display_name=display_name)
+    return list_subscriptions(source.store, source_name=source_name)
+
+
+def remove_subscription(registry, source_name: str, channel_key: str) -> list[dict[str, object]]:
+    source = registry.build(source_name)
+    source.unsubscribe(channel_key)
+    return list_subscriptions(source.store, source_name=source_name)