datasecops-cli 0.2.3__tar.gz → 0.2.5__tar.gz

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.2.5] - 2026-05-11
+
+### Fixed
+
+- **`.sqlfluff` now written to the dbt project directory** instead of the repo root — `download_sqlfluff_config()` accepts a `dbt_project_dir` parameter and all callers (lint menu, downloads menu, bootstrap) pass the resolved dbt directory so the config lands alongside `dbt_project.yml` where sqlfluff expects it
+
+## [0.2.4] - 2026-05-11
+
+### Fixed
+
+- **Use `uv pip` instead of `pip`** for all package operations — `get_installed_versions()`, `install_requirements()`, and bootstrap hints now use `uv pip show` / `uv pip install` to match the framework's `uv`-based toolchain
+- **Pin sqlfluff versions from native app** — the lint menu now fetches the framework-mandated `sqlfluff` and `sqlfluff-templater-dbt` versions from `DBT_VERSIONS` config and installs/upgrades to those exact versions before linting
+
 ## [0.2.3] - 2026-05-11
 
 ### Fixed

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datasecops-cli
-Version: 0.2.3
+Version: 0.2.5
 Summary: DataSecOps Framework CLI for Snowflake Native App
 License-Expression: MIT
 License-File: LICENSE

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datasecops-cli"
-version = "0.2.3"
+version = "0.2.5"
 description = "DataSecOps Framework CLI for Snowflake Native App"
 readme = "README.md"
 requires-python = ">=3.10"

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/src/datasecops_cli/menus/development.py

@@ -141,16 +141,18 @@ class DevelopmentMenu:
         complete_action()
     
     def _ensure_sqlfluff_config(self) -> bool:
-        """Download .sqlfluff from the framework if it doesn't exist locally, and ensure templater is installed."""
+        """Download .sqlfluff from the framework if it doesn't exist locally, and ensure correct versions are installed."""
         config_path = self.linting.project_dir / ".sqlfluff"
         if not config_path.exists():
             if not self.downloads:
                 error_line("No .sqlfluff config found and download service not available")
                 return False
             info_line("No .sqlfluff config found — downloading from framework...")
-            if not self.downloads.download_sqlfluff_config(profiles_dir=self.profiles_dir):
+            if not self.downloads.download_sqlfluff_config(profiles_dir=self.profiles_dir, dbt_project_dir=self.linting.project_dir):
                 return False
-        return self.linting.ensure_templater_installed()
+        # Fetch pinned versions from the native app and ensure they're installed
+        required = self.downloads.get_sqlfluff_requirements() if self.downloads else None
+        return self.linting.ensure_templater_installed(required_packages=required or None)
     
     def _lint_menu(self) -> None:
         clear()

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/src/datasecops_cli/menus/downloads.py

@@ -30,7 +30,7 @@ class DownloadsMenu:
             if option == 1:
                 display_action_header("Download SQLFluff Config")
                 profiles_dir = str(Path(self.project_settings.profile_dir).expanduser()) if self.project_settings else None
-                self.downloads.download_sqlfluff_config(profiles_dir=profiles_dir)
+                self.downloads.download_sqlfluff_config(profiles_dir=profiles_dir, dbt_project_dir=self.dbt_project_dir)
                 complete_action()
             elif option == 2:
                 display_action_header("Download Pipeline Files")

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/src/datasecops_cli/services/bootstrap_service.py

@@ -69,7 +69,7 @@ class BootstrapService:
         info_line("")
         info_line("[3] Downloading SQLFluff configuration...")
         profiles_dir = str(Path(self.project_settings.profile_dir).expanduser())
-        if self.download_service.download_sqlfluff_config(profiles_dir=profiles_dir):
+        if self.download_service.download_sqlfluff_config(profiles_dir=profiles_dir, dbt_project_dir=dbt_project_dir):
             steps_passed += 1
         else:
             info_line("  (skipped - no SQLFluff config in native app)")
@@ -116,7 +116,7 @@ class BootstrapService:
         requirements = self.download_service.get_sqlfluff_requirements()
         if requirements:
             info_line(f"  Required: {', '.join(requirements)}")
