@gspothq/cli 0.1.1 → 0.2.0

package/configurations/language/python/rules/DESIGN.md

@@ -1,22 +1,27 @@
 # Python Design
 
+Read this rule when you write Python functions or classes.
+
 ## Functions
 
-I/O never hides in a helper that looks like a pure transformation. Declare an ordinary no-result case in the return type and return an explicit `None`; input that
-violates the API contract raises a specific exception. A generator owns its resource lifetime
+I/O never hides in a helper that looks like a pure transformation. Declare an ordinary no-result case in the signature and return an explicit `None`. Input that
+violates the API contract raises a specific exception.
+
+A generator owns its resource lifetime
 explicitly and documents its yielded values and cleanup contract. A partially consumed
 generator never holds a resource implicitly. A generator expression serves a consumer that
-only needs a lazy projection. Comprehensions serve one mapping or one filter; nested
+only needs a lazy projection. Comprehensions serve a single mapping or filter. Nested
 logic, several conditions, mutation, or a transformation that needs explanation gets an ordinary loop so
-its ordering stays visible.
+its order stays visible.
 
 ### Function conventions
 
 <!-- level: all -->
 
-A function owns one responsibility. Name it for its action and domain concept, except required framework callback names. Make side effects clear in its name or docstring. Plain
-functions and explicit data flow come before classes. When a function passes a limit, split
-out a step with a real name. If the limit does not fit the code, ask the user to raise it:
+A function owns one responsibility. Name it for its action and domain concept. Framework callbacks keep their required names. Make side effects clear in its name or docstring. Plain
+functions and explicit data flow come before classes.
+
+When a function goes over a size limit, extract one step and name it for what it does. If the limit does not fit the code, ask the user to raise it:
 
 ```python
 """Select recent message text under a validated nonnegative limit."""
@@ -41,11 +46,11 @@ def trim_history_messages(messages: Sequence[str], max_messages: int) -> list[st
 __all__ = ["trim_history_messages"]
 ```
 
-A nested function closes over a local value to make the outer function clearer, keeping its
+A nested function closes over a local value to make the outer code clearer, and keeps its
 captured state and lifetime explicit. It never exists to
 hide a helper from users or to turn a directly usable expression into a local call. A
-module-level private helper serves reusable logic that a nested function hides. A conversion that a named helper only
-forwards has its body placed directly at the call site.
+module-level private helper serves reusable logic that a nested function hides. When a named helper only
+forwards a conversion, put its body at the call site.
 
 Write a lambda as a one-line expression at its consumer, such as
 a sorting key `lambda item: item.name`. Prefer a generator expression or `operator` function over
@@ -55,12 +60,13 @@ operations gets `if` branches.
 
 ## Classes
 
-A class exists for real state, invariants, or behavior. Keep a coordinating function without
-polymorphism as a function. Never group static functions into a class. Related
-classes that form one contract, such as schemas, exceptions, protocols, and their records,
-stay together, and modules split by independent responsibility rather than class count. Plain
-data has public attributes, internal attributes carry one leading
-underscore, and a double underscore only protects a base class from subclass collisions.
+A class exists for real state, invariants, or behavior. Do not turn a coordinating function
+without polymorphism into a class. Never group static functions into a class.
+
+Keep classes that form one contract together, for example schemas, exceptions, protocols,
+and their records. Split modules by independent responsibility, not by class count. Plain
+data has public attributes. Internal attributes carry one leading underscore. Use a double
+underscore only to protect a base class from subclass collisions.
 
 `__init__` stays small, takes the values the class needs rather than the external objects
 that carry them, and validates invariants. Keep it separate from database rows, object-relational mapping (ORM) objects,
@@ -73,13 +79,14 @@ Loading, serialization, and validation systems stay outside the
 business object. Keep a derived attribute cheap and deterministic. Build it from initialized
 fields; a named constructor handles derivation through I/O or complex parsing.
 
-Use a dataclass as a typed plain data record with methods only from the data contract. Mutable
+Use a dataclass as a typed plain record with methods only from its data contract. Mutable
 defaults use `field(default_factory=...)`, and `__post_init__` holds cheap invariants and
