refactor: remove autocommit checker, delegate to squawk config

The custom autocommit block checker duplicated what squawk handles
natively via `assume_in_transaction` in `.squawk.toml`. Consumers
configure this in their own repo, keeping the hook as a thin wrapper.

Also consolidates version-check workflow into ci.yml and bumps to v0.3.0.

Author: stephen-kintsugi

.github/workflows/ci.yml

@@ -32,5 +32,15 @@ jobs:
       - name: Run pre-commit hooks
         run: poetry run pre-commit run --all-files
 
+      - name: Check version consistency
+        run: |
+          PYPROJECT_VERSION=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/')
+          INIT_VERSION=$(grep '^__version__ = ' squawk_alembic/__init__.py | sed 's/__version__ = "\(.*\)"/\1/')
+          if [ "$PYPROJECT_VERSION" != "$INIT_VERSION" ]; then
+            echo "::error::Version mismatch: pyproject.toml ($PYPROJECT_VERSION) != __init__.py ($INIT_VERSION)"
+            echo "Run 'make bump VERSION=x.y.z' to update both files."
+            exit 1
+          fi
+
       - name: Run tests
         run: poetry run pytest tests/ -v

.github/workflows/version-check.yml

@@ -4,16 +4,14 @@ A [pre-commit](https://pre-commit.com/) hook that lints SQL in [Alembic](https:/
 
 Squawk operates on raw SQL files, but Alembic migrations are Python. This hook bridges the gap by generating DDL via `alembic upgrade --sql` (offline mode) and passing the complete SQL output to squawk for analysis. This captures all SQL statements a migration produces, including ORM operations like `op.create_index()`, `op.create_table()`, and `op.alter_column()`.
 
-The hook also checks that concurrent index operations (`CONCURRENTLY` in `op.execute()` or `postgresql_concurrently=True` in `op.create_index()` / `op.drop_index()`) are wrapped in `autocommit_block()`.
-
 ## Usage
 
 Add the following to your `.pre-commit-config.yaml`:
 
 ```yaml
 repos:
-    - repo: https://github.com/kintsugi-tax/kintsugi-squawk
-      rev: v0.2.0
+    - repo: https://github.com/kintsugi-tax/squawk-pre-commit
+      rev: v0.3.0
       hooks:
           - id: squawk-alembic
 ```
@@ -26,9 +24,8 @@ When pre-commit runs, the hook:
 
 1. Parses `alembic.ini` to find the migrations `versions/` directory
 2. Filters staged files to only those under that directory
-3. Checks for concurrent operations outside `autocommit_block()`
-4. Runs `alembic upgrade --sql` to generate the complete DDL for each migration
-5. Pipes the generated SQL to squawk for linting
+3. Runs `alembic upgrade --sql` to generate the complete DDL for each migration
+4. Pipes the generated SQL to squawk for linting
 
 Merge migrations (where `down_revision` is a tuple) are skipped since they produce no DDL.
 
@@ -55,5 +52,5 @@ To test the hook against a consumer repo locally:
 
 ```bash
 cd /path/to/consumer-repo
-pre-commit try-repo /path/to/kintsugi-squawk squawk-alembic --all-files
+pre-commit try-repo /path/to/squawk-pre-commit squawk-alembic --all-files
 ```

README.md

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "squawk-alembic"
-version = "0.2.0"
+version = "0.3.0"
 description = "Pre-commit hook to lint Alembic migration SQL with squawk"
 packages = [{include = "squawk_alembic"}]
 

pyproject.toml

@@ -1 +1 @@
-__version__ = "0.2.0"
+__version__ = "0.3.0"

squawk_alembic/__init__.py

@@ -126,86 +126,6 @@ def generate_sql(filepath):
     return result.stdout
 
 
-def check_autocommit_blocks(filepath):
-    """Check that CONCURRENTLY operations are inside autocommit blocks."""
-    with open(filepath) as f:
-        try:
-            tree = ast.parse(f.read())
-        except SyntaxError:
-            return []
-
-    checker = _AutocommitChecker()
-    checker.visit(tree)
-    return checker.warnings
-
-
-def _has_concurrent_kwarg(node):
-    """Check if an AST Call node has postgresql_concurrently=True."""
-    for kw in node.keywords:
-        if (
-            kw.arg == "postgresql_concurrently"
-            and isinstance(kw.value, ast.Constant)
-            and kw.value.value is True
-        ):
-            return True
-    return False
-
-
-class _AutocommitChecker(ast.NodeVisitor):
-    def __init__(self):
-        self.warnings = []
-        self._in_autocommit = False
-
-    def visit_With(self, node):
-        is_autocommit = any(
-            isinstance(item.context_expr, ast.Call)
-            and isinstance(item.context_expr.func, ast.Attribute)
-            and item.context_expr.func.attr == "autocommit_block"
-            for item in node.items
-        )
-        if is_autocommit:
-            old = self._in_autocommit
-            self._in_autocommit = True
-            self.generic_visit(node)
-            self._in_autocommit = old
-        else:
-            self.generic_visit(node)
-
-    def visit_Call(self, node):
-        if (
-            isinstance(node.func, ast.Attribute)
-            and isinstance(node.func.value, ast.Name)
-            and node.func.value.id == "op"
-        ):
-            # op.execute("...CONCURRENTLY...")
-            if node.func.attr == "execute" and node.args:
-                sql = _extract_string(node.args[0])
-                if sql and "concurrently" in sql.lower() and not self._in_autocommit:
-                    self.warnings.append(node.lineno)
-
-            # op.create_index(..., postgresql_concurrently=True)
-            # op.drop_index(..., postgresql_concurrently=True)
-            if node.func.attr in ("create_index", "drop_index"):
-                if _has_concurrent_kwarg(node) and not self._in_autocommit:
-                    self.warnings.append(node.lineno)
-
-        self.generic_visit(node)
-
-
-def _extract_string(node):
-    """Extract a string value from an AST node, handling common wrappers."""
-    if isinstance(node, ast.Constant) and isinstance(node.value, str):
-        return node.value
-
-    if isinstance(node, ast.Call) and node.args:
-        if isinstance(node.func, ast.Attribute) and node.func.attr == "text":
-            return _extract_string(node.args[0])
-        if isinstance(node.func, ast.Name) and node.func.id == "text":
-            return _extract_string(node.args[0])
-
-    return None
-
-
 def main():
     files = sys.argv[1:]
     if not files:
@@ -227,13 +147,6 @@ def main():
         except ValueError:
             continue
 
-        autocommit_warnings = check_autocommit_blocks(filepath)
-        for lineno in autocommit_warnings:
-            print(
-                f"{filepath}:{lineno}: CONCURRENTLY operation outside autocommit_block()"
-            )
-            exit_code = 1
-
         sql = generate_sql(filepath)
         if not sql:
             continue