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

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

@@ -2,6 +2,22 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.2.7] - 2026-05-12
+
+### Changed
+
+- **Separate SQLFluff and dbt installs** — `get_sqlfluff_requirements()` now returns only `sqlfluff` and `sqlfluff-templater-dbt`; new `get_dbt_requirements()` returns only `dbt-core` and `dbt-snowflake`. The lint menu install option and the new development menu install option each handle their own packages independently
+- **Reorganised development menu** — added `[7] parse` for `dbt parse`, added `[14] install dbt` for explicit dbt-core/dbt-snowflake installation, removed standalone retry (available in run and test submenus)
+- **Expanded test submenu** — added unit tests (`test_type:unit`), data tests (`test_type:data`), and failed test retry options alongside all tests and specific selector
+- **Clearer input prompts** — run, test, and lint specific-file prompts now include examples of valid input (e.g. `my_model+`, `tag:nightly`, `models/staging/stg_orders.sql`)
+- **Bootstrap shows separate install hints** — step 7 now lists SQLFluff and dbt requirements separately with individual `uv pip install` commands
+
+## [0.2.6] - 2026-05-11
+
+### Fixed
+
+- **Include `dbt-core` and `dbt-snowflake` in framework requirements** — `get_sqlfluff_requirements()` now fetches all four active versions from the native app (`sqlfluff`, `sqlfluff-templater-dbt`, `dbt-core`, `dbt-snowflake`) and the lint menu ensures they are all installed at the correct pinned versions before linting, resolving the "Could not find adapter type snowflake!" error
+
 ## [0.2.5] - 2026-05-11
 
 ### Fixed

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

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

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

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

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

@@ -48,33 +48,35 @@ class DevelopmentMenu:
                 self.dbt.deps()
                 complete_action()
             elif option == 7:
+                display_action_header("dbt parse")
+                self.dbt.parse()
+                complete_action()
+            elif option == 8:
                 display_action_header("dbt compile")
                 self.dbt.compile()
                 complete_action()
-            elif option == 8:
+            elif option == 9:
                 display_action_header("dbt snapshot")
                 self.dbt.snapshot()
                 complete_action()
-            elif option == 9:
+            elif option == 10:
                 display_action_header("dbt source freshness")
                 self.dbt.source_freshness()
                 complete_action()
-            elif option == 10:
+            elif option == 11:
                 display_action_header("dbt clean")
                 self.dbt.clean()
                 complete_action()
-            elif option == 11:
+            elif option == 12:
                 display_action_header("dbt debug")
                 self.dbt.debug()
                 complete_action()
-            elif option == 12:
+            elif option == 13:
                 display_action_header("dbt list")
                 self.dbt.list_models()
                 complete_action()
-            elif option == 13:
-                display_action_header("dbt retry")
-                self.dbt.retry()
-                complete_action()
+            elif option == 14:
+                self._install_dbt_requirements()
             self._menu()
             option = get_input_number("Choose an option: ")
     
@@ -87,13 +89,14 @@ class DevelopmentMenu:
         menu_option(4,  "docs          - Generate & serve dbt docs")
         menu_option(5,  "seed          - Load seed data")
         menu_option(6,  "deps          - Install dbt packages")
-        menu_option(7,  "compile       - Compile dbt models")
-        menu_option(8,  "snapshot      - Run dbt snapshots")
-        menu_option(9,  "freshness     - Check source freshness")
-        menu_option(10, "clean         - Clean dbt target")
-        menu_option(11, "debug         - Debug dbt connection")
-        menu_option(12, "list          - List dbt resources")
-        menu_option(13, "retry         - Retry failed dbt run")
+        menu_option(7,  "parse         - Parse dbt project")
+        menu_option(8,  "compile       - Compile dbt models")
+        menu_option(9,  "snapshot      - Run dbt snapshots")
+        menu_option(10, "freshness     - Check source freshness")
+        menu_option(11, "clean         - Clean dbt target")
+        menu_option(12, "debug         - Debug dbt connection")
+        menu_option(13, "list          - List dbt resources")
+        menu_option(14, "install dbt   - Install dbt-core & dbt-snowflake from framework")
         menu_option(0,  "back          - Return to main menu")
     
     def _run_menu(self) -> None:
@@ -113,7 +116,7 @@ class DevelopmentMenu:
             full_refresh = get_input_true_false("Full refresh?", "n")
             self.dbt.run(modified_only=True, full_refresh=full_refresh)
         elif option == 3:
-            select = get_input_string("Enter model selector: ")
+            select = get_input_string("Enter model selector (e.g. my_model, my_model+, tag:nightly, path:models/...): ")
             if select != "0":
                 self.dbt.run(select=select)
         elif option == 4:
@@ -129,13 +132,22 @@ class DevelopmentMenu:
         clear()
         display_action_header("dbt Test Options")
         menu_option(1, "all tests     - Run all tests")