-derived fields. A named constructor serves construction that needs parsing, I/O, or
-alternate sources. Never use it to disguise a mutable global configuration object. A frozen dataclass
+derived fields. Use a named constructor when creation needs parsing, I/O, or
+alternate sources.
+
+Never use it to disguise a mutable global configuration object. A frozen dataclass
 expresses a value fixed after construction. A project on `attrs` applies the same principles
-through its factories, validators, and converters, and do not introduce `attrs` to avoid a
-small dataclass or a function.
+through its factories, validators, and converters. Do not add `attrs` in place of a small dataclass or a function.
 
 ```python
 """Represent an independently owned batch of prompt text."""
@@ -105,30 +112,30 @@ __all__ = ["Batch"]
 
 <!-- level: all -->
 
-Document public dataclass fields in the configured docstring convention: Google style
-uses `Attributes:`, NumPy style an underlined `Attributes` heading.
+Document public dataclass fields in the configured docstring convention: `Attributes:` for
+Google style, an underlined `Attributes` heading for NumPy.
 
 A property provides cheap, unsurprising attribute access with no side effects. Never use it as a
-getter and setter over an internal attribute, expensive work, a rename of a stored attribute,
-or a computation subclasses must override. `@property` beats a hand-written descriptor unless
-the public interface requires descriptor behavior.
+getter and setter over an internal attribute, expensive work, a rename of a stored one,
+or a computation subclasses must override. Prefer `@property` to a hand-written descriptor unless
+the public interface requires one.
 
 ## Inheritance and decorators
 
-Design a class for inheritance or forbid inheritance. Composition shares code, and
+Design a class for inheritance or forbid it. Composition shares code, and
 protocols or small abstract base classes define interfaces. Reserve specialization for a
-subclass that adds to the base class and works wherever callers expect the base class. A
+subclass that extends the base class and works wherever callers expect its parent. A
 hierarchy never mixes code sharing, interface definition, and specialization, stays shallow,
-and lives physically together. Do not default to the template method pattern: a base class
+and lives physically together. Do not default to the template method pattern. A base class
 that defines control flow and calls subclass hooks takes more work to read than a function with
 explicit delegation.
 
-Do not put variants in one class with a type field and optional fields that apply to some values.
+Do not put variants in one class with a type field and optional attributes that apply to some values.
 Make invalid states unrepresentable. Behavior varying on more than one axis uses composition.
 Cross-cutting behavior such as tracking, caching, timing, or logging uses a wrapper that
-records completion only after the wrapped operation succeeds. An operation that varies by
-type without a clear owner may use `functools.singledispatch`. A class meant for subclassing
-documents its public API and its subclass API separately when the distinction matters.
+records completion only after the operation succeeds. An operation that varies by
+type without one class that handles it may use `functools.singledispatch`. A class meant for subclassing
+documents its public and subclass APIs separately when the distinction matters.
 
 A decorator removes real repetition or expresses a framework contract. It behaves
 unsurprisingly and preserves function metadata. Because it runs at import time, it never

package/configurations/language/python/rules/FLOW.md

@@ -1,5 +1,7 @@
 # Python Flow
 
+Read this rule when you write Python error handling, conditions, loops, or file handling.
+
 ## Exceptions and error handling
 
 Use explicit validation for external inputs and required preconditions. Avoid exceptions for
@@ -40,7 +42,7 @@ Keep the exception's public contract stable when changing its message.
 A custom exception inherits from `Exception`, describes its condition in the docstring, and
 lives beside the behavior that raises it rather than in a one-declaration file.
 
-Do not substitute a built-in exception for an external API's declared error type. Follow a
+Do not substitute a built-in exception for the declared error type of an external API. Follow a
 library's public error contract when callers depend on it.
 
 ## Assertions
@@ -78,9 +80,9 @@ requirements, not solely to shorten the implementation.
 
 ## Strings and output
 
-Use f-strings for ordinary value interpolation. Preserve formatting required by an external API,
-and keep logging arguments separate from the message when the logging API formats them lazily.
-Use efficient joining for a sequence of strings instead of repeatedly growing a large string.
+Use f-strings for ordinary value interpolation. Preserve formatting that an external API requires.
+Keep logging arguments apart from the message when the logger formats them lazily.
+Join a sequence of strings efficiently instead of repeatedly growing one large value.
 
 Formatting neither validates nor escapes values. Use parameterized database queries, argument arrays
 for subprocesses, and the appropriate encoder for HTML, JSON, or another output format.
@@ -88,7 +90,7 @@ for subprocesses, and the appropriate encoder for HTML, JSON, or another output
 ## Files and stateful resources
 
 Use context managers for resources with an explicit lifetime. Close files and network resources
-on both success and failure. Declare text encoding when opening a text file. Use binary mode
+on both success and failure. Declare the encoding when opening a text file. Use binary mode
 for bytes instead of relying on an implicit conversion.
 
 A generator can keep a resource open while suspended. Make that lifetime clear to callers,
@@ -118,7 +120,7 @@ if __name__ == "__main__":
 ```
 
 For large inputs, provide an explicit streaming interface whose caller owns the open resource
