databricks-agentbricks 0.2.0__py3-none-any.whl

databricks_agentbricks/render.py

@@ -0,0 +1,349 @@
+"""Terminal presentation layer for the Agent Bricks CLI.
+
+Rendering is centralized so every `list`/`get`/`create` command looks consistent.
+Functions accept an optional `console` for testability; default is stdout.
+"""
+
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from typing import Any, Iterable, Iterator, Literal, Optional, Sequence
+
+import click
+from rich import box
+from rich.console import Console, Group, RenderableType
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from databricks_agentbricks import theme
+
+# Semantic styles from the facelift palette (see `theme.py`). Color carries meaning, never
+# decoration: LINK (blue) for URLs, COMMAND (cyan) for the actionable next step, SUCCESS (green)
+# for the ✔ and success boxes, and the mid-tone greys for descriptions/metadata. There is no
+# decorative brand accent — the design reserves every color for a signal. These are raw hex/style
+# strings, not themed names, so they render on any `Console` a caller passes in — not just the
+# module's own themed stdout.
+SECONDARY = theme.SECONDARY  # descriptions, section labels
+DIM = theme.DIM  # metadata: timestamps, key labels, breadcrumbs
+FAINT = theme.FAINT  # tree branches, placeholders
+SUCCESS = theme.GREEN
+LINK = theme.BLUE
+COMMAND = theme.CYAN
+WARNING = theme.AMBER
+ERROR = theme.RED
+
+# Severity-keyword styles for `diagnostic`: error=red, warning=amber, note=blue.
+_SEVERITY_STYLE = {
+    "error": f"bold {theme.RED}",
+    "warning": f"bold {theme.AMBER}",
+    "note": f"bold {theme.BLUE}",
+}
+
+_stdout = Console(theme=theme.AGENTBRICKS_THEME)
+
+
+def console() -> Console:
+    return _stdout
+
+
+@contextmanager
+def status(message: str, con: Optional[Console] = None) -> Iterator[None]:
+    """Show an animated spinner with ``message`` while a slow call runs, then clear it.
+
+    Wraps ``rich``'s console status; a no-op spinner (no TTY) still runs the body. Use around
+    network work like store provisioning so the CLI doesn't look hung. Under ``-o json`` the spinner
+    is skipped so no control characters leak into machine-readable output.
+    """
+    from databricks_agentbricks import errors  # local import avoids a cycle at module load
+
+    con = con or _stdout
+    if errors._OUTPUT_MODE == "json":
+        yield
+        return
+    with con.status(message, spinner="dots"):
+        yield
+
+
+@contextmanager
+def progress(message: str, con: Optional[Console] = None) -> Iterator[None]:
+    """Like ``status``, but first prints a persistent line so feedback survives the spinner.
+
+    ``status`` clears itself on exit and only animates on a TTY, so a long, silent wait (e.g. waiting
+    for app compute) can look like a hang in terminals where the spinner doesn't render. This prints
+    a durable "• message" line up front, then runs a bare spinner (no repeated text) beneath it.
+    Skipped under ``-o json`` so machine output stays clean.
+    """
+    from databricks_agentbricks import errors  # local import avoids a cycle at module load
+
+    con = con or _stdout
+    if errors._OUTPUT_MODE == "json":
+        yield
+        return
+    con.print(f"[{DIM}]•[/] {message}")
+    # Empty status text: the persistent line above already carries the message, so the spinner
+    # underneath is just the animated glyph — no duplicated sentence.
+    with con.status("", spinner="dots"):
+        yield
+
+
+# --- small helpers -----------------------------------------------------------
+
+
+def field(obj: dict, name: str) -> Any:
+    """Read a field tolerating snake_case or camelCase JSON keys."""
+    if name in obj:
+        return obj[name]
+    parts = name.split("_")
+    camel = parts[0] + "".join(p.title() for p in parts[1:])
+    return obj.get(camel)
+
+
+def emit_json(data: Any) -> None:
+    """Print raw JSON for `--output json` (stable, pipe-friendly)."""
+    click.echo(json.dumps(data, indent=2, default=str))
+
+
+def confirm_destroy(target: str, *, assume_yes: bool) -> None:
+    """Guard a destructive action with a confirmation prompt.
+
+    No-op when `assume_yes` is set (the `--yes/-y` flag, for scripts). Otherwise prompts
+    on the terminal and aborts unless the user answers yes. A non-interactive stdin (a
+    pipe with no `--yes`) answers no and aborts, which is the safe default.
+    """
+    if assume_yes:
+        return
+    if not click.confirm(f"Delete {target}? This cannot be undone.", default=False):
+        raise click.Abort()
+
+
+def status_pill(status: Optional[str]) -> Text:
+    """Create a colored ●/○ status indicator, using the palette's semantic colors."""
+    value = (status or "").strip().upper()
+    if value in {"ACTIVE", "RUNNING", "READY"}:
+        return Text("● ", style=SUCCESS) + Text(value.title(), style=SUCCESS)
+    if value in {"PENDING", "CREATING", "STARTING", "DEPLOYING"}:
+        return Text("○ ", style=WARNING) + Text(value.title(), style=WARNING)
+    if value in {"DISABLED", "DELETED", "STOPPED", "ERROR", "FAILED"}:
+        return Text("⨯ ", style=ERROR) + Text(value.title(), style=ERROR)
+    return Text("● ", style=DIM) + Text(value.title() or "Unknown", style=DIM)
+
+
+def warning(message: str, con: Optional[Console] = None) -> None:
+    """Print a yellow ⚠ warning line (non-fatal; the command keeps running)."""
+    (con or _stdout).print(Text("⚠ ", style="yellow") + Text(message, style="yellow"))
+
+
+def hyperlink(text: str, url: Optional[str]) -> Text:
+    """A terminal hyperlink (OSC 8): renders `text`, opens `url` on click; plain text if no url.
+
+    Blue + underline, because the palette reserves blue for links/URLs. Supported terminals show
+    `text` as clickable so the full URL needn't fit on screen; others fall back to the plain text.
+    Use `-o json` for the raw URL where a terminal lacks OSC 8.
+    """
+    if not url:
+        return Text(text)
+    return Text(text, style=f"{LINK} underline link {url}")
+
+
+def diagnostic(
+    severity: Literal["error", "warning", "note"],
+    message: str,
+    *,
+    code: Optional[str] = None,
+    help: Optional[str] = None,
+    con: Optional[Console] = None,
+) -> None:
+    """Render one cargo/uv-style diagnostic.
+
+    A color-coded severity keyword, a plain-language message, and an optional indented ``help:``
+    line carrying the fix::
+
+        warning: active virtualenv ignored — `VIRTUAL_ENV` doesn't match `.venv`
+          help: pass --active to target the active environment
+
+    ``code`` renders cargo's ``error[CODE]:`` form (errors only). The severity keyword is colored
+    (error=red, warning=amber, note=blue); the message and fix use the default foreground so they
+    stay readable on any terminal background.
+    """
+    con = con or _stdout
+    keyword = f"{severity}[{code}]" if code and severity == "error" else severity
+    # `Text.assemble` styles each span independently; `Text(a, style=s) + Text(b)` would instead make
+    # `s` the whole line's container style, coloring the message/fix too (and dimming the fix so far
+    # it's hard to read). Only the severity keyword and the `help:` label carry weight/color; the
+    # message and the fix stay at the terminal's default foreground so they're fully legible.
+    con.print(Text.assemble((keyword, _SEVERITY_STYLE[severity]), (f": {message}", "")))
+    if help:
+        con.print(Text.assemble(("  help:", "bold"), (f" {help}", "")))
+
+
+# --- list view ---------------------------------------------------------------
+
+
+def resource_table(
+    title: str,
+    columns: Sequence[tuple[str, Literal["default", "left", "center", "right", "full"]]],
+    rows: Iterable[Sequence[Any]],
+    *,
+    subtitle: Optional[str] = None,
+    con: Optional[Console] = None,
+    no_wrap: Optional[Sequence[int]] = None,
+) -> None:
+    """Render a titled list table.
+
+    `columns` is a sequence of (header, justify) where justify is left/right/center.
+    `no_wrap` column indexes are kept full-width; the rest narrow to fit the terminal.
+    """
+    con = con or _stdout
+    rows = list(rows)
+    no_wrap_cols = set(no_wrap or ())
+
+    con.print()
+    con.print(Text(title, style="bold"))
+    if subtitle:
+        con.print(Text(subtitle, style=SECONDARY))
+
+    # Dim, uppercase headers; columns size to content so they always line up.
+    table = Table(box=box.SIMPLE_HEAD, expand=False, pad_edge=False, show_edge=False)
+    for i, (header, justify) in enumerate(columns):
+        # Reserve a no_wrap column's full content width so Rich narrows the others instead.
+        min_width = (
+            max([len(header)] + [_cell_len(row[i]) for row in rows], default=0)
+            if i in no_wrap_cols
+            else None
+        )
+        table.add_column(
+            header.upper(),
+            justify=justify,
+            header_style=f"bold {DIM}",
+            no_wrap=i in no_wrap_cols,
+            min_width=min_width,
+        )
+    for row in rows:
+        table.add_row(*[_cell(v) for v in row])
+    con.print(table)
+
+    con.print(Text(f"{len(rows)} item{'s' if len(rows) != 1 else ''}", style=DIM))
+
+
+def _cell_len(value: Any) -> int:
+    if value is None:
+        return 1  # em-dash placeholder
+    return len(value.plain if isinstance(value, Text) else str(value))
+
+
+def _cell(value: Any) -> Any:
+    if isinstance(value, Text):
+        return value
+    if value is None:
+        return Text("—", style=DIM)
+    return str(value)
+
+
+# --- detail view (aig-endpoint.png) ------------------------------------------
+
+
+def detail(
+    breadcrumb: str,
+    name: str,
+    fields: dict[str, Any],
+    *,
+    status: Optional[str] = None,
+    snippets: Optional[Sequence[tuple[str, str, str]]] = None,
+    con: Optional[Console] = None,
+) -> None:
+    """Render a resource detail page.
+
+    `breadcrumb` is the section label ("Agent Memory"); `fields` is an ordered
+    key -> value map for the details rail. `snippets` is a sequence of
+    (label, lexer, code) blocks shown under a "Starter code" panel.
+    """
+    con = con or _stdout
+
+    con.print()
+    con.print(Text(f"{breadcrumb}  ›  ", style=DIM) + Text(name, style="bold"))
+    if status is not None:
+        con.print(status_pill(status))
+    con.print()
+
+    grid = Table.grid(padding=(0, 3))
+    grid.add_column(style=DIM, justify="left")
+    grid.add_column(justify="left")
+    for key, value in fields.items():
+        grid.add_row(key, _cell(value))
+    con.print(grid)
+
+    if snippets:
+        con.print()
+        con.print(
+            Panel(
+                _snippet_group(snippets),
+                title="Starter code",
+                title_align="left",
+                border_style=DIM,
+                box=box.ROUNDED,
+            )
+        )
+
+
+def _snippet_group(snippets: Sequence[tuple[str, str, str]]) -> RenderableType:
+    parts: list[RenderableType] = []
+    for i, (label, lexer, code) in enumerate(snippets):
+        if i:
+            parts.append(Text())
+        parts.append(Text(label, style=f"bold {DIM}"))
+        parts.append(Syntax(code.strip(), lexer, background_color="default", word_wrap=True))
+    return Group(*parts)
+
+
+# --- success / next steps (the "Set up" cards) -------------------------------
+
+
+def success(
+    title: str,
+    *,
+    fields: Optional[dict[str, Any]] = None,
+    next_steps: "Optional[Sequence[str | tuple[str, str]]]" = None,
+    con: Optional[Console] = None,
+) -> None:
+    """A green success panel with optional details and a Next step(s) list.
+
+    Each next step is either a ``(command, description)`` pair — the command is shown in cyan (the
+    actionable accent) with the description in secondary — or a bare string for a non-command
+    instruction (e.g. ``"Open http://localhost:8000"``), rendered as prose. Commands are
+    **copy-safe**: no ``$`` prompt prefix, so they paste straight into a shell. The heading is
+    "Next step" or "Next steps", chosen automatically from the count.
+    """
+    con = con or _stdout
+    body: list[RenderableType] = [Text("✔ ", style=SUCCESS) + Text(title, style="bold")]
+
+    if fields:
+        grid = Table.grid(padding=(0, 3))
+        grid.add_column(style=DIM)
+        grid.add_column()
+        for key, value in fields.items():
+            grid.add_row(key, _cell(value))
+        body.append(grid)
+
+    if next_steps:
+        # Singular vs plural from the count, per the design.
+        heading = "Next step" if len(next_steps) == 1 else "Next steps"
+        body.append(Text(heading, style=SECONDARY))
+        # A two-column grid aligns every command's description at the same offset.
+        steps = Table.grid(padding=(0, 2))
+        steps.add_column()
+        steps.add_column(style=SECONDARY)
+        for step in next_steps:
+            if isinstance(step, tuple):
+                # The actionable command is cyan; its description trails in secondary.
+                command, description = step
+                steps.add_row(Text(command, style=COMMAND), description)
+            else:
+                # Prose (e.g. "Open <url>") renders plainly — no command accent, no prompt marker.
+                steps.add_row(Text(step), "")
+        body.append(steps)
+
+    con.print()
+    con.print(Panel(Group(*body), border_style=SUCCESS, box=box.ROUNDED))

