sqlbuild 0.85.0__tar.gz → 0.86.0__tar.gz

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/Cargo.lock

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

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/PKG-INFO

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

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/crates/sqlbuild-kata-native/src/sql_lint/_helpers/engine.rs

@@ -7,25 +7,55 @@ use polyglot_sql::tokens::{Span, Token, TokenType};
 use polyglot_sql::{Dialect, DialectType, Expression, ExpressionWalk, Parser};
 
 use crate::sql_lint::constants::LINT_API_VERSION;
-use crate::sql_lint::models::{LintDiagnostic, LintRequest, LintResponse, QueryFacts};
-
-const NULL_COMPARISON: &str = "SQBL001";
-const IMPLICIT_CARTESIAN_JOIN: &str = "SQBL002";
-const JOIN_WITHOUT_CONDITION: &str = "SQBL003";
-const UNORDERED_LIMIT: &str = "SQBL004";
-const UNUSED_CTE: &str = "SQBL005";
-const REDUNDANT_DISTINCT: &str = "SQBL006";
-const POSITIONAL_SET_STAR: &str = "SQBL007";
+use crate::sql_lint::models::{
+    LintDiagnostic, LintRequest, LintResponse, LintRuleMetadata, QueryFacts,
+};
+
+const NULL_COMPARISON: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL001",
+    message: "Comparison with NULL is never true",
+    remediation: "Use IS NULL or IS NOT NULL when testing for NULL.",
+};
+const IMPLICIT_CARTESIAN_JOIN: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL002",
+    message: "Comma-separated sources create an implicit cartesian join",
+    remediation: "Replace comma-separated sources with an explicit keyed join, or use CROSS JOIN when the cartesian product is intentional.",
+};
+const JOIN_WITHOUT_CONDITION: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL003",
+    message: "Non-cross join has no meaningful condition",
+    remediation: "Add a meaningful ON or USING condition, or declare an intentional cartesian product with CROSS JOIN.",
+};
+const UNORDERED_LIMIT: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL004",
+    message: "Row selection is nondeterministic",
+    remediation: "Add ORDER BY with a deterministic tie-breaker before LIMIT or OFFSET.",
+};
+const UNUSED_CTE: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL005",
+    message: "CTE is unreachable from the final query",
+    remediation: "Reference the CTE from the final query or another reachable CTE, or remove it.",
+};
+const REDUNDANT_DISTINCT: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL006",
+    message: "DISTINCT is redundant with the grouped output",
+    remediation: "Remove DISTINCT; the equivalent GROUP BY already determines the output groups.",
+};
+const POSITIONAL_SET_STAR: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBL007",
+    message: "Positional set operation is vulnerable to column-order drift",
+    remediation: "Enumerate columns in the same order in every set-operation branch.",
+};
 const TRIVIAL_EQUALITY_TOKEN_COUNT: usize = 3;
 
 const DEFAULT_RULES: [&str; 7] = [
-    NULL_COMPARISON,
-    IMPLICIT_CARTESIAN_JOIN,
-    JOIN_WITHOUT_CONDITION,
-    UNORDERED_LIMIT,
-    UNUSED_CTE,
-    REDUNDANT_DISTINCT,
-    POSITIONAL_SET_STAR,
+    NULL_COMPARISON.code,
+    IMPLICIT_CARTESIAN_JOIN.code,
+    JOIN_WITHOUT_CONDITION.code,
+    UNORDERED_LIMIT.code,
+    UNUSED_CTE.code,
+    REDUNDANT_DISTINCT.code,
+    POSITIONAL_SET_STAR.code,
 ];
 
 struct QueryTokenContext<'a> {