-or uses a context manager. Do not materialize the full input merely to avoid documenting its
+or uses a context manager. Do not materialize the full input only to avoid documenting its
 lifetime.
 
 Write to a temporary file in the same folder, validate it, then rename it over the target. Clean up only paths and resources owned by the current operation.

package/configurations/language/python/rules/PACKAGING.md

@@ -1,6 +1,6 @@
 # Python Packaging
 
-Deployment installs and lockfiles.
+Read this rule when you change Python dependencies, lockfiles, or package layout.
 
 ## Package installation security
 
@@ -10,15 +10,22 @@ Install from the uv lockfile:
 uv sync --frozen
 ```
 
-At level `all`, justify pip use with `gspot ignore python/pip-installs`. Update lockfiles only
+Update lockfiles only
 when the task includes dependency maintenance.
 
+### pip installs
+
+<!-- level: all -->
+
+`python/pip-installs` reports each `pip install`. Replace it with uv. When the project requires pip, follow the suppression
+rules.
+
 ## Import correctness
 
 - Respect the import-linter contracts the project declares.
-- Run entrypoints through the configured environment, installation, or module entrypoint.
-- Ensure packaged imports work outside the repository root. Do not depend on an accidental
-  current-directory import path.
+- Run each entrypoint through the configured environment, the installed package, or `python -m`.
+- Make packaged imports work outside the repository root. Do not depend on an accidental
+  current-folder import path.
 
 ## Packages and architecture
 
@@ -29,7 +36,7 @@ when the task includes dependency maintenance.
 - Do not use package `__init__.py` files to hide expensive imports.
 - Keep `__init__.py` files small and import-stable.
 - Barrel `__init__.py` files may contain imports and `__all__`.
-- Keep lower-level packages independent of higher-level workflow packages.
+- Keep lower-level packages independent of higher-level workflows.
 
 ## Source layout
 
@@ -46,4 +53,4 @@ src/
     accounts.py
 ```
 
-Keep helper scripts that nobody imports outside the package import path.
+Keep unimported helper scripts outside the package import path.

package/configurations/language/python/rules/PYTHON.md

@@ -1,33 +1,34 @@
 # Python
 
+Read this rule when you change Python code.
+
 ## Python scope
 
-Write readable Python before clever Python: explicit data flow, clear names, small functions,
+Prefer readable Python to clever tricks: explicit data flow, clear names, small functions,
 and the formatter's layout.
-Importing a module does no I/O, starts no work, and parses no arguments. Prefer the project's rules to generic style guides, and consistency with the
-surrounding module where a guide allows more than one style.
+Importing a module does no I/O, starts no work, and parses no arguments. Prefer the project's rules to generic style guides, and match the
+surrounding module where a guide allows several options.
 
 ## Runtime and files
 
-Use the syntax of the declared Python version, stated once in the runtime pin, and name
-version requirements in examples whose syntax depends on them. Use `.py` for source and
+Use the syntax of the declared Python version, stated once in the runtime pin. Name the
+version requirement of an example whose syntax depends on it. Use `.py` for source and
 `.pyi` for stubs.
 
 ### Comment language
 
 <!-- level: all -->
 
-Comments and docstrings use the project's declared language, and valid user content
-never restricts names to ASCII.
+Write comments and docstrings in the project's declared language. Accept valid user content outside ASCII.
 
 ## Environment and configuration
 
