adevkit 0.1.0__py3-none-any.whl

adevkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

adevkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+adevkit = devkit.cli:main
+devkit = devkit.cli:main

adevkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devkit

devkit/__init__.py

@@ -0,0 +1,4 @@
+"""Aayush's DevKit - One-command project scaffolding with Agentic skills and environments."""
+
+__version__ = "0.1.0"
+__author__ = "Aayush"

devkit/cli.py

@@ -0,0 +1,442 @@
+import os
+import sys
+from pathlib import Path
+from typing import Optional, List, Annotated
+import typer
+from rich.table import Table
+from rich.status import Status
+
+from . import __version__
+from .ui import (
+    console,
+    print_banner,
+    success,
+    info,
+    warning,
+    error,
+    section,
+    print_summary_table,
+)
+from .utils.system import (
+    detect_node_package_manager,
+    detect_git,
+    detect_python,
+    which_tool,
+)
+from .skills.catalog import (
+    AVAILABLE_SKILLS,
+    SKILL_BUNDLES,
+    get_recommended_skills_for_template,
+)
+from .skills.installer import install_skills
+from .templates import (
+    BUILTIN_TEMPLATES,
+    get_all_templates,
+    CustomProjectTemplate,
+    list_custom_templates,
+    save_custom_template,
+    delete_custom_template,
+)
+from .scaffold import (
+    generate_agents_md,
+    generate_prd_template,
+    import_prd_file,
+    setup_git_repository,
+    setup_python_environment,
+    setup_node_environment,
+    setup_dotenv_file,
+    setup_vscode_config,
+)
+from .prompts import (
+    prompt_project_name,
+    prompt_template_selection,
+    prompt_expo_backend_stack,
+    prompt_skills_selection,
+    prompt_prd_mode,
+    prompt_env_options,
+)
+
+app = typer.Typer(
+    name="devkit",
+    help="⚡ Aayush's DevKit - Single-command project initialization with Agentic skills and environments.",
+    add_completion=False,
+)
+
+template_app = typer.Typer(help="Manage and save custom reusable templates.")
+skills_app = typer.Typer(help="Inspect and install agent skills.")
+app.add_typer(template_app, name="template")
+app.add_typer(skills_app, name="skills")
+
+
+@app.callback(invoke_without_command=True)
+def main_entry(ctx: typer.Context):
+    """If no subcommand is passed, default to interactive init."""
+    if ctx.invoked_subcommand is None:
+        init()
+
+
+@app.command(name="init")
+def init(
+    target_dir: Annotated[
+        Optional[str],
+        typer.Argument(help="Directory to initialize the project in (defaults to project name)"),
+    ] = None,
+    name: Annotated[
+        Optional[str],
+        typer.Option("--name", "-n", help="Project name"),
+    ] = None,
+    template: Annotated[
+        Optional[str],
+        typer.Option("--template", "-t", help="Template ID (e.g. nextjs, python_fastapi, vite_react, minimal_agentic, expo_mobile)"),
+    ] = None,
+    skills: Annotated[
+        Optional[List[str]],
+        typer.Option("--skill", "-s", help="Skill ID(s) to install"),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip interactive prompts and use defaults"),
+    ] = False,
+):
+    """Initialize a brand new project with templates, agent skills, environments, and docs."""
+    # Defensive guard in case called directly as a Python function with default models
+    if target_dir is not None and not isinstance(target_dir, str):
+        target_dir = None
+    if name is not None and not isinstance(name, str):
+        name = None
+    if template is not None and not isinstance(template, str):
+        template = None
+    if skills is not None and not isinstance(skills, list):
+        skills = None
+    if not isinstance(yes, bool):
+        yes = False
+
+    print_banner()
+
+    all_templates = get_all_templates()
+
+    # 1. Project Name & Target Directory
+    if not name:
+        if yes:
+            project_name = target_dir or "my-agentic-project"
+        else:
+            default_proj = Path(target_dir).name if target_dir else "my-agentic-project"
+            project_name = prompt_project_name(default_name=default_proj)
+    else:
+        project_name = name
+
+    dest_path = Path(target_dir or project_name.lower().replace(" ", "-")).resolve()
+
+    if dest_path.exists() and any(dest_path.iterdir()):
+        warning(f"Target directory '{dest_path}' already exists and is not empty.")
+        if not yes:
+            if not typer.confirm("Continue and scaffold inside this directory?", default=True):
+                info("Initialization cancelled.")
+                raise typer.Exit(0)
+
+    dest_path.mkdir(parents=True, exist_ok=True)
+
+    # 2. Template Selection
+    if not template:
+        if yes:
+            chosen_template_id = "minimal_agentic"
+        else:
+            chosen_template_id = prompt_template_selection(all_templates)
+    else:
+        chosen_template_id = template
+
+    # Find template info
+    template_info = next((t for t in all_templates if t["id"] == chosen_template_id), None)
+    if not template_info:
+        error(f"Unknown template ID: '{chosen_template_id}'")
+        raise typer.Exit(1)
+
+    expo_backend_stack = "fastapi"
+    if chosen_template_id == "expo_fullstack":
+        if not yes:
+            expo_backend_stack = prompt_expo_backend_stack()
+        has_node = True
+        has_python = "fastapi" in expo_backend_stack or "python" in expo_backend_stack
+    else:
+        has_node = template_info["has_node"]
+        has_python = template_info["has_python"]
+
+    # 3. Agent Skills Selection
+    recommended_skills = get_recommended_skills_for_template(chosen_template_id)
+    if skills is None:
+        if yes:
+            chosen_skills = recommended_skills
+        else:
+            chosen_skills = prompt_skills_selection(AVAILABLE_SKILLS, recommended_skills)
+    else:
+        chosen_skills = skills
+
+    # 4. PRD Mode Selection
+    if yes:
+        prd_config = {"mode": "quick", "overview": "", "target_users": "", "core_features": ""}
+    else:
+        prd_config = prompt_prd_mode()
+
+    # 5. Environment Options
+    if yes:
+        env_config = {
+            "git": True,
+            "dotenv": True,
+            "vscode": True,
+            "venv": has_python,
+            "node": has_node,
+        }
+    else:
+        env_config = prompt_env_options(has_python, has_node)
+
+    # Summary
+    print_summary_table(
+        project_name=project_name,
+        target_dir=str(dest_path),
+        template=template_info["name"],
+        skills=chosen_skills,
+        prd_mode=prd_config["mode"],
+    )
+
+    if not yes:
+        if not typer.confirm("Ready to generate project?", default=True):
+            info("Aborted by user.")
+            raise typer.Exit(0)
+
+    section("Scaffolding Project Files")
+
+    # A. Template Files
+    with console.status(f"[cyan]Scaffolding {template_info['name']} files...[/cyan]", spinner="dots"):
+        if template_info["is_custom"]:
+            custom_data = template_info["custom_data"]
+            tmpl_instance = CustomProjectTemplate(
+                project_name=project_name,
+                target_dir=dest_path,
+                template_dir=custom_data["path"],
+                metadata=custom_data,
+            )
+        else:
+            tmpl_cls = BUILTIN_TEMPLATES[chosen_template_id]
+            if chosen_template_id == "expo_fullstack":
+                tmpl_instance = tmpl_cls(project_name=project_name, target_dir=dest_path, backend_stack=expo_backend_stack)
+            else:
+                tmpl_instance = tmpl_cls(project_name=project_name, target_dir=dest_path)
+
+        created_files = tmpl_instance.scaffold()
+        success(f"Generated {len(created_files)} template files.")
+
+    # B. Agent Skills & Lockfile
+    if chosen_skills:
+        with console.status("[cyan]Installing agent skills & generating skills-lock.json...[/cyan]", spinner="dots"):
+            skill_res = install_skills(dest_path, chosen_skills)
+            success(f"Installed {len(skill_res['installed'])} agent skill(s) into .agents/skills/")
+
+    # C. AGENTS.md
+    with console.status("[cyan]Generating customized AGENTS.md...[/cyan]", spinner="dots"):
+        generate_agents_md(
+            target_dir=dest_path,
+            project_name=project_name,
+            template_id=chosen_template_id,
+            installed_skills=chosen_skills,
+        )
+        success("Created AGENTS.md with architecture & agent instructions.")
+
+    # D. PRD.md
+    if prd_config["mode"] == "generate":
+        with console.status("[cyan]Generating PRD.md...[/cyan]", spinner="dots"):
+            generate_prd_template(
+                target_dir=dest_path,
+                project_name=project_name,
+                overview=prd_config.get("overview", ""),
+                target_users=prd_config.get("target_users", ""),
+                core_features=prd_config.get("core_features", ""),
+            )
+            success("Generated structured PRD.md.")
+    elif prd_config["mode"] == "import" and prd_config.get("source_path"):
+        with console.status("[cyan]Importing PRD.md...[/cyan]", spinner="dots"):
+            import_prd_file(dest_path, prd_config["source_path"])
+            success(f"Imported PRD.md from {prd_config['source_path']}")
+
+    # E. Git & .gitignore
+    if env_config.get("git"):
+        with console.status("[cyan]Initializing Git repository & .gitignore...[/cyan]", spinner="dots"):
+            git_ok = setup_git_repository(dest_path, has_python=has_python, has_node=has_node)
+            if git_ok:
+                success("Initialized Git repository and created .gitignore.")
+            else:
+                warning("Git initialization skipped or git not in PATH (created .gitignore).")
+
+    # F. .env setup
+    if env_config.get("dotenv"):
+        copied = setup_dotenv_file(dest_path)
+        if copied:
+            success("Created .env from .env.example.")
+
+    # G. .vscode setup
+    if env_config.get("vscode"):
+        setup_vscode_config(dest_path, has_python=has_python, has_node=has_node)
+        success("Configured .vscode/ settings and recommended extensions.")
+
+    # H. Python venv & pip
+    if env_config.get("venv"):
+        with console.status("[cyan]Setting up Python virtual environment and dependencies...[/cyan]", spinner="dots"):
+            v_ok, v_msg = setup_python_environment(dest_path)
+            if v_ok:
+                success(v_msg)
+            else:
+                warning(v_msg)
+
+    # I. Node modules install
+    if env_config.get("node"):
+        with console.status("[cyan]Installing Node.js dependencies...[/cyan]", spinner="dots"):
+            n_ok, n_msg = setup_node_environment(dest_path)
+            if n_ok:
+                success(n_msg)
+            else:
+                warning(n_msg)
+
+    # Final Celebration Message
+    section("🎉 Project Successfully Initialized!")
+    console.print(f"[bold green]Location:[/bold green] [underline]{dest_path}[/underline]")
+    console.print("[bold yellow]Next Steps:[/bold yellow]")
+    console.print(f"  1. [cyan]cd {dest_path.name}[/cyan]")
+    if has_python:
+        console.print("  2. Activate virtual environment:")
+        console.print("     - Windows: [cyan].\\.venv\\Scripts\\activate[/cyan]")
+        console.print("     - POSIX:   [cyan]source .venv/bin/activate[/cyan]")
+    if has_node:
+        pm = detect_node_package_manager()
+        console.print(f"  3. Start dev server: [cyan]{pm} run dev[/cyan]")
+    console.print("  4. Open project in your favorite editor (e.g. [cyan]code .[/cyan])")
+    console.print()
+
+
+# --- Template Subcommands ---
+
+@template_app.command(name="save")
+def template_save(
+    name: Annotated[str, typer.Argument(help="Name for the new custom template")],
+    path: Annotated[
+        Optional[str],
+        typer.Option("--path", "-p", help="Directory path to snapshot (defaults to current directory)"),
+    ] = None,
+    description: Annotated[
+        str,
+        typer.Option("--desc", "-d", help="Description of the template"),
+    ] = "",
+):
+    """Snapshot a project folder into a reusable custom template."""
+    src_dir = Path(path).resolve() if path else Path.cwd()
+    if not src_dir.exists() or not src_dir.is_dir():
+        error(f"Source directory does not exist: {src_dir}")
+        raise typer.Exit(1)
+
+    with console.status(f"[cyan]Saving template '{name}' from {src_dir}...[/cyan]", spinner="dots"):
+        saved_path = save_custom_template(name=name, source_dir=src_dir, description=description)
+        success(f"Custom template '{name}' saved successfully at: {saved_path}")
+
+
+@template_app.command(name="list")
+def template_list():
+    """List all built-in and custom saved templates."""
+    templates = get_all_templates()
+    table = Table(title="📦 Available Project Templates", border_style="cyan")
+    table.add_column("Template ID", style="bold yellow", width=18)
+    table.add_column("Type", style="magenta", width=10)
+    table.add_column("Name", style="white", width=35)
+    table.add_column("Description", style="dim")
+
+    for t in templates:
+        tmpl_type = "Custom" if t["is_custom"] else "Built-in"
+        table.add_row(t["id"], tmpl_type, t["name"], t["description"])
+
+    console.print(table)
+
+
+@template_app.command(name="delete")
+def template_delete(
+    name: Annotated[str, typer.Argument(help="Name or ID of the custom template to delete")],
+):
+    """Delete a user-saved custom template."""
+    deleted = delete_custom_template(name)
+    if deleted:
+        success(f"Custom template '{name}' deleted.")
+    else:
+        error(f"Custom template '{name}' not found.")
+
+
+# --- Skills Subcommands ---
+
+@skills_app.command(name="list")
+def skills_list():
+    """List all available curated agent skills in DevKit."""
+    table = Table(title="🤖 Curated Agent Skills Catalog", border_style="green")
+    table.add_column("Skill ID", style="bold yellow", width=22)
+    table.add_column("Category", style="cyan", width=25)
+    table.add_column("Description", style="white")
+
+    for sid, s in AVAILABLE_SKILLS.items():
+        table.add_row(sid, s.category, s.description)
+
+    console.print(table)
+
+
+@skills_app.command(name="add")
+def skills_add(
+    skill_name: Annotated[str, typer.Argument(help="ID of the skill to install")],
+    target: Annotated[
+        Optional[str],
+        typer.Option("--target", "-t", help="Target project root directory (defaults to current dir)"),
+    ] = None,
+):
+    """Install an agent skill into the target project's .agents/skills/."""
+    target_path = Path(target).resolve() if target else Path.cwd()
+    if skill_name not in AVAILABLE_SKILLS:
+        error(f"Skill '{skill_name}' not found in catalog. Run `devkit skills list` to view options.")
+        raise typer.Exit(1)
+
+    with console.status(f"[cyan]Installing {skill_name}...[/cyan]", spinner="dots"):
+        res = install_skills(target_path, [skill_name])
+        success(f"Installed '{skill_name}' into {res['skills_dir']}")
+
+
+@skills_app.command(name="update")
+def skills_update():
+    """Verify and reload the embedded agent skills catalog and lockfile."""
+    with console.status("[cyan]Verifying embedded agent skills catalog...[/cyan]", spinner="dots"):
+        from .skills.catalog import load_all_skills
+        refreshed = load_all_skills()
+        success(f"Successfully synced and indexed {len(refreshed)} agent skills in catalog.")
+
+
+# --- Info Command ---
+
+@app.command(name="info")
+def system_info():
+    """Display environment diagnostics and detected tooling."""
+    print_banner()
+    table = Table(title="🛠 System & Runtime Diagnostics", border_style="blue")
+    table.add_column("Tool / Property", style="bold yellow", width=25)
+    table.add_column("Status / Path", style="white")
+
+    table.add_row("DevKit Version", __version__)
+    table.add_row("Python Executable", detect_python())
+    table.add_row("Git Available", "Yes" if detect_git() else "No (Not in PATH)")
+    
+    node_pm = detect_node_package_manager()
+    table.add_row("Preferred Node PM", f"{node_pm} ({which_tool(node_pm) or 'Not Installed'})")
+
+    for pm in ["bun", "pnpm", "yarn", "npm"]:
+        tool_loc = which_tool(pm)
+        table.add_row(f"Node PM ({pm})", tool_loc or "Not found")
+
+    console.print(table)
+
+
+def main():
+    """Main CLI entrypoint."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

devkit/config.py

@@ -0,0 +1,21 @@
+import os
+import sys
+from pathlib import Path
+
+# Base user directory for global Aayush's DevKit settings & custom templates
+USER_DEVKIT_DIR = Path.home() / ".aayush-devkit"
+USER_TEMPLATES_DIR = USER_DEVKIT_DIR / "templates"
+USER_CONFIG_FILE = USER_DEVKIT_DIR / "config.json"
+
+# Package directory containing embedded default skills/templates
+if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+    PACKAGE_ROOT = Path(sys._MEIPASS) / "devkit"
+else:
+    PACKAGE_ROOT = Path(__file__).parent.resolve()
+
+EMBEDDED_SKILLS_DIR = PACKAGE_ROOT / "skills" / "embedded"
+
+def ensure_user_dirs():
+    """Ensure ~/.aayush-devkit and custom templates directories exist."""
+    USER_DEVKIT_DIR.mkdir(parents=True, exist_ok=True)
+    USER_TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)

devkit/prompts.py

@@ -0,0 +1,197 @@
+import shutil
+import textwrap
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from prompt_toolkit.layout.containers import Window, ConditionalContainer
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.filters import IsDone
+from InquirerPy import inquirer
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.base.control import Choice
+from InquirerPy.separator import Separator
+
+def prompt_project_name(default_name: str = "my-agentic-project") -> str:
+    """Prompt the user for the project name."""
+    return inquirer.text(
+        message="Enter your project name:",
+        default=default_name,
+        validate=lambda result: len(result.strip()) > 0 or "Project name cannot be empty.",
+    ).execute().strip()
+
+def prompt_template_selection(templates: List[Dict]) -> str:
+    """
+    Prompt the user to select from available templates.
+    Displays concise, uncluttered names in the menu and dynamically shows
+    the full description of ONLY the currently highlighted template in a
+    responsive box, optimized for all terminal sizes.
+    """
+    desc_map = {t["id"]: (t["name"], t.get("description", "")) for t in templates}
+    choices = [
+        Choice(
+            value=t["id"],
+            name=t.get("short_name") or t["name"],
+        )
+        for t in templates
+    ]
+
+    term_size = shutil.get_terminal_size((80, 24))
+    prompt_height = max(5, min(10, term_size.lines - 8))
+
+    prompt = ListPrompt(
+        message="Select a project template:",
+        choices=choices,
+        cycle=True,
+        max_height=prompt_height,
+        wrap_lines=False,
+    )
+
+    def get_desc_formatted():
+        sel = prompt.content_control.selection
+        val = sel.get("value") if sel else None
+        meta = desc_map.get(val, ("Template", ""))
+        full_name, desc = meta
+
+        tw = shutil.get_terminal_size((80, 24)).columns
+        box_w = max(34, min(76, tw - 4))
+        inner_w = box_w - 4
+
+        header_text = f" ℹ {full_name} "
+        if len(header_text) > inner_w - 4:
+            header_text = header_text[: max(10, inner_w - 7)] + "... "
+        top_dashes = max(2, box_w - 4 - len(header_text))
+
+        wrapped_lines = textwrap.wrap(desc, width=inner_w) if desc else ["No description provided."]
+
+        out = [
+            ("", "\n"),
+            ("class:instruction", "  ┌─"),
+            ("bold cyan", header_text),
+            ("class:instruction", "─" * top_dashes + "┐\n"),
+        ]
+        for line in wrapped_lines:
+            out.append(("", "  │ " + line.ljust(inner_w) + " │\n"))
+        out.append(("class:instruction", "  └" + "─" * (box_w - 2) + "┘"))
+        return out
+
+    # Add dynamic description container that disappears once selection is made
+    desc_window = ConditionalContainer(
+        Window(content=FormattedTextControl(get_desc_formatted), dont_extend_height=True),
+        filter=~IsDone(),
+    )
+    prompt._layout.content.children.append(desc_window)
+
+    return prompt.execute()
+
+def prompt_expo_backend_stack() -> str:
+    """Prompt the user for their preferred backend stack in the Expo fullstack monorepo."""
+    return inquirer.select(
+        message="Select the backend stack for backend/:",
+        choices=[
+            Choice(value="fastapi", name="Python (FastAPI + Pydantic + Uvicorn)"),
+            Choice(value="hono", name="Node.js / TypeScript (Hono + Node Server)"),
+        ],
+        default="fastapi",
+    ).execute()
+
+def prompt_skills_selection(
+    available_skills: Dict[str, Any],
+    recommended_skills: List[str],
+) -> List[str]:
+    """Prompt the user to choose skills to install into .agents/skills/."""
+    choices = []
+    term_size = shutil.get_terminal_size((80, 24))
+    max_label_w = max(30, min(60, term_size.columns - 18))
+
+    for sid, skill in available_skills.items():
+        is_rec = sid in recommended_skills
+        tag = "RECOMMENDED" if is_rec else skill.category
+        name = skill.name
+        if len(name) > max_label_w:
+            name = name[: max_label_w - 3] + "..."
+        label = f"{name} [{tag}]"
+        choices.append(
+            Choice(
+                value=sid,
+                name=label,
+                enabled=is_rec,
+            )
+        )
+
+    return inquirer.checkbox(
+        message="Select agent skills to install in .agents/skills (Space to toggle, Enter to confirm):",
+        choices=choices,
+        max_height=max(6, min(12, term_size.lines - 8)),
+        wrap_lines=False,
+        cycle=True,
+    ).execute()
+
+def prompt_prd_mode() -> Dict[str, Any]:
+    """Prompt the user how they would like to handle PRD.md."""
+    mode = inquirer.select(
+        message="How would you like to handle PRD.md?",
+        choices=[
+            Choice(value="guided", name="Generate a structured PRD template with guided inputs"),
+            Choice(value="quick", name="Generate default comprehensive PRD.md starter"),
+            Choice(value="import", name="Attach / import an existing PRD.md file from disk"),
+            Choice(value="skip", name="Skip PRD.md for now"),
+        ],
+        default="guided",
+    ).execute()
+
+    if mode == "guided":
+        overview = inquirer.text(
+            message="Brief project vision / overview (press Enter for default):",
+            default="",
+        ).execute()
+        users = inquirer.text(
+            message="Primary target users / audience (press Enter for default):",
+            default="",
+        ).execute()
+        features = inquirer.text(
+            message="Top 2-3 core features (comma-separated, or Enter for default):",
+            default="",
+        ).execute()
+        return {
+            "mode": "generate",
+            "overview": overview,
+            "target_users": users,
+            "core_features": "\n".join([f"- {f.strip()}" for f in features.split(",") if f.strip()]) if features else "",
+        }
+    elif mode == "quick":
+        return {"mode": "generate", "overview": "", "target_users": "", "core_features": ""}
+    elif mode == "import":
+        path_str = inquirer.filepath(
+            message="Enter the path to your existing PRD.md file:",
+            validate=lambda p: Path(p).is_file() or "File does not exist.",
+            only_files=True,
+        ).execute()
+        return {"mode": "import", "source_path": Path(path_str)}
+    else:
+        return {"mode": "skip"}
+
+def prompt_env_options(has_python: bool, has_node: bool) -> Dict[str, bool]:
+    """Prompt for automated environment setup toggles."""
+    choices = [
+        Choice(value="git", name="Initialize Git repository & smart .gitignore", enabled=True),
+        Choice(value="dotenv", name="Create .env from .env.example (if available)", enabled=True),
+        Choice(value="vscode", name="Configure .vscode settings and recommended extensions", enabled=True),
+    ]
+
+    if has_python:
+        choices.append(Choice(value="venv", name="Create Python .venv & install requirements.txt", enabled=True))
+
+    if has_node:
+        choices.append(Choice(value="node", name="Auto-detect package manager and install node_modules", enabled=True))
+
+    selected = inquirer.checkbox(
+        message="Select automated initialization tasks to execute:",
+        choices=choices,
+    ).execute()
+
+    return {
+        "git": "git" in selected,
+        "dotenv": "dotenv" in selected,
+        "vscode": "vscode" in selected,
+        "venv": "venv" in selected,
+        "node": "node" in selected,
+    }