@@ -583,76 +613,63 @@ fn diagnostics(
     enabled: &HashSet<String>,
 ) -> Vec<LintDiagnostic> {
     let mut diagnostics: Vec<LintDiagnostic> = Vec::new();
-    if enabled.contains(NULL_COMPARISON) {
+    if enabled.contains(NULL_COMPARISON.code) {
         diagnostics.extend(diagnostics_for_spans(
-            NULL_COMPARISON,
-            "Comparison with NULL is never true; use IS NULL or IS NOT NULL",
+            &NULL_COMPARISON,
             &facts.null_comparisons,
         ));
     }
-    if enabled.contains(IMPLICIT_CARTESIAN_JOIN) {
+    if enabled.contains(IMPLICIT_CARTESIAN_JOIN.code) {
         diagnostics.extend(diagnostics_for_spans(
-            IMPLICIT_CARTESIAN_JOIN,
-            "Comma-separated FROM sources create an implicit cartesian join; use explicit JOIN syntax",
+            &IMPLICIT_CARTESIAN_JOIN,
             &facts.implicit_cartesian_joins,
         ));
     }
-    if enabled.contains(JOIN_WITHOUT_CONDITION) {
+    if enabled.contains(JOIN_WITHOUT_CONDITION.code) {
         diagnostics.extend(diagnostics_for_spans(
-            JOIN_WITHOUT_CONDITION,
-            "Non-cross join has no meaningful ON or USING condition",
+            &JOIN_WITHOUT_CONDITION,
             &facts.joins_without_condition,
         ));
     }
-    if enabled.contains(UNORDERED_LIMIT) {
+    if enabled.contains(UNORDERED_LIMIT.code) {
         diagnostics.extend(diagnostics_for_spans(
-            UNORDERED_LIMIT,
-            "LIMIT or OFFSET without ORDER BY produces nondeterministic rows",
+            &UNORDERED_LIMIT,
             &facts.unordered_limits,
         ));
     }
-    if enabled.contains(UNUSED_CTE) {
+    if enabled.contains(UNUSED_CTE.code) {
         for span in unused_cte_spans(tokens, &facts.unused_cte_names) {
-            diagnostics.push(diagnostic(
-                UNUSED_CTE,
-                "CTE is declared but never referenced",
-                Some(span),
-            ));
+            diagnostics.push(diagnostic(&UNUSED_CTE, Some(span)));
         }
     }
-    if enabled.contains(REDUNDANT_DISTINCT) {
+    if enabled.contains(REDUNDANT_DISTINCT.code) {
         diagnostics.extend(diagnostics_for_spans(
-            REDUNDANT_DISTINCT,
-            "DISTINCT is redundant when the query already groups its output",
+            &REDUNDANT_DISTINCT,
             &facts.redundant_distincts,
         ));
     }
-    if enabled.contains(POSITIONAL_SET_STAR) {
+    if enabled.contains(POSITIONAL_SET_STAR.code) {
         diagnostics.extend(diagnostics_for_spans(
-            POSITIONAL_SET_STAR,
-            "Positional set operations with SELECT * are vulnerable to column-order drift",
+            &POSITIONAL_SET_STAR,
             &facts.positional_set_stars,
         ));
     }
     diagnostics
 }
 
-fn diagnostics_for_spans(
-    code: &'static str,
-    message: &'static str,
-    spans: &[Span],
-) -> Vec<LintDiagnostic> {
+fn diagnostics_for_spans(rule: &LintRuleMetadata, spans: &[Span]) -> Vec<LintDiagnostic> {
     spans
         .iter()
-        .map(|span| diagnostic(code, message, Some(*span)))
+        .map(|span| diagnostic(rule, Some(*span)))
         .collect()
 }
 
-fn diagnostic(code: &'static str, message: &'static str, span: Option<Span>) -> LintDiagnostic {
+fn diagnostic(rule: &LintRuleMetadata, span: Option<Span>) -> LintDiagnostic {
     let span = span.unwrap_or_default();
     LintDiagnostic {
-        code,
-        message,
+        code: rule.code,
+        message: rule.message,
+        remediation: rule.remediation,
         start: span.start,
         end: span.end,
     }

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/crates/sqlbuild-kata-native/src/sql_lint/models.rs

@@ -32,10 +32,18 @@ pub(crate) struct LintResponse {
 pub(crate) struct LintDiagnostic {
     pub code: &'static str,
     pub message: &'static str,
+    pub remediation: &'static str,
     pub start: usize,
     pub end: usize,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct LintRuleMetadata {
+    pub code: &'static str,
+    pub message: &'static str,
+    pub remediation: &'static str,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub(crate) struct FormatRequest {

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/crates/sqlbuild-kata-native/src/sql_lint/tests/test_sql_lint.rs

@@ -192,6 +192,92 @@ fn given_sql_cases_when_linting_then_diagnostics_match() -> Result<(), String> {
     Ok(())
 }
 
+#[test]
+fn given_native_rules_when_linting_then_diagnosis_and_remediation_are_actionable()
+-> Result<(), String> {
+    let test_cases = [
+        test_types::LintMetadataTestCase {
+            description: "NULL comparison guidance",
+            sql: "SELECT value FROM a WHERE value = NULL",
+            expected_code: "SQBL001",
+            expected_message: "Comparison with NULL is never true",
+            expected_remediation: "Use IS NULL or IS NOT NULL when testing for NULL.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "implicit join guidance",
+            sql: "SELECT a.id FROM a, b",
+            expected_code: "SQBL002",
+            expected_message: "Comma-separated sources create an implicit cartesian join",
+            expected_remediation: "Replace comma-separated sources with an explicit keyed join, or use CROSS JOIN when the cartesian product is intentional.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "unconditioned join guidance",
+            sql: "SELECT a.id FROM a JOIN b",
+            expected_code: "SQBL003",
+            expected_message: "Non-cross join has no meaningful condition",
+            expected_remediation: "Add a meaningful ON or USING condition, or declare an intentional cartesian product with CROSS JOIN.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "unordered limit guidance",
+            sql: "SELECT id FROM items LIMIT 1",
+            expected_code: "SQBL004",
+            expected_message: "Row selection is nondeterministic",
+            expected_remediation: "Add ORDER BY with a deterministic tie-breaker before LIMIT or OFFSET.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "unused CTE guidance",
+            sql: "WITH unused AS (SELECT 1) SELECT 1",
+            expected_code: "SQBL005",
+            expected_message: "CTE is unreachable from the final query",
+            expected_remediation: "Reference the CTE from the final query or another reachable CTE, or remove it.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "redundant distinct guidance",
+            sql: "SELECT DISTINCT id FROM items GROUP BY id",
+            expected_code: "SQBL006",
+            expected_message: "DISTINCT is redundant with the grouped output",
+            expected_remediation: "Remove DISTINCT; the equivalent GROUP BY already determines the output groups.",
+        },
+        test_types::LintMetadataTestCase {
+            description: "positional set star guidance",
+            sql: "SELECT * FROM a UNION ALL SELECT * FROM b",
+            expected_code: "SQBL007",
+            expected_message: "Positional set operation is vulnerable to column-order drift",
+            expected_remediation: "Enumerate columns in the same order in every set-operation branch.",
+        },
+    ];
+
+    for test_case in test_cases {
+        let diagnostics = helpers::diagnostics(test_case.sql)?;
+        let diagnostic = diagnostics
+            .first()
+            .ok_or_else(|| format!("{} should report a diagnostic", test_case.description))?;
+        assert_eq!(
+            diagnostic["code"], test_case.expected_code,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            diagnostic["message"], test_case.expected_message,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            diagnostic["remediation"], test_case.expected_remediation,
+            "{}",
+            test_case.description
+        );
+        let start = diagnostic["start"].as_u64().unwrap_or_default();
+        let end = diagnostic["end"].as_u64().unwrap_or_default();
+        assert!(
+            end > start,
+            "{} should report a non-empty range",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
 #[test]
 fn given_format_cases_when_formatting_then_output_matches() -> Result<(), String> {
     let test_cases = [

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/crates/sqlbuild-kata-native/src/sql_lint/tests/test_types.rs

@@ -5,6 +5,14 @@ pub(crate) struct LintTestCase {
     pub expected_anchors: &'static [(&'static str, &'static str)],
 }
 
+pub(crate) struct LintMetadataTestCase {
+    pub description: &'static str,
+    pub sql: &'static str,
+    pub expected_code: &'static str,
+    pub expected_message: &'static str,
+    pub expected_remediation: &'static str,
+}
+
 pub(crate) struct FormatTestCase {
     pub description: &'static str,
     pub sql: &'static str,

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/pyproject.toml

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

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -535,6 +535,7 @@ def _dispatch_lint_format_command(
             select=select,
             exclude=tuple(args.exclude),
             json_output=args.json,
+            no_color=args.no_color,
         )
     if args.format_diff and args.json:
         raise CliUserError("format --diff cannot be combined with --json", code="C112")
@@ -545,6 +546,7 @@ def _dispatch_lint_format_command(
         check=args.format_check,
         diff=args.format_diff,
         json_output=args.json,
+        no_color=args.no_color,
     )
 
 

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/_helpers/entry/lazy_handlers.py

@@ -258,19 +258,23 @@ def build_lazy_cli_handlers() -> CliEntrypointHandlers:
             targets=targets,
             force=force,
         ),
-        run_lint=lambda project_dir, select, exclude, json_output: lazy["lint"](
+        run_lint=lambda project_dir, select, exclude, json_output, no_color: lazy["lint"](
             project_dir=project_dir,
             select=select,
             exclude=exclude,
             json_output=json_output,
+            no_color=no_color,
         ),
-        run_format=lambda project_dir, select, exclude, check, diff, json_output: lazy["format"](
+        run_format=lambda project_dir, select, exclude, check, diff, json_output, no_color: lazy[
+            "format"
+        ](
             project_dir=project_dir,
             select=select,
             exclude=exclude,
             check=check,
             diff=diff,
             json_output=json_output,
+            no_color=no_color,
         ),
         run_scenario=lazy["scenario"],
         run_scenario_capture=lazy["scenario_capture"],

sqlbuild-0.86.0/src/sqlbuild/cli/commands/_helpers/lint/diagnostics.py

@@ -0,0 +1,123 @@
+"""Render actionable authored-source lint diagnostics."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+
+from rich.cells import cell_len
+
+from sqlbuild.lint.constants import TAB_CHARACTER, VIOLATION_SEVERITY_FAULT
+from sqlbuild.lint.models import LintRunResult, LintViolation
+from sqlbuild.presentation.classes.cli_style import CliStyle
+
+_REPORT_LINE_WIDTH: int = 100
+_HELP_PREFIX: str = "  = help: "
+_HELP_CONTINUATION: str = "          "
+
+
+def format_lint_diagnostics(
+    *, result: LintRunResult, root: Path, use_color: bool
+) -> tuple[str, ...]:
+    """Format every lint violation as a source-pointing diagnostic block."""
+
+    style: CliStyle = CliStyle(use_color=use_color)
+    return tuple(
+        _format_violation(violation=violation, result=result, root=root, style=style)
+        for violation in result.violations
+    )
+
+
+def _format_violation(
+    *, violation: LintViolation, result: LintRunResult, root: Path, style: CliStyle
+) -> str:
+    severity: str = "error" if violation.severity == VIOLATION_SEVERITY_FAULT else "warning"
+    label: str = f"{severity}[{violation.code}]"
+    styled_label: str = (
+        style.error_strong(label)
+        if violation.severity == VIOLATION_SEVERITY_FAULT
+        else style.warning_strong(label)
+    )
+    location: str = (
+        f"{_display_path(path=violation.file_path, root=root)}:{violation.line}:{violation.column}"
+    )
+    lines: list[str] = [
+        f"{styled_label}: {violation.message}",
+        style.muted(f" --> {location}"),
+    ]
+    source_text: str | None = result.source_texts.get(violation.file_path)
+    if source_text is not None:
+        source_lines: list[str] = source_text.splitlines()
+        if 1 <= violation.line <= len(source_lines):
+            lines.extend(
+                _source_excerpt(
+                    violation=violation,
+                    source_line=source_lines[violation.line - 1],
+                    style=style,
+                )
+            )
+    if violation.remediation is not None:
+        lines.extend(_help_lines(remediation=violation.remediation, style=style))
+    return "\n".join(lines)
+
+
+def _source_excerpt(
+    *, violation: LintViolation, source_line: str, style: CliStyle
+) -> tuple[str, ...]:
+    line_number: str = str(violation.line)
+    gutter: str = " " * len(line_number)
+    start_index: int = min(max(violation.column - 1, 0), len(source_line))
+    end_index: int = _excerpt_end_index(
+        violation=violation,
+        source_line=source_line,
+        start_index=start_index,
+    )
+    padding: str = _display_padding(source_line[:start_index])
+    caret_count: int = max(1, cell_len(source_line[start_index:end_index]))
+    caret: str = "^" * caret_count
+    styled_caret: str = (
+        style.error_strong(caret)
+        if violation.severity == VIOLATION_SEVERITY_FAULT
+        else style.warning_strong(caret)
+    )
+    return (
+        style.muted(f"{gutter} |"),
+        f"{style.muted(f'{line_number} |')} {source_line}",
+        f"{style.muted(f'{gutter} |')} {padding}{styled_caret}",
+        style.muted(f"{gutter} |"),
+    )
+
+
+def _excerpt_end_index(*, violation: LintViolation, source_line: str, start_index: int) -> int:
+    if violation.end_line == violation.line and violation.end_column is not None:
+        return min(max(violation.end_column - 1, start_index + 1), len(source_line))
+    if violation.end_line is not None and violation.end_line != violation.line:
+        return len(source_line)
+    return min(start_index + 1, len(source_line))
+
+
+def _display_padding(prefix: str) -> str:
+    return "".join(
+        TAB_CHARACTER if character == TAB_CHARACTER else " " * cell_len(character)
+        for character in prefix
+    )
+
+
+def _help_lines(*, remediation: str, style: CliStyle) -> tuple[str, ...]:
+    wrapped: list[str] = textwrap.wrap(
+        remediation,
+        width=_REPORT_LINE_WIDTH,
+        initial_indent=_HELP_PREFIX,
+        subsequent_indent=_HELP_CONTINUATION,
+    )
+    if not wrapped:
+        return ()
+    first: str = wrapped[0].removeprefix(_HELP_PREFIX)
+    return (f"  {style.muted('= help:')} {first}", *wrapped[1:])
+
+
+def _display_path(*, path: Path, root: Path) -> str:
+    try:
+        return path.relative_to(root).as_posix()
+    except ValueError:
+        return path.as_posix()

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/_helpers/lint/runs.py

@@ -6,6 +6,7 @@ import json
 import tomllib
 from pathlib import Path
 
+from sqlbuild.cli.commands._helpers.lint.diagnostics import format_lint_diagnostics
 from sqlbuild.compiler.discovery.constants import LOCAL_CONFIG_FILENAME
 from sqlbuild.lint.constants import (
     ADAPTER_CONFIG_KEY,
@@ -16,6 +17,7 @@ from sqlbuild.lint.constants import (
     PROJECT_CONFIG_FILENAME_KEY,
 )
 from sqlbuild.lint.models import LintConfig, LintRunResult
+from sqlbuild.presentation.classes.cli_style import CliStyle
 
 
 def resolve_lint_config(*, project_dir: Path) -> LintConfig:
@@ -59,6 +61,8 @@ def prepare_lint_run(*, project_dir: Path) -> tuple[LintConfig, str | None]:
 def render_lint_result(
     *,
     result: LintRunResult,
+    root: Path,
+    use_color: bool,
     show_formatted: bool,
     formatted_heading: str = "Formatted files:",
 ) -> None:
@@ -71,11 +75,13 @@ def render_lint_result(
             print(f"  {formatted_path}")
         print()
     if result.violations:
-        _print_violations(result=result)
-    print(
+        print("\n\n".join(format_lint_diagnostics(result=result, root=root, use_color=use_color)))
+        print()
+    summary: str = (
         f"Completed.  FAULT={len(result.faults)}  WARN={len(result.warnings)}  "
         f"FILES={result.files_checked}"
     )
+    print(_styled_summary(summary=summary, result=result, use_color=use_color))
 
 
 def render_lint_result_json(*, result: LintRunResult) -> None:
@@ -91,10 +97,13 @@ def render_lint_result_json(*, result: LintRunResult) -> None:
                     {
                         "code": violation.code,
                         "column": violation.column,
+                        "end_column": violation.end_column,
+                        "end_line": violation.end_line,
                         "engine": violation.engine,
                         "file": str(violation.file_path),
                         "line": violation.line,
                         "message": violation.message,
+                        "remediation": violation.remediation,
                         "severity": violation.severity,
                     }
                     for violation in result.violations
@@ -107,18 +116,13 @@ def render_lint_result_json(*, result: LintRunResult) -> None:
     )
 
 
-def _print_violations(*, result: LintRunResult) -> None:
-    current_file: Path | None = None
-    violation: object
-    for violation in result.violations:
-        if violation.file_path != current_file:
-            current_file = violation.file_path
-            print(f"{current_file}")
-        print(
-            f"  {violation.line}:{violation.column}  "
-            f"{violation.engine}  {violation.code}  {violation.message}"
-        )
-    print()
+def _styled_summary(*, summary: str, result: LintRunResult, use_color: bool) -> str:
+    style: CliStyle = CliStyle(use_color=use_color)
+    if result.faults:
+        return style.error_strong(summary)
+    if result.warnings:
+        return style.warning_strong(summary)
+    return style.success_strong(summary)
 
 
 def _resolve_int(*, section: dict[str, object], key: str, current: int) -> int:

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/main/project/_format.py

@@ -15,6 +15,7 @@ from sqlbuild.cli.commands._helpers.lint.selection import resolve_lint_inputs
 from sqlbuild.compiler.compile.types import TypedSqlValueRenderer
 from sqlbuild.lint.main.run_format import run_format
 from sqlbuild.lint.models import LintConfig, LintRunResult
+from sqlbuild.presentation.main.supports_color import supports_color
 
 
 def run_format_command(
@@ -25,6 +26,7 @@ def run_format_command(
     check: bool = False,
     diff: bool = False,
     json_output: bool = False,
+    no_color: bool = False,
 ) -> int:
     """Apply autofixes in place; non-zero when faults remain after formatting."""
 
@@ -59,6 +61,8 @@ def run_format_command(
     else:
         _ = render_lint_result(
             result=result,
+            root=base_dir,
+            use_color=not no_color and supports_color(),
             show_formatted=True,
             formatted_heading="Would format files:" if check or diff else "Formatted files:",
         )

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/main/project/_lint.py

@@ -13,6 +13,7 @@ from sqlbuild.cli.commands._helpers.lint.runs import (
 from sqlbuild.cli.commands._helpers.lint.selection import resolve_lint_inputs
 from sqlbuild.lint.main.run_lint import run_lint
 from sqlbuild.lint.models import LintConfig, LintRunResult
+from sqlbuild.presentation.main.supports_color import supports_color
 
 
 def run_lint_command(
@@ -21,6 +22,7 @@ def run_lint_command(
     select: tuple[str, ...] = (),
     exclude: tuple[str, ...] = (),
     json_output: bool = False,
+    no_color: bool = False,
 ) -> int:
     """Report lint violations without modifying authored files; non-zero on violations."""
 
@@ -46,5 +48,10 @@ def run_lint_command(
     if json_output:
         _ = render_lint_result_json(result=result)
     else:
-        _ = render_lint_result(result=result, show_formatted=False)
+        _ = render_lint_result(
+            result=result,
+            root=base_dir,
+            use_color=not no_color and supports_color(),
+            show_formatted=False,
+        )
     return 1 if result.violations else 0

{sqlbuild-0.85.0 → sqlbuild-0.86.0}/src/sqlbuild/cli/commands/types.py

@@ -173,6 +173,7 @@ class LintCommandHandler(Protocol):
         select: tuple[str, ...],
         exclude: tuple[str, ...],
         json_output: bool,
+        no_color: bool,
     ) -> int: ...
 
 
@@ -186,6 +187,7 @@ class FormatCommandHandler(Protocol):
         check: bool,
         diff: bool,
         json_output: bool,
+        no_color: bool,
     ) -> int: ...