-An importable module never depends on an active shell, a virtual environment, the working directory, or a
+An importable module never depends on an active shell, a virtual environment, the current folder, or a
 globally installed package. Imports resolve through project configuration, editable
 installs, `python -m`, or the configured environment. Virtual environments and package caches
 stay out of commits.
 
-The configuration owner takes the environment as a mapping, so a test passes its own:
+The module that reads the configuration takes the environment as a mapping, so a test passes its own:
 
 ```python
 
@@ -59,24 +60,24 @@ Every runtime module has a docstring describing its present purpose.
 
 ## Imports
 
-Imports resolve in the declared project environment, never through the script directory on
-`sys.path`, and break cycles by moving shared data or interfaces into a lower-level module.
+Imports resolve in the declared project environment, never through the script folder on
+`sys.path`. Break import cycles by moving shared data or interfaces into a lower-level module.
 
 ### Import conventions
 
 <!-- level: all -->
 
-Imports sit at the top after the docstring and future imports, one per line, with typing and
-`collections.abc` symbols imported directly. Use absolute cross-package imports; explicit
-relative imports serve siblings inside a package where surrounding code does that. Never an
-implicit relative import, a wildcard import, an import inside a function, method, or class
-body in runtime code, or a dynamic import through `importlib.import_module`, `__import__`, or
-`builtins.__import__`.
+Place imports at the top after the docstring and future statements, one per line. Take typing and
+`collections.abc` symbols directly. Use absolute cross-package imports. Explicit
+relative ones serve siblings inside a package where surrounding code does that. Never use an
+implicit relative, wildcard, or dynamic import through `importlib.import_module`, `__import__`, or
+`builtins.__import__`. In runtime code, never import inside a function, method, or class body.
 
-Direct symbol imports keep call sites readable; use a module import when
-its prefix identifies the module, as `logging.getLogger(__name__)` does. Give every alias a reason. Two modules can share a final name, a module can collide with a local
-name, or a name can have too many words for the call site. A standard abbreviation such as `np` and a
-disambiguated generic name provide the other reasons.
+Direct symbol imports keep call sites readable. Import the module instead when
+its prefix identifies the source, as `logging.getLogger(__name__)` does. Give every alias a reason.
+Valid reasons include a shared final name between two modules, a collision with a local symbol,
+or too many words for the call site. A standard abbreviation such as `np` and a
+disambiguated generic name also count.
 
 ## Docstrings
 
@@ -94,9 +95,9 @@ here follow Google style.
 
 ## Constants, globals, and mutable state
 
-Prefer module constants. Do not expose mutable global state, lazy singletons, or mutable globals as
-public API. Required mutable state stays internal with its design reason documented,
-and no ordinary call mutates a module global as a hidden side effect. Validated configuration
+Prefer module constants. Do not expose mutable global state or lazy singletons as
+public API. Required mutable state stays internal, with its design reason documented.
+No ordinary call changes a module global as a hidden side effect. Validated configuration
 passes into the client or operation that consumes it, without a renaming wrapper.
 
 ### Constant naming
@@ -104,7 +105,7 @@ passes into the client or operation that consumes it, without a renaming wrapper
 <!-- level: all -->
 
 Name constants `UPPER_SNAKE`, private ones with one leading underscore, and retained module
-state takes a name for its concept.
+state for its concept.
 
 ## Main programs
 
@@ -114,23 +115,72 @@ Repository entrypoints run as `python -m package.module`, and shell scripts call
 modules rather than inline snippets. A shebang appears only on a file meant to execute
 directly.
 
-Never execute untrusted input as Python code, and dynamic execution never replaces input
-validation.
+Never execute untrusted input as Python code. Dynamic execution never replaces validation.
 
 ## Power features
 
 <!-- level: all -->
 
-Avoid power features unless the project has a clear local pattern and the feature serves
-necessary. That covers custom metaclasses, bytecode manipulation, dynamic inheritance, object
+Avoid power features unless the project already uses one and no plain alternative works. That covers custom metaclasses, bytecode manipulation, dynamic inheritance, object
 reparenting, import hooks, runtime monkeypatching, and reflection-heavy designs. It also
 covers interpreter internals, `__del__` cleanup, manual descriptors, and dynamic code
-generation. A power feature never makes code shorter or hides a dependency cycle; ordinary
-functions, dataclasses, explicit imports, and explicit data structures come first.
+generation. Never use a power feature to shorten code or hide a dependency cycle. Ordinary
+functions, dataclasses, and explicit imports and data structures come first.
 
 ## Threading
 
-Built-in types and variable assignment do not synchronize threads: use `queue.Queue` for thread
+Built-in types and variable assignment do not synchronize threads. Use `queue.Queue` for
 communication and locks or conditions for shared state, which stays small and explicit.
 
-Name Python test files `test_<behavior>.py`, grouped by behavior.
+## Naming
+
+### Command inputs and external names
+
+<!-- level: all -->
+
+- CLI flags use lowercase kebab case, such as `--account-name` and
+  `--output-dir`.
+- Avoid single-letter names except loop counters and math notation.
+- Preserve provider capitalization in external names such as `AWS_REGION` and
+  resource IDs.
+
+### Python modules and imports
+
+<!-- level: all -->
+
+- Name test files `test_<behavior>.py`, grouped by behavior.
+
+- Do not create package-level re-export layers only to preserve old names.
+- Keep `__all__` names accurate and ordered according to local lint rules.
+
+Import `AccountSettings` under its declared name. An alias such as `Thing`
+hides the contract and provides no collision information.
+
+### Python types and dataclasses
+
+<!-- level: all -->
+
+- Dataclass names describe the domain value they represent.
+- Field names describe the value inside the owning type without repeating it.
+- Give `Path` variables names that reveal whether they point to a folder,
+  file, report, output, or repository root.
+- Use `*_path` for filesystem paths and `*_dir` only for folders.
+- Use `*_id` only for real identifiers. Never use it for arbitrary names or labels.
+- Use `*_name` for display or provider names.
+- Use `*_key` for dictionary and supported variant keys.
+
+| Avoid                    | Prefer           | Meaning             |
+| ------------------------ | ---------------- | ------------------- |
+| `Invoice.invoice_number` | `Invoice.number` | The invoice number. |
+| `Shipment.shipment_date` | `Shipment.date`  | The shipment date.  |
+
+### Python boundary names
+
+<!-- level: all -->
+
+- Keep raw provider or CLI names at the boundary.
+- Translate an external name into the domain term before passing values inward when
+  the two differ.
+- Keep path construction with the code that owns the resource instead of repeating it in
+  unrelated operations.
+- Name functions that cross boundaries for the operation they perform.

package/configurations/language/python/rules/TYPING.md

@@ -1,5 +1,7 @@
 # Python Typing
 
+Read this rule when you write Python type annotations.
+
 ## Annotations
 
 <!-- level: all -->
@@ -23,13 +25,13 @@ def group_records[Key: Hashable](records: Iterable[tuple[Key, str]]) -> dict[Key
     return grouped
 ```
 
