cortexdb-cli 0.2.0__py3-none-any.whl

cortexdb_cli/output.py

@@ -0,0 +1,399 @@
+"""Output formatting for CortexDB CLI.
+
+Two modes:
+  - Rich mode (TTY): colored panels, tables, spinners
+  - JSON mode (pipe/--json): machine-readable JSON to stdout
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Any, Generator
+
+from rich.console import Console
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.theme import Theme
+
+THEME = Theme({
+    "info": "cyan",
+    "success": "green bold",
+    "warning": "yellow",
+    "error": "red bold",
+    "dim": "dim",
+    "score.high": "green bold",
+    "score.mid": "yellow",
+    "score.low": "red",
+    "header": "bold magenta",
+})
+
+console = Console(theme=THEME, stderr=False)
+err_console = Console(theme=THEME, stderr=True)
+
+
+def is_json_mode(ctx: dict[str, Any]) -> bool:
+    return ctx.get("json_output", False) or not sys.stdout.isatty()
+
+
+def print_json(data: Any) -> None:
+    """Print JSON to stdout (for pipe mode)."""
+    print(json.dumps(data, indent=2, default=str))
+
+
+def print_error(message: str, ctx: dict[str, Any] | None = None) -> None:
+    if ctx and is_json_mode(ctx):
+        print_json({"error": message})
+    else:
+        err_console.print(f"[error]Error:[/error] {escape(message)}")
+
+
+def print_success(message: str, ctx: dict[str, Any] | None = None) -> None:
+    if ctx and is_json_mode(ctx):
+        return
+    console.print(f"[success]{escape(message)}[/success]")
+
+
+@contextmanager
+def spinner(message: str = "Working...") -> Generator[None, None, None]:
+    """Show a spinner while work is in progress."""
+    with console.status(f"[info]{message}[/info]", spinner="dots"):
+        yield
+
+
+def format_confidence(score: float) -> Text:
+    """Color-code a confidence score."""
+    text = f"{score:.1%}"
+    if score >= 0.8:
+        return Text(text, style="score.high")
+    elif score >= 0.5:
+        return Text(text, style="score.mid")
+    else:
+        return Text(text, style="score.low")
+
+
+def format_timestamp(ts: str | float | int) -> str:
+    """Format a timestamp for display."""
+    try:
+        if isinstance(ts, (int, float)):
+            # Microsecond timestamps
+            if ts > 1e15:
+                ts = ts / 1e6
+            dt = datetime.fromtimestamp(ts, tz=timezone.utc)
+        else:
+            dt = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M")
+    except Exception:
+        return str(ts)[:16]
+
+
+# ---------------------------------------------------------------------------
+# High-level formatters
+# ---------------------------------------------------------------------------
+
+
+def print_health(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render the /v1/auth/whoami response as a quick auth + reachability check."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+    caller = data.get("caller", "")
+    tenant = data.get("tenant_id", "")
+    preset = data.get("deployment_preset", "")
+    token = data.get("token", {}) or {}
+    panel_text = "[green bold]OK[/green bold] — token verified, server reachable\n"
+    if caller:
+        panel_text += f"\nCaller: [bold]{escape(caller)}[/bold]"
+    if tenant:
+        panel_text += f"\nTenant: {escape(tenant)}"
+    if preset:
+        panel_text += f"\nDeployment: {escape(preset)}"
+    if token.get("jti"):
+        panel_text += f"\nToken jti: [dim]{escape(token['jti'])}[/dim]"
+    console.print(
+        Panel(panel_text, title="[header]CortexDB health[/header]", border_style="cyan")
+    )
+
+
+def print_usage(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render whoami + rate-limit + token-expiry response headers."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    caller = data.get("caller", "")
+    tenant = data.get("tenant_id", "")
+    caps = data.get("effective_capabilities", []) or []
+
+    table = Table(
+        title=f"[header]Identity & quota[/header] [dim]({escape(caller)})[/dim]",
+        border_style="cyan",
+    )
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+
+    if tenant:
+        table.add_row("Tenant", escape(tenant))
+    if data.get("deployment_preset"):
+        table.add_row("Deployment", escape(data["deployment_preset"]))
+
+    if data.get("X-RateLimit-Limit"):
+        table.add_row("Rate limit", escape(data["X-RateLimit-Limit"]))
+    if data.get("X-RateLimit-Reset"):
+        table.add_row("Resets at", escape(data["X-RateLimit-Reset"]))
+    if data.get("X-Cortex-Token-Expires-In"):
+        secs = int(data["X-Cortex-Token-Expires-In"])
+        days = secs // 86400
+        hrs = (secs % 86400) // 3600
+        table.add_row("Token expires in", f"{days}d {hrs}h")
+    if data.get("X-Cortex-Token-Expires-At"):
+        table.add_row("Token expires at", escape(data["X-Cortex-Token-Expires-At"]))
+
+    table.add_row("Capabilities", f"{len(caps)} granted")
+
+    console.print(table)
+    if caps:
+        console.print(
+            "[dim]" + "  ".join(escape(c) for c in caps[:24]) + "[/dim]"
+        )
+
+
+def print_remember(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render the POST /v1/experience response."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+    event_id = data.get("event_id") or data.get("id") or "unknown"
+    status = data.get("status", "captured")
+    scope = data.get("scope", "")
+    panel_text = f"[success]Stored[/success] [dim]({escape(status)})[/dim]"
+    panel_text += f"\n[dim]Event:  {escape(event_id)}[/dim]"
+    if scope:
+        panel_text += f"\n[dim]Scope:  {escape(scope)}[/dim]"
+    console.print(
+        Panel(panel_text, title="[header]Remember[/header]", border_style="green")
+    )
+
+
+def print_recall(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render a v1 StratifiedPack from /v1/recall."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+    context = data.get("context_block") or data.get("context") or "(empty pack)"
+    pack_id = data.get("pack_id", "")
+    view = data.get("view", "")
+    prov = data.get("provenance", {}) or {}
+    trail = prov.get("trail") or []
+    latency = sum(p.get("elapsed_ms", 0) for p in trail if isinstance(p, dict))
+
+    header = Text()
+    if view:
+        header.append(f"View: {view}  ", style="dim")
+    if latency:
+        header.append(f"Latency: {latency}ms  ", style="dim")
+    if pack_id:
+        header.append(f"Pack: {pack_id}", style="dim")
+
+    console.print(
+        Panel(
+            f"{escape(str(context))}\n\n{header}",
+            title="[header]Memory recall[/header]",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )
+
+
+def print_search(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render the granular events surface of a v1 recall pack."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    layers = data.get("layers", {}) or {}
+    events = layers.get("events") or data.get("events") or []
+    if isinstance(events, dict):
+        events = events.get("items", [])
+
+    if not events:
+        # Some servers return granular hits inline; fall back to context_block.
+        context = data.get("context_block") or ""
+        if context:
+            console.print(
+                Panel(escape(context), title="[header]Context[/header]", border_style="cyan")
+            )
+        else:
+            console.print("[dim]No results found.[/dim]")
+        return
+
+    table = Table(
+        title=f"[dim]{len(events)} matching events[/dim]",
+        border_style="blue",
+        show_lines=True,
+    )
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Content", max_width=60)
+    table.add_column("Modality", style="cyan", width=12)
+    table.add_column("Observed at", style="dim", width=20)
+
+    for i, ev in enumerate(events, 1):
+        content = ev.get("content") or {}
+        text = ""
+        if isinstance(content, dict):
+            text = content.get("text") or content.get("summary") or ""
+        elif isinstance(content, str):
+            text = content
+        modality = ev.get("modality", "")
+        ts = (ev.get("context") or {}).get("observed_at") if isinstance(ev.get("context"), dict) else ev.get("observed_at", "")
+        table.add_row(str(i), escape(str(text)[:120]), escape(modality), format_timestamp(ts or ""))
+
+    console.print(table)
+
+
+def print_episodes(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render a v1 episodes response: {items: [Episode, …]}"""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    episodes = data.get("items") or data.get("episodes") or []
+    if not episodes:
+        console.print("[dim]No episodes found.[/dim]")
+        return
+
+    table = Table(
+        title=f"[header]Episodes[/header] [dim]({len(episodes)})[/dim]",
+        border_style="blue",
+    )
+    table.add_column("ID", style="dim", max_width=16)
+    table.add_column("Summary", max_width=60)
+    table.add_column("Span events", style="cyan", justify="right", width=12)
+    table.add_column("Valid from", style="dim", width=20)
+
+    for ep in episodes:
+        eid = str(ep.get("episode_id") or ep.get("id", ""))[:16]
+        summary = ep.get("summary") or ep.get("title") or ""
+        spans = ep.get("event_count") or len(ep.get("event_ids") or [])
+        valid_from = ep.get("valid_from") or ep.get("observed_at", "")
+        table.add_row(
+            escape(eid), escape(str(summary)[:80]), str(spans), format_timestamp(valid_from)
+        )
+
+    console.print(table)
+
+
+def print_entities(data: list[dict[str, Any]], ctx: dict[str, Any]) -> None:
+    """Render entity rollups derived from /v1/facts (subject, predicate count)."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    if not data:
+        console.print("[dim]No entities found.[/dim]")
+        return
+
+    table = Table(title="[header]Entities[/header]", border_style="blue")
+    table.add_column("Subject", style="bold", max_width=40)
+    table.add_column("Predicates", style="cyan", max_width=60)
+    table.add_column("Facts", justify="right")
+
+    for ent in data:
+        preds = ent.get("predicates") or []
+        preds_str = ", ".join(preds[:6])
+        if len(preds) > 6:
+            preds_str += f", +{len(preds) - 6}"
+        table.add_row(
+            escape(str(ent.get("subject") or ent.get("id", ""))),
+            escape(preds_str),
+            str(ent.get("fact_count", 0)),
+        )
+
+    console.print(table)
+
+
+def print_entity_detail(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render every fact about an entity (output of /v1/facts?subject=…)."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    subject = data.get("id") or data.get("subject", "")
+    facts = data.get("facts") or []
+    console.print(
+        Panel(
+            f"[bold]{escape(subject)}[/bold]\n[dim]{len(facts)} facts[/dim]",
+            title="[header]Entity[/header]",
+            border_style="cyan",
+        )
+    )
+
+    if not facts:
+        console.print("[dim]No facts recorded yet — the LLM extractor may not have run on related events.[/dim]")
+        return
+
+    table = Table(border_style="blue")
+    table.add_column("Predicate", style="magenta", max_width=24)
+    table.add_column("Object", style="bold")
+    table.add_column("Confidence", justify="right", width=10)
+    table.add_column("Valid from", style="dim", width=20)
+    for f in facts:
+        obj = f.get("object")
+        if isinstance(obj, dict):
+            obj_str = str(obj.get("value") or obj.get("id") or obj)
+        else:
+            obj_str = str(obj or "")
+        table.add_row(
+            escape(f.get("predicate", "")),
+            escape(obj_str),
+            f"{(f.get('confidence') or 0):.0%}",
+            format_timestamp(f.get("valid_from") or f.get("observed_at", "")),
+        )
+    console.print(table)
+
+
+def print_forget(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render the /v1/forget response."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+    deleted = data.get("deleted_count") or data.get("forgotten") or 0
+    erasure_id = data.get("erasure_id") or data.get("audit_id", "")
+    cascade = data.get("cascade", "")
+    panel_text = f"Forgot [bold]{deleted}[/bold] item(s)"
+    if cascade:
+        panel_text += f" [dim](cascade: {escape(cascade)})[/dim]"
+    if erasure_id:
+        panel_text += f"\n[dim]Erasure id: {escape(erasure_id)}[/dim]"
+    console.print(
+        Panel(panel_text, title="[header]Forget[/header]", border_style="yellow")
+    )
+
+
+def print_ontology(data: dict[str, Any], ctx: dict[str, Any]) -> None:
+    """Render /v1/admin/layers/stats (per-layer counts + lag)."""
+    if is_json_mode(ctx):
+        print_json(data)
+        return
+
+    layers = data.get("layers") or data
+    if not isinstance(layers, dict) or not layers:
+        console.print("[dim]No layer stats available on this tier.[/dim]")
+        return
+
+    table = Table(title="[header]Layer stats[/header]", border_style="cyan")
+    table.add_column("Layer", style="bold")
+    table.add_column("Count", justify="right")
+    table.add_column("Lag", style="dim", justify="right")
+    for name, info in layers.items():
+        if isinstance(info, dict):
+            count = info.get("count", info.get("total", ""))
+            lag = info.get("lag") or info.get("synthesis_lag", "")
+            table.add_row(escape(name), str(count), escape(str(lag)))
+        else:
+            table.add_row(escape(name), str(info), "")
+    console.print(table)

cortexdb_cli/state.py

@@ -0,0 +1,53 @@
+"""Persistent state for the CortexDB CLI.
+
+We split secrets out of `~/.cortexdb/config.toml` (which is meant to be
+human-editable) and into `~/.cortexdb/state.json`, written 0600 on POSIX.
+State holds the PASETO bearer, actor, scope, and token expiry produced by
+`POST /v1/auth/signup` — exactly the same shape the cortexdb-mcp 0.3.0
+server persists. Keeping the format identical means a user who signed up
+through one tool can copy state.json across to use the other.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+from cortexdb_cli.config import config_dir
+
+
+def state_path() -> Path:
+    return config_dir() / "state.json"
+
+
+def load_state() -> dict[str, Any]:
+    """Load persistent state. Returns {} if no state file exists."""
+    path = state_path()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save_state(state: dict[str, Any]) -> None:
+    """Atomically write state and tighten permissions on POSIX."""
+    path = state_path()
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(state, indent=2, sort_keys=True), encoding="utf-8")
+    tmp.replace(path)
+    if os.name == "posix":
+        try:
+            os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+        except OSError:
+            pass
+
+
+def clear_state() -> None:
+    path = state_path()
+    if path.exists():
+        path.unlink()

