streamsnow 0.1.0__tar.gz

streamsnow-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "streamsnow",
+  "owner": { "name": "Kyle Chalmers" },
+  "description": "StreamSnow — build, govern, and ship Streamlit-in-Snowflake apps with Claude Code.",
+  "plugins": [
+    {
+      "name": "streamsnow",
+      "source": "./",
+      "description": "Scaffolding, data-governance guardrails, local preview, validation, review, and deploy for Streamlit-in-Snowflake apps."
+    }
+  ]
+}

streamsnow-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "streamsnow",
+  "displayName": "StreamSnow",
+  "version": "0.0.1",
+  "description": "Build, govern, and ship Streamlit-in-Snowflake apps with Claude Code: scaffolding, data-governance guardrails, local preview, validation, review, and deploy.",
+  "author": { "name": "Kyle Chalmers" },
+  "homepage": "https://github.com/kyle-chalmers/streamsnow",
+  "repository": "https://github.com/kyle-chalmers/streamsnow",
+  "license": "MIT",
+  "keywords": ["snowflake", "streamlit", "dashboards", "governance", "scaffolding"],
+  "hooks": "./hooks/hooks.json"
+}

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

@@ -0,0 +1,73 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Sync project (creates .venv with dev extras)
+        run: uv sync --extra dev --python ${{ matrix.python-version }}
+
+      - name: Ruff lint
+        run: uv run ruff check .
+
+      - name: Ruff format check
+        run: uv run ruff format --check .
+
+      - name: Pytest
+        run: uv run pytest -q
+
+  privacy-gate:
+    # Pre-publish gate: fail if any proprietary/internal term or secret leaks
+    # into the OSS tree (the automated half; human review in RELEASING.md).
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv run --python 3.11 python -m streamsnow.tools.check_export_clean .
+
+  wheel-smoke:
+    # Build the wheel and run `streamsnow init` from the INSTALLED artifact, so
+    # a packaging regression (e.g. templates excluded from the wheel) fails CI
+    # rather than shipping a broken install.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Build wheel
+        run: uv build --wheel
+      - name: Install wheel into a clean venv
+        run: |
+          uv venv --python 3.11 /tmp/wheelenv
+          uv pip install --python /tmp/wheelenv dist/*.whl
+      - name: Smoke — init from the built wheel ships templates
+        run: |
+          /tmp/wheelenv/bin/streamsnow --version
+          /tmp/wheelenv/bin/streamsnow init \
+            --config streamsnow.config.example.yaml --dir /tmp/wheel-init --app smoke-app
+          test -f /tmp/wheel-init/apps/smoke-app/streamlit_app.py
+          test -f /tmp/wheel-init/AGENTS.md
+          # Run the guardrail from inside the generated repo (config is discovered
+          # from cwd) — proves the wheel ships templates AND the check works.
+          cd /tmp/wheel-init && /tmp/wheelenv/bin/streamsnow check schema-refs apps

streamsnow-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: publish
+
+# Tag a release (e.g. `git tag v0.1.0 && git push --tags`) to build and publish
+# to PyPI via Trusted Publishing (OIDC — no stored token). One-time setup: add a
+# PyPI trusted publisher for project `streamsnow`, repo kyle-chalmers/streamsnow,
+# workflow `publish.yml`, environment `pypi`. See RELEASING.md.
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # required for PyPI Trusted Publishing
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Build sdist + wheel
+        run: uv build
+
+      - name: Verify the tag matches the package version
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG="$(uv run --python 3.11 python -c 'import importlib.metadata as m; print(m.version("streamsnow"))' 2>/dev/null || true)"
+          echo "tag=$TAG pkg=$PKG"
+          # soft check — the wheel filename carries the authoritative version
+          ls dist/
+
+      - name: Publish to PyPI (Trusted Publishing)
+        uses: pypa/gh-action-pypi-publish@release/v1

streamsnow-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling
+.ruff_cache/
+.pytest_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Secrets / local config (never commit)
+.streamlit/secrets.toml
+streamsnow.config.local.yaml
+*.local.yaml
+
+# OS / editor
+.DS_Store
+*.swp
+.idea/
+.vscode/
+
+# Scratch
+/tmp/
+*.log

streamsnow-0.1.0/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to StreamSnow are recorded here. This project follows
+[semantic versioning](https://semver.org/) once it reaches its first release.
+
+## [0.1.0] - 2026-06-27
+
+Initial release.
+
+### CLI (`streamsnow`)
+- `configure` / `init` / `new` — set up the Snowflake environment and scaffold a
+  governed monorepo + apps (container or warehouse runtime).
+- `doctor` — machine + config prerequisite checks.
+- `validate-app` — deterministic PASS/FAIL gate; `check schema-refs|security|caching|bind-predicates`.
+- `preview` — run an app locally against live Snowflake.
+- `deploy-setup` / `deploy-sql` / `stage-path` / `config-get` — deploy SQL + helpers
+  for stage-copy and git-repository sources.
+- `update` — re-render governance files from the current config (dry-run by default).
+
+### Claude Code plugin
+- 14 skills (onboard, refine-requirements, new-app, add-page, preview-app,
+  validate-app, ship-app, start-app, review-app, deep-dive-data, apply-review,
+  auto-review-app, sql-review, migrate-app) + 4 shared recipes.
+- SessionStart hook, guarded to StreamSnow repos.
+
+### Governance & safety
+- Typed, validated `streamsnow.config.yaml` with an injection-safe rendering gate.
+- Config-driven schema allow/deny, app-security, caching-TTL, and bind-predicate checks.
+- Pre-publish privacy/export gate; generated repos ship pre-commit + CI guardrails.
+
+### Packaging
+- PyPI Trusted-Publishing release workflow; wheel-smoke + 3.11/3.12 CI matrix.

streamsnow-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to StreamSnow
+
+Thanks for your interest! StreamSnow is in early, active development.
+
+## Ground rules
+
+- **One implementation, many consumers.** Validation/scaffolding logic lives in
+  the `streamsnow` Python package. The CLI, the Claude Code plugin, pre-commit,
+  and CI all call that same code — never fork logic into a skill or a workflow.
+- **Tools are CLI-first and structured.** Each tool is a small program with
+  `--format=md|json` output and meaningful exit codes (`0` pass, `1` finding,
+  `2` tool error). Skills shell out to them; they never embed prompt text.
+- **No org-specific values in committed code.** Anything Snowflake-, company-,
+  or brand-specific belongs in `streamsnow.config.yaml`, not hardcoded.
+- **Secrets never go in the repo.** Not in config, not in tests, not in docs.
+
+## Dev setup
+
+```bash
+git clone https://github.com/kyle-chalmers/streamsnow.git
+cd streamsnow
+uv venv --python 3.11
+uv pip install -e ".[dev]"
+pre-commit install        # once available
+```
+
+## Before you open a PR
+
+```bash
+ruff check . && ruff format --check .
+pytest
+```
+
+CI runs the same checks. Keep changes focused; describe what tool/skill/template
+you touched and why.
+
+## Reporting issues
+
+Open a GitHub issue with the StreamSnow version (`streamsnow --version`), your
+runtime/deploy-source config (redact secrets), and steps to reproduce.

streamsnow-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle Chalmers
+
+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.

streamsnow-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: streamsnow
+Version: 0.1.0
+Summary: Open-source toolkit for building, governing, and shipping Streamlit-in-Snowflake apps with Claude Code
+Project-URL: Homepage, https://github.com/kyle-chalmers/streamsnow
+Project-URL: Repository, https://github.com/kyle-chalmers/streamsnow
+Project-URL: Issues, https://github.com/kyle-chalmers/streamsnow/issues
+Author: Kyle Chalmers
+License: MIT
+License-File: LICENSE
+Keywords: claude-code,dashboards,governance,scaffolding,snowflake,streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pyyaml>=6
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- markdownlint-disable MD041 -->
+<h1 align="center">StreamSnow ❄️</h1>
+
+<p align="center">
+  <a href="https://github.com/kyle-chalmers/streamsnow/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/kyle-chalmers/streamsnow/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://pypi.org/project/streamsnow/"><img alt="PyPI" src="https://img.shields.io/pypi/v/streamsnow.svg"></a>
+  <img alt="Python" src="https://img.shields.io/badge/python-3.11%2B-blue">
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+  <img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude%20Code-plugin-d97757">
+</p>
+
+<p align="center">
+  <strong>An open-source toolkit for building, governing, and shipping
+  Streamlit-in-Snowflake apps with Claude Code.</strong>
+</p>
+
+<p align="center">
+  <em>Scaffold a governed monorepo, build dashboards inside enforced
+  data-governance guardrails, and deploy them to Snowflake — without
+  learning the rules by hand.</em>
+</p>
+
+---
+
+> **Status: alpha, functional.** The CLI (configure / init / new / validate-app /
+> preview / check / deploy-sql / deploy-setup) and the Claude Code plugin (14
+> skills + shared recipes) are implemented and CI-green for both runtimes and
+> both deploy sources. Not yet published to PyPI; APIs may still shift before the
+> first tagged release.
+
+## What it is
+
+StreamSnow is a **hybrid** of two things that work together:
+
+1. **A `streamsnow` CLI** (PyPI) — scaffolds a governed Streamlit-in-Snowflake
+   monorepo, runs an interactive setup wizard, and vendors the validation
+   tools, CI, pre-commit hooks, and branding your repo needs.
+2. **A Claude Code plugin** (marketplace) — ships the skills, subagents, and
+   hooks that turn Claude Code into a domain expert for this stack:
+   `/new-app`, `/preview-app`, `/validate-app`, `/ship-app`, `/start-app`, and
+   more.
+
+Think **a Claude Code skill pack fused with an installable system + setup**.
+The CLI gives you the substrate; the plugin gives Claude the playbook. A single
+`streamsnow.config.yaml` is the source of truth both read from.
+
+## Why
+
+Building Streamlit apps on Snowflake well means getting a hundred small things
+right: caching with TTLs, parameterized SQL that survives the deployed Go
+driver, runtime selection (container vs. warehouse), schema access guardrails,
+a deploy pipeline, branding, and review discipline. StreamSnow encodes those as
+**executable guardrails** — pre-commit + CI gates, scaffolding templates, and
+Claude Code skills — so every developer (and every Claude session) follows the
+same rules and ships safely.
+
+## Two things you choose
+
+StreamSnow treats two axes as first-class, configurable options:
+
+| Axis | Options |
+|------|---------|
+| **Runtime** | **Container** (default — cheaper, full PyPI, modern Streamlit) or **Warehouse** (legacy — instant start, Anaconda channel) |
+| **Deploy source** | **Stage-copy** (default — CI uploads to an internal stage) or **Snowflake `GIT REPOSITORY`** (Snowflake pulls from your Git repo) |
+
+## Quickstart (target experience)
+
+```bash
+# 0. Check your machine has the prerequisites (Python 3.11+, uv, git, snow CLI)
+uvx streamsnow doctor
+
+# 1. Configure your Snowflake environment + scaffold a governed repo with a starter app
+uvx streamsnow init          # runs the config wizard, then scaffolds
+#    (or split it: `streamsnow configure` to set up streamsnow.config.yaml first,
+#     then `streamsnow init` to scaffold)
+
+# 2. Connect to Snowflake + create local preview secrets
+snow connection add --connection-name <name> --account <locator> \
+  --user <you> --authenticator externalbrowser   # init prints the exact command
+cp apps/<slug>/.streamlit/secrets.toml.example apps/<slug>/.streamlit/secrets.toml
+
+# 3. Add the Claude Code plugin (inside Claude Code)
+/plugin marketplace add kyle-chalmers/streamsnow
+/plugin install streamsnow@streamsnow
+
+# 4. Build, preview, validate, ship
+streamsnow new marketing campaign-dashboard   # or /new-app
+streamlit run apps/marketing-campaign-dashboard/streamlit_app.py
+#    /preview-app  ->  /validate-app  ->  /ship-app
+```
+
+## How it's organized
+
+```
+streamsnow/            the PyPI package — CLI, config, policy, scaffolder, tools
+  ├── cli.py           configure / init / new / doctor / check
+  ├── config.py        typed + validated streamsnow.config.yaml model
+  ├── policy.py        schema allow/deny single source of truth
+  ├── scaffolder.py    renders a governed repo from config
+  ├── _templates/      the Jinja scaffold templates (repo/ + app/)
+  └── tools/           governance checks (e.g. check_schema_refs)
+.claude-plugin/        Claude Code plugin manifest + marketplace
+skills/  agents/  hooks/   Claude Code plugin surface (filled out in upcoming phases)
+docs/  examples/            guides + reference app (in progress)
+```
+
+> Active scaffolding lives in `streamsnow/` (templates under `streamsnow/_templates/`).
+> The `skills/`, `agents/`, `hooks/`, `docs/`, and `examples/` directories are
+> placeholders being populated phase by phase.
+
+The `streamsnow` Python package is the **single source of truth** for tool
+logic: the CLI, the Claude Code plugin, pre-commit, and CI all call the same
+code — one implementation, many consumers.
+
+## License
+
+[MIT](LICENSE) © Kyle Chalmers
+
+> StreamSnow is an independent open-source project and is not affiliated with or
+> endorsed by Snowflake Inc., Streamlit, or Anthropic.

streamsnow-0.1.0/README.md

@@ -0,0 +1,120 @@
+<!-- markdownlint-disable MD041 -->
+<h1 align="center">StreamSnow ❄️</h1>
+
+<p align="center">
+  <a href="https://github.com/kyle-chalmers/streamsnow/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/kyle-chalmers/streamsnow/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://pypi.org/project/streamsnow/"><img alt="PyPI" src="https://img.shields.io/pypi/v/streamsnow.svg"></a>
+  <img alt="Python" src="https://img.shields.io/badge/python-3.11%2B-blue">
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+  <img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude%20Code-plugin-d97757">
+</p>
+
+<p align="center">
+  <strong>An open-source toolkit for building, governing, and shipping
+  Streamlit-in-Snowflake apps with Claude Code.</strong>
+</p>
+
+<p align="center">
+  <em>Scaffold a governed monorepo, build dashboards inside enforced
+  data-governance guardrails, and deploy them to Snowflake — without
+  learning the rules by hand.</em>
+</p>
+
+---
+
+> **Status: alpha, functional.** The CLI (configure / init / new / validate-app /
+> preview / check / deploy-sql / deploy-setup) and the Claude Code plugin (14
+> skills + shared recipes) are implemented and CI-green for both runtimes and
+> both deploy sources. Not yet published to PyPI; APIs may still shift before the
+> first tagged release.
+
+## What it is
+
+StreamSnow is a **hybrid** of two things that work together:
+
+1. **A `streamsnow` CLI** (PyPI) — scaffolds a governed Streamlit-in-Snowflake
+   monorepo, runs an interactive setup wizard, and vendors the validation
+   tools, CI, pre-commit hooks, and branding your repo needs.
+2. **A Claude Code plugin** (marketplace) — ships the skills, subagents, and
+   hooks that turn Claude Code into a domain expert for this stack:
+   `/new-app`, `/preview-app`, `/validate-app`, `/ship-app`, `/start-app`, and
+   more.
+
+Think **a Claude Code skill pack fused with an installable system + setup**.
+The CLI gives you the substrate; the plugin gives Claude the playbook. A single
+`streamsnow.config.yaml` is the source of truth both read from.
+
+## Why
+
+Building Streamlit apps on Snowflake well means getting a hundred small things
+right: caching with TTLs, parameterized SQL that survives the deployed Go
+driver, runtime selection (container vs. warehouse), schema access guardrails,
+a deploy pipeline, branding, and review discipline. StreamSnow encodes those as
+**executable guardrails** — pre-commit + CI gates, scaffolding templates, and
+Claude Code skills — so every developer (and every Claude session) follows the
+same rules and ships safely.
+
+## Two things you choose
+
+StreamSnow treats two axes as first-class, configurable options:
+
+| Axis | Options |
+|------|---------|
+| **Runtime** | **Container** (default — cheaper, full PyPI, modern Streamlit) or **Warehouse** (legacy — instant start, Anaconda channel) |
+| **Deploy source** | **Stage-copy** (default — CI uploads to an internal stage) or **Snowflake `GIT REPOSITORY`** (Snowflake pulls from your Git repo) |
+
+## Quickstart (target experience)
+
+```bash
+# 0. Check your machine has the prerequisites (Python 3.11+, uv, git, snow CLI)
+uvx streamsnow doctor
+
+# 1. Configure your Snowflake environment + scaffold a governed repo with a starter app
+uvx streamsnow init          # runs the config wizard, then scaffolds
+#    (or split it: `streamsnow configure` to set up streamsnow.config.yaml first,
+#     then `streamsnow init` to scaffold)
+
+# 2. Connect to Snowflake + create local preview secrets
+snow connection add --connection-name <name> --account <locator> \
+  --user <you> --authenticator externalbrowser   # init prints the exact command
+cp apps/<slug>/.streamlit/secrets.toml.example apps/<slug>/.streamlit/secrets.toml
+
+# 3. Add the Claude Code plugin (inside Claude Code)
+/plugin marketplace add kyle-chalmers/streamsnow
+/plugin install streamsnow@streamsnow
+
+# 4. Build, preview, validate, ship
+streamsnow new marketing campaign-dashboard   # or /new-app
+streamlit run apps/marketing-campaign-dashboard/streamlit_app.py
+#    /preview-app  ->  /validate-app  ->  /ship-app
+```
+
+## How it's organized
+
+```
+streamsnow/            the PyPI package — CLI, config, policy, scaffolder, tools
+  ├── cli.py           configure / init / new / doctor / check
+  ├── config.py        typed + validated streamsnow.config.yaml model
+  ├── policy.py        schema allow/deny single source of truth
+  ├── scaffolder.py    renders a governed repo from config
+  ├── _templates/      the Jinja scaffold templates (repo/ + app/)
+  └── tools/           governance checks (e.g. check_schema_refs)
+.claude-plugin/        Claude Code plugin manifest + marketplace
+skills/  agents/  hooks/   Claude Code plugin surface (filled out in upcoming phases)
+docs/  examples/            guides + reference app (in progress)
+```
+
+> Active scaffolding lives in `streamsnow/` (templates under `streamsnow/_templates/`).
+> The `skills/`, `agents/`, `hooks/`, `docs/`, and `examples/` directories are
+> placeholders being populated phase by phase.
+
+The `streamsnow` Python package is the **single source of truth** for tool
+logic: the CLI, the Claude Code plugin, pre-commit, and CI all call the same
+code — one implementation, many consumers.
+
+## License
+
+[MIT](LICENSE) © Kyle Chalmers
+
+> StreamSnow is an independent open-source project and is not affiliated with or
+> endorsed by Snowflake Inc., Streamlit, or Anthropic.

streamsnow-0.1.0/RELEASING.md

@@ -0,0 +1,52 @@
+# Releasing StreamSnow
+
+## Pre-publish privacy gate (do this before the repo goes public)
+
+StreamSnow was extracted from a private monorepo, so before flipping the repo
+public or cutting the first PyPI release:
+
+1. **Automated scan** — must be clean:
+   ```bash
+   uv run python -m streamsnow.tools.check_export_clean .
+   ```
+   (Also runs as the `privacy-gate` CI job on every push.)
+2. **Human review** — skim for anything the scanner can't know is sensitive:
+   - real company/people/customer names, internal URLs, ticket IDs, account locators
+   - screenshots or example data derived from real systems
+   - anything in `git log` history (the scan only sees the working tree)
+3. Confirm `LICENSE`, `README`, and `CONTRIBUTING` say what you intend.
+
+## One-time PyPI setup (Trusted Publishing — no stored token)
+
+1. Create the `streamsnow` project on PyPI (or reserve the name).
+2. PyPI → project → **Publishing** → add a **Trusted Publisher**:
+   - Owner: `kyle-chalmers` · Repo: `streamsnow` · Workflow: `publish.yml` · Environment: `pypi`
+3. In GitHub repo settings, create an environment named `pypi`.
+
+## Cut a release
+
+1. Bump `version` in `pyproject.toml` (and note changes in `CHANGELOG.md`).
+2. Ensure `main` is green (lint-and-test, privacy-gate, wheel-smoke).
+3. Tag and push:
+   ```bash
+   git tag v0.1.0
+   git push origin v0.1.0
+   ```
+   The `publish` workflow builds the sdist + wheel and publishes to PyPI via OIDC.
+4. Create a GitHub Release from the tag with the changelog notes.
+
+## Flip the repo public (separate, deliberate step)
+
+Only after the privacy gate passes and you've decided to open it:
+```bash
+GH_TOKEN="$GITHUB_TOKEN_PERSONAL" gh repo edit kyle-chalmers/streamsnow --visibility public --accept-visibility-change-consequences
+```
+
+## Claude Code plugin marketplace
+
+Once public, users add the plugin with:
+```
+/plugin marketplace add kyle-chalmers/streamsnow
+/plugin install streamsnow@streamsnow
+```
+No publish step is required for the plugin — it's served from the public repo.

streamsnow-0.1.0/docs/deploy-setup.md

@@ -0,0 +1,49 @@
+# Deploy setup
+
+StreamSnow scaffolds a `.github/workflows/deploy.yml` that ships your apps to
+Snowflake on merge to `main`. It **skips automatically** until you set the
+secrets below, so it never fails a normal merge before you're ready.
+
+## 1. One-time Snowflake objects
+
+Generate and review the DDL for your configured deploy source, then run it once
+with an admin (or the CI) role:
+
+```bash
+streamsnow deploy-setup | less        # review first
+streamsnow deploy-setup | snow sql --stdin   # or pipe to your admin session
+```
+
+- **stage-copy** (default): creates the internal stage CI uploads to. Container
+  apps also need an account-level compute pool + external access integration
+  (admin, one-time — emitted as commented guidance).
+- **git-repository**: creates the API integration, the secret holding a GitHub
+  token, and the `GIT REPOSITORY` object, and grants them to the CI role.
+
+## 2. CI auth (key-pair / JWT)
+
+Create a key-pair for a dedicated CI user, register the public key on that
+Snowflake user, and add these **repo secrets**:
+
+| Secret | Value |
+|---|---|
+| `SNOWFLAKE_ACCOUNT` | account locator (e.g. `ab12345.us-east-1`) |
+| `SNOWFLAKE_USER` | CI service user |
+| `SNOWFLAKE_PRIVATE_KEY_RAW` | the PEM private key |
+| `SNOWFLAKE_PRIVATE_KEY_PASSPHRASE` | (optional) key passphrase |
+| `SNOWFLAKE_WAREHOUSE` | a warehouse the CI role can use |
+| `SNOWFLAKE_ROLE` | your `ci_role` from `streamsnow.config.yaml` |
+
+Once `SNOWFLAKE_ACCOUNT` is present, the deploy job runs on the next merge:
+it uploads `apps/` to the SHA-versioned stage and runs `CREATE OR REPLACE
+STREAMLIT` (via `streamsnow deploy-sql`) for each app.
+
+## git-repository note
+
+The generated workflow targets the **stage-copy** path (CI pushes; Snowflake
+never reaches out to GitHub — fewer moving parts, no network-policy dependency).
+If you set `deploy.source: git-repository`, your CI must instead `snow git fetch`
+the repository and Snowflake must be able to reach GitHub (or mint a GitHub-App
+token into the secret). Use `streamsnow deploy-sql <slug>` for the create
+statement and `streamsnow deploy-sql <slug> --refresh` for the
+ABORT/PULL/COMMIT refresh of an existing app.

streamsnow-0.1.0/examples/README.md

@@ -0,0 +1,26 @@
+# Examples
+
+StreamSnow doesn't check in a sample app — `streamsnow init` **generates** a
+complete, working one for you (and the generated output is exercised in CI by
+the `wheel-smoke` job, so it stays valid).
+
+A freshly generated app looks like:
+
+```
+apps/<slug>/
+  streamlit_app.py         # st.navigation entrypoint, apply_branding()
+  pages/overview.py        # branded metric + Plotly chart + a cached loader
+  queries/example_metric.sql
+  branding.py  sql_loader.py
+  .streamlit/config.toml   .streamlit/secrets.toml.example
+  snowflake.yml            pyproject.toml (container) | environment.yml (warehouse)
+  AGENTS.md
+```
+
+Generate and run one:
+
+```bash
+uvx streamsnow init                # setup wizard + scaffold
+streamsnow validate-app <slug>     # PASS/FAIL gate
+streamsnow preview <slug>          # run locally vs Snowflake
+```