datasecops-cli 0.3.4__tar.gz → 0.4.0__tar.gz

datasecops_cli-0.4.0/.github/workflows/auto-tag.yml

@@ -0,0 +1,113 @@
+name: Tag and Deploy
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  id-token: write
+  contents: write
+
+jobs:
+  auto-tag:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+      created: ${{ steps.tag.outputs.created }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Extract version from pyproject.toml
+        id: version
+        run: |
+          set -euo pipefail
+          VERSION=$(python3 -c "
+          import tomllib, pathlib
+          data = tomllib.loads(pathlib.Path('pyproject.toml').read_text())
+          print(data['project']['version'])
+          ")
+          if [ -z "$VERSION" ]; then
+            echo "Failed to extract version from pyproject.toml" >&2
+            exit 1
+          fi
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Detected version: $VERSION"
+
+      - name: Create and push tag
+        id: tag
+        run: |
+          TAG="cli-v${{ steps.version.outputs.version }}"
+          echo "tag=$TAG" >> "$GITHUB_OUTPUT"
+          if git ls-remote --tags origin "refs/tags/$TAG" | grep -q "$TAG"; then
+            echo "Tag $TAG already exists, skipping."
+            echo "created=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          git tag "$TAG"
+          PUSH_OUTPUT=$(git push origin "$TAG" 2>&1) && {
+            echo "Created and pushed tag: $TAG"
+            echo "created=true" >> "$GITHUB_OUTPUT"
+          } || {
+            if echo "$PUSH_OUTPUT" | grep -qi "already exists"; then
+              echo "Tag $TAG was created by another run, skipping."
+              echo "created=false" >> "$GITHUB_OUTPUT"
+            else
+              echo "Tag push failed unexpectedly:"
+              echo "$PUSH_OUTPUT"
+              exit 1
+            fi
+          }
+
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    needs: auto-tag
+    if: needs.auto-tag.outputs.created == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.auto-tag.outputs.tag }}
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package with test dependencies
+        run: pip install -e ".[test]"
+
+      - name: Run tests
+        run: pytest --tb=short
+
+  build-and-publish:
+    name: Build and publish to PyPI
+    needs: [auto-tag, test]
+    if: needs.auto-tag.outputs.created == 'true'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.auto-tag.outputs.tag }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.4.0] - 2026-05-16
+
+### Added
+
+- **Framework-aligned project scaffolding** — `datasecops bootstrap` now generates `dbt_project.yml` directly from the native app configuration instead of running `dbtf init`. The generated project matches the `setup-dbt-project` Cortex Code skill specification, including:
+  - Model sections based on profile's `MODEL_TYPES` (sources, dimensional_modelling, domains, cortex_models)
+  - Object sections with doc node colors (stored_procedures, tasks, UDFs)
+  - `dispatch` with framework package search order
+  - `on-run-end` with `clean_objects` macro
+  - `quoting` and `vars` configuration
+- **Directory structure scaffolding** — bootstrap creates the full directory tree with `.gitkeep` files in empty model/object subdirectories (models/sources/, models/dm/dims/, objects/stored_procedures/, etc.)
+- **`.gitignore` generation** — bootstrap creates a `.gitignore` with standard dbt exclusions including `profiles.yml`
+- **Macro category subdirectories** — macros are now written to `macros/{category}/{file_name}` (e.g., `macros/schema/generate_schema_name.sql`) matching the framework's category organisation
+- **Upstream project support in packages.yml** — profiles with `upstream_projects` configured now generate `local: "local_packages/{name}"` entries in `packages.yml`
+- **profiles.yml database suffixes** — each target's database name now includes the branch suffix in uppercase (e.g., `MY_DB_PROD`) matching the skill specification
+- **New MCP tools** — 5 new tools exposed via the MCP server:
+  - `get_model_definitions` — model types with paths, prefixes, and metadata fields
+  - `get_object_definitions` — object types with paths, prefixes, and options
+  - `get_source_definitions` — configured source systems and their schemas
+  - `get_access_groups` — RBAC access groups with owners
+  - `get_support_contacts` — team contact details
+- **New native app stored procedures** — `api.get_model_definitions()`, `api.get_object_definitions()`, `api.get_source_definitions()`, `api.get_access_groups()`, `api.get_support_contacts()` for CLI/MCP consumption
+- **New SnowflakeService methods** — both CLI and MCP Snowflake services expose the new stored procedures
+- **Multi-IDE skill installation** — skills now install to Cursor (`.cursor/rules/{id}.mdc` with frontmatter) and Claude Code (`.claude/commands/{id}.md`) in addition to Cortex Code. Bootstrap and downloads menu prompt users to select target IDE(s) via a multi-select prompt (`[1] Cortex Code`, `[2] Cursor`, `[3] Claude Code`, `[a] All`)
+- **`select_multiple_from_list` display helper** — new utility for comma-separated multi-select input with "all" shortcut
+
+### Changed
+
+- **Bootstrap no longer requires `dbtf` for init** — project scaffolding is now pure Python, removing the dependency on having dbt Fusion installed before bootstrapping
+- **`init_dbt_project()` rewritten** — replaced `subprocess.run(["dbtf", "init"])` with framework-specific `dbt_project_generator` and `directory_scaffolder` services
+
+### Fixed
+
+- **Version drift** — `__init__.py` version now matches `pyproject.toml` (was stuck at `0.1.0`)
+- **Path safety** — replaced unsafe `lstrip("./")` with `removeprefix("./")` in bootstrap and download services
+- **Path traversal prevention** — macro category and file names sanitized with `Path.name` before writing
+- **MCP SQL safety** — added `_ALLOWED_PROCEDURES` frozenset to `MCPSnowflakeService._call_procedure` to prevent arbitrary procedure calls
+- **Narrowed exception handling** — replaced bare `Exception` with `OSError` in skill installation; failed installs no longer added to success list
+- **Cursor `.mdc` frontmatter** — fixed `globs:` to `globs: []` for valid YAML
+
 ## [0.3.4] - 2026-05-15
 
 ### Added

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/PKG-INFO

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

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/pyproject.toml

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

