snowflake-cli 3.21.0__tar.gz → 3.22.0__tar.gz

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/.gitignore

@@ -18,9 +18,13 @@ gen_docs/
 .env
 .vscode
 tmp/
+uv.lock
 
 ^app.zip
 ^snowflake.yml
 
 plans/
 .claude/settings.local.json
+.cursor/mcp.json
+.mcp.json
+.ai/review/**/*.json

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/.pre-commit-config.yaml

@@ -1,3 +1,9 @@
+# The cookiecutter scaffold under plugin-template/ contains Jinja placeholders
+# (e.g. {{ cookiecutter.* }} in file paths, .py, and .toml) that are not valid
+# Python/TOML, so black/ruff/check-ast and the other hooks cannot process them.
+# Exclude the whole directory from every hook.
+exclude: '^plugin-template/'
+
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v5.0.0
@@ -24,6 +30,10 @@ repos:
     rev: v1.18.2
     hooks:
       - id: mypy
+        # The eval harness under .github/scripts/eval is loaded dynamically
+        # (importlib + sys.path, non-package case dirs), so it is not statically
+        # type-checkable; ruff/black/pytest still cover it.
+        exclude: '^(\.github/scripts/eval/|tests/eval/|\.ai/)'
         additional_dependencies: [types-pkg-resources==0.1.3, types-all==1.0.0]
   - repo: https://github.com/codespell-project/codespell
     rev: v2.2.4
@@ -135,9 +145,12 @@ repos:
           - --fuzzy-match-generates-todo
       - id: insert-license
         name: Add license for all Markdown files
+        # Skills under .claude/ require YAML frontmatter at the very top of
+        # SKILL.md, which is incompatible with a leading license-header comment.
         exclude: |
           (?x)
           ^\.github/|
+          ^\.claude/|
           tests/test_data/projects/.*|
           tests_integration/test_data/projects/.*
         files: \.md$

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/CONTRIBUTING.md

@@ -20,6 +20,8 @@
 
 - **Adding commands**: [docs/contributing/adding-commands.md](docs/contributing/adding-commands.md)
   — design sign-off, plugin structure, registration, return types, destructive commands
+- **Writing a plugin (interface-first)**: [docs/contributing/writing-a-plugin.md](docs/contributing/writing-a-plugin.md)
+  — two-phase contribution workflow, interface/handler split, cookiecutter template
 - **Command lifecycle and feature flags**: [docs/contributing/lifecycle.md](docs/contributing/lifecycle.md)
   — PrPr/PuPr/GA rules, feature flag mechanics, release notes format
 - **Code conventions**: [docs/contributing/conventions.md](docs/contributing/conventions.md)

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-cli
-Version: 3.21.0
+Version: 3.22.0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/RELEASE-NOTES.md

@@ -23,6 +23,24 @@
 ## Fixes and improvements
 
 
+# v3.22.0
+
+## Deprecations
+
+## New additions
+* Added `tags` field to Streamlit entity so that tags can be set with `snow streamlit deploy`.
+* `config.toml` and `connections.toml` files with `0644` permissions (readable by group or others) now emit a warning instead of a hard error when `SF_SKIP_TOKEN_FILE_PERMISSIONS_VERIFICATION=true` or `SKIP_TOKEN_FILE_PERMISSIONS_VERIFICATION=true` is set, aligning with snowflake-connector-python behaviour. Files writable by group or others remain a hard error regardless of the env var.
+
+## Fixes and improvements
+* `snow app setup` now correctly preserves case-sensitive (double-quoted) identifiers in the generated `snowflake.yml`. Previously, values such as `"lower_db"` were silently stripped of their surrounding quotes by YAML, causing Snowflake to uppercase the identifier and fail to locate the object.
+* `snow app setup` no longer writes `build_compute_pool` / `service_compute_pool` to the generated `snowflake.yml`, and no longer reads the `DEFAULT_SNOWFLAKE_APPS_BUILD_COMPUTE_POOL` / `DEFAULT_SNOWFLAKE_APPS_SERVICE_COMPUTE_POOL` account parameters. Snowflake App Runtime services now always run on server-managed compute pools. Existing projects that set these fields in `snowflake.yml` continue to be honored by `snow app deploy`.
+* `snow app setup --dry-run` now exits with code 0 while still printing the same setup validation errors that a non-dry-run invocation surfaces.
+* `snow app deploy` now supports a separate `service_eai` field on `snowflake-app` entities for newly created application services. When `service_eai` is not set, deploy continues to fall back to `build_eai` for backward compatibility.
+* `snow dbt deploy` now preserves the customer's original key order in `profiles.yml` instead of silently reordering keys alphabetically.
+* `snow app setup` and `snow app deploy` resolve their Snowflake App Runtime defaults via the `SYSTEM$GET_APPLICATION_SERVICE_DEFAULTS()` system function, and automatically fall back to the previous `SHOW PARAMETERS` based resolution on accounts where that function is not yet available. The fallback is transitional and will be removed once the function has fully rolled out.
+* Fixed `snow app events` and `snow app setup --dry-run` crashing on Windows with an uncaught `UnicodeEncodeError` when their output contained non-ASCII characters (e.g. emoji, box-drawing, or accented text in application logs or the dry-run plan preview). The `snow app` commands now render output as UTF-8 instead of the platform default code page (cp1252/cp932 on Windows).
+
+
 # v3.21.0
 
 ## Deprecations