databricks_agentbricks/templates/agent-bricks-migrate/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: agent-bricks-migrate
+description: Adapt an existing LangGraph or OpenAI Agents SDK agent project to use Agent Bricks CLI (`ab`) development, tools, managed state, tracing, recovery, and deployment commands. Use with the migration bundle generated by `ab init --existing`.
+---
+
+# Migrate an existing LangGraph or OpenAI Agents SDK agent to the managed runtime
+
+Integrate the managed runtime so Agent Bricks CLI commands work through the same integration points
+as the bundled template for the project's framework. Preserve the existing agent and application
+contracts. Configuration alone does not complete migration.
+
+## Inspect the project and reference
+
+Read `references/migration.json` for the server, bundled template version, chat-app choice, and
+optional profile. It names the `framework` the reference was generated for; the migration follows
+that framework's runtime semantics. `references/template/` is a candidate project generated
+from the templates shipped with the installed CLI. Use it as migration evidence, not an importable
+application dependency.
+
+Read [the shared runtime contract](references/template/AGENTKIT_CONTRACT.md). It is written for the
+named framework — LangGraph or OpenAI Agents — and its runtime requirements apply as written.
+Then inspect adjacent template code for the integration points being adapted. If the chat app is
+enabled, also read `references/template/CHAT_APP.md` and inspect `runtime/ui.py`. The contract owns
+runtime requirements; this skill owns migration decisions.
+
+Locate agent construction, state and history handling, model/tool wiring, persistence, invocation
+config, interrupt/resume handling, HTTP serving, authentication, and tests. Identify
+package/import conflicts with the reference. Explain the concrete changes, then implement them.
+Preserve the agent's model, prompts, structure, tools, routing, and approval policy unless a
+change is required and accepted.
+
+## Explicitly handle existing state and contracts
+
+State and durability semantics differ by framework; handle the ones that apply:
+
+- **LangGraph:** checkpointer, thread IDs, checkpoint namespaces, graph state, reducers,
+  subgraphs, and pending interrupts. Runtime recovery may resume a checkpoint belonging to the
+  current invocation; otherwise original input replays.
+- **OpenAI Agents SDK:** the `Session` transcript is the persistent conversation state. There is
+  no checkpoint continuation; recovery replays the persisted application input against the same
+  session. HITL `RunState` is process-local and does not survive worker loss even with a Session
+  Store bound.
+
+- **Persistence and history:** Identify the current checkpointer or session store, memory store,
+  thread/session IDs, actor/tenant mapping, and pending interrupts or approvals. Switching stores
+  does not migrate checkpoints, transcripts, or memories. Preserve access to existing history
+  until the transition is decided. Do not silently reset state, delete storage, or claim old
+  conversations were migrated. Surface choices about copying history, starting new threads or
+  sessions, or retiring storage.
+- **Custom state and outputs:** Preserve fields, reducers and subgraphs where the framework has
+  them, structured inputs/outputs, streaming events, and interrupts or approval flows. The
+  reference assumes message-oriented events and is not a generic serializer. Implement explicit
+  mappings without discarding custom results to fit the reference UI.
+- **Identity and sessions:** Preserve authentication, actor/tenant isolation, and session/thread
+  identity. The reference separates invocation UUIDs, application session IDs, and the routing
+  cookie. Map existing IDs explicitly, including reopening sessions. Derive actor identity from
+  the trusted application context; do not blindly trust a caller field or adopt a shared
+  fallback. If the existing server used a different request/response shape (e.g. a
+  `{conversation_id, message}` body), map it explicitly in `runtime/adapter.py` to the runtime's
+  `input.session_id` / `input.messages`, and preserve response fields clients depend on.
+- **Recovery and durability:** Distinguish Runtime Store invocation recovery from Session Store
+  persistence. Address at-least-once side effects and retain stronger existing guarantees. Do not
+  silently enable replay of non-idempotent tools.
+
+## Implement the shared contract
+
+Implement the command requirements in `references/template/AGENTKIT_CONTRACT.md`, using the template
+as an example. Merge candidate `agent.toml`, the existing `.agentbricks/project.toml` marker, dependencies, and startup config
+without overwriting existing choices. `ab init --existing` writes these manifests only inside
+`references/template/`, not into the project, so copy or merge them to the project root; default
+store names come from the reference's generated `agent.toml`. Candidate stores are migration
+intent, not authorization to provision resources or switch live state. Use `uv` and the bundled
+template's current `databricks-agentbricks` dependency. Migration may raise the project's minimum Python version:
+the templates require `>=3.11` (the runtime uses 3.11+ features such as `asyncio.timeout`). Check
+and bump `requires-python` and CI accordingly.
+
+Keep framework-native execution independent of runtime request/context types. Adapt package
+conflicts and preserve tool execution and approval logic. Merge run configuration without losing
+callbacks, run limits, configurable fields, or session/checkpoint settings. Preserve existing
+tracing when composing Agent Bricks CLI tracing.
+
+Reuse the HTTP server where feasible. Follow the contract's distinction between basic CLI launch
+requirements, managed `DurableAgentServer` hooks, and optional chat UI mappings. Adapt the UI only when
+selected. Do not copy sample tools, models, prompts, or business logic into the application.
+Model provider is a migration decision: keep the existing one or adopt the gateway; the
+reference example is not mandatory.
+
+## Verify and hand off
+
+Run existing tests and relevant lint/type checks. Add focused offline regression tests for custom
+inputs/outputs, streaming, remote and local tool wiring, store selection, actor/session isolation,
+interrupt/resume and approval flows, and invocation recovery where used. Use fakes for remote
+services. Confirm the configured entrypoint starts with the project's test setup.
+
+Do not provision, deploy, make live model/tool calls, or run integration tests unless authorized.
+`ab doctor` is a separate planned feature; do not implement it here.
+
+Report changes, validation, unresolved state or client-contract decisions, and readiness for
+`dev`, `tools add`, `sessions bind`, `memory bind`, tracing, `endpoint`, and `deploy`. Distinguish
+local wiring from live validation. Exclude the reference snapshot from application packaging and
+test discovery if the project would otherwise collect it.

