graphe-cli 0.1.1__py3-none-any.whl

graphe_cli/__init__.py

@@ -0,0 +1 @@
+"""Graphe CLI."""

graphe_cli/context.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from graphe_sdk import GrapheClient, GrapheConfig
+
+
+@dataclass
+class CliContext:
+    client: GrapheClient
+    config: GrapheConfig
+    output: str
+
+
+def build_context(
+    *,
+    base_url: str | None,
+    api_key: str | None,
+    workspace_id: str | None,
+    project_id: str | None,
+    actor_id: str | None,
+    config_path: Path | None,
+    output: str,
+) -> CliContext:
+    loaded = GrapheConfig.from_env(config_path=config_path)
+    config = GrapheConfig(
+        base_url=base_url or loaded.base_url,
+        api_key=api_key or loaded.api_key,
+        workspace_id=workspace_id or loaded.workspace_id,
+        project_id=project_id or loaded.project_id,
+        actor_id=actor_id or loaded.actor_id,
+    )
+    if not config.api_key:
+        raise typer.BadParameter("API key is required. Set GRAPHE_API_KEY or pass --api-key.")
+    client = GrapheClient(config.base_url, config.api_key)
+    return CliContext(client=client, config=config, output=output)

graphe_cli/display.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, Mapping
+
+from graphe_sdk.output import emit, print_table
+
+
+def short_id(value: Any, *, head: int = 8, tail: int = 4) -> str:
+    text = str(value)
+    if len(text) <= head + tail + 3:
+        return text
+    return f"{text[:head]}...{text[-tail:]}"
+
+
+def print_kv_table(data: Mapping[str, Any], *, stream: Any = None) -> None:
+    target = stream or sys.stdout
+    rows = [{"field": key, "value": value} for key, value in data.items()]
+    print_table(rows, ["field", "value"], stream=target)
+
+
+def search_result_row(row: Mapping[str, Any]) -> dict[str, str]:
+    source_type = row.get("source_type") or row.get("kind") or ""
+    source_id = row.get("source_id") or row.get("id") or ""
+    summary = row.get("summary") or row.get("snippet") or ""
+    return {
+        "type": str(source_type),
+        "id": short_id(source_id),
+        "score": f"{float(row.get('score', 0)):.3f}",
+        "summary": str(summary)[:56],
+    }
+
+
+def render(cli_output: str, data: Any, *, kind: str = "auto") -> None:
+    if cli_output == "json":
+        emit(data, output="json")
+        return
+
+    if kind == "kv" and isinstance(data, Mapping):
+        print_kv_table({key: _format_scalar(value) for key, value in data.items()})
+        return
+
+    if kind == "search" and isinstance(data, Mapping):
+        rows = [search_result_row(row) for row in data.get("results", [])]
+        print_table(rows, ["type", "id", "score", "summary"])
+        mode = data.get("mode")
+        if mode:
+            sys.stdout.write(f"mode: {mode}\n")
+        return
+
+    if kind == "state" and isinstance(data, Mapping):
+        _render_state(data)
+        return
+
+    if kind == "runs" and isinstance(data, Mapping):
+        print_table(
+            [
+                {
+                    "run_id": short_id(r.get("run_id", "")),
+                    "status": r.get("status", ""),
+                    "started_at": _format_scalar(r.get("started_at", "")),
+                }
+                for r in data.get("runs", [])
+            ],
+            ["run_id", "status", "started_at"],
+        )
+        return
+
+    if kind == "claims" and isinstance(data, Mapping):
+        print_table(
+            [
+                {
+                    "claim_id": short_id(c.get("claim_id", "")),
+                    "status": c.get("status", ""),
+                    "predicate": c.get("predicate", ""),
+                }
+                for c in data.get("claims", [])
+            ],
+            ["claim_id", "status", "predicate"],
+        )
+        return
+
+    if kind == "trace" and isinstance(data, Mapping):
+        records = data.get("context_used", [])
+        if records:
+            sys.stdout.write("context used\n")
+            print_table(
+                [
+                    {
+                        "event": short_id(r.get("event_id", "")),
+                        "type": r.get("event_type", ""),
+                        "query": (r.get("query") or "")[:24],
+                        "items": str(len(r.get("items", []))),
+                    }
+                    for r in records
+                ],
+                ["event", "type", "query", "items"],
+            )
+        else:
+            sys.stdout.write("(no context_used records)\n")
+        sys.stdout.write(
+            f"events={len(data.get('events', []))} "
+            f"observations={len(data.get('observations', []))} "
+            f"claims={len(data.get('claims', []))}\n"
+        )
+        return
+
+    if kind == "entities" and isinstance(data, Mapping):
+        print_table(
+            [
+                {
+                    "entity_type": e.get("entity_type", ""),
+                    "entity_id": short_id(e.get("entity_id", "")),
+                    "label": (e.get("label") or "")[:40],
+                }
+                for e in data.get("entities", [])
+            ],
+            ["entity_type", "entity_id", "label"],
+        )
+        return
+
+    if isinstance(data, Mapping):
+        print_kv_table({key: _format_scalar(value) for key, value in data.items()})
+        return
+
+    emit(data, output="table")
+
+
+def _render_state(data: Mapping[str, Any]) -> None:
+    header = {
+        "workspace_id": short_id(data.get("workspace_id", "")),
+        "project_id": short_id(data.get("project_id", "")),
+    }
+    if "as_of" in data:
+        header["as_of"] = _format_scalar(data["as_of"])
+    print_kv_table(header)
+
+    claims = data.get("claims", [])
+    if claims:
+        sys.stdout.write("\nclaims\n")
+        print_table(
+            [
+                {
+                    "claim_id": short_id(c.get("claim_id", "")),
+                    "status": c.get("status", ""),
+                    "predicate": c.get("predicate", ""),
+                }
+                for c in claims
+            ],
+            ["claim_id", "status", "predicate"],
+        )
+
+    observations = data.get("observations", [])
+    if observations:
+        sys.stdout.write("\nobservations\n")
+        print_table(
+            [
+                {
+                    "observation_id": short_id(o.get("observation_id", "")),
+                    "type": o.get("observation_type", ""),
+                    "summary": (o.get("summary") or "")[:48],
+                }
+                for o in observations
+            ],
+            ["observation_id", "type", "summary"],
+        )
+
+    if not claims and not observations:
+        sys.stdout.write("(no claims or observations)\n")
+
+
+def _format_scalar(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, default=str)[:80]
+    return str(value)

