datasecops-cli 0.4.3__tar.gz → 0.4.5__tar.gz

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.4.5] - 2026-05-18
+
+### Fixed
+
+- **Package downloads now respect profile selection** — `datasecops download packages` and the interactive downloads menu now only include dbt packages enabled on the active profile, instead of downloading all packages from the global catalog. This matches the native app's Streamlit UI behavior.
+- **Upstream package exclusion** — packages already provided by upstream projects are automatically excluded from `packages.yml`, preventing duplicate dependencies when using multi-project setups.
+- **`generate_packages_yml()` filtering** — the dbt project generator now also filters packages by profile, fixing the same issue in the bootstrap/init path.
+
+## [0.4.4] - 2026-05-18
+
+### Added
+
+- **dbt engine toggle** — new `dbt_engine` field in `.datasecops.yml` to switch between `dbtf` (dbt Fusion) and `dbt` (dbt Core). Defaults to `dbtf`. Toggleable via Configure menu `[6] dbt engine`. All dbt commands use the configured engine binary.
+
 ## [0.4.3] - 2026-05-17
 
 ### Added

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/PKG-INFO

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

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/pyproject.toml

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

datasecops_cli-0.4.5/src/datasecops_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.5"

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/config.py

@@ -36,7 +36,14 @@ class Config:
             app_database=raw.get("app_database", ""),
             profile_name=raw.get("profile_name", ""),
             cortex_connection=raw.get("cortex_connection", ""),
+            dbt_engine=raw.get("dbt_engine", "dbtf"),
         )
+
+        # Validate dbt_engine
+        if self.datasecops.dbt_engine not in self.datasecops.VALID_ENGINES:
+            from datasecops_cli.utilities.display import warning_line
+            warning_line(f"Invalid dbt_engine '{self.datasecops.dbt_engine}' in .datasecops.yml — falling back to dbtf")
+            self.datasecops.dbt_engine = "dbtf"
         
         if not self.datasecops.connection_name or not self.datasecops.app_database:
             error_line(".datasecops.yml is missing connection_name or app_database.")

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/main.py

@@ -473,11 +473,17 @@ def _run_interactive(config: Config):
     sf_service = _connect_and_load(config)
 
     try:
-        # Check for dbt Fusion (dbtf) on PATH
-        if not shutil.which("dbtf"):
+        # Check for configured dbt engine on PATH
+        dbt_engine = config.datasecops.dbt_engine or "dbtf"
+        if not shutil.which(dbt_engine):
             from datasecops_cli.utilities.display import warning_line
-            warning_line("dbt Fusion (dbtf) not found on PATH — dbt commands will not work.")
-            warning_line("Install dbt Fusion: https://docs.getdbt.com/docs/core/installation")
+            warning_line(f"{dbt_engine} not found on PATH — dbt commands will not work.")
+            if dbt_engine == "dbtf":
+                warning_line("Install dbt Fusion: https://docs.getdbt.com/docs/core/installation")
+            else:
+                warning_line("Install dbt Core: uv pip install dbt-core dbt-snowflake")
+        else:
+            info_line(f"dbt engine: {config.datasecops.get_engine_label()}")
 
         # Check upstream project versions
         from datasecops_cli.services.upstream_service import check_upstream_versions
@@ -492,7 +498,8 @@ def _run_interactive(config: Config):
         dbt_runner = DbtRunner(
             project_dir=config.dbt_project_dir,
             profiles_dir=config.get_dbt_profiles_dir(),
-            target=config.project_settings.get_default_target().target_name if config.get_default_target() else "dev"
+            target=config.project_settings.get_default_target().target_name if config.get_default_target() else "dev",
+            engine=config.datasecops.dbt_engine or "dbtf"
         )
 
         try:
@@ -558,7 +565,10 @@ def _run_download(config: Config, items: list[str],
                 if not download_service.download_pipelines(platform=platform, profile_name=config.profile_name):
                     failed = True
             elif item == "packages":
-                if not download_service.download_dbt_packages(config.dbt_project_dir):
+                if not download_service.download_dbt_packages(
+                    config.dbt_project_dir, profile=config.profile,
+                    all_profiles=config.all_profiles
+                ):
                     failed = True
             elif item == "macros":
                 if not download_service.download_macros(config.profile_name, config.dbt_project_dir):
@@ -685,6 +695,8 @@ def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
                 project_settings=config.project_settings,
                 profile=config.profile,
                 source_control=config.source_control,
+                datasecops_config=config.datasecops,
+                project_dir=config.project_dir,
             )
             config_menu.show()
 
