deepctl-cmd-init 0.0.2__tar.gz → 0.0.3__tar.gz

{deepctl_cmd_init-0.0.2 → deepctl_cmd_init-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepctl-cmd-init
-Version: 0.0.2
+Version: 0.0.3
 Summary: Init command for deepctl — scaffold Deepgram starter apps
 Author-email: Deepgram <devrel@deepgram.com>
 Maintainer-email: Deepgram <devrel@deepgram.com>

{deepctl_cmd_init-0.0.2 → deepctl_cmd_init-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepctl-cmd-init"
-version = "0.0.2" # x-release-please-version
+version = "0.0.3" # x-release-please-version
 description = "Init command for deepctl — scaffold Deepgram starter apps"
 readme = "README.md"
 license = "MIT"

deepctl_cmd_init-0.0.3/src/deepctl_cmd_init/command.py

@@ -0,0 +1,415 @@
+"""Init command for deepctl — scaffold Deepgram starter apps."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from deepctl_core import (
+    AuthManager,
+    BaseCommand,
+    Config,
+    DeepgramClient,
+)
+from deepctl_core.output import _agentic
+from rich.console import Console
+from rich.table import Table
+
+from . import lifecycle, templates_api
+from .models import InitResult, TemplateDetail, TemplateInfo
+
+console = Console()
+status_console = Console(stderr=True)
+
+
+class InitCommand(BaseCommand):
+    """Scaffold a Deepgram starter app from the templates gallery."""
+
+    name = "init"
+    help = (
+        "Browse, clone, and set up Deepgram starter apps.\n\n"
+        "Fetches templates from the Deepgram templates gallery. "
+        "Run with no arguments for an interactive search-and-select picker, "
+        "or pass a template name directly to clone immediately."
+    )
+    short_help = "Scaffold a Deepgram starter app (alpha)"
+
+    requires_auth = False
+    requires_project = False
+    ci_friendly = True
+
+    examples = [
+        "dg init",
+        "dg init --search python",
+        "dg init node-transcription",
+        "dg init node-transcription --dir ./my-app",
+        "dg init node-transcription --install",
+        "dg init node-transcription --no-install",
+        "dg init --list",
+        "dg init --list --search flask",
+    ]
+    agent_help = (
+        "Scaffold a Deepgram starter app from the templates gallery. "
+        "Pass the template name/slug directly (e.g. 'node-transcription'). "
+        "Use --list to enumerate available templates. "
+        "After cloning, runs make check-prereqs then make init automatically. "
+        "Use --no-install to skip setup. "
+        "Requires git, node, npm, make, and curl to be installed."
+    )
+
+    def get_arguments(self) -> list[dict[str, Any]]:
+        """Get command arguments and options."""
+        return [
+            {
+                "name": "template",
+                "help": "Template name/slug to clone (e.g. node-transcription)",
+                "type": str,
+                "required": False,
+                "default": None,
+            },
+            {
+                "names": ["--dir", "-d"],
+                "help": "Target directory (default: ./{template-name})",
+                "type": str,
+                "is_option": True,
+            },
+            {
+                "names": ["--search", "-s"],
+                "help": "Filter templates by keyword",
+                "type": str,
+                "is_option": True,
+            },
+            {
+                "names": ["--list", "-l"],
+                "help": "List available templates and exit",
+                "is_flag": True,
+                "is_option": True,
+            },
+            {
+                "names": ["--install"],
+                "help": "Run setup (make check-prereqs && make init) without prompting",
+                "is_flag": True,
+                "is_option": True,
+            },
+            {
+                "names": ["--no-install"],
+                "help": "Skip setup step without prompting",
+                "is_flag": True,
+                "is_option": True,
+            },
+            {
+                "names": ["--start"],
+                "help": "Run start step after install without prompting",
+                "is_flag": True,
+                "is_option": True,
+            },
+            {
+                "names": ["--no-start"],
+                "help": "Skip start step without prompting",
+                "is_flag": True,
+                "is_option": True,
+            },
+        ]
+
+    def handle(
+        self,
+        config: Config,
+        auth_manager: AuthManager,
+        client: DeepgramClient,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle the init command."""
+        template_slug: str | None = kwargs.get("template")
+        target_dir: str | None = kwargs.get("dir")
+        search: str | None = kwargs.get("search")
+        list_mode: bool = kwargs.get("list", False)
+        do_install: bool = kwargs.get("install", False)
+        no_install: bool = kwargs.get("no_install", False)
+        do_start: bool = kwargs.get("start", False)
+        no_start: bool = kwargs.get("no_start", False)
+
+        # ── List mode ──────────────────────────────────────────────────────────
+        if list_mode:
+            return self._handle_list(search)
+
+        # ── Prerequisite check ─────────────────────────────────────────────────
+        # Check before any clone attempt so users get a clear error with install
+        # hints rather than a confusing git/make error mid-setup.
+        missing = lifecycle.check_prereqs()
+        if missing:
+            console.print("[red bold]Missing required tools:[/red bold]")
+            for _key, name, hint in missing:
+                console.print(f"  [red]✗[/red] [bold]{name}[/bold]")
+                console.print(f"    {hint}")
+            console.print()
+            console.print(
+                "[dim]Install the tools above and re-run [bold]dg init[/bold].[/dim]"
+            )
+            return InitResult(
+                status="error",
+                message=f"Missing tools: {', '.join(k for k, _, _ in missing)}",
+            )
+
+        # ── Template selection ─────────────────────────────────────────────────
+        if template_slug:
+            detail = self._fetch_template(template_slug)
+            if not detail:
+                return InitResult(
+                    status="error", message=f"Template not found: {template_slug}"
+                )
+        elif _agentic:
+            # In agent mode, require an explicit template name
+            return InitResult(
+                status="error",
+                message=(
+                    "In agent mode, pass the template slug directly, e.g.: "
+                    "dg init node-transcription\n"
+                    "Use dg init --list to see available templates."
+                ),
+            )
+        else:
+            detail = self._interactive_pick(search)
+            if not detail:
+                return InitResult(status="cancelled", message="No template selected")
+
+        # ── Resolve target directory ───────────────────────────────────────────
+        dest = Path(target_dir) if target_dir else Path(f"./{detail.name}")
+        dest = dest.resolve()
+
+        # ── Confirm ────────────────────────────────────────────────────────────
+        self._print_template_summary(detail)
+        console.print(f"[dim]Destination:[/dim] {dest}")
+        console.print()
+
+        if not _agentic and not self.confirm("Clone this template?", default=True):
+            return InitResult(status="cancelled", message="Clone cancelled")
+
+        # ── Clone ──────────────────────────────────────────────────────────────
+        github_url = detail.links.get("github")
+        if not github_url:
+            return InitResult(status="error", message="Template has no GitHub URL")
+
+        console.print()
+        with console.status("[blue]Cloning repository...[/blue]"):
+            try:
+                lifecycle.clone_template(github_url, dest)
+            except RuntimeError as e:
+                return InitResult(status="error", message=str(e))
+
+        console.print(f"[green]✓[/green] Cloned to [cyan]{dest}[/cyan]")
+        console.print(
+            "[dim]The cloned directory is a full git repository — "
+            "you can add your own remote and push.[/dim]"
+        )
+
+        # ── Inject API key ─────────────────────────────────────────────────────
+        try:
+            api_key = auth_manager.get_api_key()
+            if api_key:
+                lifecycle.inject_env(dest, api_key)
+        except Exception:
+            pass  # Auth is optional
+
+        # ── Setup (make check-prereqs && make init) ────────────────────────────
+        installed = False
+        has_makefile = (dest / "Makefile").exists()
+
+        if not no_install:
+            if _agentic or do_install:
+                run_setup = True
+            elif has_makefile:
+                console.print()
+                run_setup = self.confirm(
+                    "Run setup? (make check-prereqs && make init)", default=True
+                )
+            else:
+                run_setup = False
+
+            if run_setup:
+                console.print()
+                if has_makefile:
+                    installed = lifecycle.run_make_init(dest)
+                elif detail.config and detail.config.install:
+                    # Fallback: TOML lifecycle for repos without a Makefile
+                    installed = lifecycle.run_lifecycle_step(
+                        detail.config.install, dest
+                    )
+
+        # ── Start step (optional) ──────────────────────────────────────────────
+        started = False
+        if installed and detail.config and detail.config.start and not no_start:
+            if _agentic or do_start:
+                run_start = True
+            else:
+                console.print()
+                run_start = self.confirm("Run start step?", default=False)
+
+            if run_start:
+                console.print()
+                started = lifecycle.run_lifecycle_step(detail.config.start, dest)
+
+        # ── Summary ────────────────────────────────────────────────────────────
+        console.print()
+        console.print(
+            f"[green bold]Done![/green bold] "
+            f"[cyan]{detail.title}[/cyan] is ready at [cyan]{dest}[/cyan]"
+        )
+        console.print()
+
+        if not installed and has_makefile:
+            console.print(f"[dim]To set up:  cd {dest.name} && make init[/dim]")
+        if not started and detail.config and detail.config.start:
+            console.print(f"[dim]To start:   cd {dest.name} && make start[/dim]")
+
+        return InitResult(
+            status="success",
+            message=f"Cloned {detail.name}",
+            template=detail.name,
+            directory=str(dest),
+            installed=installed,
+            started=started,
+        )
+
+    def output_result(self, result: Any, config: Config) -> None:
+        """Only emit structured output when an explicit --output format is set."""
+        from deepctl_core.output import get_output_format
+
+        if get_output_format() in ("default",):
+            return
+        super().output_result(result, config)
+
+    # ── List ──────────────────────────────────────────────────────────────────
+
+    def _handle_list(self, search: str | None) -> list[dict[str, Any]]:
+        """List templates and return structured data."""
+        with console.status("[blue]Fetching templates...[/blue]"):
+            response = templates_api.list_templates(search=search)
+
+        templates = response.items
+        if not templates:
+            console.print("[yellow]No templates found[/yellow]")
+            return []
+
+        self._print_templates_table(templates)
+        console.print(f"\n[dim]{len(templates)} template(s)[/dim]")
+        return [t.model_dump() for t in templates]
+
+    # ── Interactive picker ────────────────────────────────────────────────────
+
+    def _interactive_pick(self, search: str | None) -> TemplateDetail | None:
+        """Interactive search-and-select picker.
+
+        The user can type a number to select, or type a search term to filter
+        and re-display the list. Loops until a selection is made or cancelled.
+        """
+        with console.status("[blue]Fetching templates...[/blue]"):
+            response = templates_api.list_templates()
+
+        all_templates = response.items
+        if not all_templates:
+            console.print("[yellow]No templates found[/yellow]")
+            return None
+
+        # Apply initial search filter if provided
+        filtered = (
+            templates_api.filter_templates(all_templates, search)
+            if search
+            else all_templates
+        )
+
+        selected: TemplateInfo | None = None
+
+        while selected is None:
+            self._print_templates_table(filtered)
+            console.print()
+
+            if len(filtered) == 0:
+                console.print("[yellow]No templates match your search.[/yellow]")
+                filtered = all_templates
+                continue
+
+            console.print(
+                "[dim]Type a [bold]number[/bold] to select, "
+                "or a [bold]search term[/bold] to filter. "
+                "Ctrl+C to cancel.[/dim]"
+            )
+            try:
+                raw = input("> ").strip()
+            except (EOFError, KeyboardInterrupt):
+                console.print()
+                return None
+
+            if not raw:
+                if len(filtered) == 1:
+                    selected = filtered[0]
+                continue
+
+            # Try numeric selection
+            try:
+                idx = int(raw)
+                if 1 <= idx <= len(filtered):
+                    selected = filtered[idx - 1]
+                else:
+                    console.print(
+                        f"[yellow]Enter a number between 1 and {len(filtered)}.[/yellow]"
+                    )
+            except ValueError:
+                # Treat as search term
+                new_filtered = templates_api.filter_templates(all_templates, raw)
+                if not new_filtered:
+                    console.print(
+                        f"[yellow]No templates match '{raw}'. Showing all.[/yellow]"
+                    )
+                    filtered = all_templates
+                else:
+                    filtered = new_filtered
+                console.print()
+
+        console.print()
+        with console.status(f"[blue]Fetching {selected.name}...[/blue]"):
+            return templates_api.get_template(selected.name)
+
+    def _fetch_template(self, slug: str) -> TemplateDetail | None:
+        """Fetch template detail by slug."""
+        try:
+            with console.status(f"[blue]Fetching {slug}...[/blue]"):
+                return templates_api.get_template(slug)
+        except Exception as e:
+            console.print(f"[red]Error:[/red] {e}")
+            return None
+
+    # ── Rendering ─────────────────────────────────────────────────────────────
+
+    def _print_templates_table(self, templates: list[TemplateInfo]) -> None:
+        """Print a numbered table of templates."""
+        table = Table(show_header=True, header_style="bold blue")
+        table.add_column("#", style="dim", width=4, justify="right")
+        table.add_column("Name")
+        table.add_column("Language")
+        table.add_column("Framework")
+        table.add_column("Use case")
+        table.add_column("Description", no_wrap=False, max_width=50)
+
+        for i, t in enumerate(templates, 1):
+            table.add_row(
+                str(i),
+                t.name,
+                t.language,
+                t.framework or "—",
+                t.category or "—",
+                t.description,
+            )
+
+        console.print(table)
+
+    def _print_template_summary(self, detail: TemplateDetail) -> None:
+        """Print a one-line summary of the selected template."""
+        console.print()
+        console.print(f"[bold]{detail.title}[/bold]  [dim]{detail.name}[/dim]")
+        console.print(f"[dim]{detail.description}[/dim]")
+        lang_line = f"Language: [cyan]{detail.language}[/cyan]"
+        if detail.framework:
+            lang_line += f"  Framework: [cyan]{detail.framework}[/cyan]"
+        if detail.stats.stars:
+            lang_line += f"  ★ {detail.stats.stars}"
+        console.print(lang_line)

deepctl_cmd_init-0.0.3/src/deepctl_cmd_init/lifecycle.py

@@ -0,0 +1,204 @@
+"""Clone template repos and run lifecycle steps from deepgram.toml."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from .models import LifecycleStep
+
+console = Console()
+
+# ── Prerequisite tools ────────────────────────────────────────────────────────
+
+#: Each entry: tool key → (display name, install hint)
+PREREQS: dict[str, tuple[str, str]] = {
+    "git": (
+        "git",
+        "https://git-scm.com/downloads",
+    ),
+    "node": (
+        "Node.js",
+        "https://nodejs.org",
+    ),
+    "npm": (
+        "npm",
+        "bundled with Node.js — reinstall from https://nodejs.org",
+    ),
+    "make": (
+        "make",
+        "macOS: xcode-select --install  |  Linux: sudo apt-get install make",
+    ),
+    "curl": (
+        "curl",
+        "macOS: brew install curl  |  Linux: sudo apt-get install curl",
+    ),
+}
+
+
+def check_prereqs() -> list[tuple[str, str, str]]:
+    """Check for required tools.
+
+    Returns:
+        List of ``(key, display_name, install_hint)`` tuples for every missing tool.
+        Empty list means all tools are present.
+    """
+    missing: list[tuple[str, str, str]] = []
+    for key, (name, hint) in PREREQS.items():
+        if shutil.which(key) is None:
+            missing.append((key, name, hint))
+    return missing
+
+
+# ── Git clone ─────────────────────────────────────────────────────────────────
+
+
+def clone_template(github_url: str, target_dir: Path) -> None:
+    """Clone a template repository, keeping the .git directory intact.
+
+    The cloned directory is a fully functional git repository so users can
+    commit changes, add their own remote, and push to their own repo.
+
+    Args:
+        github_url: Full GitHub URL to clone.
+        target_dir: Local directory to clone into (must not exist).
+
+    Raises:
+        RuntimeError: If the directory already exists or git clone fails.
+    """
+    if target_dir.exists():
+        raise RuntimeError(f"Directory already exists: {target_dir}")
+
+    result = subprocess.run(
+        ["git", "clone", github_url, str(target_dir)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"git clone failed:\n{result.stderr.strip()}")
+
+
+# ── .env injection ────────────────────────────────────────────────────────────
+
+
+def inject_env(target_dir: Path, api_key: str) -> None:
+    """Create or update DEEPGRAM_API_KEY in .env inside target_dir.
+
+    Args:
+        target_dir: Directory containing the cloned template.
+        api_key: Deepgram API key to inject.
+    """
+    env_path = target_dir / ".env"
+
+    if env_path.exists():
+        content = env_path.read_text()
+        if "DEEPGRAM_API_KEY=" in content and "DEEPGRAM_API_KEY=$" not in content:
+            console.print("[dim]DEEPGRAM_API_KEY already set in .env[/dim]")
+            return
+        # Replace placeholder or append
+        if "DEEPGRAM_API_KEY=" in content:
+            lines = content.splitlines()
+            new_lines = [
+                f"DEEPGRAM_API_KEY={api_key}"
+                if ln.startswith("DEEPGRAM_API_KEY=")
+                else ln
+                for ln in lines
+            ]
+            env_path.write_text("\n".join(new_lines) + "\n")
+        else:
+            with open(env_path, "a") as f:
+                if not content.endswith("\n"):
+                    f.write("\n")
+                f.write(f"DEEPGRAM_API_KEY={api_key}\n")
+    else:
+        env_path.write_text(f"DEEPGRAM_API_KEY={api_key}\n")
+
+    console.print("[green]✓[/green] Injected DEEPGRAM_API_KEY into .env")
+
+
+# ── make init ─────────────────────────────────────────────────────────────────
+
+
+def run_make_init(dest: Path) -> bool:
+    """Run ``make check-prereqs && make init`` in the cloned directory.
+
+    Used for starter repos that ship a Makefile with these standard targets.
+
+    Args:
+        dest: The cloned project directory.
+
+    Returns:
+        True if both commands succeeded, False otherwise.
+    """
+    makefile = dest / "Makefile"
+    if not makefile.exists():
+        return False
+
+    for target in ("check-prereqs", "init"):
+        result = subprocess.run(
+            ["make", target],
+            cwd=str(dest),
+        )
+        if result.returncode != 0:
+            console.print(
+                f"\n[red]✗[/red] [bold]make {target}[/bold] failed "
+                f"(exit {result.returncode})"
+            )
+            if target == "check-prereqs":
+                console.print(
+                    "[dim]Fix the missing prerequisites above and run "
+                    f"[bold]make init[/bold] inside [cyan]{dest.name}[/cyan][/dim]"
+                )
+            else:
+                console.print(
+                    f"[dim]Re-run manually: cd {dest.name} && make init[/dim]"
+                )
+            return False
+
+    return True
+
+
+# ── TOML lifecycle (fallback) ─────────────────────────────────────────────────
+
+
+def run_lifecycle_step(step: LifecycleStep, cwd: Path) -> bool:
+    """Execute a lifecycle step from deepgram.toml.
+
+    Used as a fallback for repos that don't have a Makefile.
+
+    Args:
+        step: The lifecycle step definition.
+        cwd: Working directory for command execution.
+
+    Returns:
+        True if the step succeeded, False otherwise.
+    """
+    if step.command is None:
+        return True
+
+    commands = step.command if isinstance(step.command, list) else [step.command]
+
+    for cmd in commands:
+        if step.message:
+            console.print(f"[blue]{step.message}[/blue]")
+        else:
+            console.print(f"[dim]Running: {cmd}[/dim]")
+
+        result = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            shell=True,
+        )
+        if result.returncode != 0:
+            console.print(
+                f"[red]✗[/red] Command failed (exit {result.returncode}): {cmd}"
+            )
+            return False
+
+    return True

{deepctl_cmd_init-0.0.2 → deepctl_cmd_init-0.0.3}/src/deepctl_cmd_init.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepctl-cmd-init
-Version: 0.0.2
+Version: 0.0.3
 Summary: Init command for deepctl — scaffold Deepgram starter apps
 Author-email: Deepgram <devrel@deepgram.com>
 Maintainer-email: Deepgram <devrel@deepgram.com>

deepctl_cmd_init-0.0.2/src/deepctl_cmd_init/command.py

@@ -1,321 +0,0 @@
-"""Init command for deepctl — scaffold Deepgram starter apps."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import click
-from deepctl_core import (
-    AuthManager,
-    BaseCommand,
-    Config,
-    DeepgramClient,
-)
-from rich.console import Console
-from rich.table import Table
-
-from . import lifecycle, templates_api
-from .models import InitResult, TemplateDetail, TemplateInfo
-
-console = Console()
-
-
-class InitCommand(BaseCommand):
-    """Scaffold a Deepgram starter app from the templates gallery."""
-
-    name = "init"
-    help = (
-        "Browse, clone, and set up Deepgram starter apps. "
-        "Fetches templates from the Deepgram templates gallery and "
-        "optionally runs install/start lifecycle steps."
-    )
-    short_help = "Scaffold a Deepgram starter app"
-
-    requires_auth = False
-    requires_project = False
-    ci_friendly = True
-
-    examples = [
-        "dg init",
-        "dg init --search python",
-        "dg init node-transcription",
-        "dg init node-transcription --dir ./my-app",
-        "dg init node-transcription --install --start",
-        "dg init --list",
-        "dg init --list --search flask",
-    ]
-    agent_help = (
-        "Scaffold a Deepgram starter app from the templates gallery. "
-        "Can list available templates, search/filter them, or clone a "
-        "specific template by name. After cloning, optionally runs "
-        "install and start lifecycle steps defined in deepgram.toml. "
-        "If authenticated, injects DEEPGRAM_API_KEY into .env automatically."
-    )
-
-    def get_arguments(self) -> list[dict[str, Any]]:
-        """Get command arguments and options."""
-        return [
-            {
-                "name": "template",
-                "help": "Template name/slug to clone directly",
-                "type": str,
-                "required": False,
-                "default": None,
-            },
-            {
-                "names": ["--dir", "-d"],
-                "help": "Target directory (default: ./{template-name})",
-                "type": str,
-                "is_option": True,
-            },
-            {
-                "names": ["--search", "-s"],
-                "help": "Filter templates by search term",
-                "type": str,
-                "is_option": True,
-            },
-            {
-                "names": ["--list", "-l"],
-                "help": "List matching templates and exit",
-                "is_flag": True,
-                "is_option": True,
-            },
-            {
-                "names": ["--install"],
-                "help": "Run install step without prompting",
-                "is_flag": True,
-                "is_option": True,
-            },
-            {
-                "names": ["--start"],
-                "help": "Run start step without prompting",
-                "is_flag": True,
-                "is_option": True,
-            },
-            {
-                "names": ["--no-install"],
-                "help": "Skip install step without prompting",
-                "is_flag": True,
-                "is_option": True,
-            },
-            {
-                "names": ["--no-start"],
-                "help": "Skip start step without prompting",
-                "is_flag": True,
-                "is_option": True,
-            },
-        ]
-
-    def handle(
-        self,
-        config: Config,
-        auth_manager: AuthManager,
-        client: DeepgramClient,
-        **kwargs: Any,
-    ) -> Any:
-        """Handle the init command."""
-        template_slug: str | None = kwargs.get("template")
-        target_dir: str | None = kwargs.get("dir")
-        search: str | None = kwargs.get("search")
-        list_mode: bool = kwargs.get("list", False)
-        do_install: bool = kwargs.get("install", False)
-        do_start: bool = kwargs.get("start", False)
-        no_install: bool = kwargs.get("no_install", False)
-        no_start: bool = kwargs.get("no_start", False)
-
-        # --- List mode ---
-        if list_mode:
-            return self._handle_list(search)
-
-        # --- Direct template selection ---
-        if template_slug:
-            detail = self._fetch_template(template_slug)
-            if not detail:
-                return InitResult(
-                    status="error", message=f"Template not found: {template_slug}"
-                )
-        else:
-            # --- Interactive picker ---
-            detail = self._interactive_pick(search)
-            if not detail:
-                return InitResult(status="cancelled", message="No template selected")
-
-        # Resolve target directory
-        dest = Path(target_dir) if target_dir else Path(f"./{detail.name}")
-        dest = dest.resolve()
-
-        # Confirm selection
-        self._print_template_summary(detail)
-        console.print(f"[dim]Directory:[/dim] {dest}")
-        console.print()
-
-        if not self.confirm("Clone this template?", default=True):
-            return InitResult(status="cancelled", message="Clone cancelled")
-
-        # Clone
-        github_url = detail.links.get("github")
-        if not github_url:
-            return InitResult(status="error", message="Template has no GitHub URL")
-
-        console.print()
-        with console.status("[blue]Cloning template...[/blue]"):
-            lifecycle.clone_template(github_url, dest)
-        console.print(f"[green]Cloned to {dest}[/green]")
-
-        # Inject API key if authenticated
-        try:
-            api_key = auth_manager.get_api_key()
-            if api_key:
-                lifecycle.inject_env(dest, api_key)
-        except Exception:
-            pass  # Auth is optional
-
-        installed = False
-        started = False
-
-        # Run lifecycle steps if config exists
-        if detail.config:
-            # Install step
-            if detail.config.install:
-                should_install = do_install or (
-                    not no_install and self.confirm("Run install step?", default=True)
-                )
-                if should_install:
-                    console.print()
-                    installed = lifecycle.run_lifecycle_step(
-                        detail.config.install, dest
-                    )
-
-            # Start step
-            if detail.config.start:
-                should_start = do_start or (
-                    not no_start and self.confirm("Run start step?", default=True)
-                )
-                if should_start:
-                    console.print()
-                    started = lifecycle.run_lifecycle_step(detail.config.start, dest)
-
-        # Summary
-        console.print()
-        console.print(
-            f"[green bold]Done![/green bold] Your app is ready at [cyan]{dest}[/cyan]"
-        )
-        if not installed and detail.config and detail.config.install:
-            console.print(
-                f"[dim]To install: cd {dest.name} && run the install command[/dim]"
-            )
-        if not started and detail.config and detail.config.start:
-            console.print(
-                f"[dim]To start: cd {dest.name} && run the start command[/dim]"
-            )
-
-        return InitResult(
-            status="success",
-            message=f"Cloned {detail.name}",
-            template=detail.name,
-            directory=str(dest),
-            installed=installed,
-            started=started,
-        )
-
-    def output_result(self, result: Any, config: Config) -> None:
-        """Only emit structured output when an explicit --output format is set."""
-        from deepctl_core.output import get_output_format
-
-        output_format = get_output_format()
-
-        # Default format: the Rich table / console messages are already printed,
-        # so skip the automatic JSON dump.
-        if output_format in ("default",):
-            return
-
-        # Explicit --output json/yaml/table/csv: delegate to base
-        super().output_result(result, config)
-
-    def _handle_list(self, search: str | None) -> list[dict[str, Any]]:
-        """List templates and return structured data."""
-        with console.status("[blue]Fetching templates...[/blue]"):
-            response = templates_api.list_templates(search=search)
-
-        templates = response.items
-        if not templates:
-            console.print("[yellow]No templates found[/yellow]")
-            return []
-
-        self._print_templates_table(templates)
-        console.print(f"\n[dim]{len(templates)} template(s) found[/dim]")
-
-        return [t.model_dump() for t in templates]
-
-    def _interactive_pick(self, search: str | None) -> TemplateDetail | None:
-        """Show interactive picker and return selected template detail."""
-        with console.status("[blue]Fetching templates...[/blue]"):
-            response = templates_api.list_templates(search=search)
-
-        templates = response.items
-        if not templates:
-            console.print("[yellow]No templates found[/yellow]")
-            return None
-
-        self._print_templates_table(templates)
-        console.print()
-
-        try:
-            choice = click.prompt(
-                "Select a template",
-                type=click.IntRange(1, len(templates)),
-            )
-        except (click.Abort, EOFError):
-            return None
-
-        selected = templates[choice - 1]
-        console.print()
-
-        # Fetch full detail
-        with console.status(f"[blue]Fetching {selected.name}...[/blue]"):
-            return templates_api.get_template(selected.name)
-
-    def _fetch_template(self, slug: str) -> TemplateDetail | None:
-        """Fetch template detail by slug, handling errors."""
-        try:
-            with console.status(f"[blue]Fetching {slug}...[/blue]"):
-                return templates_api.get_template(slug)
-        except Exception as e:
-            console.print(f"[red]Error:[/red] {e}")
-            return None
-
-    def _print_templates_table(self, templates: list[TemplateInfo]) -> None:
-        """Print a numbered table of templates."""
-        table = Table(show_header=True, header_style="bold blue")
-        table.add_column("#", style="dim", width=4, justify="right")
-        table.add_column("Name")
-        table.add_column("Language")
-        table.add_column("Framework")
-        table.add_column("Category")
-
-        for i, t in enumerate(templates, 1):
-            table.add_row(
-                str(i),
-                t.name,
-                t.language,
-                t.framework or "—",
-                t.category or "—",
-            )
-
-        console.print(table)
-
-    def _print_template_summary(self, detail: TemplateDetail) -> None:
-        """Print a summary of the selected template."""
-        console.print()
-        console.print(f"[bold]{detail.title}[/bold]")
-        console.print(f"[dim]{detail.description}[/dim]")
-        console.print(
-            f"Language: [cyan]{detail.language}[/cyan]"
-            + (
-                f"  Framework: [cyan]{detail.framework}[/cyan]"
-                if detail.framework
-                else ""
-            )
-            + (f"  Stars: {detail.stats.stars}" if detail.stats.stars else "")
-        )

deepctl_cmd_init-0.0.2/src/deepctl_cmd_init/lifecycle.py

@@ -1,104 +0,0 @@
-"""Clone template repos and run lifecycle steps from deepgram.toml."""
-
-from __future__ import annotations
-
-import shutil
-import subprocess
-from typing import TYPE_CHECKING
-
-from rich.console import Console
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    from .models import LifecycleStep
-
-console = Console()
-
-
-def clone_template(github_url: str, target_dir: Path) -> None:
-    """Clone a template repo with depth 1, then remove .git.
-
-    Args:
-        github_url: Full GitHub URL to clone.
-        target_dir: Local directory to clone into.
-
-    Raises:
-        RuntimeError: If git clone fails.
-    """
-    if target_dir.exists():
-        raise RuntimeError(f"Directory already exists: {target_dir}")
-
-    result = subprocess.run(
-        ["git", "clone", "--depth", "1", github_url, str(target_dir)],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"git clone failed: {result.stderr.strip()}")
-
-    # Remove .git so the user starts fresh
-    git_dir = target_dir / ".git"
-    if git_dir.exists():
-        shutil.rmtree(git_dir)
-
-
-def inject_env(target_dir: Path, api_key: str) -> None:
-    """Create or append DEEPGRAM_API_KEY to .env in target_dir.
-
-    Args:
-        target_dir: Directory containing the cloned template.
-        api_key: Deepgram API key to inject.
-    """
-    env_path = target_dir / ".env"
-
-    # Check if key already present
-    if env_path.exists():
-        content = env_path.read_text()
-        if "DEEPGRAM_API_KEY=" in content:
-            console.print("[dim]DEEPGRAM_API_KEY already set in .env, skipping[/dim]")
-            return
-        # Append with newline separator
-        with open(env_path, "a") as f:
-            if not content.endswith("\n"):
-                f.write("\n")
-            f.write(f"DEEPGRAM_API_KEY={api_key}\n")
-    else:
-        env_path.write_text(f"DEEPGRAM_API_KEY={api_key}\n")
-
-    console.print("[green]Injected DEEPGRAM_API_KEY into .env[/green]")
-
-
-def run_lifecycle_step(step: LifecycleStep, cwd: Path) -> bool:
-    """Execute a lifecycle step from deepgram.toml.
-
-    Args:
-        step: The lifecycle step definition.
-        cwd: Working directory for command execution.
-
-    Returns:
-        True if the step succeeded, False otherwise.
-    """
-    if step.command is None:
-        return True
-
-    commands = step.command if isinstance(step.command, list) else [step.command]
-
-    for cmd in commands:
-        if step.message:
-            console.print(f"[blue]{step.message}[/blue]")
-        else:
-            console.print(f"[dim]Running: {cmd}[/dim]")
-
-        result = subprocess.run(
-            cmd,
-            cwd=str(cwd),
-            shell=True,
-        )
-        if result.returncode != 0:
-            console.print(
-                f"[red]Command failed (exit {result.returncode}):[/red] {cmd}"
-            )
-            return False
-
-    return True