-        menu_option(2, "specific      - Run specific test(s)")
+        menu_option(2, "unit tests    - Run unit tests only")
+        menu_option(3, "data tests    - Run data tests only")
+        menu_option(4, "failed        - Retry failed tests")
+        menu_option(5, "specific      - Run specific test(s)")
         menu_option(0, "back          - Return to development menu")
         option = get_input_number("Choose an option: ")
         if option == 1:
             self.dbt.test()
         elif option == 2:
-            select = get_input_string("Enter test selector: ")
+            self.dbt.test(select="test_type:unit")
+        elif option == 3:
+            self.dbt.test(select="test_type:data")
+        elif option == 4:
+            self.dbt.retry()
+        elif option == 5:
+            select = get_input_string("Enter test selector (e.g. test_name, model_name, tag:nightly): ")
             if select != "0":
                 self.dbt.test(select=select)
         complete_action()
@@ -179,7 +191,7 @@ class DevelopmentMenu:
         elif option == 4:
             self.linting.lint_file(fix=True)
         elif option == 5:
-            path = get_input_string("Enter file path: ")
+            path = get_input_string("Enter SQL file path (e.g. models/staging/stg_orders.sql): ")
             if path != "0":
                 self.linting.lint_file(file_path=path, fix=False)
         elif option == 6:
@@ -192,11 +204,11 @@ class DevelopmentMenu:
             error_line("Download service not available")
             return
         
-        # Show current versions
+        # Show current sqlfluff versions
         installed = self.linting.get_installed_versions()
         info_line("Currently installed:")
-        for pkg, ver in installed.items():
-            info_line(f"  {pkg}: {ver or 'not installed'}")
+        for pkg in ("sqlfluff", "sqlfluff-templater-dbt"):
+            info_line(f"  {pkg}: {installed.get(pkg) or 'not installed'}")
         
         # Fetch required versions from framework
         packages = self.downloads.get_sqlfluff_requirements()
@@ -210,3 +222,32 @@ class DevelopmentMenu:
         
         info_line("")
         self.linting.install_requirements(packages)
+
+    def _install_dbt_requirements(self) -> None:
+        """Install dbt-core and dbt-snowflake at versions defined by the framework."""
+        display_action_header("Install dbt Requirements")
+        if not self.downloads:
+            error_line("Download service not available")
+            complete_action()
+            return
+        
+        # Show current dbt versions
+        installed = self.linting.get_installed_versions()
+        info_line("Currently installed:")
+        for pkg in ("dbt-core", "dbt-snowflake"):
+            info_line(f"  {pkg}: {installed.get(pkg) or 'not installed'}")
+        
+        # Fetch required dbt versions from framework
+        packages = self.downloads.get_dbt_requirements()
+        if not packages:
+            complete_action()
+            return
+        
+        info_line("")
+        info_line("Framework requires:")
+        for pkg in packages:
+            info_line(f"  {pkg}")
+        
+        info_line("")
+        self.linting.install_requirements(packages)
+        complete_action()

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

@@ -109,14 +109,18 @@ class BootstrapService:
                 info_line("  (dbt deps failed - run manually after fixing packages.yml)")
                 steps_passed += 1
 
-        # Step 7: Download SQLFluff requirements
+        # Step 7: Check SQLFluff & dbt version requirements
         info_line("")
         step_num = 7 if run_deps else 6
-        info_line(f"[{step_num}] Checking SQLFluff version requirements...")
-        requirements = self.download_service.get_sqlfluff_requirements()
-        if requirements:
-            info_line(f"  Required: {', '.join(requirements)}")
-            info_line("  (install with: uv pip install " + " ".join(requirements) + ")")
+        info_line(f"[{step_num}] Checking SQLFluff & dbt version requirements...")
+        sqlfluff_requirements = self.download_service.get_sqlfluff_requirements()
+        if sqlfluff_requirements:
+            info_line(f"  SQLFluff: {', '.join(sqlfluff_requirements)}")
+            info_line("  (install with: uv pip install " + " ".join(sqlfluff_requirements) + ")")
+        dbt_requirements = self.download_service.get_dbt_requirements()
+        if dbt_requirements:
+            info_line(f"  dbt:      {', '.join(dbt_requirements)}")
+            info_line("  (install with: uv pip install " + " ".join(dbt_requirements) + ")")
         steps_passed += 1
 
         # Step 8: Install Cortex Code skills

{datasecops_cli-0.2.5 → datasecops_cli-0.2.7}/src/datasecops_cli/services/dbt_runner.py

@@ -117,6 +117,9 @@ class DbtRunner:
         self._copy_manifest()
         return result
     
+    def parse(self) -> subprocess.CompletedProcess:
+        return self._run_command("parse")
+
     def run_operation(self, macro: str, args_str: str = None) -> subprocess.CompletedProcess:
         cmd_args = [f"--target={self.target}"]
         if args_str:

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

@@ -168,32 +168,52 @@ class DownloadService:
         success_line(f"SQLFluff config written to {dest}")
         return True
     
