dlthub-init 0.1.0__py3-none-any.whl

dlthub_init/__init__.py

@@ -0,0 +1 @@
+"""dlthub-init: scaffold a dltHub workspace into a new or existing directory."""

dlthub_init/__main__.py

@@ -0,0 +1,10 @@
+"""Enable `python -m dlthub_init`."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

dlthub_init/_bundled_skills/dlthub-router/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: dlthub-router
+description: "The entry point for building anything with dlthub. Use this skill to route the user to the right workflow toolkit and install it on demand. MUST use when the user asks 'what can you do', 'what can I build', 'what are toolkits', 'how do I build a pipeline', 'I want to pull data from a REST API', 'ingest from a SQL database', 'load CSVs from S3', 'make reports / dashboards', 'transform / model my data', 'add data quality checks', 'how do I deploy / schedule a pipeline', 'I'm new to dlthub', 'where do I start', or seems unsure what to do next after setup. Also use whenever the user expresses a data-engineering goal but no matching workflow toolkit is installed yet — this skill installs it on demand. Do NOT use when the toolkit matching the user's intent is already installed — go straight to its entry skill instead; only route/install when the matching toolkit is missing. Do NOT use when a specific task is already in progress (debugging a pipeline, validating data, adding endpoints) and its toolkit is installed. Do NOT use when the user explicitly wants a guided end-to-end demo — use **quick-start** for that."
+---
+
+# dlthub-router
+
+Route the user to the right toolkit and skill, then install it. **Fast path first** — the always-loaded toolkit index (in your project rules / `AGENTS.md`) already maps intent → toolkit → install command → entry skill, so you usually do **not** need any discovery round-trip.
+
+> **Router vs handovers.** This skill handles **cold start** — picking and installing a toolkit when none relevant is installed. Once inside a workflow, a toolkit's `workflow.md` **handover** sections take over: they carry context forward (pipeline name, dataset, destination) and route to a specific skill. Do **not** use this skill mid-workflow when the relevant toolkit is already installed. But when a handover names a toolkit that **isn't installed yet**, that's your cue — install it via the index below, then follow the handover's entry point + context.
+
+## Step 1: Route from the always-loaded index (fast path)
+
+The `# toolkits` index is already in your context. Match the user's intent to a row, then:
+
+1. **Install** it: `dlthub --non-interactive ai toolkit install <name>`
+2. **Confirm** (Step 3) and **hand over** to that toolkit's entry skill (Step 4).
+
+This needs **no MCP call** — the index is authoritative for the shipped toolkits and is the fast path. Use it whenever the intent matches a row.
+
+## Step 2: Live discovery (fallback only)
+
+Use this **only** when the index has no matching row (an unfamiliar need, or you suspect a newer toolkit exists):
+
+- **Prefer MCP** — `list_toolkits` from `dlt-workspace-mcp` for the live catalog, then `toolkit_info <name>` for skill details.
+- **CLI fallback** (MCP not connected): `dlthub --non-interactive ai toolkit list`, then `dlthub --non-interactive ai toolkit info <name>`.
+
+Match intent to the best toolkit, then install as in Step 1. Toolkits marked `(installed: <version>)` are already available.
+
+## Step 3: Confirm & enable MCP
+
+```
+uv run dlthub ai status
+```
+1. You should see the new toolkit and its entry skill.
+2. If you see any **WARNING** about the MCP server (e.g. cannot be started), **fix it** using the error message.
+
+## Step 4: Handover (no restart needed)
+
+The `dlt-workspace-mcp` server is already running (installed with `init`) and toolkits reuse it — installing one adds **no new MCP server**, so continue in this session. Do **not** ask the user to restart; that would lose the conversation context.
+
+1. **Load the new toolkit inline** — prefer `toolkit_info <name>` (MCP), which is agent-agnostic and returns the entry skill + workflow rule. If MCP is unavailable, read the installed files directly; the install path depends on the agent (`.claude/`, `.cursor/`, or `.agents/`) — e.g. `<agent-dir>/skills/<entry-skill>/SKILL.md` and the toolkit's workflow rule.
+2. **Follow that workflow rule and start at the entry skill**, continuing the user's task with the context you already have. Do not start unrelated workflows on your own.
+3. The new skills become natively registered (`/`-invocable, always-loaded workflow rule) on the next natural session start — no need to restart now.
+
+> Exception: if a future toolkit ever ships its **own** MCP server (none do today), that server only starts on restart — suggest a restart **only** in that case, and use CLI fallbacks until then.
+
+<!-- Loading the new skill/rule inline is a stopgap: until the harness can hot-reload skills/rules after install, newly installed components aren't natively registered until the next session start. Tracked in dlt-hub/dlthub-ai-workbench-internal#72. -->
+

dlthub_init/_bundled_skills/improve-skills/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: improve-skills
+description: Improve existing skills based on the current session. Use at the end of a session (or when the user asks) to capture new debugging patterns, data issues, data validation tracks, querying techniques, doc references, or workflow improvements learned during the session. Keeps skills lean and personalized.
+---
+
+# Improve skills from session
+
+Review the current session and update skills with essential learnings. Skills are the team's institutional memory — keep them lean, specific, and actionable.
+
+## Principles
+
+- **Read the skill first** — always read the current SKILL.md before proposing changes. Don't duplicate what's already there.
+- **Lean updates only** — add the minimum needed. A single bullet point or a 3-line code snippet is often enough.
+- **Real problems only** — only add things that actually happened in this session or that the user explicitly asked to capture. No hypothetical scenarios.
+- **Doc references matter** — if you found a docs page that was essential to solving a problem, add it as an "Essential Reading" link.
+- **Tools and commands** — if a specific CLI command or MCP tool was key to diagnosing an issue, add it.
+- **Don't restructure** — don't reorganize or rewrite existing skill content. Append to the right section or add a new subsection.
+
+## Process
+
+### 1. Scan the session for learnings
+
+First identify which skills are active in the current toolkit — check the installed skills directory or use the `toolkit_info` MCP tool. Then review the conversation for:
+
+**Errors and debugging**:
+- New error types, root causes, and the commands or MCP tools that diagnosed them
+- Config settings that helped (e.g., verbosity, timeouts, flags)
+- Workarounds for API, source, or destination-specific behaviors
+
+**Data and schema**:
+- Unexpected data types or coercions needed
+- Schema surprises (nesting, missing columns, naming conventions)
+- Processing patterns that worked
+
+**Data access and querying**:
+- Library-specific gotchas (e.g., ibis, dlt dataset API)
+- Useful query patterns or MCP tool calls
+
+**Source and pipeline configuration**:
+- Auth, pagination, or rate-limit quirks
+- Config resolution surprises
+- Source/resource parameterization patterns
+
+**Workflow**:
+- Missing cross-references between skills
+- New skills that should be in the workflow
+- Steps that are in the wrong order
+
+Map each learning to the most relevant skill in the active toolkit.
+
+### 2. Read the target skills
+
+For each learning, read the relevant SKILL.md. Check:
+- Is this already covered?
+- Where does it fit best? (which section)
+- Would it contradict or duplicate existing content?
+
+### 3. Propose changes to the user
+
+Present a summary of proposed updates:
+
+```
+Proposed skill updates:
+
+<skill-name>:
+  + [section] Added: <brief description>
+
+<skill-name>:
+  (no changes)
+
+<skill-name>:
+  + [section] Added: <brief description>
+```
+
+Get user approval before editing. The user may want to adjust, skip, or add more.
+
+### 4. Apply changes
+
+Edit the SKILL.md files. For each change:
+- Add to the most relevant existing section
+- If no section fits, add a new subsection at the end (before "Next steps" if present)
+- Include doc links as `**Ref:** <url>` or `**Essential Reading:** <url>`
+- Keep code examples minimal — 3-5 lines max
+
+### 5. Update workflow if needed
+
+Check if `workflow.md` cross-references are still accurate after skill changes. Update if new skills were added or handoff points changed.

dlthub_init/_bundled_skills/setup-secrets/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: setup-secrets
+description: Safely manage dlthub secrets in *.secrets.toml. Use when the user directly asks to set up, configure, or inspect credentials (API keys, database passwords, tokens). Also use when writing Python code that needs to read secrets via dlt.secrets without exposing values. Do NOT use for pipeline creation, source discovery, or debugging pipeline execution — those skills call setup-secrets when they need credentials configured.
+argument-hint: "[source-name]"
+---
+
+# Set up dlthub secrets
+
+**Essential Reading** Credentials & config resolution: `https://dlthub.com/docs/general-usage/credentials/setup.md` `https://dlthub.com/docs/general-usage/credentials/advanced`
+
+Configure credentials in `.dlt/secrets.toml`. **Never read secrets files directly** — use `dlt-workspace-mcp` tools or `dlthub ai secrets` CLI commands.
+
+**Prefer MCP** — use `secrets_list`, `secrets_view_redacted`, `secrets_update_fragment` tools from `dlt-workspace-mcp`.
+
+**CLI fallback**: If MCP is not connected, see [cli-reference.md](cli-reference.md) for equivalent `dlthub ai secrets` commands.
+
+**Read additional docs as needed:**
+- Connection string credentials (databases, warehouses): `https://dlthub.com/docs/general-usage/credentials/complex_types.md`
+- Built-in credential types (`GcpServiceAccountCredentials`, `AwsCredentials`, etc.): `https://dlthub.com/docs/general-usage/credentials/complex_types.md#built-in-credentials`
+- Destination-specific credentials: `https://dlthub.com/docs/dlt-ecosystem/destinations/`
+
+Parse `$ARGUMENTS`:
+- `source_name` or description of what credentials are needed (e.g. "stripe api key", "postgres credentials")
+
+## 1. Figure out what to configure
+
+If called from another skill, you already know the source, destination, and which fields are needed — skip to step 3.
+
+If called standalone (e.g. user says "set up secrets" or hit `ConfigFieldMissingException`):
+- Read the exception message — it tells you the exact field name and TOML path
+- Read the pipeline script to find `dlt.secrets.value` parameters on `@dlt.source`/`@dlt.resource` functions
+- Identify the destination type for required credentials
+
+## 2. Find the right secrets file and inspect its shape
+
+Use `secrets_list` to list workspace-scoped secrets files. Profile-scoped files (e.g. `.dlt/dev.secrets.toml`) appear first — **use those when present**, fall back to `.dlt/secrets.toml` otherwise.
+
+**Pick the target file** from the list — you will pass it as `path` to `secrets_update_fragment` in step 4.
+
+Then use `secrets_view_redacted` (no `path` argument) to see the **unified merged** view with values replaced by `***`. To inspect a specific file, pass `path=".dlt/<profile>.secrets.toml"`.
+
+Look for:
+- Which sections already exist (`[sources.<name>]`, `[destination.<name>]`)
+- Which fields have real values (stars) vs placeholders (`<configure me>`)
+- Whether the layout matches what the pipeline expects
+
+Skip this step if you already know the secrets file is empty or doesn't exist.
+
+## 3. Research credentials
+
+Before asking the user for values:
+- **Web search** the data source for how credentials are obtained (API docs, developer portal)
+- Tell the user exactly what they need and where to get it (e.g. "Go to https://dashboard.stripe.com/apikeys")
+- Explain what each credential field is for
+
+## 4. Write secrets
+
+Use `secrets_update_fragment` with `fragment` (TOML string) and `path` (target file from step 2). Creates the file if needed, deep-merges without overwriting other sections, returns the redacted result.
+
+**CRITICAL: Only write placeholders** — never pass actual secret values through `secrets_update_fragment` or any other tool. The user fills in real values themselves by editing the file directly.
+
+### Layout rules
+
+**Always** scope secrets under the source or destination name:
+
+```toml
+[sources.<source_name>]
+api_key = "<paste-your-api-key-here>"
+
+[destination.<destination_name>.credentials]
+host = "localhost"
+port = 5432
+database = "analytics"
+username = "loader"
+password = "<paste-your-password-here>"
+```
+
+`<source_name>` = `name=` arg on `@dlt.source`, or the function name if not set.
+
+### Placeholders
+
+Use **meaningful placeholders** that hint at the format:
+- API keys: `"sk-*****-your-key"` or `"ak-xxxx-xxxx-xxxx"`
+- Tokens: `"ghp_xxxxxxxxxxxxxxxxxxxx"` (GitHub), `"xoxb-xxxx"` (Slack)
+- Passwords: `"<paste-your-password-here>"`
+- URLs: `"https://your-instance.example.com"`
+
+**Never** use the generic `"<configure me>"`.
+
+## 5. Verify
+
+Use `secrets_view_redacted` to see the unified merged view across all workspace secret files. Tell the user which fields still have placeholders and how to obtain real values.
+
+
+## 6. Use secrets in Python
+You can write Python scripts that read and use secrets without ever revealing them. `dlt.secrets` and `dlt.config` work as dictionaries using the same TOML paths shown by `view-redacted`.
+
+Example: you need to call the GitHub REST API and `view-redacted` shows `[sources.github] api_key = "***"`:
+```py
+import dlt
+import requests
+
+# reads from secrets.toml [sources.github] api_key — never prints the value
+api_key = dlt.secrets["sources.github.api_key"]
+resp = requests.get(
+    "https://api.github.com/user",
+    headers={"Authorization": f"Bearer {api_key}"},
+)
+print(resp.json()["login"])
+```
+
+You can also retrieve typed credentials:
+```py
+from dlt.sources.credentials import GcpServiceAccountCredentials
+
+creds = dlt.secrets.get("destination.bigquery.credentials", GcpServiceAccountCredentials)
+```
+
+**Reference**: https://dlthub.com/docs/general-usage/credentials/advanced.md#access-configs-and-secrets-in-code
+

dlthub_init/_bundled_skills/setup-secrets/cli-reference.md

@@ -0,0 +1,69 @@
+# CLI reference for dlthub secrets
+
+Use these commands when `dlt-workspace-mcp` is not connected. All MCP tools have CLI equivalents:
+
+| MCP tool | CLI equivalent |
+|---|---|
+| `secrets_list` | `dlthub ai secrets list` |
+| `secrets_view_redacted` | `dlthub ai secrets view-redacted [--path <file>]` |
+| `secrets_update_fragment` | `dlthub ai secrets update-fragment --path <file> '<toml>'` |
+
+## `secrets list`
+
+Lists project-scoped secrets files. Profile-scoped files (e.g. `.dlt/dev.secrets.toml`) appear first.
+
+```sh
+dlthub ai secrets list
+```
+
+## `secrets view-redacted`
+
+Shows TOML structure with values replaced by `***`. Without `--path`, shows the unified merged view across all workspace secret files.
+
+```sh
+dlthub ai secrets view-redacted
+dlthub ai secrets view-redacted --path .dlt/<profile>.secrets.toml
+```
+
+## `secrets update-fragment`
+
+Merges a TOML fragment into a secrets file. Creates the file if needed, deep-merges without overwriting other sections, prints the redacted result. `--path` is required.
+
+### Linux / macOS
+
+Use multiline single-quoted strings — all POSIX shells (bash, zsh, sh, dash, fish) pass real newlines:
+
+```sh
+dlthub ai secrets update-fragment --path .dlt/secrets.toml '[sources.stripe]
+api_key = "sk-test-xxxxxxxxxxxx"
+'
+```
+
+```sh
+dlthub ai secrets update-fragment --path .dlt/secrets.toml '[destination.postgres.credentials]
+host = "localhost"
+port = 5432
+database = "analytics"
+username = "loader"
+password = "<paste-your-password-here>"
+'
+```
+
+Profile-scoped:
+```sh
+dlthub ai secrets update-fragment --path .dlt/<profile>.secrets.toml '[sources.my_api]
+api_key = "sk-xxxxxxxxxxxx"
+'
+```
+
+### Windows
+
+Use `\n` for newlines in a single-line string. The CLI converts literal `\n` to real newlines before parsing:
+
+```
+dlthub ai secrets update-fragment --path .dlt/secrets.toml "[sources.stripe]\napi_key = \"sk-test-xxxxxxxxxxxx\""
+```
+
+```
+dlthub ai secrets update-fragment --path .dlt/secrets.toml "[destination.postgres.credentials]\nhost = \"localhost\"\nport = 5432\ndatabase = \"analytics\"\nusername = \"loader\"\npassword = \"<paste-your-password-here>\""
+```

dlthub_init/cli.py

@@ -0,0 +1,170 @@
+"""Command-line entrypoint for the `dlthub-init` CLI."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import strings
+from .collisions import Flags
+from .config import DEFAULT_SCAFFOLD
+from .display import (
+    console,
+    err_console,
+    print_collision,
+    print_header,
+    print_next_steps,
+    print_summary,
+    substep,
+    substep_detail,
+)
+from .errors import CollisionError, UvError, WorkspaceError
+from .prompts import confirm
+from .scaffold import apply_scaffold, resolve_target
+from .skills import install_skills
+from .uv import execute_uv_install, find_uv, run_uv_sync
+
+
+def _ensure_utf8_io_on_windows() -> None:
+    if sys.platform != "win32":
+        return
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8")
+        except (OSError, ValueError):
+            pass
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="dlthub-init",
+        description="Scaffold a dltHub workspace into a new or existing directory.",
+    )
+    parser.add_argument(
+        "project_dir",
+        nargs="?",
+        default=None,
+        help="Directory to initialize. Defaults to the current directory.",
+    )
+    parser.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Stream output from uv.",
+    )
+    parser.add_argument(
+        "--no-sync",
+        action="store_true",
+        help="Scaffold files only; do not create a virtual environment or install dependencies.",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite existing generated files (never secrets).",
+    )
+    parser.add_argument(
+        "--merge",
+        action="store_true",
+        help="Append missing entries to an existing .gitignore instead of skipping it.",
+    )
+    parser.add_argument(
+        "--no-pyproject",
+        action="store_true",
+        help="Skip pyproject.toml.",
+    )
+    parser.add_argument(
+        "--no-gitignore",
+        action="store_true",
+        help="Skip .gitignore.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    _ensure_utf8_io_on_windows()
+    args = build_parser().parse_args(argv)
+
+    try:
+        run(args)
+    except KeyboardInterrupt:
+        console.print(strings.MSG_CANCELLED)
+        return 130
+    except CollisionError as exc:
+        print_collision(exc.conflicts)
+        return 2
+    except WorkspaceError as exc:
+        console.print(strings.MSG_ERROR_PREFIX.format(message=exc))
+        return 1
+    except Exception as exc:
+        console.print(strings.MSG_UNEXPECTED_ERROR.format(message=exc))
+        if args.verbose:
+            console.print_exception()
+        else:
+            console.print(strings.MSG_UNEXPECTED_ERROR_HINT)
+        return 1
+    return 0
+
+
+def run(args: argparse.Namespace) -> None:
+    if args.yes:
+        err_console.print(strings.MSG_TESTING_SHORTCUT_NOTE)
+
+    verbose = args.verbose
+    scaffold = DEFAULT_SCAFFOLD
+    flags = Flags(
+        force=args.force,
+        merge=args.merge,
+        no_pyproject=args.no_pyproject,
+        no_gitignore=args.no_gitignore,
+    )
+
+    project_dir = resolve_target(args.project_dir)
+    print_header(project_dir)
+
+    plan = apply_scaffold(project_dir, scaffold=scaffold, flags=flags)
+    installed_skills = install_skills(project_dir)
+    print_summary(plan)
+    if installed_skills:
+        substep_detail(strings.MSG_SKILLS_INSTALLED.format(count=len(installed_skills)))
+
+    synced = _maybe_sync(project_dir, args, verbose=verbose)
+    print_next_steps(project_dir, synced=synced, uv_installed=find_uv() is not None)
+
+
+def _maybe_sync(project_dir: Path, args: argparse.Namespace, *, verbose: bool) -> bool:
+    if args.no_sync:
+        console.print(strings.MSG_SKIPPED_SYNC)
+        return False
+
+    uv_executable = find_uv()
+    if uv_executable is None and not (args.yes or confirm(strings.PROMPT_INSTALL_UV, default=True)):
+        console.print(strings.MSG_SKIPPED_SYNC)
+        return False
+
+    if not args.yes and not confirm(strings.PROMPT_CREATE_VENV, default=True):
+        console.print(strings.MSG_SKIPPED_SYNC)
+        return False
+
+    try:
+        if uv_executable is None:
+            uv_executable = execute_uv_install(verbose=verbose)
+        with substep(strings.MSG_INSTALLING_DEPS, strings.MSG_INSTALLED_DEPS, verbose=verbose):
+            run_uv_sync(uv_executable, project_dir, verbose=verbose)
+    except UvError as exc:
+        console.print(strings.MSG_SYNC_FAILED.format(message=exc))
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dlthub_init/collisions.py

@@ -0,0 +1,83 @@
+"""Non-destructive write planning for `dlthub-init`."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+PYPROJECT = Path("pyproject.toml")
+UV_LOCK = Path("uv.lock")
+GITIGNORE = Path(".gitignore")
+WORKSPACE_MARKER = Path(".dlt") / ".workspace"
+SECRET_FILES = frozenset({Path(".dlt") / "secrets.toml"})
+MERGEABLE_FILES = frozenset({GITIGNORE})
+
+
+class Outcome(Enum):
+    CREATE = "create"
+    OVERWRITE = "overwrite"
+    MERGE = "merge"
+    SKIP = "skip"
+    DISABLED = "disabled"
+    CONFLICT = "conflict"
+
+
+@dataclass(frozen=True)
+class Flags:
+    force: bool = False
+    merge: bool = False
+    no_pyproject: bool = False
+    no_gitignore: bool = False
+
+
+@dataclass(frozen=True)
+class PlannedPath:
+    relative: Path
+    outcome: Outcome
+
+
+def build_plan(relatives: list[Path], project_dir: Path, flags: Flags) -> list[PlannedPath]:
+    outcomes = {rel: _classify(rel, project_dir, flags) for rel in relatives}
+    _couple_lock_to_pyproject(outcomes, project_dir)
+    return [PlannedPath(rel, outcomes[rel]) for rel in sorted(outcomes)]
+
+
+def conflicts(plan: list[PlannedPath]) -> list[str]:
+    return [str(p.relative) for p in plan if p.outcome is Outcome.CONFLICT]
+
+
+def _classify(rel: Path, project_dir: Path, flags: Flags) -> Outcome:
+    if _disabled_by_flag(rel, flags):
+        return Outcome.DISABLED
+    if not (project_dir / rel).exists():
+        return Outcome.CREATE
+    if rel in SECRET_FILES:
+        return Outcome.SKIP
+    if rel in MERGEABLE_FILES:
+        return Outcome.MERGE if flags.merge else Outcome.SKIP
+    if flags.force:
+        return Outcome.OVERWRITE
+    if rel == WORKSPACE_MARKER:
+        return Outcome.CONFLICT
+    return Outcome.SKIP
+
+
+def _couple_lock_to_pyproject(outcomes: dict[Path, Outcome], project_dir: Path) -> None:
+    # The bundled uv.lock only matches the bundled pyproject, so ship them together.
+    if UV_LOCK not in outcomes:
+        return
+    if outcomes.get(PYPROJECT) in (Outcome.CREATE, Outcome.OVERWRITE):
+        outcomes[UV_LOCK] = Outcome.OVERWRITE if (project_dir / UV_LOCK).exists() else Outcome.CREATE
+    elif (project_dir / UV_LOCK).exists():
+        outcomes[UV_LOCK] = Outcome.SKIP
+    else:
+        del outcomes[UV_LOCK]
+
+
+def _disabled_by_flag(rel: Path, flags: Flags) -> bool:
+    if rel == PYPROJECT:
+        return flags.no_pyproject
+    if rel == GITIGNORE:
+        return flags.no_gitignore
+    return False

dlthub_init/config.py

@@ -0,0 +1,5 @@
+"""Project-wide constants for the `dlthub-init` CLI."""
+
+from __future__ import annotations
+
+DEFAULT_SCAFFOLD = "minimal_workspace"