databricks_agentbricks/templates/agent-langgraph/.env.example

@@ -0,0 +1,36 @@
+# Copy to .env for local development:  cp .env.example .env
+#
+# The only required setting for local dev is a Databricks auth profile (used to call the model).
+# Everything else — MLflow tracing, long-term memory — is optional and off by default. Invocation
+# durability uses an in-memory store locally; conversation history uses an in-process checkpointer.
+
+# Databricks auth profile (from `databricks auth profiles`). Used to call the model endpoint.
+DATABRICKS_CONFIG_PROFILE=DEFAULT
+# Or use explicit host/token instead of a profile:
+# DATABRICKS_HOST=https://<your-workspace>.databricks.com
+# DATABRICKS_TOKEN=dapi...
+
+# --- Optional: MLflow tracing ---
+# Leave UNSET to skip tracing (local dev). To enable, set a destination AND an experiment (either
+# form of each works): destination = MLFLOW_TRACKING_URI or MLFLOW_TRACING_DESTINATION;
+# experiment = MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME.
+# MLFLOW_TRACKING_URI="databricks"
+# MLFLOW_EXPERIMENT_ID=
+# MLFLOW_EXPERIMENT_NAME=
+# For fully-local tracing (no workspace), point MLFLOW_TRACKING_URI at a local OSS MLflow server
+# (`mlflow server`), e.g. MLFLOW_TRACKING_URI="http://localhost:5000".
+
+# --- Optional: long-term memory tools ---
+# Leave UNSET to skip. Set to a managed memory store ID to register the remember/recall tools
+# (persist/search facts across conversations); see databricks_agentkit/langgraph/memory.py. Memory is
+# partitioned per user: the agent uses the signed-in user as the actor (falls back to "agent"
+# locally); edit `_actor` in agent/agent.py to change that.
+# AGENT_MEMORY_STORE=<memory-store-id>
+
+# --- Optional: durable state (managed Session Store) ---
+# Leave UNSET to keep the in-process LangGraph checkpointer (InMemorySaver): multi-turn and HITL
+# pauses work within one process but don't survive restarts/replicas. Set to an existing managed
+# Session Store name to persist checkpoints through its REST API (DatabricksSessionStoreSaver) —
+# durable graph state incl. paused HITL runs, over RPCs (no DB connection). Access uses your normal
+# Databricks auth (must have access to the store). See databricks_agentkit/langgraph/session_store.py.
+# AGENT_SESSION_STORE=my-agent-sessions

databricks_agentbricks/templates/agent-langgraph/.gitignore

@@ -0,0 +1,199 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# VS Code
+.vscode/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+
+.DS_*
+
+# Databricks / MLflow local artifacts
+**/mlruns/
+mlflow.db
+**/.databricks
+.claude/
+
+# Environment files
+**/.env
+**/.env.local
+
+# Local (Lakebase-free) SQLite session store
+local_agent_sessions.db
+local_agent_sessions.db-*
+*.db-journal
+
+# Agent Bricks local dev artifacts (`agentbricks dev`)
+.agentbricks/
+app.agentbricksdev.yaml