datasecops_cli-0.4.0/src/datasecops_cli/__init__.py

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

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/src/datasecops_cli/main.py

@@ -423,10 +423,14 @@ def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
             dl_menu.show()
         
         elif option == 4:
-            from datasecops_cli.utilities.display import get_input_true_false
+            from datasecops_cli.utilities.display import get_input_true_false, select_multiple_from_list
             platform = config.source_control.source_control_platform.lower()
             info_line(f"Platform: {platform}")
-            install_skills = get_input_true_false("Install Cortex Code skills?")
+            install_skills = get_input_true_false("Install AI coding skills?")
+            skill_targets = None
+            if install_skills:
+                info_line("Which AI coding tools should receive the skills?")
+                skill_targets = select_multiple_from_list(SkillService.TARGETS, "targets")
             run_deps = get_input_true_false("Run dbt deps after downloading packages?")
             bootstrap = BootstrapService(
                 snowflake_service=sf_service,
@@ -434,7 +438,8 @@ def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
                 project_settings=config.project_settings,
                 profile=config.profile,
             )
-            bootstrap.run(platform=platform, install_skills=install_skills, run_deps=run_deps)
+            bootstrap.run(platform=platform, install_skills=install_skills,
+                         skill_targets=skill_targets, run_deps=run_deps)
 
         elif option == 5 and has_outdated:
             _update_upstream_packages(config, dbt_runner, upstream_statuses)