@@ -35,6 +53,7 @@
 ## Fixes and improvements
 * Fixed REST API object operations (e.g. `snow object create`) crashing with `ModuleNotFoundError: No module named 'snowflake.connector.vendored'` when running against the Snowflake Universal Driver (connector-python v5). HTTP error handling now works on both connector v4.x and the Universal Driver v5.
 * The `snow app setup` `--compute-pool` option and the `build_compute_pool` / `service_compute_pool` fields of a `snowflake-app` entity are now hidden and undocumented (omitted from `--help` and the generated project-definition JSON schema). They remain fully functional: `snow app setup` and `snow app deploy` still honor the `DEFAULT_SNOWFLAKE_APPS_BUILD_COMPUTE_POOL` / `DEFAULT_SNOWFLAKE_APPS_SERVICE_COMPUTE_POOL` account parameters and any compute pools configured in `snowflake.yml`. The `ENABLE_APPLICATION_SERVICE_MANAGED_COMPUTE_POOL` and `ENABLE_APPLICATION_SERVICE_MANAGED_COMPUTE_POOL_FALLBACK` parameter checks (and the related deploy-time warning) have been removed.
+* `snow streamlit deploy --replace` now uses `ALTER STREAMLIT ... SET` instead of `CREATE OR REPLACE STREAMLIT` when the app already exists, preserving existing grants and permissions on the object.
 * Fixed `snow app setup` incorrectly treating system-default parameter values as admin-configured values. After running `ALTER ACCOUNT UNSET` on `DEFAULT_SNOWFLAKE_APPS_BUILD_COMPUTE_POOL` or `DEFAULT_SNOWFLAKE_APPS_SERVICE_COMPUTE_POOL`, those fields no longer appear in the generated `snowflake.yml` or `--dry-run` output.
 * Upgraded `pip` from 26.1.1 to 26.1.2.
 * `snow app setup` and `snow app deploy` now default to a workspace (instead of a stage) for app code whenever the resolved destination is a personal database (`USER$<user>`), which do not support stages. An explicitly configured `code_stage` is still honored, with a warning when the destination is a personal database.

{snowflake_cli-3.21.0 → snowflake_cli-3.22.0}/docs/contributing/adding-commands.md

@@ -16,6 +16,10 @@
 
 # Adding Commands
 
+> **Interface-first plugins:** to declare a reviewable command surface separately
+> from its implementation (the two-phase contribution workflow used by teams
+> outside the CLI core), see [writing-a-plugin.md](writing-a-plugin.md).
+
 ## Design sign-off before writing code
 
 Before implementing any change to the user-facing interface — new commands,

snowflake_cli-3.22.0/docs/contributing/writing-a-plugin.md