-            info_line("  (install with: pip install " + " ".join(requirements) + ")")
+            info_line("  (install with: uv pip install " + " ".join(requirements) + ")")
         steps_passed += 1
 
         # Step 8: Install Cortex Code skills

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/src/datasecops_cli/services/download_service.py

@@ -95,7 +95,7 @@ class DownloadService:
             lines.append(f"{key} = {DownloadService._format_value(val)}")
         lines.append("")
     
-    def download_sqlfluff_config(self, profiles_dir: str = None) -> bool:
+    def download_sqlfluff_config(self, profiles_dir: str = None, dbt_project_dir: Path = None) -> bool:
         info_line("Downloading SQLFluff configuration...")
         raw = self.sf.get_framework_config("SQLFLUFF_RULES")
         if not raw:
@@ -163,7 +163,7 @@ class DownloadService:
                 self._emit_section(lines, f"sqlfluff:rules:{section_name}", opts)
 
         content = "\n".join(lines)
-        dest = self.project_dir / ".sqlfluff"
+        dest = (dbt_project_dir or self.project_dir) / ".sqlfluff"
         write_file(dest, content)
         success_line(f"SQLFluff config written to {dest}")
         return True

{datasecops_cli-0.2.3 → datasecops_cli-0.2.5}/src/datasecops_cli/services/linting_service.py

@@ -15,7 +15,7 @@ class LintingService:
         versions = {}
         for package in ["sqlfluff", "sqlfluff-templater-dbt"]:
             result = subprocess.run(
-                ["pip", "show", package],
+                ["uv", "pip", "show", package],
                 capture_output=True, text=True
             )
             if result.returncode == 0:
@@ -33,20 +33,50 @@ class LintingService:
             warning_line("No packages to install")
             return False
         
-        cmd = ["pip", "install"] + packages
+        cmd = ["uv", "pip", "install"] + packages
         info_line(f"Installing: {', '.join(packages)}")
         result = subprocess.run(cmd, capture_output=False)
         if result.returncode == 0:
             success_line("SQLFluff requirements installed successfully")
             return True
         else:
-            error_line(f"pip install failed with exit code {result.returncode}")
+            error_line(f"uv pip install failed with exit code {result.returncode}")
             return False
     
-    def ensure_templater_installed(self) -> bool:
-        """Check if sqlfluff-templater-dbt is installed; install it if missing."""
-        versions = self.get_installed_versions()
-        missing = [pkg for pkg in ["sqlfluff", "sqlfluff-templater-dbt"] if not versions.get(pkg)]
+    def ensure_templater_installed(self, required_packages: list[str] = None) -> bool:
+        """Check sqlfluff packages are installed at the required versions.
+        
+        Args:
+            required_packages: Pinned packages from the framework, e.g. ["sqlfluff==3.4.0", "sqlfluff-templater-dbt==3.4.0"].
+                               If None, just checks that the packages are present (any version).
+        """
+        installed = self.get_installed_versions()
+
+        if required_packages:
+            # Build a map of package -> required version from "pkg==ver" strings
+            required: dict[str, str | None] = {}
+            for spec in required_packages:
+                if "==" in spec:
+                    name, ver = spec.split("==", 1)
+                    required[name] = ver
+                else:
+                    required[spec] = None
+
+            to_install: list[str] = []
+            for name, req_ver in required.items():
+                cur_ver = installed.get(name)
+                if not cur_ver:
+                    to_install.append(f"{name}=={req_ver}" if req_ver else name)
+                elif req_ver and cur_ver != req_ver:
+                    info_line(f"  {name}: installed {cur_ver}, framework requires {req_ver}")
+                    to_install.append(f"{name}=={req_ver}")
+
+            if not to_install:
+                return True
+            return self.install_requirements(to_install)
+
+        # No pinned versions — just ensure packages are present
+        missing = [pkg for pkg in ["sqlfluff", "sqlfluff-templater-dbt"] if not installed.get(pkg)]
         if not missing:
             return True
         warning_line(f"Missing packages: {', '.join(missing)}")