@@ -468,7 +473,7 @@ def _show_main_menu(profile_name: str, git_service: GitService = None,
 
 def _run_bootstrap(config: Config):
     """Run the bootstrap command to initialise a new project."""
-    from datasecops_cli.utilities.display import get_input_true_false
+    from datasecops_cli.utilities.display import get_input_true_false, select_multiple_from_list
 
     sf_service = _connect_and_load(config)
 
@@ -480,7 +485,11 @@ def _run_bootstrap(config: Config):
         info_line(f"Platform: {platform}")
 
         # Ask about optional steps
-        install_skills = get_input_true_false("Install Cortex Code skills?")
+        install_skills = get_input_true_false("Install AI coding skills?")
+        skill_targets = None
+        if install_skills:
+            info_line("Which AI coding tools should receive the skills?")
+            skill_targets = select_multiple_from_list(SkillService.TARGETS, "targets")
         run_deps = get_input_true_false("Run dbt deps after downloading packages?")
 
         bootstrap = BootstrapService(
@@ -489,7 +498,8 @@ def _run_bootstrap(config: Config):
             project_settings=config.project_settings,
             profile=config.profile,
         )
-        success = bootstrap.run(platform=platform, install_skills=install_skills, run_deps=run_deps)
+        success = bootstrap.run(platform=platform, install_skills=install_skills,
+                               skill_targets=skill_targets, run_deps=run_deps)
         sys.exit(0 if success else 1)
 
     finally:

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/src/datasecops_cli/menus/downloads.py

@@ -7,7 +7,7 @@ from datasecops_cli.services.dbt_runner import DbtRunner
 from datasecops_cli.utilities.display import (
     clear, section_header, display_action_header, menu_option,
     get_input_number, get_input_true_false, complete_action,
-    info_line, select_from_list
+    info_line, select_from_list, select_multiple_from_list
 )
 
 
@@ -74,7 +74,7 @@ class DownloadsMenu:
     
     def _skills_menu(self) -> None:
         clear()
-        display_action_header("Cortex Code Skills")
+        display_action_header("AI Coding Skills")
         menu_option(1, "list          - List available skills")
         menu_option(2, "install       - Install a specific skill")
         menu_option(3, "install all   - Install all available skills")
@@ -89,11 +89,19 @@ class DownloadsMenu:
                 names = {s.name: s for s in available}
                 selected = select_from_list(list(names.keys()), "skill")
                 if selected != "back" and selected in names:
-                    self.skills.install_skill(names[selected])
+                    targets = self._select_skill_targets()
+                    self.skills.install_skill(names[selected], targets=targets)
             else:
                 info_line("No skills available")
         elif option == 3:
-            self.skills.install_all()
+            targets = self._select_skill_targets()
+            self.skills.install_all(targets=targets)
         elif option == 4:
-            self.skills.update_skills()
+            targets = self._select_skill_targets()
+            self.skills.update_skills(targets=targets)
         complete_action()
+
+    def _select_skill_targets(self) -> list[str]:
+        """Prompt user to select which IDE(s) to install skills for."""
+        info_line("Which AI coding tools should receive the skills?")
+        return select_multiple_from_list(SkillService.TARGETS, "targets")

{datasecops_cli-0.3.4 → datasecops_cli-0.4.0}/src/datasecops_cli/services/bootstrap_service.py

@@ -23,12 +23,13 @@ class BootstrapService:
         self.skill_service = SkillService(snowflake_service)
 
     def run(self, platform: str = "github", install_skills: bool = True,
-            run_deps: bool = True) -> bool:
+            skill_targets: list[str] = None, run_deps: bool = True) -> bool:
         """Run the full bootstrap process.
 
         Args:
             platform: Source control platform - "github" or "azuredevops".
-            install_skills: Whether to install Cortex Code skills.
+            install_skills: Whether to install AI coding skills.
+            skill_targets: List of IDE targets (e.g. ["Cortex Code", "Cursor", "Claude Code"]).
             run_deps: Whether to run dbt deps after downloading packages.
 
         Returns True if all steps succeeded.
@@ -42,16 +43,20 @@ class BootstrapService:
         steps_passed = 0
         total_steps = 6 + (1 if install_skills else 0) + (1 if run_deps else 0)
 
-        # Step 1: Init dbt project
-        info_line("[1] Initialising dbt project...")
+        # Step 1: Scaffold dbt project (dbt_project.yml, profiles.yml, .gitignore, directory structure)
+        info_line("[1] Scaffolding dbt project...")
         if not self.download_service.init_dbt_project(self.project_settings, self.profile):
-            error_line("Bootstrap failed at: init dbt project")
+            error_line("Bootstrap failed at: scaffold dbt project")
             return False
         steps_passed += 1
 
-        # Resolve the dbt project directory after init
+        # Resolve the dbt project directory after scaffolding
         dbt_project_dir = self.project_dir
-        for candidate in [self.project_dir / "dbt", self.project_dir]:
+        for candidate in [
+            self.project_dir / self.project_settings.project_dir.removeprefix("./"),
+            self.project_dir / "dbt",
+            self.project_dir,
+        ]:
             if (candidate / "dbt_project.yml").exists():
                 dbt_project_dir = candidate
                 break
@@ -84,10 +89,10 @@ class BootstrapService:
             info_line("  (skipped - no pipeline config in native app)")
             steps_passed += 1
 
-        # Step 5: Download dbt packages
+        # Step 5: Generate packages.yml
         info_line("")
-        info_line("[5] Downloading dbt packages...")
-        if self.download_service.download_dbt_packages(dbt_project_dir):
+        info_line("[5] Generating packages.yml...")
+        if self.download_service.download_dbt_packages(dbt_project_dir, profile=self.profile):
             steps_passed += 1
         else:
             info_line("  (skipped - no dbt packages config in native app)")
@@ -123,12 +128,13 @@ class BootstrapService:
             info_line("  (install with: uv pip install " + " ".join(dbt_requirements) + ")")
         steps_passed += 1
 
-        # Step 8: Install Cortex Code skills
+        # Step 8: Install AI coding skills
         if install_skills:
             info_line("")
             step_num += 1
-            info_line(f"[{step_num}] Installing Cortex Code skills...")
-            count = self.skill_service.install_all()
+            targets_label = ", ".join(skill_targets) if skill_targets else "all"
+            info_line(f"[{step_num}] Installing AI coding skills ({targets_label})...")
+            count = self.skill_service.install_all(targets=skill_targets)
             steps_passed += 1
 
         # Done

datasecops_cli-0.4.0/src/datasecops_cli/services/dbt_project_generator.py

@@ -0,0 +1,211 @@
+"""Generate dbt_project.yml matching the DataSecOps Framework skill specification."""
+
+import re
+import yaml
+from typing import Any
+
+from datasecops_cli.models.project_config import ProjectProfile, ProjectSettings
+
+
+# Model type keys that map to dbt_project.yml model sections
+MODEL_SECTION_DEFAULTS: dict[str, dict[str, Any]] = {
+    "sources": {"tags": "ods", "materialized": "view"},
+    "domains": {"tags": "domains", "materialized": "view"},
+    "dimensional_modelling": {"tags": "dm", "materialized": "view"},
+    "cortex_models": {"tags": "cortex", "materialized": "view"},
+}
+
+# Object type keys that map to dbt_project.yml model sections with doc colors
+OBJECT_SECTION_DEFAULTS: dict[str, dict[str, Any]] = {
+    "stored_procedures": {"tags": "stored_procedures", "docs": {"node_color": "DarkOrchid"}},
+    "tasks": {"tags": "tasks", "docs": {"node_color": "Coral"}},
+    "user_defined_functions": {"tags": "user_defined_functions", "docs": {"node_color": "DarkCyan"}},
+}
+
+
+def _snake_case(name: str) -> str:
+    """Convert a project name to snake_case."""
+    return re.sub(r"[\s\-]+", "_", name).lower()
+
+
+def generate_dbt_project_yml(
+    profile: ProjectProfile,
+    project_settings: ProjectSettings,
+) -> str:
+    """Generate a dbt_project.yml string matching the framework skill specification.
+
+    Args:
+        profile: The project profile from the native app.
+        project_settings: The project settings from the native app.
+
+    Returns:
+        The YAML content as a string.
+    """
+    project_name = _snake_case(profile.project_name)
+    dbt_version = profile.dbt_version.lstrip("v")
+    default_target = project_settings.get_default_target()
+    target_warehouse = default_target.target_warehouse if default_target else "DEV_WH"
+
+    # Build the models section based on profile's model_types
+    models_section: dict[str, Any] = {
+        "+persist_docs": {"relation": True, "columns": True},
+    }
+
+    for model_type in profile.model_types:
+        defaults = MODEL_SECTION_DEFAULTS.get(model_type)
+        if defaults:
+            # Map model type keys to shorter dbt_project.yml section names
+            key_map = {"dimensional_modelling": "dm", "cortex_models": "cortex"}
+            section_key = key_map.get(model_type, model_type)
+            section = {f"+tags": defaults["tags"], "+materialized": defaults["materialized"]}
+            models_section[section_key] = section
+
+    # Add object sections
+    for obj_key, obj_defaults in OBJECT_SECTION_DEFAULTS.items():
+        section: dict[str, Any] = {f"+tags": obj_defaults["tags"]}
+        if "docs" in obj_defaults:
+            section["+docs"] = obj_defaults["docs"]
+        models_section[obj_key] = section
+
+    project = {
+        "name": project_name,
+        "version": "1.0.0",
+        "config-version": 2,
+        "profile": profile.profile_name,
+        "model-paths": ["models", "objects"],
+        "analysis-paths": ["analyses"],
+        "test-paths": ["tests"],
+        "seed-paths": ["seeds"],
+        "macro-paths": ["macros"],
+        "snapshot-paths": ["snapshots"],
+        "clean-targets": ["target", "dbt_packages"],
+        "require-dbt-version": f">={dbt_version}",
+        "models": {project_name: models_section},
+        "quoting": {"database": False, "schema": False, "identifier": False},
+        "dispatch": [
+            {
+                "macro_namespace": "dbt",
+                "search_order": [
+                    project_name,
+                    "dbt_dataengineers_utils",
+                    "dbt_dataengineers_materializations",
+                    "dbt",
+                ],
+            }
+        ],
+        "on-run-start": [],
+        "on-run-end": [
+            "{{ dbt_dataengineers_utils.clean_objects(database=target.database, "
+            "clean_targets=['local-dev', 'test', 'prod'], "
+            "object_types=['schemas', 'functions_and_procedures', 'tasks', 'streams', "
+            "'stages', 'tables_and_views', 'alerts', 'file_formats', 'semantic_views', 'agents']) }}"
+        ],
+        "vars": {"dbt_project_target_warehouse": target_warehouse},
+    }
+
+    return yaml.dump(project, default_flow_style=False, sort_keys=False, allow_unicode=True)
+
+
+def generate_profiles_yml(
+    profile: ProjectProfile,
+    project_settings: ProjectSettings,
+    account: str,
+    user: str = "",
+) -> str:
+    """Generate profiles.yml from framework targets.
+
+    Args:
+        profile: The project profile.
+        project_settings: The project settings with targets.
+        account: Snowflake account name.
+        user: Snowflake user name.
+
+    Returns:
+        The YAML content as a string.
+    """
+    outputs: dict[str, Any] = {}
+
+    # Add local-dev target
+    outputs["local-dev"] = {
+        "type": "snowflake",
+        "account": account,
+        "authenticator": "externalbrowser",
+        "role": project_settings.targets[0].target_role if project_settings.targets else "DEVELOPERS",
+        "warehouse": project_settings.targets[0].target_warehouse if project_settings.targets else "DEV_WH",
+        "database": profile.target_database,
+        "schema": project_settings.targets[0].target_schema if project_settings.targets else "PUBLIC",
+        "threads": 4,
+    }
+
+    # Add all framework targets
+    for target in project_settings.targets:
+        branch_suffix = target.branch_name.upper()
+        outputs[target.target_name] = {
+            "type": "snowflake",
+            "account": account,
+            "user": user or "{{ env_var('SNOWFLAKE_USER') }}",
+            "role": target.target_role,
+            "warehouse": target.target_warehouse,
+            "database": f"{profile.target_database}_{branch_suffix}",
+            "schema": target.target_schema,
+            "threads": 4,
+        }
+
+    default_target = project_settings.get_default_target()
+    profiles_data = {
+        profile.profile_name: {
+            "target": default_target.target_name if default_target else "local-dev",
+            "outputs": outputs,
+        }
+    }
+
+    return yaml.dump(profiles_data, default_flow_style=False, sort_keys=False)
+
+
+def generate_packages_yml(
+    profile: ProjectProfile,
+    packages_config: dict,
+) -> str:
+    """Generate packages.yml from profile's packages and upstream projects.
+
+    Args:
+        profile: The project profile.
+        packages_config: The DBT_PACKAGES framework config.
+
+    Returns:
+        The YAML content as a string.
+    """
+    packages = packages_config.get("packages", [])
+    pkg_list: list[dict[str, Any]] = []
+
+    for pkg in packages:
+        source = pkg.get("source", "git")
+        url = pkg.get("url", "")
+        version = pkg.get("latest_version", "")
+        if source == "git" and url:
+            entry: dict[str, Any] = {"git": url}
+            if version:
+                entry["revision"] = version
+            pkg_list.append(entry)
+        elif source == "package" and url:
+            entry = {"package": url}
+            if version:
+                entry["version"] = version
+            pkg_list.append(entry)
+
+    # Add upstream project dependencies as local packages
+    for upstream_name in profile.upstream_projects:
+        pkg_list.append({"local": f"local_packages/{upstream_name}"})
+
+    return yaml.dump({"packages": pkg_list}, default_flow_style=False, sort_keys=False)
+
+
+def generate_gitignore() -> str:
+    """Generate a .gitignore for dbt projects."""
+    return """target/
+dbt_packages/
+logs/
+*.pyc
+__pycache__/
+profiles.yml
+"""

datasecops_cli-0.4.0/src/datasecops_cli/services/directory_scaffolder.py

@@ -0,0 +1,81 @@
+"""Create the dbt project directory structure based on framework definitions."""
+
+from pathlib import Path
+
+from datasecops_cli.utilities.file_utils import ensure_dir, write_file
+from datasecops_cli.utilities.display import info_line
+
+
+# Default model subdirectories per model type
+MODEL_TYPE_DIRS: dict[str, list[str]] = {
+    "sources": ["models/sources"],
+    "dimensional_modelling": [
+        "models/dm/dims",
+        "models/dm/facts",
+        "models/dm/aggregates",
+        "models/dm/modelling_intermediates",
+    ],
+    "domains": ["models/domains"],
+    "cortex_models": ["models/cortex"],
+}
+
+# Default object subdirectories
+OBJECT_DIRS: list[str] = [
+    "objects/stored_procedures",
+    "objects/user_defined_functions",
+    "objects/tasks",
+    "objects/alerts",
+    "objects/stages",
+    "objects/file_formats",
+    "objects/data_metric_functions",
+]
+
+# Standard dbt directories
+STANDARD_DIRS: list[str] = [
+    "analyses",
+    "tests",
+    "seeds",
+    "snapshots",
+    "macros",
+]
+
+
+def scaffold_directories(project_dir: Path, model_types: list[str]) -> None:
+    """Create the full directory structure for a dbt project.
+
+    Args:
+        project_dir: Root of the dbt project.
+        model_types: List of model type keys from the profile (e.g. ["sources", "dimensional_modelling"]).
+    """
+    created: list[str] = []
+
+    # Model directories based on profile's model_types
+    for model_type in model_types:
+        dirs = MODEL_TYPE_DIRS.get(model_type, [])
+        for d in dirs:
+            target = project_dir / d
+            ensure_dir(target)
+            _place_gitkeep(target)
+            created.append(d)
+
+    # Object directories
+    for d in OBJECT_DIRS:
+        target = project_dir / d
+        ensure_dir(target)
+        _place_gitkeep(target)
+        created.append(d)
+
+    # Standard directories
+    for d in STANDARD_DIRS:
+        target = project_dir / d
+        ensure_dir(target)
+        created.append(d)
+
+    info_line(f"  Created {len(created)} directories")
+
+
+def _place_gitkeep(directory: Path) -> None:
+    """Place a .gitkeep file in an empty directory."""
+    gitkeep = directory / ".gitkeep"
+    if not gitkeep.exists():
+        write_file(gitkeep, "")