-    def get_sqlfluff_requirements(self) -> list[str]:
-        """Fetch active sqlfluff package versions from the framework."""
-        info_line("Fetching SQLFluff requirements from framework...")
+    def _fetch_framework_versions(self) -> dict[str, str]:
+        """Fetch all active package versions from the framework's DBT_VERSIONS config.
+        
+        Returns a dict mapping pip package name to pinned spec, e.g. {"dbt-core": "dbt-core==1.9.0", ...}.
+        """
         raw = self.sf.get_framework_config("DBT_VERSIONS")
         if not raw:
             error_line("No DBT_VERSIONS configuration found in native app")
-            return []
+            return {}
         
-        packages = []
-        
-        # Find active sqlfluff version
-        for entry in raw.get("sqlfluff_versions", []):
-            if entry.get("active"):
-                packages.append(f"sqlfluff=={entry['version']}")
-                break
+        version_keys = {
+            "sqlfluff_versions": "sqlfluff",
+            "sqlfluff_templater_versions": "sqlfluff-templater-dbt",
+            "dbt_core_versions": "dbt-core",
+            "dbt_snowflake_versions": "dbt-snowflake",
+        }
         
-        # Find active sqlfluff-templater-dbt version
-        for entry in raw.get("sqlfluff_templater_versions", []):
-            if entry.get("active"):
-                packages.append(f"sqlfluff-templater-dbt=={entry['version']}")
-                break
+        result: dict[str, str] = {}
+        for config_key, pkg_name in version_keys.items():
+            for entry in raw.get(config_key, []):
+                if entry.get("active"):
+                    result[pkg_name] = f"{pkg_name}=={entry['version']}"
+                    break
         
-        if not packages:
-            error_line("No active sqlfluff versions found in framework configuration")
+        if not result:
+            error_line("No active versions found in framework configuration")
         
-        return packages
+        return result
+
+    def get_sqlfluff_requirements(self) -> list[str]:
+        """Fetch active sqlfluff and sqlfluff-templater-dbt versions from the framework."""
+        info_line("Fetching SQLFluff requirements from framework...")
+        versions = self._fetch_framework_versions()
+        sqlfluff_packages = [versions[k] for k in ("sqlfluff", "sqlfluff-templater-dbt") if k in versions]
+        if not sqlfluff_packages:
+            error_line("No active SQLFluff versions found in framework configuration")
+        return sqlfluff_packages
+
+    def get_dbt_requirements(self) -> list[str]:
+        """Fetch active dbt-core and dbt-snowflake versions from the framework."""
+        info_line("Fetching dbt requirements from framework...")
+        versions = self._fetch_framework_versions()
+        dbt_packages = [versions[k] for k in ("dbt-core", "dbt-snowflake") if k in versions]
+        if not dbt_packages:
+            error_line("No active dbt versions found in framework configuration")
+        return dbt_packages
     
     def download_pipelines(self, platform: str = "github") -> bool:
         info_line(f"Downloading {platform} pipeline configurations...")

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

@@ -10,10 +10,16 @@ class LintingService:
     def __init__(self, project_dir: Path):
         self.project_dir = project_dir
     
-    def get_installed_versions(self) -> dict[str, str]:
-        """Get currently installed versions of sqlfluff packages."""
+    def get_installed_versions(self, packages: list[str] = None) -> dict[str, str]:
+        """Get currently installed versions of the specified packages.
+        
+        Args:
+            packages: Package names to check. Defaults to sqlfluff, sqlfluff-templater-dbt, dbt-core, dbt-snowflake.
+        """
+        if packages is None:
+            packages = ["sqlfluff", "sqlfluff-templater-dbt", "dbt-core", "dbt-snowflake"]
         versions = {}
-        for package in ["sqlfluff", "sqlfluff-templater-dbt"]:
+        for package in packages:
             result = subprocess.run(
                 ["uv", "pip", "show", package],
                 capture_output=True, text=True
@@ -28,7 +34,7 @@ class LintingService:
         return versions
     
     def install_requirements(self, packages: list[str]) -> bool:
-        """Install sqlfluff packages at specified versions."""
+        """Install packages at specified versions via uv pip."""
         if not packages:
             warning_line("No packages to install")
             return False
@@ -37,7 +43,7 @@ class LintingService:
         info_line(f"Installing: {', '.join(packages)}")
         result = subprocess.run(cmd, capture_output=False)
         if result.returncode == 0:
-            success_line("SQLFluff requirements installed successfully")
+            success_line("Packages installed successfully")
             return True
         else:
             error_line(f"uv pip install failed with exit code {result.returncode}")
@@ -75,7 +81,7 @@ class LintingService:
                 return True
             return self.install_requirements(to_install)
 
-        # No pinned versions — just ensure packages are present
+        # No pinned versions — just ensure sqlfluff packages are present
         missing = [pkg for pkg in ["sqlfluff", "sqlfluff-templater-dbt"] if not installed.get(pkg)]
         if not missing:
             return True