@@ -695,6 +707,7 @@ def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
                 project_settings=config.project_settings,
                 profile=config.profile,
                 source_control=config.source_control,
+                all_profiles=config.all_profiles,
             )
             dl_menu.show()
 
@@ -713,6 +726,7 @@ def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
                 project_dir=config.project_dir,
                 project_settings=config.project_settings,
                 profile=config.profile,
+                all_profiles=config.all_profiles,
             )
             bootstrap.run(platform=platform, install_skills=install_skills,
                          skill_targets=skill_targets, run_deps=run_deps)
@@ -775,6 +789,7 @@ def _run_bootstrap(config: Config):
             project_dir=config.project_dir,
             project_settings=config.project_settings,
             profile=config.profile,
+            all_profiles=config.all_profiles,
         )
         success = bootstrap.run(platform=platform, install_skills=install_skills,
                                skill_targets=skill_targets, run_deps=run_deps)

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/menus/configuration.py

@@ -5,7 +5,7 @@ import shutil
 import subprocess
 from pathlib import Path
 
-from datasecops_cli.models.project_config import ProjectProfile, ProjectSettings, SourceControl
+from datasecops_cli.models.project_config import DatasecopsConfig, ProjectProfile, ProjectSettings, SourceControl
 from datasecops_cli.services.download_service import DownloadService
 from datasecops_cli.services.linting_service import LintingService
 from datasecops_cli.utilities.display import (
@@ -14,13 +14,15 @@ from datasecops_cli.utilities.display import (
     info_line, success_line, warning_line, error_line,
     get_input_string, select_from_list, select_multiple_from_list
 )
+from datasecops_cli.utilities.yaml_utils import write_datasecops_config
 
 
 class ConfigurationMenu:
     def __init__(self, download_service: DownloadService, linting_service: LintingService,
                  profile_name: str, dbt_project_dir: Path,
                  project_settings: ProjectSettings = None, profile: ProjectProfile = None,
-                 source_control: SourceControl = None):
+                 source_control: SourceControl = None,
+                 datasecops_config: DatasecopsConfig = None, project_dir: Path = None):
         self.downloads = download_service
         self.linting = linting_service
         self.profile_name = profile_name
@@ -28,6 +30,8 @@ class ConfigurationMenu:
         self.project_settings = project_settings
         self.profile = profile
         self.source_control = source_control
+        self.datasecops_config = datasecops_config or DatasecopsConfig()
+        self.project_dir = project_dir or Path.cwd()
 
     def show(self) -> None:
         self._menu()
@@ -45,17 +49,21 @@ class ConfigurationMenu:
                 complete_action()
             elif option == 5:
                 self._cortex_upgrade()
+            elif option == 6:
+                self._toggle_dbt_engine()
             self._menu()
             option = get_input_number("Choose an option: ")
 
     def _menu(self) -> None:
         clear()
+        engine_label = self.datasecops_config.get_engine_label()
         section_header("Configuration", self.profile_name)
         menu_option(1, "install dbt   - Install dbt-core & dbt-snowflake from framework versions")
         menu_option(2, "install lint  - Install SQLFluff from framework versions")
         menu_option(3, "mcp servers   - Configure MCP servers for AI tools")
         menu_option(4, "new project   - Initialize a new dbt project with framework profiles")
         menu_option(5, "cortex update - Update Cortex Code to the latest version")
+        menu_option(6, f"dbt engine    - Switch dbt engine (current: {engine_label})")
         menu_option(0, "back          - Return to main menu")
 
     def _install_dbt_requirements(self) -> None:
@@ -250,3 +258,33 @@ class ConfigurationMenu:
         except FileNotFoundError:
             error_line("Cortex Code CLI not found.")
         complete_action()