graphe_cli/main.py

@@ -0,0 +1,432 @@
+from __future__ import annotations
+
+import json
+import sys
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from typer import Context
+
+from graphe_sdk import AuthError, ConflictError, GrapheError, NotFoundError
+from graphe_cli.context import CliContext, build_context
+from graphe_cli.display import render
+
+app = typer.Typer(
+    name="graphe",
+    help="Graphe CLI - query and update shared agent state.",
+    no_args_is_help=True,
+)
+
+runs_app = typer.Typer(help="Agent runs.")
+claims_app = typer.Typer(help="Claims lifecycle.")
+entities_app = typer.Typer(help="Entities.")
+events_app = typer.Typer(help="Event ingestion.")
+annotations_app = typer.Typer(help="Human annotations.")
+
+app.add_typer(runs_app, name="runs")
+app.add_typer(claims_app, name="claims")
+app.add_typer(entities_app, name="entities")
+app.add_typer(events_app, name="events")
+app.add_typer(annotations_app, name="annotations")
+
+
+def _ctx(ctx: Context) -> CliContext:
+    if ctx.obj is None:
+        raise typer.Exit(code=2)
+    return ctx.obj
+
+
+def _handle_api_error(exc: GrapheError) -> None:
+    typer.secho(str(exc), fg=typer.colors.RED, err=True)
+    raise typer.Exit(code=1) from exc
+
+
+def _scope_params(ctx: CliContext, workspace: str | None, project: str | None) -> dict[str, str]:
+    ws = workspace or ctx.config.workspace_id
+    proj = project or ctx.config.project_id
+    if not ws or not proj:
+        raise typer.BadParameter("workspace and project are required (flags or GRAPHE_* env).")
+    return {"workspace_id": ws, "project_id": proj}
+
+
+def _read_json(value: str | None, path: Path | None) -> dict[str, Any]:
+    if path:
+        return json.loads(path.read_text(encoding="utf-8"))
+    if value:
+        return json.loads(value)
+    raise typer.BadParameter("Provide --json or --file.")
+
+
+@app.callback()
+def main(
+    ctx: Context,
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Graphe API base URL."),
+    api_key: Optional[str] = typer.Option(None, "--api-key", "-k", help="API key."),
+    workspace: Optional[str] = typer.Option(None, "--workspace", help="Default workspace ID."),
+    project: Optional[str] = typer.Option(None, "--project", help="Default project ID."),
+    actor: Optional[str] = typer.Option(None, "--actor", help="Default actor ID."),
+    config: Optional[Path] = typer.Option(None, "--config", help="Path to graphe.toml."),
+    output: str = typer.Option("table", "--output", help="Output format: table or json."),
+) -> None:
+    if output not in {"table", "json"}:
+        raise typer.BadParameter("--output must be 'table' or 'json'.")
+    ctx.obj = build_context(
+        base_url=base_url,
+        api_key=api_key,
+        workspace_id=workspace,
+        project_id=project,
+        actor_id=actor,
+        config_path=config,
+        output=output,
+    )
+
+
+@app.command("health")
+def health(ctx: Context) -> None:
+    """Check API health."""
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_health()
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="kv")
+
+
+@app.command("state")
+def state_current(
+    ctx: Context,
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+    entity_type: Optional[str] = typer.Option(None, "--entity-type"),
+    entity_id: Optional[str] = typer.Option(None, "--entity-id"),
+) -> None:
+    """Get current derived state."""
+    cli = _ctx(ctx)
+    params = _scope_params(cli, workspace, project)
+    if entity_type:
+        params["entity_type"] = entity_type
+    if entity_id:
+        params["entity_id"] = entity_id
+    try:
+        result = cli.client.get_current_state(**params)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="state")
+
+
+@app.command("history")
+def state_history(
+    ctx: Context,
+    as_of: str = typer.Option(..., "--as-of", help="ISO-8601 timestamp."),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+    entity_type: Optional[str] = typer.Option(None, "--entity-type"),
+    entity_id: Optional[str] = typer.Option(None, "--entity-id"),
+) -> None:
+    """Get historical state at a point in time."""
+    cli = _ctx(ctx)
+    params = {**_scope_params(cli, workspace, project), "as_of": as_of}
+    if entity_type:
+        params["entity_type"] = entity_type
+    if entity_id:
+        params["entity_id"] = entity_id
+    try:
+        result = cli.client.get_history(**params)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="state")
+
+
+@app.command("search")
+def search(
+    ctx: Context,
+    query: str = typer.Option(..., "--query", "-q"),
+    mode: Optional[str] = typer.Option(None, "--mode", help="graph_first, vector_first, or balanced."),
+    limit: int = typer.Option(10, "--limit", help="Max results (maps to API top_k)."),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+) -> None:
+    """Hybrid graph + vector search."""
+    cli = _ctx(ctx)
+    scope = _scope_params(cli, workspace, project)
+    payload = {"query": query, "top_k": limit, **scope}
+    try:
+        result = cli.client.hybrid_search(payload, mode=mode)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="search")
+
+
+@runs_app.command("list")
+def runs_list(
+    ctx: Context,
+    limit: int = typer.Option(20, "--limit"),
+    cursor: Optional[str] = typer.Option(None, "--cursor"),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+) -> None:
+    cli = _ctx(ctx)
+    params = {**_scope_params(cli, workspace, project), "limit": limit}
+    if cursor:
+        params["cursor"] = cursor
+    try:
+        result = cli.client.list_runs(**params)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="runs")
+
+
+@runs_app.command("get")
+def runs_get(ctx: Context, run_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_run(run_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@runs_app.command("trace")
+def runs_trace(ctx: Context, run_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_trace(run_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="trace")
+
+
+@runs_app.command("create")
+def runs_create(
+    ctx: Context,
+    json_body: Optional[str] = typer.Option(None, "--json"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+    actor: Optional[str] = typer.Option(None, "--actor"),
+    goal: Optional[str] = typer.Option(None, "--goal"),
+) -> None:
+    cli = _ctx(ctx)
+    if json_body or file:
+        payload = _read_json(json_body, file)
+    else:
+        scope = _scope_params(cli, workspace, project)
+        actor_id = actor or cli.config.actor_id or str(uuid.uuid4())
+        if not goal:
+            raise typer.BadParameter("Provide --goal or --json/--file.")
+        payload = {
+            **scope,
+            "actor_id": actor_id,
+            "goal": goal,
+            "metadata": {},
+        }
+    try:
+        result = cli.client.create_run(payload)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@claims_app.command("list")
+def claims_list(
+    ctx: Context,
+    limit: int = typer.Option(20, "--limit"),
+    status: Optional[str] = typer.Option(None, "--status"),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+) -> None:
+    cli = _ctx(ctx)
+    params: dict[str, Any] = {**_scope_params(cli, workspace, project), "limit": limit}
+    if status:
+        params["status"] = status
+    try:
+        result = cli.client.list_claims(**params)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="claims")
+
+
+@claims_app.command("get")
+def claims_get(ctx: Context, claim_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_claim(claim_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@claims_app.command("propose")
+def claims_propose(
+    ctx: Context,
+    json_body: Optional[str] = typer.Option(None, "--json"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+) -> None:
+    cli = _ctx(ctx)
+    payload = _read_json(json_body, file)
+    try:
+        result = cli.client.propose_claim(payload)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@claims_app.command("confirm")
+def claims_confirm(ctx: Context, claim_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.confirm_claim(claim_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@claims_app.command("invalidate")
+def claims_invalidate(ctx: Context, claim_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.invalidate_claim(claim_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@claims_app.command("supersede")
+def claims_supersede(
+    ctx: Context,
+    claim_id: str,
+    json_body: Optional[str] = typer.Option(None, "--json"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+) -> None:
+    cli = _ctx(ctx)
+    payload = _read_json(json_body, file)
+    try:
+        result = cli.client.supersede_claim(claim_id, payload)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@entities_app.command("list")
+def entities_list(
+    ctx: Context,
+    limit: int = typer.Option(20, "--limit"),
+    entity_type: Optional[str] = typer.Option(None, "--entity-type"),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+) -> None:
+    cli = _ctx(ctx)
+    params: dict[str, Any] = {**_scope_params(cli, workspace, project), "limit": limit}
+    if entity_type:
+        params["entity_type"] = entity_type
+    try:
+        result = cli.client.list_entities(**params)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result, kind="entities")
+
+
+@entities_app.command("get")
+def entities_get(ctx: Context, entity_type: str, entity_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_entity(entity_type, entity_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    emit(result, output=cli.output)
+
+
+@entities_app.command("subgraph")
+def entities_subgraph(ctx: Context, entity_type: str, entity_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_entity_subgraph(entity_type, entity_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@events_app.command("log")
+def events_log(
+    ctx: Context,
+    json_body: Optional[str] = typer.Option(None, "--json"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+    idempotency_key: Optional[str] = typer.Option(None, "--idempotency-key"),
+    event_type: Optional[str] = typer.Option(None, "--event-type"),
+    summary: Optional[str] = typer.Option(None, "--summary"),
+    workspace: Optional[str] = typer.Option(None, "--workspace"),
+    project: Optional[str] = typer.Option(None, "--project"),
+    actor: Optional[str] = typer.Option(None, "--actor"),
+) -> None:
+    cli = _ctx(ctx)
+    if json_body or file:
+        payload = _read_json(json_body, file)
+    else:
+        scope = _scope_params(cli, workspace, project)
+        actor_id = actor or cli.config.actor_id
+        if not actor_id or not event_type:
+            raise typer.BadParameter("Provide --json/--file or --actor, --event-type, and scope.")
+        payload = {
+            **scope,
+            "actor_id": actor_id,
+            "event_type": event_type,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "payload": {"summary": summary or ""},
+        }
+    if idempotency_key:
+        payload["idempotency_key"] = idempotency_key
+    try:
+        result = cli.client.log_event(payload)
+    except ConflictError as exc:
+        typer.secho(f"Conflict (idempotency): {exc}", fg=typer.colors.YELLOW, err=True)
+        raise typer.Exit(code=2) from exc
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@annotations_app.command("create")
+def annotations_create(
+    ctx: Context,
+    json_body: Optional[str] = typer.Option(None, "--json"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+    idempotency_key: Optional[str] = typer.Option(None, "--idempotency-key"),
+) -> None:
+    cli = _ctx(ctx)
+    payload = _read_json(json_body, file)
+    if idempotency_key:
+        payload["idempotency_key"] = idempotency_key
+    try:
+        result = cli.client.create_annotation(payload)
+    except ConflictError as exc:
+        typer.secho(f"Conflict (idempotency): {exc}", fg=typer.colors.YELLOW, err=True)
+        raise typer.Exit(code=2) from exc
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+@app.command("observation")
+def observation_get(ctx: Context, observation_id: str) -> None:
+    cli = _ctx(ctx)
+    try:
+        result = cli.client.get_observation(observation_id)
+    except GrapheError as exc:
+        _handle_api_error(exc)
+    render(cli.output, result)
+
+
+def run() -> None:
+    try:
+        app()
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    run()

graphe_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: graphe-cli
+Version: 0.1.1
+Summary: Command-line interface for the Graphe API
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: graphe-sdk>=0.1.1
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+
+# graphe-cli
+
+Command-line interface for [Graphe](https://graphe.dev) — query shared agent memory, search project context, and ingest events.
+
+## Install
+
+```bash
+pip install graphe-cli
+```
+
+## Configuration
+
+Environment variables:
+
+| Variable | Purpose |
+|----------|---------|
+| `GRAPHE_API_BASE` | API URL (default `http://localhost:8000`) |
+| `GRAPHE_API_KEY` | API key from the Graphe console |
+| `GRAPHE_WORKSPACE_ID` | Default workspace |
+| `GRAPHE_PROJECT_ID` | Default project |
+| `GRAPHE_ACTOR_ID` | Default actor for ingestion |
+
+Optional config file: `~/.config/graphe/config.toml` or `./graphe.toml`.
+
+## Examples
+
+```bash
+graphe health
+graphe --output json state
+graphe search -q "authentication middleware"
+graphe runs list --workspace <ws> --project <proj>
+graphe runs trace <run-id>
+graphe events log --event-type agent.action --summary "Started refactor"
+graphe claims propose --file claim.json
+```
+
+Use `--output json` for machine-readable output.
+
+Claim lifecycle commands (`propose`, `confirm`, `invalidate`, `supersede`) are available in the CLI. The MCP server focuses on read tools and safe ingestion writes.
+
+## Documentation
+
+See [connecting clients](https://github.com/ShauryaVM/KG-Idea/blob/main/docs/connecting-clients.md) for cloud setup and API keys.

graphe_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+graphe_cli/__init__.py,sha256=0Ixnz9x7480EiBcs2aSMYQk3ouciCVVgr7dEXI3Oqoc,18
+graphe_cli/context.py,sha256=EgCWzwAj02TGjaSkdOz9PJDQcyf4QJqgi2TyJPpURXk,1070
+graphe_cli/display.py,sha256=9F2iCEfaIY-DaIH3-hyyZa4Gbu7igoVVVFYSgndo4Pg,5682
+graphe_cli/main.py,sha256=2n3bZuWZSBRUd-ew-faRXad_zywuR1vs9c9TR43CGN0,13972
+graphe_cli-0.1.1.dist-info/METADATA,sha256=Vy_Jv88_LXHCCsV2OHZ4aQC0lKD1rCGOZ-J-00ai940,1581
+graphe_cli-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+graphe_cli-0.1.1.dist-info/entry_points.txt,sha256=jjDg0_u_PmEomvkom_8MSL5qVDf5wtdwjH0wSP0JZcQ,47
+graphe_cli-0.1.1.dist-info/top_level.txt,sha256=SsW8o7DXmYfIAYzzb4b9mEEp-L_Jm1kRIGAfyhW5C6Y,11
+graphe_cli-0.1.1.dist-info/RECORD,,

graphe_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

graphe_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graphe = graphe_cli.main:app

graphe_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+graphe_cli