@@ -0,0 +1,381 @@
+<!--
+ Copyright (c) 2024 Snowflake Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+# Writing a Plugin (Interface-First)
+
+Snowflake CLI supports an **interface-first** plugin pattern that separates a
+command's *surface* — its name, parameters, and help text — from its
+*implementation*. The surface is declared as plain data in `interface.py` and
+can be reviewed on its own; the business logic follows in `handler.py`.
+
+This is an alternative to the classic plugin layout in
+[adding-commands.md](adding-commands.md), where commands are defined directly
+with `@app.command()` in `commands.py`. Reach for interface-first when the
+command surface should be signed off **before** any implementation is written —
+most useful for plugins contributed by teams outside the CLI core, where the two
+phases are reviewed by different people.
+
+The design principles and the sign-off requirement from
+[adding-commands.md](adding-commands.md#design-sign-off-before-writing-code)
+still apply: get the command surface approved before writing code.
+
+---
+
+## Two-phase contribution workflow
+
+```
+Phase 1 PR:  interface.py                 -->  review command surface  -->  merge
+Phase 2 PR:  handler.py + plugin_spec.py  -->  review implementation   -->  merge
+```
+
+Phase 1 is reviewable on its own: reviewers evaluate the complete command
+surface — names, parameters, help text, connection requirements — as plain data,
+without any implementation to wade through.
+
+---
+
+## Quickstart with the plugin template
+
+The fastest way to start is the cookiecutter template under
+[`plugin-template/`](../../plugin-template):
+
+```bash
+pip install cookiecutter
+cookiecutter plugin-template/
+```
+
+You will be prompted for:
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `plugin_name` | Package name (used in `pip install`) | `snow-analytics` |
+| `plugin_module` | Python module name (auto-derived) | `snow_analytics` |
+| `cli_command_name` | CLI command name under `snow` | `analytics` |
+| `command_type` | `group` (multiple subcommands) or `single` | `group` |
+| `requires_connection` | Whether commands need a Snowflake connection | `true` |
+
+This generates a complete, installable project with `interface.py`,
+`handler.py`, `plugin_spec.py`, and a passing contract test — the structure
+described below.
+
+---
+
+## Phase 1: define the interface
+
+`interface.py` holds two things:
+
+1. **A command spec** — frozen dataclasses describing every command, its
+   parameters, help text, and connection requirements.
+2. **A handler ABC** — an abstract class with one method per command.
+
+Example for a group with two commands (`snow analytics run` and
+`snow analytics report`):
+
+```python
+from __future__ import annotations
+
+from abc import abstractmethod
+
+from snowflake.cli.api.output.types import CommandResult
+from snowflake.cli.api.plugins.command.interface import (
+    REQUIRED,
+    CommandDef,
+    CommandGroupSpec,
+    CommandHandler,
+    ParamDef,
+    ParamKind,
+)
+
+ANALYTICS_SPEC = CommandGroupSpec(
+    name="analytics",
+    help="Run analytics queries.",
+    parent_path=(),  # () = attach at root: `snow analytics`
+    commands=(
+        CommandDef(
+            name="run",
+            help="Run an analytics query.",
+            handler_method="run",
+            requires_connection=True,
+            params=(
+                ParamDef(
+                    name="query_name",
+                    type=str,
+                    kind=ParamKind.ARGUMENT,
+                    help="Name of the query to run.",
+                ),
+                ParamDef(
+                    name="limit",
+                    type=int,
+                    kind=ParamKind.OPTION,
+                    cli_names=("--limit", "-l"),
+                    help="Maximum rows to return.",
+                    default=100,  # any value other than REQUIRED makes it optional
+                ),
+            ),
+            output_type="QueryResult",
+        ),
+        CommandDef(
+            name="report",
+            help="Generate a summary report.",
+            handler_method="report",
+            requires_connection=True,
+            output_type="MessageResult",
+        ),
+    ),
+)
+
+
+class AnalyticsHandler(CommandHandler):
+    # @abstractmethod is optional here. CommandHandler is a marker base with no
+    # abstract methods of its own; the framework enforces the contract via
+    # validate_interface_handler at build time, not through ABC. The decorators
+    # are kept for IDE/type-checker support and to document the contract.
+    @abstractmethod
+    def run(self, query_name: str, limit: int) -> CommandResult: ...
+
+    @abstractmethod
+    def report(self) -> CommandResult: ...
+```
+
+The spec variable name (`ANALYTICS_SPEC` here) is yours to choose, but it must
+match the name imported in `plugin_spec.py` (see
+[Phase 2](#phase-2-implement-the-handler)). The cookiecutter template names it
+`PLUGIN_SPEC` — if you start from the template, either keep that name or rename
+it in both `interface.py` and `plugin_spec.py`.
+
+**Key spec types** (from `snowflake.cli.api.plugins.command.interface`):
+
+| Dataclass | Purpose |
+|-----------|---------|
+| `CommandGroupSpec` | A command group with subcommands (e.g. `snow notebook`) |
+| `SingleCommandSpec` | A single command with no subcommands |
+| `CommandDef` | One command: name, help, params, connection requirements |
+| `ParamDef` | One parameter: name, type, argument vs option, CLI names |
+| `CommandHandler` | The ABC your handler subclasses |
+
+The example above uses `CommandGroupSpec`. A plugin that contributes a **single**
+command uses `SingleCommandSpec` instead (import it in place of
+`CommandGroupSpec`) — note the singular `command=` field, not `commands=(...)`:
+
+```python
+ANALYTICS_SPEC = SingleCommandSpec(
+    parent_path=(),  # () = attach at root: `snow analytics`
+    command=CommandDef(
+        name="analytics",
+        help="Run an analytics query.",
+        handler_method="run",
+        requires_connection=True,
+    ),
+)
+```
+
+**`ParamDef` fields:**
+
+| Field | Description |
+|-------|-------------|
+| `name` | Python parameter name (passed as a kwarg to the handler method) |
+| `type` | Python type (`str`, `int`, `bool`, `FQN`, `Path`, ...) |
+| `kind` | `ParamKind.ARGUMENT` or `ParamKind.OPTION` |
+| `help` | Help text shown in `--help` |
+| `cli_names` | Explicit CLI names, e.g. `("--limit", "-l")`. Empty = auto-derived from `name` |
+| `default` | Default value. `REQUIRED` (the default) marks the parameter required; any other value (e.g. `None`, `100`) makes it optional |
+| `is_flag` | `True` for boolean flags such as `--replace` (give flags an explicit `default`, e.g. `False`) |
+| `click_type` | Custom Click `ParamType` for non-standard types (e.g. `IdentifierType()` for `FQN`) |
+
+Submit the interface for review on its own. Reviewers can evaluate the whole
+command surface without seeing any implementation.
+
+### CODEOWNERS for Phase 2
+
+For a **built-in** plugin (one that lives in this repository), add yourself and a
+colleague as `CODEOWNERS` for your plugin directory in the Phase 1 PR, so the
+Phase 2 implementation only needs review from your team:
+
+```
+# analytics plugin
+/src/snowflake/cli/_plugins/analytics/   @your-handle @colleague-handle
+```
+
+For a plugin in its own repository this is unnecessary — you already own the repo.
+
+---
+
+## Phase 2: implement the handler
+
+After the interface is approved, implement each handler method in `handler.py`.
+Follow [conventions.md](conventions.md) — in particular, **never interpolate
+user input into SQL**. Escape string values with `to_string_literal`, wrap
+object identifiers with `FQN.sql_identifier`, and prefer the helpers over
+f-strings:
+
+```python
+from snowflake.cli.api.output.types import CommandResult, MessageResult, QueryResult
+from snowflake.cli.api.project.util import to_string_literal
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+
+from .interface import AnalyticsHandler
+
+
+class AnalyticsHandlerImpl(AnalyticsHandler, SqlExecutionMixin):
+    def run(self, query_name: str, limit: int) -> CommandResult:
+        # query_name is user input -> escape it with to_string_literal.
+        # limit is a validated int, so it is safe to format directly.
+        # For object identifiers use FQN.sql_identifier (see conventions.md).
+        cursor = self.execute_query(
+            f"SELECT * FROM analytics_queries "
+            f"WHERE name = {to_string_literal(query_name)} "
+            f"LIMIT {limit}"
+        )
+        return QueryResult(cursor)
+
+    def report(self) -> CommandResult:
+        return MessageResult("Report generated.")
+```
+
+The handler mixes in `SqlExecutionMixin` to get `self.execute_query(...)` —
+`SqlExecutionMixin` is meant to be inherited, not instantiated. Built-in plugins
+more commonly keep SQL in a dedicated `AnalyticsManager(SqlExecutionMixin)` and
+have the handler delegate to it; either layout works, as long as the mixin is
+inherited rather than constructed inline.
+
+Then wire the spec and handler together in `plugin_spec.py`:
+
+```python
+from snowflake.cli.api.plugins.command import plugin_hook_impl
+from snowflake.cli.api.plugins.command.bridge import build_command_spec
+
+from .handler import AnalyticsHandlerImpl
+from .interface import ANALYTICS_SPEC
+
+
+@plugin_hook_impl
+def command_spec():
+    return build_command_spec(ANALYTICS_SPEC, AnalyticsHandlerImpl())
+```
+
+`build_command_spec` validates that the handler implements every method declared
+in the spec, then produces a standard `CommandSpec`. The rest of the CLI is
+unaware of the interface/handler split.
+
+**Built-in plugins:** wiring `plugin_spec.py` is enough for a plugin distributed
+as its own package, but a plugin that lives in this repository must also be
+registered in `builtin_plugins.py` (add an import and a dict entry), as described
+in [Registering the plugin](adding-commands.md#registering-the-plugin). Without
+that step the plugin is valid Python but is never loaded by the CLI.
+
+---
+
+## Testing your plugin
+
+Use the helpers from `snowflake.cli.api.plugins.command.testing` to validate the
+interface and the handler contract without a Snowflake connection:
+
+```python
+from snowflake.cli.api.plugins.command.testing import (
+    assert_builds_valid_spec,
+    assert_handler_satisfies,
+    assert_interface_well_formed,
+)
+
+from .handler import AnalyticsHandlerImpl
+from .interface import ANALYTICS_SPEC
+
+
+def test_interface_is_well_formed():
+    assert_interface_well_formed(ANALYTICS_SPEC)
+
+
+def test_handler_satisfies_interface():
+    assert_handler_satisfies(ANALYTICS_SPEC, AnalyticsHandlerImpl())
+
+
+def test_builds_valid_command_spec():
+    assert_builds_valid_spec(ANALYTICS_SPEC, AnalyticsHandlerImpl())
+```
+
+| Helper | Checks |
+|--------|--------|
+| `assert_interface_well_formed` | The spec tree is complete and consistent (names, help text, unique handler methods) |
+| `assert_handler_satisfies` | The handler implements every method the spec declares |
+| `assert_builds_valid_spec` | The spec + handler build into a valid Click command tree |
+
+See [testing.md](testing.md) for the wider test setup (the `runner` fixture,
+snapshots, and feature-flag helpers) once your commands need integration tests.
+
+---
+
+## Installing and enabling your plugin
+
+```bash
+# Install in development mode
+pip install -e /path/to/your/plugin
+
+# Enable it (use the plugin module name)
+snow plugin enable <plugin_module>
+
+# Verify it is registered
+snow plugin list
+```
+
+`snow plugin enable` only finds a plugin whose `pyproject.toml` declares the CLI
+plugin entry point — this is what makes the installed package discoverable:
+
+```toml
+[project.entry-points."snowflake.cli.plugin.command"]
+<plugin_module> = "<package_namespace>.<plugin_module>.plugin_spec"
+```
+
+The cookiecutter template generates this automatically. Without it, `snow plugin
+enable` reports the plugin as not installed even after a successful `pip install`.
+
+---
+
+## Using decorators
+
+Some commands need extra decorators such as `with_project_definition`. Name them
+in `CommandDef.decorators`; the bridge applies them when building the command:
+
+```python
+CommandDef(
+    name="deploy",
+    help="Deploy from a project definition.",
+    handler_method="deploy",
+    requires_connection=True,
+    decorators=("with_project_definition",),
+)
+```
+
+The built-in registry currently provides `with_project_definition`. Register
+additional decorators with `register_decorator("name", factory_fn)` from
+`snowflake.cli.api.plugins.command.bridge`. `factory_fn` is called with **no
+arguments** and must return the decorator — pass the factory, not the decorator
+itself:
+
+```python
+from snowflake.cli.api.plugins.command.bridge import register_decorator
+
+# factory_fn takes no arguments and returns a decorator:
+register_decorator("with_my_decorator", lambda: with_my_decorator)
+```
+
+---
+
+## Reference example
+
+The cookiecutter template under [`plugin-template/`](../../plugin-template) is
+the canonical, working example. Generate a project from it (see
+[Quickstart](#quickstart-with-the-plugin-template)) to get `interface.py`,
+`handler.py`, `plugin_spec.py`, and a passing contract test to build on.

snowflake_cli-3.21.0/scripts/release-plugin/pyproject.toml → snowflake_cli-3.22.0/plugin-template/conftest.py

@@ -12,18 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "snowflakecli-internal-release-plugin"
-requires-python = ">=3.8"
-dependencies = [
-    "snowflake-cli>=1.1.0",
-    "PyGithub"
-]
-version = "0.0.1"
-
-[project.entry-points."snowflake.cli.plugin.command"]
-release-plugin = "snowflakecli_internal_release_plugin.plugin_spec"
+# This cookiecutter template is not part of the snowflake-cli test suite. Its
+# files contain Jinja placeholders (`{{ cookiecutter.* }}`) and are not valid
+# Python, so the repo-wide pytest runs that collect from the project root
+# (e.g. `pytest -m performance`, `pytest -m e2e`) would fail trying to import
+# them. Ignore everything under this directory during collection; the generated
+# project ships its own valid tests.
+collect_ignore_glob = ["*"]

snowflake_cli-3.22.0/plugin-template/cookiecutter.json

@@ -0,0 +1,14 @@
+{
+    "plugin_name": "my-snow-plugin",
+    "plugin_module": "{{ cookiecutter.plugin_name | replace('-', '_') }}",
+    "plugin_class_name": "{{ cookiecutter.plugin_module | replace('_', ' ') | title | replace(' ', '') }}",
+    "package_namespace": "snowflakecli_plugins",
+    "cli_command_name": "{{ cookiecutter.plugin_name }}",
+    "cli_parent_path": "",
+    "plugin_description": "A Snowflake CLI plugin.",
+    "author_name": "Your Name",
+    "author_email": "you@example.com",
+    "requires_connection": true,
+    "command_type": ["group", "single"],
+    "python_requires": ">=3.10"
+}

snowflake_cli-3.22.0/plugin-template/{{cookiecutter.plugin_name}}/README.md

@@ -0,0 +1,53 @@
+<!--
+ Copyright (c) 2024 Snowflake Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+# {{ cookiecutter.plugin_name }}
+
+{{ cookiecutter.plugin_description }}
+
+## Development
+
+### Install in development mode
+
+```bash
+pip install -e .
+```
+
+### Enable the plugin
+
+```bash
+snow plugin enable {{ cookiecutter.plugin_module }}
+```
+
+### Run tests
+
+```bash
+pytest
+```
+
+## Plugin Structure
+
+| File | Purpose |
+|------|---------|
+| `interface.py` | Command surface definition (spec + handler ABC) -- reviewed in Phase 1 |
+| `handler.py` | Business logic implementation -- reviewed in Phase 2 |
+| `plugin_spec.py` | Wires interface + handler into Snowflake CLI |
+
+## Contributing
+
+1. Modify `interface.py` to define your command surface (Phase 1 PR)
+2. After approval, implement handlers in `handler.py` (Phase 2 PR)
+3. Run `pytest` to validate the interface-handler contract

snowflake_cli-3.22.0/plugin-template/{{cookiecutter.plugin_name}}/pyproject.toml

@@ -0,0 +1,38 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ cookiecutter.plugin_name }}"
+version = "0.1.0"
+description = "{{ cookiecutter.plugin_description }}"
+requires-python = "{{ cookiecutter.python_requires }}"
+authors = [
+    { name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}" },
+]
+dependencies = [
+    "snowflake-cli",
+]
+
+[project.entry-points."snowflake.cli.plugin.command"]
+{{ cookiecutter.plugin_module }} = "{{ cookiecutter.package_namespace }}.{{ cookiecutter.plugin_module }}.plugin_spec"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{{ cookiecutter.package_namespace }}"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

snowflake_cli-3.22.0/plugin-template/{{cookiecutter.plugin_name}}/src/{{cookiecutter.package_namespace}}/{{cookiecutter.plugin_module}}/handler.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""{{ cookiecutter.plugin_description }} -- Implementation.
+
+This file contains the concrete handler implementing the interface
+defined in ``interface.py``.  Submit this for review (Phase 2) after
+the interface has been approved.
+"""
+
+from __future__ import annotations
+
+from snowflake.cli.api.output.types import CommandResult, MessageResult
+
+from {{ cookiecutter.package_namespace }}.{{ cookiecutter.plugin_module }}.interface import (
+    {{ cookiecutter.plugin_class_name }}Handler,
+)
+
+
+class {{ cookiecutter.plugin_class_name }}HandlerImpl(
+    {{ cookiecutter.plugin_class_name }}Handler,
+):
+{% if cookiecutter.command_type == "group" %}
+    def hello(self, name: str) -> CommandResult:
+        return MessageResult(f"Hello, {name}!")
+
+    def status(self) -> CommandResult:
+        return MessageResult("Plugin is running.")
+{%- else %}
+    def run(self, name: str) -> CommandResult:
+        return MessageResult(f"Hello, {name}!")
+{%- endif %}