+
+    def _toggle_dbt_engine(self) -> None:
+        """Toggle between dbt Fusion and dbt Core."""
+        display_action_header("Switch dbt Engine")
+        current = self.datasecops_config.dbt_engine or "dbtf"
+        info_line(f"Current engine: {self.datasecops_config.get_engine_label()} ({current})")
+        info_line("")
+        menu_option(1, "dbt Fusion    - dbtf (recommended)")
+        menu_option(2, "dbt Core      - dbt")
+        menu_option(0, "cancel")
+        option = get_input_number("Choose an option: ")
+
+        if option == 1:
+            new_engine = "dbtf"
+        elif option == 2:
+            new_engine = "dbt"
+        else:
+            return
+
+        if new_engine == current:
+            info_line("No change.")
+            complete_action()
+            return
+
+        self.datasecops_config.dbt_engine = new_engine
+        config_data = self.datasecops_config.model_dump(exclude={"VALID_ENGINES"})
+        write_datasecops_config(self.project_dir, config_data)
+        success_line(f"dbt engine switched to {self.datasecops_config.get_engine_label()} ({new_engine})")
+        warning_line("Restart the CLI for the change to take effect.")
+        complete_action()

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/menus/downloads.py

@@ -19,7 +19,7 @@ class DownloadsMenu:
     def __init__(self, download_service: DownloadService, skill_service: SkillService,
                  dbt_runner: DbtRunner, profile_name: str, dbt_project_dir: Path,
                  project_settings: ProjectSettings = None, profile: ProjectProfile = None,
-                 source_control: SourceControl = None):
+                 source_control: SourceControl = None, all_profiles: list[ProjectProfile] = None):
         self.downloads = download_service
         self.skills = skill_service
         self.dbt = dbt_runner
@@ -28,6 +28,7 @@ class DownloadsMenu:
         self.project_settings = project_settings
         self.profile = profile
         self.source_control = source_control
+        self.all_profiles = all_profiles
     
     def show(self) -> None:
         self._menu()
@@ -46,7 +47,8 @@ class DownloadsMenu:
                 complete_action()
             elif option == 3:
                 display_action_header("Download dbt Packages")
-                self.downloads.download_dbt_packages(self.dbt_project_dir)
+                self.downloads.download_dbt_packages(self.dbt_project_dir, profile=self.profile,
+                                                     all_profiles=self.all_profiles)
                 if get_input_true_false("Run dbt deps now?"):
                     self.dbt.deps()
                 complete_action()

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/models/project_config.py

@@ -7,6 +7,15 @@ class DatasecopsConfig(BaseModel):
     app_database: str = ""
     profile_name: str = ""
     cortex_connection: str = ""
+    dbt_engine: str = "dbtf"  # "dbtf" for dbt Fusion, "dbt" for dbt Core
+
+    VALID_ENGINES: dict = {"dbtf": "dbt Fusion", "dbt": "dbt Core"}
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def get_engine_label(self) -> str:
+        """Return human-readable label for the current dbt engine."""
+        return self.VALID_ENGINES.get(self.dbt_engine, f"unknown ({self.dbt_engine})")
 
 class DbtTarget(BaseModel):
     target_name: str = ""

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/services/bootstrap_service.py

@@ -14,11 +14,13 @@ class BootstrapService:
     """Bootstraps a new dbt project with all framework configuration."""
 
     def __init__(self, snowflake_service: SnowflakeService, project_dir: Path,
-                 project_settings: ProjectSettings, profile: ProjectProfile):
+                 project_settings: ProjectSettings, profile: ProjectProfile,
+                 all_profiles: list[ProjectProfile] = None):
         self.sf = snowflake_service
         self.project_dir = project_dir
         self.project_settings = project_settings
         self.profile = profile
+        self.all_profiles = all_profiles or []
         self.download_service = DownloadService(snowflake_service, project_dir)
         self.skill_service = SkillService(snowflake_service)
 
@@ -92,7 +94,8 @@ class BootstrapService:
         # Step 5: Generate packages.yml
         info_line("")
         info_line("[5] Generating packages.yml...")
