sqlbuild 0.91.2__tar.gz → 0.91.4__tar.gz

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/Cargo.lock

@@ -597,7 +597,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.91.2"
+version = "0.91.4"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.91.2
+Version: 0.91.4
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql==0.9.2

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.91.2"
+version = "0.91.4"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.91.2"
+version = "0.91.4"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/cli/commands/_helpers/audit/outputs.py

@@ -61,7 +61,7 @@ def write_audit_completion_output(
             document["projection_degraded"] = True
             document["projection_degradation_reasons"] = [
                 {
-                    "reason": "audit_result_persistence_failure",
+                    "reason": "audit_result_projection_failure",
                     "attempted_count": projection.attempted_count,
                     "written_count": projection.written_count,
                     "failed_count": projection.failed_count,

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/cli/commands/_helpers/build_execution/outputs.py

@@ -172,7 +172,7 @@ def _with_audit_result_projection(*, payload: str, result: BuildExecutionResult)
         )
         reasons.append(
             {
-                "reason": "audit_result_persistence_failure",
+                "reason": "audit_result_projection_failure",
                 "attempted_count": attempted,
                 "written_count": written,
                 "failed_count": failed,

sqlbuild-0.91.4/src/sqlbuild/cli/commands/_helpers/contract/__init__.py

@@ -0,0 +1 @@
+"""Contract command helpers."""

sqlbuild-0.91.4/src/sqlbuild/cli/commands/_helpers/contract/progress.py

@@ -0,0 +1,128 @@
+"""Lifecycle progress for contract inspection and repository updates."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, TextIO
+
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands.models import AdapterConnectionContext, ContractCommandRequest
+from sqlbuild.cli.progress.classes.connection_progress_reporter import (
+    ConnectionProgressReporter,
+)
+from sqlbuild.compiler.compile.models import CompiledModel, CompiledSource
+from sqlbuild.compiler.contract_adoption.main.compare import compare_contracts
+from sqlbuild.compiler.contract_adoption.models import ContractAdoptionResult, ContractEvidence
+from sqlbuild.compiler.pipeline.models import ProjectGraph
+from sqlbuild.presentation.classes.transient_status_reporter import TransientStatusReporter
+
+
+def inspect_contracts_with_progress(
+    *,
+    context: AdapterConnectionContext,
+    request: ContractCommandRequest,
+    selected_models: tuple[CompiledModel, ...],
+    selected_sources: tuple[CompiledSource, ...],
+    progress_stream: TextIO,
+    use_progress_color: bool,
+) -> tuple[ContractEvidence, ...]:
+    """Connect once and report contract inspection lifecycle progress."""
+
+    connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
+        adapter_name=context.adapter_name,
+        stream=progress_stream,
+        use_color=use_progress_color,
+    )
+    connection_started: float = time.monotonic()
+    connection_progress.on_connection_start(1)
+    try:
+        connection: Any = context.adapter.connect(context.connection_config)
+    except Exception:
+        connection_progress.on_connection_error(
+            connection_count=1,
+            elapsed_seconds=time.monotonic() - connection_started,
+        )
+        raise
+    try:
+        connection_progress.on_connection_complete(
+            connection_count=1,
+            elapsed_seconds=time.monotonic() - connection_started,
+        )
+
+        resource_count: int = len(selected_models) + len(selected_sources)
+        resource_label: str = "contract" if resource_count == 1 else "contracts"
+        inspection_progress: TransientStatusReporter = TransientStatusReporter(
+            stream=progress_stream,
+            use_color=use_progress_color,
+        )
+        inspection_started: float = time.monotonic()
+        inspection_progress.start(
+            f"Inspecting {resource_count} {resource_label} from target '{request.from_target}'..."
+        )
+        try:
+            evidence: tuple[ContractEvidence, ...] = compare_contracts(
+                adapter=context.adapter,
+                connection=connection,
+                models=selected_models,
+                sources=selected_sources,
+            )
+        except Exception:
+            inspection_progress.error(
+                f"Contract inspection failed after {time.monotonic() - inspection_started:.2f}s"
+            )
+            raise
+        inspection_progress.complete(
+            message=(
+                f"Inspected {resource_count} {resource_label} from target "
+                f"'{request.from_target}' ({time.monotonic() - inspection_started:.2f}s)"
+            )
+        )
+    finally:
+        context.adapter.close(connection)
+    return evidence
+
+
+def write_contract_updates_with_progress(
+    *,
+    project_dir: Path,
+    graph: ProjectGraph,
+    result: ContractAdoptionResult,
+    request: ContractCommandRequest,
+    adapter: BaseAdapter,
+    progress_stream: TextIO,
+    use_progress_color: bool,
+) -> ContractAdoptionResult:
+    """Write contract declarations and report repository-update lifecycle progress."""
+
+    from sqlbuild.compiler.contract_adoption.main.write import write_contracts
+
+    write_progress: TransientStatusReporter = TransientStatusReporter(
+        stream=progress_stream,
+        use_color=use_progress_color,
+    )
+    write_started: float = time.monotonic()
+    write_progress.start("Updating repository contracts...")
+    try:
+        updated_result: ContractAdoptionResult = write_contracts(
+            project_dir=project_dir,
+            graph=graph,
+            result=result,
+            overwrite=request.overwrite,
+            adapter=adapter,
+            cli_vars=request.cli_vars,
+        )
+    except Exception:
+        write_progress.error(
+            f"Repository contract update failed after {time.monotonic() - write_started:.2f}s"
+        )
+        raise
+    written_count: int = len(updated_result.written_paths)
+    written_label: str = "file" if written_count == 1 else "files"
+    write_progress.complete(
+        message=(
+            f"Updated repository contracts ({written_count} {written_label}, "
+            f"{time.monotonic() - write_started:.2f}s)"
+        )
+    )
+    return updated_result

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/cli/commands/_helpers/entry/dispatch_errors.py

@@ -34,6 +34,7 @@ def dispatch_and_handle_errors(
 ) -> int:
     """Dispatch once and preserve the CLI's established error projection."""
 
+    _report_skill_freshness(invocation=invocation)
     try:
         return dispatch_with_observability(args=args, handlers=handlers)
     except SystemExit as error:
@@ -65,8 +66,6 @@ def dispatch_and_handle_errors(
             file=sys.stderr,
         )
         return 1
-    finally:
-        _report_skill_freshness(invocation=invocation)
 
 
 def _report_skill_freshness(*, invocation: ParsedCliInvocation) -> None:
@@ -80,7 +79,7 @@ def _report_skill_freshness(*, invocation: ParsedCliInvocation) -> None:
     project_dir: Path = Path(args.project_dir) if args.project_dir is not None else Path.cwd()
     try:
         result: SkillMaintenanceResult = maintain_sqlbuild_skills(project_dir=project_dir)
-    except (CliUserError, OSError):
+    except (CliUserError, OSError, UnicodeError):
         return
     if result.message:
         print(result.message, file=sys.stderr, end="")

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/cli/commands/_helpers/skills/update.py

@@ -186,7 +186,7 @@ def maintain_sqlbuild_skills(*, project_dir: Path) -> SkillMaintenanceResult:
     if settings.auto_update and stale_paths:
         for path in stale_paths:
             write_skill_file(path=path, content=expected_content)
-        message: str = "\nUpdated stale SQLBuild skill files:\n" + "".join(
+        message: str = "Updated stale SQLBuild skill files:\n" + "".join(
             f"  {path}\n" for path in stale_paths
         )
         if collision_paths:
@@ -203,7 +203,7 @@ def _stale_skill_message(*, collision_paths: list[Path]) -> str:
         collision_detail = "  Custom files were not overwritten:\n" + "".join(
             f"    {path}\n" for path in collision_paths
         )
-    return f"\nSQLBuild skill files are out of date\n{collision_detail}  Run: sqb skills\n"
+    return f"SQLBuild skill files are out of date\n{collision_detail}  Run: sqb skills\n"
 
 
 def _local_install_path(*, project_dir: Path, target_name: str) -> Path:

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/cli/commands/main/inspection/_contract.py

@@ -3,16 +3,20 @@
 from __future__ import annotations
 
 import json
+import sys
 from pathlib import Path
-from typing import Any
+from typing import TextIO
 
+from sqlbuild.cli.commands._helpers.contract.progress import (
+    inspect_contracts_with_progress,
+    write_contract_updates_with_progress,
+)
 from sqlbuild.cli.commands._helpers.runtime.adapter_context import (
     resolve_adapter_connection_context,
 )
 from sqlbuild.cli.commands.exceptions import CliUserError
 from sqlbuild.cli.commands.models import AdapterConnectionContext, ContractCommandRequest
 from sqlbuild.compiler.compile.models import CompiledModel, CompiledObjectKey, CompiledSource
-from sqlbuild.compiler.contract_adoption.main.compare import compare_contracts
 from sqlbuild.compiler.contract_adoption.models import ContractAdoptionResult, ContractEvidence
 from sqlbuild.compiler.contract_adoption.types import ContractAction
 from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
@@ -22,6 +26,7 @@ from sqlbuild.compiler.pipeline.models import ProjectGraph
 from sqlbuild.compiler.planner.main.selection.selection import (
     resolve_project_selectors,
 )
+from sqlbuild.presentation.main.supports_color import supports_color
 
 
 def run_contract(request: ContractCommandRequest) -> int:
@@ -66,29 +71,29 @@ def run_contract(request: ContractCommandRequest) -> int:
     )
     if not selected_models and not selected_sources:
         raise CliUserError("contract selection contains no models or sources", code="C473")
-    connection: Any = context.adapter.connect(context.connection_config)
-    try:
-        evidence: tuple[ContractEvidence, ...] = compare_contracts(
-            adapter=context.adapter,
-            connection=connection,
-            models=selected_models,
-            sources=selected_sources,
-        )
-    finally:
-        context.adapter.close(connection)
+
+    progress_stream: TextIO = sys.stderr if request.json_output else sys.stdout
+    use_progress_color: bool = not request.no_color and not request.json_output and supports_color()
+    evidence: tuple[ContractEvidence, ...] = inspect_contracts_with_progress(
+        context=context,
+        request=request,
+        selected_models=selected_models,
+        selected_sources=selected_sources,
+        progress_stream=progress_stream,
+        use_progress_color=use_progress_color,
+    )
     result: ContractAdoptionResult = ContractAdoptionResult(
         from_target=request.from_target, evidence=evidence
     )
     if request.action == ContractAction.GENERATE and request.write:
-        from sqlbuild.compiler.contract_adoption.main.write import write_contracts
-
-        result = write_contracts(
+        result = write_contract_updates_with_progress(
             project_dir=project_dir,
             graph=graph,
             result=result,
-            overwrite=request.overwrite,
+            request=request,
             adapter=context.adapter,
-            cli_vars=request.cli_vars,
+            progress_stream=progress_stream,
+            use_progress_color=use_progress_color,
         )
     _write_output(request=request, result=result)
     return 1 if result.findings else 0

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/executor/auditing/_helpers/result_projection.py

@@ -20,7 +20,6 @@ from sqlbuild.executor.audit_results.constants import AUDIT_RESULT_SCHEMA_VERSIO
 from sqlbuild.executor.audit_results.exceptions import AuditResultStorageError
 from sqlbuild.executor.audit_results.main._write import write_audit_result_records
 from sqlbuild.executor.audit_results.models import AuditResultRecord, build_audit_result_id
-from sqlbuild.executor.auditing.exceptions import AuditResultProjectionError
 from sqlbuild.executor.auditing.models import AuditExecutionResult, AuditResultProjection
 from sqlbuild.runtime.observability.classes.operation_lifecycle import OperationLifecycle
 from sqlbuild.runtime.observability.main.current_execution_identity import (
@@ -88,8 +87,6 @@ def project_audit_result_batch_impl(
             storage_database=database,
             storage_schema=schema,
         )
-        for record in records:
-            _ = _publish_audit_completed(record)
     except Exception as error:
         _LOGGER.warning(
             "Audit result projection degraded: attempted=%d written=0 failed=%d (%s)",
@@ -102,6 +99,22 @@ def project_audit_result_batch_impl(
         )
         _LAST_AUDIT_RESULT_PROJECTION.set(projection)
         return projection
+    unmatched_count: int = len(executed) - len(records)
+    for record in records:
+        try:
+            _publish_audit_completed(record)
+        except Exception as error:
+            _LOGGER.warning(
+                "Audit result lifecycle publication degraded for '%s' (%s)",
+                record.audit_name,
+                error,
+            )
+    if not records:
+        projection = AuditResultProjection(
+            attempted_count=len(executed), failed_count=len(executed)
+        )
+        _LAST_AUDIT_RESULT_PROJECTION.set(projection)
+        return projection
     try:
         write_audit_result_records(
             connection=connection,
@@ -117,14 +130,20 @@ def project_audit_result_batch_impl(
     except AuditResultStorageError as error:
         _LOGGER.warning(
             "Audit result persistence degraded: attempted=%d written=0 failed=%d (%s)",
-            len(records),
-            len(records),
+            len(executed),
+            len(executed),
             error,
         )
-        projection = AuditResultProjection(attempted_count=len(records), failed_count=len(records))
+        projection = AuditResultProjection(
+            attempted_count=len(executed), failed_count=len(executed)
+        )
         _LAST_AUDIT_RESULT_PROJECTION.set(projection)
         return projection
-    projection = AuditResultProjection(attempted_count=len(records), written_count=len(records))
+    projection = AuditResultProjection(
+        attempted_count=len(executed),
+        written_count=len(records),
+        failed_count=unmatched_count,
+    )
     _LAST_AUDIT_RESULT_PROJECTION.set(projection)
     return projection
 
@@ -146,9 +165,10 @@ def _build_records(
             None,
         )
         if entry is None:
-            raise AuditResultProjectionError(
-                f"audit result '{result.audit_name}' does not match a planned audit entry"
+            _LOGGER.warning(
+                "Audit result projection skipped unknown audit result '%s'", result.audit_name
             )
+            continue
         audit_id: AuditIdentity = build_audit_gate_identity(audits=(entry,)).audits[0]
         occurrence_key: tuple[str, str] = (audit_id.binding_key, result.run_scope_phase.value)
         ordinal: int = occurrence[occurrence_key]

{sqlbuild-0.91.2 → sqlbuild-0.91.4}/src/sqlbuild/executor/auditing/exceptions.py

@@ -3,7 +3,3 @@
 
 class AuditMeasurementExecutionError(Exception):
     """Raised when an internally validated measurement contract is unavailable."""
-
-
-class AuditResultProjectionError(Exception):
-    """Raised when executed audit results cannot be projected consistently."""