cortexdb_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: cortexdb-cli
+Version: 0.2.0
+Summary: Command-line interface for CortexDB — the long-term memory layer for AI.
+Project-URL: Homepage, https://cortexdb.ai
+Project-URL: Documentation, https://cortexdb.ai/docs
+Project-URL: Repository, https://github.com/cortexdb/cortexdb
+Project-URL: Issues, https://github.com/cortexdb/cortexdb/issues
+Author-email: CortexDB Team <team@cortexdb.ai>
+License-Expression: Apache-2.0
+Keywords: agents,ai,cli,cortexdb,llm,memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich-click>=1.7
+Requires-Dist: rich>=13.0
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Description-Content-Type: text/markdown
+
+# cortexdb-cli
+
+Command-line interface for [CortexDB](https://cortexdb.ai) — the long-term memory layer for AI systems.
+
+Wraps the v1 HTTP API in a small, fast Click + Rich CLI. Anonymous signup
+in one command, no email or card; works against the public SaaS or any
+self-hosted CortexDB deployment.
+
+## Install
+
+```bash
+pip install cortexdb-cli
+```
+
+Requires Python 3.10+.
+
+## Quickstart
+
+```bash
+# 1. One-time setup — anonymous signup, writes ~/.cortexdb/state.json
+cortexdb init
+
+# 2. Store a memory
+cortexdb remember "Q3 revenue: $2.4M. We're on track for $10M ARR by year-end."
+
+# 3. Recall it
+cortexdb recall "Q3 revenue?"
+
+# 4. Or just type — drops into a REPL
+cortexdb
+```
+
+The signup token has a 7-day TTL on the free tier. Re-run `cortexdb init`
+to refresh, or pass `--api-key` + `--actor` to use a token from your IdP.
+
+## Commands
+
+```
+cortexdb init                                 anonymous signup; persist token + actor
+cortexdb remember "..."                       store a memory (POST /v1/experience)
+cortexdb recall   "..."                       recall a stratified context pack
+cortexdb search   "..."                       granular event-level search
+cortexdb forget   --memory-id ...             delete with audit
+cortexdb episodes {list,get,delete}           episode CRUD
+cortexdb entities {list,get,link}             entity rollups over the Facts layer
+cortexdb admin    {health,usage,layers}       diagnostics
+cortexdb import   data.json                   bulk-load (JSON / JSONL / CSV / TXT)
+cortexdb export   -o backup.json              export memories
+cortexdb config   {show,set}                  view / edit ~/.cortexdb/config.toml
+cortexdb                                      interactive REPL
+```
+
+## Configuration
+
+Three layers, in precedence order:
+
+1. **CLI flags** — `--api-key`, `--endpoint`, `--actor`, `--scope`, `--profile`
+2. **Environment** — `CORTEXDB_API_KEY`, `CORTEXDB_URL`, `CORTEXDB_ACTOR`, `CORTEXDB_SCOPE`
+3. **Persisted state**:
+   - `~/.cortexdb/config.toml` — endpoint, profile names (human-editable)
+   - `~/.cortexdb/state.json` — token, actor, scope, expiry (managed by `init`, 0600 on POSIX)
+
+The state.json format matches the cortexdb-mcp 0.3.0 server's, so you can
+copy state across to use both tools from the same anonymous identity.
+
+## Pipe-friendly
+
+Auto-detects when stdout isn't a TTY and emits JSON:
+
+```bash
+cortexdb recall "Q3 revenue" | jq .context_block
+cortexdb entities list      | jq '.[].subject'
+echo "remember this"        | cortexdb remember -
+```
+
+Force JSON mode any time with `--json`.
+
+## Auth notes
+
+- The v1 API requires both `Authorization: Bearer <PASETO>` and `X-Cortex-Actor`.
+  The CLI stamps both on every request — you never need to pass them by hand.
+- 401s show the specific error code (`TOKEN_EXPIRED`, `actor_mismatch`, …)
+  and the remediation: usually `cortexdb init`.
+- 403s cite the missing capability and the policy tier that denied. If a
+  recall returns `diagnostics.read denied`, pass `--diagnostics none` —
+  free-tier tokens don't carry the `diagnostics.read` capability.
+
+## License
+
+Apache-2.0

cortexdb_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+cortexdb_cli/__init__.py,sha256=ixhxihEV952X_SmT9JyodCc15IxaOntRFdA1XOFz72g,92
+cortexdb_cli/client.py,sha256=t2i1jlIoNkppYaKtZMTkv99rwXI9v9iLQ_2BCX599Cw,2866
+cortexdb_cli/config.py,sha256=JrHwQsfLAw56j0Yrafp_4HyW4TqIUVBEZuZFjxSlB0c,3609
+cortexdb_cli/errors.py,sha256=xwxAWYY7KtNa-e7dyLQECnsKcciVcKC41CXFFF_-0VU,3924
+cortexdb_cli/main.py,sha256=RLqcyQzDSTk-IlE2jJ9Camf3FrqH2GZb-TAMRItwB80,5272
+cortexdb_cli/output.py,sha256=X2XosVQXEHPSQy0UnEzJyCDiOI9h3TRMneLlgEaEFQM,14014
+cortexdb_cli/state.py,sha256=yxy1ODTdBkRUKnTz8vBEvojuH4ieRbME4ccVMj--bwk,1529
+cortexdb_cli/commands/__init__.py,sha256=TeF4ieMQkbgBr9Fco9VAiIZvKQ4vdg4yhkz4fvwfToc,37
+cortexdb_cli/commands/admin.py,sha256=1fyMVujNTBzBkWthgj1GXRsWXGM2FyBv_PfvZUMBfFQ,2516
+cortexdb_cli/commands/answer.py,sha256=m9Tn2XAdXpwgYQDEaBVex3PAyGO5NisVAhU83dzoDVo,2904
+cortexdb_cli/commands/auth.py,sha256=0kbOZenps3ydPM_HIisZNXFoQhNuG4hyBNnvF5UYHt8,4521
+cortexdb_cli/commands/beliefs.py,sha256=55zNUMfwzqRWlkGHuv5xJFN_QEeLMhqXK2qf5zl9gCc,4043
+cortexdb_cli/commands/config_cmd.py,sha256=9XwPJLWubvc6QY8EnVJd8mhQFSITnhQYlclJaQqr0VU,1519
+cortexdb_cli/commands/entities.py,sha256=8jQwL14yzwF2j7_-447WTlFTFsNxZ30MWH4na1K2CdE,6067
+cortexdb_cli/commands/episodes.py,sha256=oeXSSgnt_FPqgoI2nTHdYe56iwo6ydzR2Bp1_K25CV0,4135
+cortexdb_cli/commands/experience.py,sha256=13u8907HrQz8UepD9agv22UOMzOdV6Hq654qswdsgOQ,7591
+cortexdb_cli/commands/export_cmd.py,sha256=v5nnApGz6yJRhnTh2CCB8siYI1xJfn9dOaeSgZb1Zdo,1986
+cortexdb_cli/commands/facts.py,sha256=2eFLum7kIG3QiS5_M_5yrv8puxwXZ-bE8dMhtks9Fco,5405
+cortexdb_cli/commands/forget.py,sha256=tEhXHlpM6mXIxe0TJrwAnfNNBvDXm1dNgVXwKuNHpaM,2948
+cortexdb_cli/commands/import_cmd.py,sha256=SEsxTStwS8LF5ebehCZtvyYGAPEAnq5rqFPTrem3oCY,6458
+cortexdb_cli/commands/init.py,sha256=FgFwPell0x8-rA1ECKiT0cBcDWoIhCVS6TsRp-_JH84,3035
+cortexdb_cli/commands/interactive.py,sha256=L0qUCMfm1jzPrPKvKXqu9Tiz9qvcrRCsICs7OAvyZ3I,9518
+cortexdb_cli/commands/policy.py,sha256=IT2o-OogGHfcBCyMM3ht_OCpmG7d2ryHsJpFxK-l6R4,3362
+cortexdb_cli/commands/recall.py,sha256=nmFVQyojaI6xHVWh3rIF5nKo8_chYc7BFlp_zu4JPXk,2680
+cortexdb_cli/commands/scopes.py,sha256=6cNGt9mHJe8M10QkekifhJ86TVuzWIOxHzxUrDUQPhY,3052
+cortexdb_cli/commands/search.py,sha256=aRAd8161ItytQJvYaG7K1an003GA8yDbW4AwOhfRkIE,1957
+cortexdb_cli/commands/understanding.py,sha256=6YJEmRPGkP6jqn7RQgp6zkbbvYZis2eHDbQ190Y0UXM,5009
+cortexdb_cli-0.2.0.dist-info/METADATA,sha256=lnIlhxdPYCQVaCAn-osZ3BXuLC2vyP0u3SZ29mw3R0o,4429
+cortexdb_cli-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cortexdb_cli-0.2.0.dist-info/entry_points.txt,sha256=h3sEbdqqvtv8LBbRLUgybYPo9N2lpU85fQUSh5ToEvs,51
+cortexdb_cli-0.2.0.dist-info/RECORD,,

cortexdb_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cortexdb_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cortexdb = cortexdb_cli.main:cli