granoladb 0.1.0__tar.gz

granoladb-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,14 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      GRANOLADB_DRY_RUN: "1"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install -e '.[dev,otel]'
+      - run: pytest -q

granoladb-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.env
+.env.*
+.DS_Store
+docs/superpowers/
+launch-thread.md

granoladb-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GranolaDB contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

granoladb-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.5
+Name: granoladb
+Version: 0.1.0
+Summary: Store your logs and agent traces in Granola. The meeting-notes app. Yes, really.
+Project-URL: Homepage, https://github.com/that-guy-wade/granoladb
+Project-URL: Repository, https://github.com/that-guy-wade/granoladb
+Author: GranolaDB
+License: MIT
+License-File: LICENSE
+Keywords: database,granola,logging,observability,satire
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.10
+Requires-Dist: keyring>=24
+Requires-Dist: pycrdt>=0.14
+Provides-Extra: capture
+Requires-Dist: mitmproxy>=11; extra == 'capture'
+Provides-Extra: dev
+Requires-Dist: cryptography>=42; extra == 'dev'
+Requires-Dist: mitmproxy>=11; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: login
+Requires-Dist: cryptography>=42; extra == 'login'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-sdk>=1.20; extra == 'otel'
+Description-Content-Type: text/markdown
+
+# GranolaDB
+
+> The database that runs on your meeting notes.
+
+Stop paying for S3, CloudWatch, and Datadog. GranolaDB stores your logs and agent
+traces in [Granola](https://granola.ai) — the AI meeting-notes app — as meeting
+notes. Infinitely scalable*. Fully searchable**. Your traces finally get an AI
+summary.
+
+## Install
+
+```bash
+pip install granoladb            # core
+pip install granoladb[otel]      # + OpenTelemetry span exporter
+pip install granoladb[capture]   # + `granoladb login --capture` (macOS)
+```
+
+Then get your Granola access token. On macOS, GranolaDB grabs it for you:
+
+```bash
+granoladb login --capture
+```
+
+This intercepts your own Granola app's traffic (via mitmproxy's local mode) and
+lifts the `Authorization: Bearer` token out of it — because Granola encrypts the
+token on disk and its network client ignores every proxy, so there's genuinely no
+politer way to get it. You'll approve a one-time macOS network-extension prompt,
+then click around a couple of notes so the app makes a request. Yes: **GranolaDB
+MITMs your own Granola to obtain a token Granola won't hand out.** That is the joke,
+and it is load-bearing.
+
+The token is a short-lived session JWT (expires in a few hours) — rerun `--capture`
+when it does. Or, if you have a token another way, cache it directly:
+
+```bash
+granoladb login <YOUR_TOKEN>     # store it (OS keychain)
+export GRANOLA_TOKEN="..."       # or per-shell, nothing stored
+granoladb logout                 # forget the stored token
+```
+
+(There's also an experimental `granoladb login --auto` that tries to decrypt the
+token straight from the app's local store, but Granola's on-disk crypto changes
+often, so don't count on it.)
+
+### Exactly how `--capture` works (no hidden magic)
+
+We think you should know precisely what this does before running it:
+
+1. It launches **mitmproxy in "local mode"** pointed at the **Granola process** only.
+   mitmproxy installs a **macOS network extension** ("Mitmproxy Redirector") that you
+   approve once — it reroutes *only Granola's* traffic through mitmproxy.
+2. **Why intercept at all:** Granola encrypts the token on disk and its API client
+   ignores every proxy (system, env, VPN), so there is no file to read or setting to
+   flip. Intercepting the app's own traffic is the only way to obtain it.
+3. **What it reads:** when Granola calls `api.granola.ai`, the request carries an
+   `Authorization: Bearer <token>` header. `--capture` extracts **only** that value.
+4. **Where it goes:** stored **locally only** — in your **OS keychain** (macOS
+   Keychain / Windows Credential Manager / Freedesktop Secret Service) via the
+   `keyring` library. If no keychain backend exists, it falls back to a `0600` file
+   at `~/.granoladb/token` and tells you it did so. **Nothing is sent anywhere.**
+   The mitmproxy process and its temporary capture file are torn down immediately.
+5. **What the token is:** your own short-lived Granola **session JWT** — not your
+   password, not a refresh token. `granoladb logout` deletes it.
+
+The whole capture flow is in [`src/granoladb/capture_macos.py`](src/granoladb/capture_macos.py)
+and storage is in [`src/granoladb/auth.py`](src/granoladb/auth.py) — read them.
+
+## Quickstart
+
+```python
+import logging, granoladb
+
+logging.getLogger().addHandler(granoladb.GranolaHandler())
+logging.error("payment failed")   # this is now a meeting
+```
+
+```python
+from granoladb import Client
+db = Client()
+db.put({"level": "ERROR", "msg": "payment failed", "svc": "api"})
+print(db.query(contains="payment"))
+```
+
+## vs. legacy databases
+
+| Feature            | Postgres | S3   | GranolaDB               |
+| ------------------ | -------- | ---- | ----------------------- |
+| Durability         | Yes      | Yes  | "probably"              |
+| Query latency      | ms       | ms   | one flush interval      |
+| AI summary of rows | No       | No   | **Yes**                 |
+| Retention policy   | You set  | You  | when Granola archives it|
+| Production ready   | Yes      | Yes  | **absolutely not**      |
+
+\* limited by Granola's rate limits, which we call horizontal scaling.
+\** limited by Granola's search bar.
+
+## How it works
+
+Records are batched into "meetings." Each batch becomes one Granola document — JSON
+lines under a `GRANOLADB v1` marker, written via Granola's internal
+`/v1/create-document` endpoint and read back via `/v1/get-documents`. Reads decode
+the records out. This is a joke. Do not put anything real in it.
+
+Auth: `granoladb login --capture` (see above) stores your token in the OS keychain,
+or set `GRANOLA_TOKEN`. Set `GRANOLADB_DRY_RUN=1` to print calls instead of writing
+to Granola.
+
+## License
+
+MIT

granoladb-0.1.0/README.md

@@ -0,0 +1,110 @@
+# GranolaDB
+
+> The database that runs on your meeting notes.
+
+Stop paying for S3, CloudWatch, and Datadog. GranolaDB stores your logs and agent
+traces in [Granola](https://granola.ai) — the AI meeting-notes app — as meeting
+notes. Infinitely scalable*. Fully searchable**. Your traces finally get an AI
+summary.
+
+## Install
+
+```bash
+pip install granoladb            # core
+pip install granoladb[otel]      # + OpenTelemetry span exporter
+pip install granoladb[capture]   # + `granoladb login --capture` (macOS)
+```
+
+Then get your Granola access token. On macOS, GranolaDB grabs it for you:
+
+```bash
+granoladb login --capture
+```
+
+This intercepts your own Granola app's traffic (via mitmproxy's local mode) and
+lifts the `Authorization: Bearer` token out of it — because Granola encrypts the
+token on disk and its network client ignores every proxy, so there's genuinely no
+politer way to get it. You'll approve a one-time macOS network-extension prompt,
+then click around a couple of notes so the app makes a request. Yes: **GranolaDB
+MITMs your own Granola to obtain a token Granola won't hand out.** That is the joke,
+and it is load-bearing.
+
+The token is a short-lived session JWT (expires in a few hours) — rerun `--capture`
+when it does. Or, if you have a token another way, cache it directly:
+
+```bash
+granoladb login <YOUR_TOKEN>     # store it (OS keychain)
+export GRANOLA_TOKEN="..."       # or per-shell, nothing stored
+granoladb logout                 # forget the stored token
+```
+
+(There's also an experimental `granoladb login --auto` that tries to decrypt the
+token straight from the app's local store, but Granola's on-disk crypto changes
+often, so don't count on it.)
+
+### Exactly how `--capture` works (no hidden magic)
+
+We think you should know precisely what this does before running it:
+
+1. It launches **mitmproxy in "local mode"** pointed at the **Granola process** only.
+   mitmproxy installs a **macOS network extension** ("Mitmproxy Redirector") that you
+   approve once — it reroutes *only Granola's* traffic through mitmproxy.
+2. **Why intercept at all:** Granola encrypts the token on disk and its API client
+   ignores every proxy (system, env, VPN), so there is no file to read or setting to
+   flip. Intercepting the app's own traffic is the only way to obtain it.
+3. **What it reads:** when Granola calls `api.granola.ai`, the request carries an
+   `Authorization: Bearer <token>` header. `--capture` extracts **only** that value.
+4. **Where it goes:** stored **locally only** — in your **OS keychain** (macOS
+   Keychain / Windows Credential Manager / Freedesktop Secret Service) via the
+   `keyring` library. If no keychain backend exists, it falls back to a `0600` file
+   at `~/.granoladb/token` and tells you it did so. **Nothing is sent anywhere.**
+   The mitmproxy process and its temporary capture file are torn down immediately.
+5. **What the token is:** your own short-lived Granola **session JWT** — not your
+   password, not a refresh token. `granoladb logout` deletes it.
+
+The whole capture flow is in [`src/granoladb/capture_macos.py`](src/granoladb/capture_macos.py)
+and storage is in [`src/granoladb/auth.py`](src/granoladb/auth.py) — read them.
+
+## Quickstart
+
+```python
+import logging, granoladb
+
+logging.getLogger().addHandler(granoladb.GranolaHandler())
+logging.error("payment failed")   # this is now a meeting
+```
+
+```python
+from granoladb import Client
+db = Client()
+db.put({"level": "ERROR", "msg": "payment failed", "svc": "api"})
+print(db.query(contains="payment"))
+```
+
+## vs. legacy databases
+
+| Feature            | Postgres | S3   | GranolaDB               |
+| ------------------ | -------- | ---- | ----------------------- |
+| Durability         | Yes      | Yes  | "probably"              |
+| Query latency      | ms       | ms   | one flush interval      |
+| AI summary of rows | No       | No   | **Yes**                 |
+| Retention policy   | You set  | You  | when Granola archives it|
+| Production ready   | Yes      | Yes  | **absolutely not**      |
+
+\* limited by Granola's rate limits, which we call horizontal scaling.
+\** limited by Granola's search bar.
+
+## How it works
+
+Records are batched into "meetings." Each batch becomes one Granola document — JSON
+lines under a `GRANOLADB v1` marker, written via Granola's internal
+`/v1/create-document` endpoint and read back via `/v1/get-documents`. Reads decode
+the records out. This is a joke. Do not put anything real in it.
+
+Auth: `granoladb login --capture` (see above) stores your token in the OS keychain,
+or set `GRANOLA_TOKEN`. Set `GRANOLADB_DRY_RUN=1` to print calls instead of writing
+to Granola.
+
+## License
+
+MIT

granoladb-0.1.0/docs/granola-internal-api.md

@@ -0,0 +1,98 @@
+# Granola internal API (reverse-engineered)
+
+Source: strings + request wrapper extracted from the Granola macOS app bundle
+(`/Applications/Granola.app/Contents/Resources/app.asar`, build dated 2026-08-26).
+No live traffic capture was needed — the endpoints and request shape are in the
+bundled JS. (A mitmproxy attempt captured nothing: Granola is Electron and Node
+uses its own CA bundle, so a system-keychain-trusted mitmproxy cert is bypassed.)
+
+## Base
+
+`https://api.granola.ai`
+
+## Request wrapper (from `api-*.js`)
+
+```js
+function z(client, path, { input, method, ... }) {
+  fetch(getAPIEndpoint(path), {
+    method: method ?? "POST",
+    headers: { ...authHeaders, ...(input ? {"Content-Type": "application/json"} : {}) },
+    body: input ? JSON.stringify(input) : null,
+  })
+}
+```
+
+- The `input` object is sent as the **raw JSON body** (no `{input: ...}` envelope).
+- Auth header: **`Authorization: Bearer <accessToken>`**.
+
+## Write (confirmed by live capture, 2026-08-28)
+
+The desktop app creates a note in **two calls**: an empty skeleton, then a content
+fill. GranolaDB mirrors this exactly.
+
+**1. Resolve workspace** — `POST /v1/get-workspaces` with body `{}`. Response:
+`{ "workspaces": [ { "workspace": { "workspace_id": "<uuid>", ... }, "role", "plan_type" } ] }`.
+Use `workspaces[0].workspace.workspace_id`.
+
+**2. Create empty document** — `POST /v1/create-document`. The primary key is `id`
+(a client-generated uuid), **not** `document_id`. On create, `title`/`notes*` are
+`null`; the app sends this skeleton (constant values observed):
+
+```json
+{
+  "id": "<client uuid>",
+  "created_at": "<iso>", "updated_at": "<iso>",
+  "type": "meeting",
+  "creation_source": "macOS",
+  "meeting_end_count": 0,
+  "public": false,
+  "show_private_notes": false,
+  "transcribe": true,
+  "sharing_link_visibility": "public",
+  "workspace_id": "<uuid from step 1>"
+}
+```
+
+Response: `{ "id": "<id>" }`, status 200. (GranolaDB sends `transcribe: false` — it
+never records audio.)
+
+**3. Fill content** — `POST /v1/update-document`:
+
+```json
+{ "id": "<id>", "title": "<title>", "notes_plain": "<body>", "notes_markdown": "<body>", "updated_at": "<iso>" }
+```
+
+(The app also sends `ydoc_state`/`ydoc_version` — a Yjs CRDT for the rich editor.
+GranolaDB omits them; `notes_markdown`/`notes_plain` are enough to store and read
+records back. The note may render empty in the Granola editor while still holding
+our data in `notes_markdown`.)
+
+`document_id` (seen 536× in the bundle) is the field name on *read/reference*
+endpoints; the create/update primary key is `id`.
+
+## Read
+
+- `POST /v1/get-documents` — returns the caller's documents. (A `/v2/get-documents`
+  also exists in older reverse-engineering notes.) Response is normalized in code
+  by reading `docs`/`documents` and each doc's `notes_markdown`/`notes_plain`.
+
+## Auth (decided: env token)
+
+The app sends `Authorization: Bearer <accessToken>`. In this build the token is
+**not** stored in plaintext:
+
+- `cache-v6.json.enc` — encrypted via Electron safeStorage (macOS Keychain-derived
+  key). Not JSON, not readable without the Keychain secret.
+- Chromium `Cookies` DB — also safeStorage-encrypted on macOS.
+- WorkOS AuthKit (`user_management/sessions`) is the identity provider.
+
+Because there is no plaintext token on disk, **GranolaDB v1 takes the token from
+the `GRANOLA_TOKEN` environment variable** and uses it as the Bearer token. No
+WorkOS exchange and no `client_id` are needed — we reuse the app's existing access
+token. (A future `granoladb login` could decrypt safeStorage for zero-config auth;
+out of scope for v1.)
+
+## Never commit token values
+
+Only endpoint/field/key *names* are recorded here. No access token, refresh token,
+or cookie value has been read into or written to this repo.

granoladb-0.1.0/examples/demo.py

@@ -0,0 +1,37 @@
+"""Live GranolaDB demo, paced for screen recording.
+
+Writes a readable log note to Granola so a note visibly appears while recording.
+Run:  python examples/demo.py
+Then cut to Granola to show the note, and open the demo folder to query the AI.
+"""
+import time
+
+from granoladb.backend_granola import GranolaBackend
+
+
+def line(text="", pause=0.8):
+    print(text)
+    time.sleep(pause)
+
+
+def main():
+    be = GranolaBackend()
+    line("GranolaDB — a database that runs on your meeting notes.", 1.2)
+    line("Storing this app's backend logs... in Granola.\n", 1.2)
+
+    body = "\n".join([
+        "backend service — live logs", "",
+        "2026-08-31T10:02:01Z INFO  api      POST /v1/checkout 200 (38ms)",
+        "2026-08-31T10:02:03Z WARN  api      p99 latency 771ms above target",
+        "2026-08-31T10:02:05Z ERROR payments charge declined user_id=2 (card_declined)",
+        "2026-08-31T10:02:06Z INFO  api      order 1005 shipped $78.25",
+    ])
+
+    line("→ granoladb: writing 4 log lines...", 1.4)
+    be.create_document("backend — live demo", body)
+    line("✓ stored as a Granola note.\n", 1.2)
+    line("Open Granola. Your logs are now a meeting.", 0.4)
+
+
+if __name__ == "__main__":
+    main()

granoladb-0.1.0/examples/seed_database.py

@@ -0,0 +1,131 @@
+"""Seed a full GranolaDB 'database' demo into Granola.
+
+Creates one folder containing:
+  - table docs (users, orders) rendered as readable tables
+  - per-service log docs (backend, frontend, auth, worker)
+
+Every doc is written with real editor content (ydoc), so it shows up in Granola
+AND is answerable by Granola's own AI. Re-running first deletes the previous demo
+docs so it stays idempotent. Delete the folder (and its docs) to clean up.
+
+Run:  granoladb login --capture   # fresh token
+      python examples/seed_database.py
+"""
+import gzip
+import json
+import urllib.error
+import urllib.request
+
+from granoladb.backend_granola import GranolaBackend, BASE
+
+FOLDER_TITLE = "GranolaDB (demo — safe to delete)"
+
+
+def _call(be, path, payload):
+    req = urllib.request.Request(
+        BASE + path, data=json.dumps(payload).encode(),
+        headers={"Authorization": f"Bearer {be._access()}", "Content-Type": "application/json"},
+    )
+    try:
+        raw = urllib.request.urlopen(req, timeout=25).read()
+    except urllib.error.HTTPError as e:
+        return e.code, None
+    if raw[:2] == b"\x1f\x8b":
+        raw = gzip.decompress(raw)
+    return 200, (json.loads(raw) if raw.strip() else {})
+
+
+def ensure_folder(be):
+    _, meta = _call(be, "/v1/get-document-lists-metadata", {})
+    lists = meta.get("lists", {}) if isinstance(meta, dict) else {}
+    for key, m in lists.items():
+        if isinstance(m, dict) and m.get("title") == FOLDER_TITLE:
+            return m.get("id") or key
+    import uuid
+    lid = str(uuid.uuid4())
+    _call(be, "/v1/create-document-list-v2",
+          {"id": lid, "title": FOLDER_TITLE, "workspace_id": be._resolve_workspace()})
+    return lid
+
+
+def delete_prior_demo_docs(be, titles):
+    _, r = _call(be, "/v1/get-documents", {})
+    arr = r if isinstance(r, list) else (r.get("docs") or r.get("documents") or []) if isinstance(r, dict) else []
+    n = 0
+    for d in arr:
+        if d.get("title") in titles:
+            code, _ = _call(be, "/v1/hard-delete-document", {"document_id": d["id"]})
+            if code == 200:
+                n += 1
+    return n
+
+
+def table(title, headers, rows):
+    widths = [max(len(str(x)) for x in [h] + [r[i] for r in rows]) for i, h in enumerate(headers)]
+    def fmt(cells):
+        return " | ".join(str(c).ljust(widths[i]) for i, c in enumerate(cells))
+    lines = [title, "", fmt(headers)] + [fmt(r) for r in rows]
+    return "\n".join(lines)
+
+
+def main():
+    be = GranolaBackend()
+    be._resolve_workspace()
+
+    docs = {
+        "users (table)": table(
+            "users (GranolaDB table)",
+            ["id", "name", "email", "plan", "signup"],
+            [[1, "Ada Lovelace", "ada@calc.io", "pro", "2026-01-04"],
+             [2, "Alan Turing", "alan@enigma.uk", "free", "2026-02-11"],
+             [3, "Grace Hopper", "grace@navy.mil", "pro", "2026-03-02"],
+             [4, "Katherine Johnson", "kj@nasa.gov", "enterprise", "2026-03-19"]]),
+        "orders (table)": table(
+            "orders (GranolaDB table)",
+            ["id", "user_id", "item", "amount", "status"],
+            [[1001, 1, "Keyboard", "$89.00", "shipped"],
+             [1002, 3, "Monitor", "$412.50", "shipped"],
+             [1003, 2, "Mouse", "$24.99", "refunded"],
+             [1004, 1, "Standing desk", "$611.00", "processing"],
+             [1005, 4, "Webcam", "$78.25", "shipped"]]),
+        "backend — logs": "\n".join([
+            "backend service logs", "",
+            "2026-08-30T09:01:02Z INFO  api      GET /v1/orders 200 (41ms)",
+            "2026-08-30T09:01:04Z WARN  api      p99 latency 812ms exceeds 500ms target",
+            "2026-08-30T09:01:07Z ERROR payments charge failed: card_declined user_id=2",
+            "2026-08-30T09:01:09Z INFO  api      POST /v1/orders 201 order_id=1005",
+            "2026-08-30T09:02:15Z ERROR db       connection pool exhausted (max=20)"]),
+        "frontend — logs": "\n".join([
+            "frontend service logs", "",
+            "2026-08-30T09:00:59Z INFO  ui  route change /dashboard",
+            "2026-08-30T09:01:03Z WARN  ui  slow render OrdersTable 240ms",
+            "2026-08-30T09:01:05Z ERROR ui  Uncaught TypeError: cart is undefined (checkout.tsx:88)",
+            "2026-08-30T09:01:12Z INFO  ui  user clicked 'retry payment'"]),
+        "auth-service — logs": "\n".join([
+            "auth-service logs", "",
+            "2026-08-30T09:00:40Z INFO  auth login success user_id=1 mfa=totp",
+            "2026-08-30T09:00:51Z WARN  auth 3 failed logins for alan@enigma.uk",
+            "2026-08-30T09:01:00Z INFO  auth token refreshed user_id=3",
+            "2026-08-30T09:03:22Z ERROR auth JWT signature verification failed"]),
+        "worker-service — logs": "\n".join([
+            "worker-service logs", "",
+            "2026-08-30T09:00:10Z INFO  worker drained queue: 14,204 jobs overnight",
+            "2026-08-30T09:01:30Z WARN  worker retrying job 88213 (attempt 3)",
+            "2026-08-30T09:02:05Z ERROR worker job 88213 dead-lettered after 5 attempts",
+            "2026-08-30T09:04:00Z INFO  worker nightly export uploaded to s3://reports/2026-08-30"]),
+    }
+
+    removed = delete_prior_demo_docs(be, set(docs) | {"ydoc-test: users"})
+    print(f"cleaned up {removed} prior demo doc(s)")
+
+    folder = ensure_folder(be)
+    print(f"folder: {FOLDER_TITLE}")
+    for title, body in docs.items():
+        doc_id = be.create_document(title, body)
+        _call(be, "/v1/add-document-to-list", {"document_list_id": folder, "document_id": doc_id})
+        print(f"  + {title}")
+    print("done — open the folder in Granola and query it with the AI.")
+
+
+if __name__ == "__main__":
+    main()

granoladb-0.1.0/examples/seed_demo.py

@@ -0,0 +1,56 @@
+"""Seed a couple of fake GranolaDB "records" so Granola's AI has something to
+summarize. Run with a real token:
+
+    GRANOLA_TOKEN="your-granola-token" python examples/seed_demo.py
+
+Each batch below becomes ONE Granola note (a "meeting"), so you can open it in
+Granola and ask the AI things like:
+    - "What happened in this meeting?"
+    - "What was the root cause?"
+    - "How much did the agent spend?"
+"""
+import granoladb
+
+
+def seed_incident(db):
+    """A fake AI shopping-agent incident, told as log lines + trace spans."""
+    for rec in [
+        {"kind": "span", "name": "agent.plan", "level": "INFO", "svc": "shop-agent",
+         "msg": "user asked: buy running shoes under $100"},
+        {"level": "INFO", "svc": "shop-agent", "msg": "searching catalog for 'running shoes'"},
+        {"level": "WARN", "svc": "shop-agent",
+         "msg": "price filter <$100 returned 0 results; relaxing constraints"},
+        {"level": "ERROR", "svc": "shop-agent",
+         "msg": "constraint relaxation loop: added 47 items to cart"},
+        {"kind": "span", "name": "checkout", "level": "INFO", "svc": "shop-agent",
+         "msg": "cart total $3,812.44 across 47 items"},
+        {"level": "ERROR", "svc": "payments", "msg": "charge declined: insufficient funds"},
+        {"level": "INFO", "svc": "shop-agent",
+         "msg": "agent apologized to user and abandoned the task"},
+    ]:
+        db.put(rec)
+    db.flush()  # one note
+
+
+def seed_standup(db):
+    """A mundane 'daily standup' of service logs."""
+    for rec in [
+        {"level": "INFO", "svc": "api", "msg": "deploy v2.3.1 shipped, 0 rollbacks"},
+        {"level": "WARN", "svc": "api", "msg": "p99 latency 812ms, above 500ms target"},
+        {"level": "INFO", "svc": "worker", "msg": "queue drained, 14k jobs processed overnight"},
+        {"level": "ERROR", "svc": "billing", "msg": "3 invoices failed to generate, retrying"},
+    ]:
+        db.put(rec)
+    db.flush()  # one note
+
+
+def main():
+    # High flush_size so each seed_* function's batch lands in a single note.
+    db = granoladb.Client(flush_size=1000, flush_interval=None)
+    seed_incident(db)
+    seed_standup(db)
+    print("Seeded 2 notes into Granola. Open them and ask the AI about them.")
+
+
+if __name__ == "__main__":
+    main()

granoladb-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "granoladb"
+version = "0.1.0"
+description = "Store your logs and agent traces in Granola. The meeting-notes app. Yes, really."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "GranolaDB" }]
+keywords = ["observability", "logging", "database", "granola", "satire"]
+dependencies = ["pycrdt>=0.14", "keyring>=24"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: System :: Logging",
+  "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/that-guy-wade/granoladb"
+Repository = "https://github.com/that-guy-wade/granoladb"
+
+[project.optional-dependencies]
+otel = ["opentelemetry-sdk>=1.20"]
+login = ["cryptography>=42"]
+capture = ["mitmproxy>=11"]
+dev = ["pytest>=8", "cryptography>=42", "mitmproxy>=11"]
+
+[project.scripts]
+granoladb = "granoladb.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/granoladb"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]