-        if self.download_service.download_dbt_packages(dbt_project_dir, profile=self.profile):
+        if self.download_service.download_dbt_packages(dbt_project_dir, profile=self.profile,
+                                                       all_profiles=self.all_profiles):
             steps_passed += 1
         else:
             info_line("  (skipped - no dbt packages config in native app)")

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/services/dbt_project_generator.py

@@ -165,17 +165,36 @@ def generate_profiles_yml(
 def generate_packages_yml(
     profile: ProjectProfile,
     packages_config: dict,
+    all_profiles: list[ProjectProfile] = None,
 ) -> str:
     """Generate packages.yml from profile's packages and upstream projects.
 
     Args:
         profile: The project profile.
         packages_config: The DBT_PACKAGES framework config.
+        all_profiles: All project profiles (used for upstream package exclusion).
 
     Returns:
         The YAML content as a string.
     """
     packages = packages_config.get("packages", [])
+
+    # Filter to only packages enabled on the profile
+    if profile.dbt_packages:
+        from datasecops_cli.services.download_service import _collect_upstream_packages
+
+        enabled = set(profile.dbt_packages)
+
+        # Exclude packages already provided by upstream projects
+        if profile.upstream_projects and all_profiles:
+            profile_map = {p.profile_name: p for p in all_profiles}
+            upstream_pkgs = _collect_upstream_packages(
+                profile.upstream_projects, profile_map
+            )
+            enabled -= upstream_pkgs
+
+        packages = [p for p in packages if p.get("name") in enabled]
+
     pkg_list: list[dict[str, Any]] = []
 
     for pkg in packages:

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/services/dbt_runner.py

@@ -7,12 +7,14 @@ from datasecops_cli.utilities.display import info_line, error_line, success_line
 
 
 class DbtRunner:
-    """Runs dbt commands via subprocess (dbt Fusion)."""
+    """Runs dbt commands via subprocess (dbt Fusion or dbt Core)."""
     
-    def __init__(self, project_dir: Path, profiles_dir: Path, target: str = "dev"):
+    def __init__(self, project_dir: Path, profiles_dir: Path, target: str = "dev",
+                 engine: str = "dbtf"):
         self.project_dir = project_dir
         self.profiles_dir = profiles_dir
         self.target = target
+        self.engine = engine  # "dbtf" or "dbt"
     
     def _default_args(self) -> list[str]:
         return [
@@ -21,7 +23,7 @@ class DbtRunner:
         ]
     
     def _run_command(self, command: str, extra_args: list[str] = None) -> subprocess.CompletedProcess:
-        cmd = ["dbtf", command] + (extra_args or []) + self._default_args()
+        cmd = [self.engine, command] + (extra_args or []) + self._default_args()
         info_line(f"Running: {' '.join(cmd)}")
         result = subprocess.run(cmd, capture_output=False)
         if result.returncode != 0:
@@ -94,7 +96,7 @@ class DbtRunner:
         return self._run_command("docs", ["generate", f"--target={self.target}"])
     
     def docs_serve(self) -> subprocess.Popen:
-        cmd = ["dbtf", "docs", "serve"] + self._default_args()
+        cmd = [self.engine, "docs", "serve"] + self._default_args()
         info_line(f"Running: {' '.join(cmd)}")
         return subprocess.Popen(cmd)
     

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/src/datasecops_cli/services/download_service.py

@@ -10,6 +10,30 @@ from datasecops_cli.utilities.display import info_line, success_line, error_line
 from datasecops_cli.utilities.file_utils import write_file, ensure_dir
 
 
+def _collect_upstream_packages(
+    upstream_names: list[str],
+    profile_map: dict[str, ProjectProfile],
+    visited: set[str] | None = None,
+) -> set[str]:
+    """Recursively collect dbt package names from all upstream projects."""
+    if visited is None:
+        visited = set()
+    result: set[str] = set()
+    for name in upstream_names:
+        if name in visited:
+            continue
+        visited.add(name)
+        upstream = profile_map.get(name)
+        if upstream:
+            result.update(upstream.dbt_packages)
+            result.update(
+                _collect_upstream_packages(
+                    upstream.upstream_projects or [], profile_map, visited
+                )
+            )
+    return result
+
+
 class DownloadService:
     """Downloads configurations from the native app."""
 
@@ -279,7 +303,8 @@ class DownloadService:
         success_line(f"Downloaded {count} script(s) to {scripts_dir}")
         return True
 
-    def download_dbt_packages(self, dbt_project_dir: Path, profile: ProjectProfile = None) -> bool:
+    def download_dbt_packages(self, dbt_project_dir: Path, profile: ProjectProfile = None,
+                              all_profiles: list[ProjectProfile] = None) -> bool:
         info_line("Downloading dbt package versions...")
         raw = self.sf.get_framework_config("DBT_PACKAGES")
         if not raw:
@@ -287,6 +312,22 @@ class DownloadService:
             return False
         
         packages = raw.get("packages", [])
+
+        # Filter to only packages enabled on the active profile
+        if profile and profile.dbt_packages:
+            enabled = set(profile.dbt_packages)
+
+            # Exclude packages already provided by upstream projects
+            if profile.upstream_projects and all_profiles:
+                profile_map = {p.profile_name: p for p in all_profiles}
+                upstream_pkgs = _collect_upstream_packages(
+                    profile.upstream_projects, profile_map
+                )
+                enabled -= upstream_pkgs
+
+            packages = [p for p in packages if p.get("name") in enabled]
+            info_line(f"  Filtered to {len(packages)} package(s) for profile '{profile.profile_name}'")
+
         pkg_list = []
         for pkg in packages:
             source = pkg.get("source", "git")

{datasecops_cli-0.4.3 → datasecops_cli-0.4.5}/tests/test_main.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 from datasecops_cli.main import _build_parser, _run_download, DOWNLOAD_ITEMS
 from datasecops_cli.config import Config
+from datasecops_cli.models.project_config import ProjectProfile
 
 
 class TestBuildParser:
@@ -64,6 +65,11 @@ class TestRunDownload:
         config.project_dir = tmp_path
         config.dbt_project_dir = tmp_path
         config.profile_name = "test_profile"
+        config.profile = ProjectProfile(
+            profile_name="test_profile",
+            dbt_packages=["dbt_utils", "dbt_expectations"],
+        )
+        config.all_profiles = [config.profile]
         # source_control defaults to GitHub
         return config
 
@@ -119,7 +125,9 @@ class TestRunDownload:
                 _run_download(config, ["packages"])
 
             assert exc.value.code == 0
-            mock_ds.download_dbt_packages.assert_called_once_with(tmp_path)
+            mock_ds.download_dbt_packages.assert_called_once_with(
+                tmp_path, profile=config.profile, all_profiles=config.all_profiles
+            )
 
     @patch("datasecops_cli.main._connect_and_load")
     def test_download_macros(self, mock_connect, tmp_path):
@@ -300,3 +308,112 @@ class TestRunDownload:
                 _run_download(config, ["install-dbt"])
 
             assert exc.value.code == 1
+
+
+class TestDownloadPackageFiltering:
+    """Tests for dbt package filtering by profile."""
+
+    def test_download_dbt_packages_filters_by_profile(self, tmp_path):
+        """Only packages in profile.dbt_packages should appear in packages.yml."""
+        from datasecops_cli.services.download_service import DownloadService
+
+        mock_sf = MagicMock()
+        mock_sf.get_framework_config.return_value = {
+            "packages": [
+                {"name": "dbt_utils", "source": "git", "url": "https://github.com/dbt-labs/dbt-utils.git", "latest_version": "1.0.0"},
+                {"name": "dbt_expectations", "source": "git", "url": "https://github.com/calogica/dbt-expectations.git", "latest_version": "0.10.0"},
+                {"name": "dbt_constraints", "source": "git", "url": "https://github.com/Snowflake-Labs/dbt_constraints.git", "latest_version": "0.6.0"},
+            ]
+        }
+
+        profile = ProjectProfile(
+            profile_name="test",
+            dbt_packages=["dbt_utils", "dbt_expectations"],
+        )
+
+        service = DownloadService(mock_sf, tmp_path)
+        service.download_dbt_packages(tmp_path, profile=profile)
+
+        import yaml
+        result = yaml.safe_load((tmp_path / "packages.yml").read_text())
+        assert len(result["packages"]) == 2
+        urls = [p.get("git") for p in result["packages"]]
+        assert "https://github.com/dbt-labs/dbt-utils.git" in urls
+        assert "https://github.com/calogica/dbt-expectations.git" in urls
+        assert "https://github.com/Snowflake-Labs/dbt_constraints.git" not in urls
+
+    def test_download_dbt_packages_excludes_upstream(self, tmp_path):
+        """Packages provided by upstream projects should be excluded."""
+        from datasecops_cli.services.download_service import DownloadService
+
+        mock_sf = MagicMock()
+        mock_sf.get_framework_config.return_value = {
+            "packages": [
+                {"name": "dbt_utils", "source": "git", "url": "https://github.com/dbt-labs/dbt-utils.git", "latest_version": "1.0.0"},
+                {"name": "dbt_expectations", "source": "git", "url": "https://github.com/calogica/dbt-expectations.git", "latest_version": "0.10.0"},
+            ]
+        }
+
+        upstream_profile = ProjectProfile(
+            profile_name="upstream_project",
+            dbt_packages=["dbt_utils"],
+        )
+        profile = ProjectProfile(
+            profile_name="test",
+            dbt_packages=["dbt_utils", "dbt_expectations"],
+            upstream_projects=["upstream_project"],
+        )
+
+        service = DownloadService(mock_sf, tmp_path)
+        service.download_dbt_packages(tmp_path, profile=profile, all_profiles=[profile, upstream_profile])
+
+        import yaml
+        result = yaml.safe_load((tmp_path / "packages.yml").read_text())
+        # dbt_utils excluded (provided by upstream), only dbt_expectations + local upstream dep
+        git_packages = [p for p in result["packages"] if "git" in p]
+        local_packages = [p for p in result["packages"] if "local" in p]
+        assert len(git_packages) == 1
+        assert git_packages[0]["git"] == "https://github.com/calogica/dbt-expectations.git"
+        assert len(local_packages) == 1
+        assert local_packages[0]["local"] == "local_packages/upstream_project"
+
+    def test_download_dbt_packages_no_profile_downloads_all(self, tmp_path):
+        """When no profile is passed, all packages should be included."""
+        from datasecops_cli.services.download_service import DownloadService
+
+        mock_sf = MagicMock()
+        mock_sf.get_framework_config.return_value = {
+            "packages": [
+                {"name": "dbt_utils", "source": "git", "url": "https://github.com/dbt-labs/dbt-utils.git", "latest_version": "1.0.0"},
+                {"name": "dbt_expectations", "source": "git", "url": "https://github.com/calogica/dbt-expectations.git", "latest_version": "0.10.0"},
+                {"name": "dbt_constraints", "source": "git", "url": "https://github.com/Snowflake-Labs/dbt_constraints.git", "latest_version": "0.6.0"},
+            ]
+        }
+
+        service = DownloadService(mock_sf, tmp_path)
+        service.download_dbt_packages(tmp_path, profile=None)
+
+        import yaml
+        result = yaml.safe_load((tmp_path / "packages.yml").read_text())
+        assert len(result["packages"]) == 3
+
+    def test_download_dbt_packages_empty_dbt_packages_downloads_all(self, tmp_path):
+        """When profile.dbt_packages is empty, all packages should be included."""
+        from datasecops_cli.services.download_service import DownloadService
+
+        mock_sf = MagicMock()
+        mock_sf.get_framework_config.return_value = {
+            "packages": [
+                {"name": "dbt_utils", "source": "git", "url": "https://github.com/dbt-labs/dbt-utils.git", "latest_version": "1.0.0"},
+                {"name": "dbt_expectations", "source": "git", "url": "https://github.com/calogica/dbt-expectations.git", "latest_version": "0.10.0"},
+            ]
+        }
+
+        profile = ProjectProfile(profile_name="test", dbt_packages=[])
+
+        service = DownloadService(mock_sf, tmp_path)
+        service.download_dbt_packages(tmp_path, profile=profile)
+
+        import yaml
+        result = yaml.safe_load((tmp_path / "packages.yml").read_text())
+        assert len(result["packages"]) == 2

datasecops_cli-0.4.3/src/datasecops_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.3"