-The type parameter syntax needs Python 3.12; `Key` connects input keys to output keys, and
+The type parameter syntax needs Python 3.12. `Key` ties the input to the output, and
 `Hashable` states the dictionary-key requirement. A variable annotation appears where the
 compiler cannot infer a clear type, such as an empty collection, not on every
 intermediate value.
 
-`typing.Annotated` attaches framework or validation metadata to a real type, real type
-first. The default stays an ordinary parameter default and never repeats in the
+`typing.Annotated` attaches framework or validation metadata to a real type, which comes
+first. The default stays an ordinary parameter value and never repeats in the
 metadata object. Arbitrary string metadata never replaces a domain type or validator. A
 FastAPI query field reads `Annotated[str | None, Query(max_length=50)] = None`.
 
@@ -37,12 +39,12 @@ FastAPI query field reads `Annotated[str | None, Query(max_length=50)] = None`.
 
 Use `object` for a value of any type when the function only uses operations
 every object has, such as passing it to `str()`. Also use it for an ignored callback
-result. Reserve `Any` for a type the type system cannot express, a correct type that makes the
-API unreasonable, or a value that intentionally escapes checking. Never use it as a shortcut; a
+result. Reserve `Any` for what the type system cannot express, a correct annotation that makes the
+API unreasonable, or a value that escapes checking on purpose. Never use it as a shortcut; a
 protocol, type variable, overload, or small value object models the contract first.
 
 Arguments take protocols and abstract collections from `collections.abc`, such as `Iterable`,
-`Sequence`, `Mapping`, or `Callable`, and `object` for any value. Concrete implementations return
+`Sequence`, `Mapping`, or `Callable`, and `object` for any value. Implementations return
 concrete types such as `list`, `dict`, or a dataclass. Protocols and abstract base classes choose
 return types by the promised interface. A union return that forces callers into an immediate
 `isinstance()` branch becomes separate functions, a tagged dataclass, a protocol, or a small
@@ -52,34 +54,34 @@ Use `float` for numeric APIs that also accept integers. Use `str` for text and `
 `AnyStr` ties several annotations to one text or binary type.
 
 A `Path | None = None` input handles its `None` branch
-before calling path methods, and the default path belongs to the configuration owner. Generic
+before calling path methods. The default path belongs to the module that reads the configuration. Generic
 types name their parameters, such as `Sequence[int]`. A bare `Sequence` or `dict` exists only when
-the element type intentionally accepts any type and says so with `Any`. A `TypeVar` connects
+the elements accept any value on purpose and say so with `Any`. A `TypeVar` connects
 input and output types when that relationship matters, as `Key` does above.
 
 ## Aliases, variables, and forward references
 
-A type alias names a complex repeated type in CapWords, with a leading underscore when
-internal. It uses a `type` statement when the Python version supports it and the module
-already uses it, or `TypeAlias` where a syntax change falls outside the task. `MetricMap` for
-`Mapping[str, float]` names an alias; `Path = pathlib.Path` names a class alias and `errno.EEXIST` a
-value, and neither defines a typing interface.
+A type alias names a complex repeated annotation in CapWords, with a leading underscore when
+internal. Use a `type` statement when the Python version supports it and the module
+already does. Use `TypeAlias` where a syntax change falls outside the task. `MetricMap` for
+`Mapping[str, float]` names an alias. `Path = pathlib.Path` aliases a class and `errno.EEXIST` holds a
+value; neither defines a typing interface.
 
 ### Type variable naming
 
 <!-- level: all -->
 
-A private unconstrained type variable can use `_T` or `_P`; a public or constrained one has a
-descriptive name such as `Key`, with `_co` and `_contra` for variance, and no public
-single-letter `T` or `P`. `ParamSpec` forwards a callable's parameters, and declare a `Callable` with
-bound to the signature its consumer needs rather than left bare.
+A private unconstrained type variable can use `_T` or `_P`. A public or constrained one has a
+descriptive name such as `Key`, with `_co` and `_contra` for variance, never a
+single-letter `T` or `P`. `ParamSpec` forwards the parameters of a callable. Give a `Callable` the
+signature its consumer needs; do not leave it bare.
 
 ### Forward references
 
 `from __future__ import annotations` handles forward references and stays as the project's
-convention even where newer Python defers evaluation. String annotations exist only where
-the runtime does not provide future annotations or a type-checking-only import needs them. A
-`TYPE_CHECKING` import avoids a runtime import only when the runtime does not need the
+convention even where newer Python defers evaluation. Quote a type only where
+the runtime does not provide future annotations or a type-checking-only import needs it. Use a
+`TYPE_CHECKING` import only when the runtime does not need the
 symbol. Validators and frameworks that evaluate annotations need the real import. A type-only circular
 import signals a need to move the shared contract.
 
@@ -109,9 +111,9 @@ class Node:
 
 ## Protocols
 
-Define a structural interface with a narrow `typing.Protocol` near the consumer, with
-only what that consumer needs; implementations satisfy it without importing or subclassing
-it. `@runtime_checkable` exists only for a real `isinstance()` need, and an abstract base
+Define a structural interface with a narrow `typing.Protocol` near the consumer, holding
+only what it needs. Implementations satisfy it without importing or subclassing
+it. `@runtime_checkable` exists only for a real `isinstance()` need. An abstract base
 class serves nominal identity, runtime instantiation checks, or a standard-library contract,
 never shared implementation mixed with interface definition.
 

package/configurations/language/sql/manifest.toml

@@ -1,68 +1,50 @@
 allowed_words = ["SQL"]
+
 [configuration]
-title = "SQL"
+description = "SQLFluff checks layout and style in the project dialect. At level all, the configuration also checks line comments and file length."
 suggests = []
-description = "SQLFluff checks layout and style in the project dialect. At all, SQL checks line comments, file length, and PostgreSQL function structure."
+title = "SQL"
 
 [files]
 extensions = [".sql", ".pgsql", ".psql"]
 
 [[tool]]
-name = "sqlfluff"
+brew = "sqlfluff"
 crash_pattern = '^Traceback \(most recent call last\):$'
-suppression = { marker = "\\bnoqa\\b", reason = "--[^\\n]*?-- ?(?<reason>\\S.*)" }
-version = "4.3.0"
 min_version = "3.0.0"
-pypi = "sqlfluff"
 mise = "pipx:sqlfluff"
-brew = "sqlfluff"
-[[tool.replace]]
-file = ".sqlfluff"
-shared = false
-
-[[tool.replace]]
-file = ".sqlfluffignore"
-shared = false
+name = "sqlfluff"
+pypi = "sqlfluff"
+replace = [".sqlfluff", ".sqlfluffignore"]
+suppression = { marker = "\\bnoqa\\b", reason = "--[^\\n]*?-- ?(?<reason>\\S.*)" }
+version = "4.3.0"
 
-[[tool.replace]]
+[[tool.replace_key]]
 file = "pyproject.toml"
 table = "tool.sqlfluff"
-shared = true
 
-[[tool.replace]]
+[[tool.replace_key]]
 file = "setup.cfg"
 table = "sqlfluff"
-shared = true
 
-[[tool.replace]]
+[[tool.replace_key]]
 file = "tox.ini"
 table = "sqlfluff"
-shared = true
 
 [[tool_file]]
+per_scope = true
 target = ".gspot/config/sqlfluff.cfg"
 tool = "sqlfluff"
-per_scope = true
-rule_keys = ["sqlfluff.exclude_rules", "sqlfluff:rules"]
 
 [[check]]
-name = "sqlfluff"
-example = "The query `select id from user_accounts;` reports CP01 under the configured uppercase keyword policy. Format it as `SELECT id FROM user_accounts;` and rerun using the project dialect."
-level = "recommended"
-stage = "commit"
 command = ["sqlfluff", "lint", "--config", "{tool_file:sqlfluff}", "--ignore-local-config", "--disable-progress-bar", "--format", "json", "{files}"]
+example = "The query `select id from user_accounts;` reports CP01 for lowercase keywords. Write it as `SELECT id FROM user_accounts;`."
 exit_codes = [1]
 fix = ["sqlfluff", "fix", "--config", "{tool_file:sqlfluff}", "--ignore-local-config", "--disable-progress-bar", "{files}"]
+help = "Run `gspot check --fix`. Turn one rule off with `gspot ignore sql/sqlfluff --rule <code> --reason \"<why>\"`."
+level = "recommended"
+name = "sqlfluff"
 output = { format = "json", children = "violations", fields = { file = "filepath", line = "start_line_no", column = "start_line_pos", rule = "code", message = "description" } }
-summary = "Lints every SQL file for layout, capitalization, aliasing, and ambiguous references, in the dialect the database configuration names."
-why = "SQL that reads one way in every file lets a reviewer look at what the statement does."
-help = "Run gspot check --fix. Turn one rule off with gspot ignore sql/sqlfluff --rule `<code>` --reason \"`<why>`\"."
-
-[[check]]
-name = "functions"
-example = "A SQL function that only forwards one expression reports a trivial-function finding. Inline unnecessary calls and delete the function. If an external API requires the signature, record that with `gspot ignore` and a reason."
-level = "all"
 stage = "commit"
-summary = "For the postgres dialect, reports trivial SQL and PL/pgSQL functions and excessive declared input parameters."
-why = "Unnecessary functions add indirection; excessive parameters obscure responsibilities."
-help = "Inline unnecessary functions. If a required API needs one, run `gspot ignore sql/functions --paths <file> --reason <why>`. Reduce parameters or configure limits.sql.function_parameters."
+summary = "Lints every SQL file for layout, capitalization, aliasing, and ambiguous references, in the dialect the database configuration names."
+why = "When every SQL file follows one style, a reviewer can focus on what each statement does."