app-generator-cli 1.0.1__py3-none-any.whl

app_generator/__init__.py

@@ -0,0 +1,10 @@
+"""PyForge CLI package."""
+
+from importlib.metadata import metadata
+
+try:
+	_meta = metadata("app-generator-cli")
+except Exception:
+	_meta = metadata("pyforge-cli")
+__version__ = _meta["Version"]
+__author__ = _meta["Author-email"]

app_generator/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules."""

app_generator/commands/create.py

@@ -0,0 +1,74 @@
+"""
+`appgenerator create` subcommand group.
+Delegates to template-specific generators.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from app_generator.generator import ProjectGenerator
+
+create_app = typer.Typer(no_args_is_help=True, rich_markup_mode="rich")
+console = Console()
+
+
+def _run_generator(
+    template: str,
+    project_name: str,
+    output_dir: Optional[Path],
+    docker: bool,
+    postgres: bool,
+    redis: bool,
+) -> None:
+    target = (output_dir or Path.cwd()) / project_name
+    if target.exists():
+        console.print(f"[bold red]✗[/] Directory [bold]{target}[/] already exists.")
+        raise typer.Exit(code=1)
+
+    generator = ProjectGenerator(
+        template=template,
+        project_name=project_name,
+        target_dir=target,
+        options={"docker": docker, "postgres": postgres, "redis": redis},
+    )
+    generator.run()
+
+
+@create_app.command("fastapi", help="Scaffold a [bold]FastAPI[/] backend project.")
+def create_fastapi(
+    project_name: str = typer.Argument(..., help="Name of the new project."),
+    output_dir: Optional[Path] = typer.Option(None, "--output", "-o", help="Parent directory."),
+    docker: bool = typer.Option(False, "--docker", help="Add Dockerfile & docker-compose.yml."),
+    postgres: bool = typer.Option(False, "--postgres", help="Add PostgreSQL support."),
+    redis: bool = typer.Option(False, "--redis", help="Add Redis support."),
+) -> None:
+    _run_generator("fastapi", project_name, output_dir, docker, postgres, redis)
+
+
+@create_app.command(
+    "fastapi-with-frontend",
+    help="Scaffold a [bold]FastAPI + Jinja frontend[/] project.",
+)
+def create_fastapi_with_frontend(
+    project_name: str = typer.Argument(..., help="Name of the new project."),
+    output_dir: Optional[Path] = typer.Option(None, "--output", "-o", help="Parent directory."),
+    docker: bool = typer.Option(False, "--docker", help="Add Dockerfile & docker-compose.yml."),
+    postgres: bool = typer.Option(False, "--postgres", help="Add PostgreSQL support."),
+    redis: bool = typer.Option(False, "--redis", help="Add Redis support."),
+) -> None:
+    _run_generator("fastapi-with-frontend", project_name, output_dir, docker, postgres, redis)
+
+
+@create_app.command("ai", help="Scaffold a [bold]LangChain / LangGraph[/] AI project.")
+def create_ai(
+    project_name: str = typer.Argument(..., help="Name of the new project."),
+    output_dir: Optional[Path] = typer.Option(None, "--output", "-o", help="Parent directory."),
+    docker: bool = typer.Option(False, "--docker", help="Add Dockerfile & docker-compose.yml."),
+    postgres: bool = typer.Option(False, "--postgres", help="Add PostgreSQL vector DB support."),
+    redis: bool = typer.Option(False, "--redis", help="Add Redis cache support."),
+) -> None:
+    _run_generator("ai", project_name, output_dir, docker, postgres, redis)

app_generator/generator.py

@@ -0,0 +1,265 @@
+"""
+Core project generation engine.
+Handles file rendering, uv init, and dependency installation.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+console = Console()
+
+# Package root — templates live here
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+
+class ProjectGenerator:
+    """Renders a project template and initialises it with uv."""
+
+    FASTAPI_DEPS = [
+        "fastapi",
+        "uvicorn[standard]",
+        "sqlmodel",
+        "aiosqlite",
+        "pydantic",
+        "pydantic-settings",
+        "python-dotenv",
+        "alembic",
+        "httpx",
+    ]
+    FASTAPI_DEV_DEPS = ["pytest", "pytest-asyncio", "httpx", "ruff", "mypy"]
+
+    FASTAPI_FRONTEND_DEPS = FASTAPI_DEPS + ["jinja2"]
+    FASTAPI_FRONTEND_DEV_DEPS = FASTAPI_DEV_DEPS
+
+    AI_DEPS = [
+        "langchain",
+        "langgraph",
+        "langchain-community",
+        "langchain-openai",
+        "langchain-ollama",
+        "langchain-chroma",
+        "chromadb",
+        "openai",
+        "tiktoken",
+        "python-dotenv",
+        "pydantic",
+        "pydantic-settings",
+        "httpx",
+    ]
+    AI_DEV_DEPS = ["pytest", "pytest-asyncio", "ruff", "mypy"]
+
+    TEMPLATE_DEPS: dict[str, list[str]] = {
+        "fastapi": FASTAPI_DEPS,
+        "fastapi-with-frontend": FASTAPI_FRONTEND_DEPS,
+        "ai": AI_DEPS,
+    }
+    TEMPLATE_DEV_DEPS: dict[str, list[str]] = {
+        "fastapi": FASTAPI_DEV_DEPS,
+        "fastapi-with-frontend": FASTAPI_FRONTEND_DEV_DEPS,
+        "ai": AI_DEV_DEPS,
+    }
+
+    OPTIONAL_DEPS: dict[str, list[str]] = {
+        "postgres": ["asyncpg", "psycopg2-binary"],
+        "redis": ["redis", "hiredis"],
+    }
+
+    def __init__(
+        self,
+        template: str,
+        project_name: str,
+        target_dir: Path,
+        options: dict[str, Any],
+    ) -> None:
+        self.template = template  # "fastapi" | "ai"
+        self.project_name = project_name
+        self.target_dir = target_dir
+        self.options = options
+        self.template_dir = TEMPLATES_DIR / template
+        self.env = Environment(
+            loader=FileSystemLoader(str(self.template_dir)),
+            keep_trailing_newline=True,
+        )
+
+    # ------------------------------------------------------------------ #
+    #  Public API
+    # ------------------------------------------------------------------ #
+
+    def run(self) -> None:
+        console.print()
+        console.print(
+            Panel.fit(
+                f"[bold cyan]⚒  AppGenerator[/]  ·  Creating [bold]{self.project_name}[/] "
+                f"([italic]{self.template}[/] template)",
+                border_style="cyan",
+            )
+        )
+        console.print()
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            t = progress.add_task("Rendering template files …", total=None)
+            self._render_template()
+            progress.update(t, description="[green]✓[/] Template files written")
+
+            progress.update(t, description="Initialising uv project …", completed=None)
+            self._uv_init()
+            progress.update(t, description="[green]✓[/] uv project initialised")
+
+            progress.update(t, description="Installing dependencies …", completed=None)
+            self._install_deps()
+            progress.update(t, description="[green]✓[/] Dependencies installed")
+
+        self._print_success()
+
+    # ------------------------------------------------------------------ #
+    #  Steps
+    # ------------------------------------------------------------------ #
+
+    def _render_template(self) -> None:
+        """Walk the template directory, render Jinja files, copy static files."""
+        ctx = self._build_context()
+
+        for src in self.template_dir.rglob("*"):
+            if src.is_dir():
+                continue
+
+            rel = src.relative_to(self.template_dir)
+            dest = self.target_dir / rel
+
+            # Skip optional files based on flags
+            if self._should_skip(rel):
+                continue
+
+            dest.parent.mkdir(parents=True, exist_ok=True)
+
+            if src.suffix in {".py", ".toml", ".env", ".yml", ".yaml", ".md", ".txt", ".cfg", ".ini", ".dockerfile", ""} or src.name == ".env.example":
+                try:
+                    template = self.env.get_template(str(rel).replace("\\", "/"))
+                    dest.write_text(template.render(**ctx), encoding="utf-8")
+                except Exception:
+                    # Binary or unparseable — just copy
+                    shutil.copy2(src, dest)
+            else:
+                shutil.copy2(src, dest)
+
+    def _uv_init(self) -> None:
+        """Run `uv init` inside the target directory (no-op if uv not found)."""
+        if not shutil.which("uv"):
+            console.print(
+                "[yellow]⚠[/]  [bold]uv[/] not found — skipping venv initialisation. "
+                "Install uv: [link=https://docs.astral.sh/uv/]https://docs.astral.sh/uv/[/link]"
+            )
+            return
+
+        # uv init creates a pyproject.toml — we already created ours, so just create the venv
+        self._run(["uv", "venv"], cwd=self.target_dir)
+
+    def _install_deps(self) -> None:
+        """Write dependencies into pyproject.toml and sync the venv.
+
+        Uses --no-sync on `uv add` so uv only updates pyproject.toml + uv.lock
+        without trying to build/install the generated project itself as an
+        editable package.
+
+        The actual installation is done by a follow-up
+        `uv sync --no-install-project`.
+        """
+        if not shutil.which("uv"):
+            return
+
+        deps = self.TEMPLATE_DEPS.get(self.template)
+        dev_deps = self.TEMPLATE_DEV_DEPS.get(self.template)
+        if deps is None or dev_deps is None:
+            console.print(f"[red]Unknown template:[/] {self.template}")
+            sys.exit(1)
+
+        for flag, pkgs in self.OPTIONAL_DEPS.items():
+            if self.options.get(flag):
+                deps = deps + pkgs
+
+        # --no-sync: only pin versions into pyproject.toml / uv.lock, don't build project
+        self._run(["uv", "add", "--no-sync"] + deps, cwd=self.target_dir)
+        self._run(["uv", "add", "--no-sync", "--dev"] + dev_deps, cwd=self.target_dir)
+
+        # Install all pinned deps into .venv, skipping the project root package
+        self._run(["uv", "sync", "--no-install-project"], cwd=self.target_dir)
+
+    # ------------------------------------------------------------------ #
+    #  Helpers
+    # ------------------------------------------------------------------ #
+
+    def _build_context(self) -> dict[str, Any]:
+        pkg = self.project_name.lower().replace("-", "_").replace(" ", "_")
+        return {
+            "project_name": self.project_name,
+            "package_name": pkg,
+            "template": self.template,
+            "docker": self.options.get("docker", False),
+            "postgres": self.options.get("postgres", False),
+            "redis": self.options.get("redis", False),
+            "fastapi_deps": self.FASTAPI_DEPS,
+            "ai_deps": self.AI_DEPS,
+        }
+
+    def _should_skip(self, rel: Path) -> bool:
+        name = rel.name
+        parts = set(rel.parts)
+        if name in {"Dockerfile", "docker-compose.yml"} and not self.options.get("docker"):
+            return True
+        if "postgres" in parts and not self.options.get("postgres"):
+            return True
+        if "redis" in parts and not self.options.get("redis"):
+            return True
+        return False
+
+    def _run(self, cmd: list[str], cwd: Path) -> None:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            console.print(f"[red]Command failed:[/] {' '.join(cmd)}")
+            console.print(result.stderr)
+            sys.exit(result.returncode)
+
+    def _print_success(self) -> None:
+        table = Table.grid(padding=(0, 2))
+        table.add_column(style="bold green")
+        table.add_column()
+
+        rel = self.target_dir.resolve()
+        run_cmd = (
+            "uvicorn app.main:app --reload"
+            if self.template in {"fastapi", "fastapi-with-frontend"}
+            else "python main.py"
+        )
+
+        table.add_row("Project:", str(rel))
+        table.add_row("Template:", self.template)
+        table.add_row("venv:", str(rel / ".venv"))
+        table.add_row("", "")
+        table.add_row("Next steps:", f"cd {self.project_name}")
+        table.add_row("", "cp .env.example .env  # fill in your secrets")
+        table.add_row("", f"uv run {run_cmd}")
+
+        console.print(
+            Panel(table, title="[bold green]✓  Project created[/]", border_style="green")
+        )
+        console.print()

app_generator/main.py

@@ -0,0 +1,32 @@
+"""
+AppGenerator CLI — A scaffolding tool for FastAPI and LangChain/LangGraph projects.
+"""
+import typer
+from rich.console import Console
+
+from app_generator.commands.create import create_app
+
+app = typer.Typer(
+    name="app-generator-cli",
+    help="⚒️  AppGenerator — Scaffold production-ready Python projects instantly.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+
+app.add_typer(create_app, name="create", help="Create a new project from a template.")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
+) -> None:
+    if version:
+        from app_generator import __version__
+        console.print(f"[bold cyan]AppGenerator[/] version [bold]{__version__}[/]")
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

app_generator/templates/ai/.env.example

@@ -0,0 +1,29 @@
+# ── LLM Providers ────────────────────────────────────────────
+OPENAI_API_KEY=sk-...
+OPENAI_MODEL=gpt-4o-mini
+
+# Ollama (local models) — optional
+OLLAMA_BASE_URL=http://localhost:11434
+OLLAMA_MODEL=llama3.2
+
+# ── Application ──────────────────────────────────────────────
+APP_NAME="{{ project_name }}"
+APP_ENV=development
+DEBUG=true
+
+# ── Vector Store ──────────────────────────────────────────────
+CHROMA_PERSIST_DIR=./chroma_db
+{% if postgres %}
+# pgvector (PostgreSQL) — enable with --postgres
+PGVECTOR_URL=postgresql://postgres:postgres@localhost:5432/{{ package_name }}_vectors
+{% endif %}
+
+{% if redis %}
+# ── Redis Cache ───────────────────────────────────────────────
+REDIS_URL=redis://localhost:6379/0
+{% endif %}
+
+# ── LangSmith (optional tracing) ─────────────────────────────
+# LANGCHAIN_TRACING_V2=true
+# LANGCHAIN_API_KEY=ls__...
+# LANGCHAIN_PROJECT={{ project_name }}

app_generator/templates/ai/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# uv
+.uv/
+
+# Environment
+.env
+!.env.example
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking
+.mypy_cache/
+
+# Vector DB / embeddings
+chroma_db/
+*.faiss
+*.pkl
+
+# LangSmith / LangChain cache
+.langchain.db
+langchain_cache/
+
+# Logs
+*.log
+logs/

app_generator/templates/ai/Dockerfile

@@ -0,0 +1,22 @@
+# ── Build stage ────────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+COPY pyproject.toml uv.lock* ./
+RUN uv sync --frozen --no-dev
+
+# ── Runtime stage ──────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS runtime
+
+WORKDIR /app
+
+COPY --from=builder /app/.venv /app/.venv
+ENV PATH="/app/.venv/bin:$PATH"
+
+COPY app ./app
+COPY main.py ./main.py
+
+CMD ["python", "main.py"]

app_generator/templates/ai/README.md

@@ -0,0 +1,97 @@
+# {{ project_name }}
+
+A production-ready LangChain / LangGraph AI application, scaffolded by [AppGenerator](https://github.com/yourname/appgenerator-cli).
+
+## Tech Stack
+
+- **[LangChain](https://python.langchain.com/)** — LLM orchestration framework
+- **[LangGraph](https://langchain-ai.github.io/langgraph/)** — stateful agent graphs
+- **[LangChain-OpenAI](https://python.langchain.com/docs/integrations/chat/openai)** — OpenAI chat models
+- **[LangChain-Ollama](https://python.langchain.com/docs/integrations/chat/ollama)** — local Ollama models
+- **[ChromaDB](https://docs.trychroma.com/)** — local vector store for RAG
+- **[Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)** — typed config from env
+- **[uv](https://docs.astral.sh/uv/)** — blazing-fast package management
+{% if postgres %}- **pgvector** — PostgreSQL vector extension
+{% endif %}{% if redis %}- **Redis** — semantic caching layer
+{% endif %}{% if docker %}- **Docker** — containerisation
+{% endif %}
+
+## Project Structure
+
+```
+{{ project_name }}/
+├── main.py                  # Interactive REPL entry point
+├── app/
+│   ├── config.py            # Typed settings (pydantic-settings)
+│   ├── agents/
+│   │   ├── __init__.py
+│   │   └── assistant.py     # LangGraph ReAct agent
+│   ├── chains/
+│   │   ├── __init__.py
+│   │   └── rag.py           # RAG chain example
+│   ├── tools/
+│   │   ├── __init__.py
+│   │   ├── registry.py      # Tool registry (add tools here)
+│   │   └── search.py        # Web search tool stub
+├── tests/
+│   ├── conftest.py
+│   ├── test_agent.py
+│   └── __init__.py
+├── .env.example
+├── .gitignore
+└── pyproject.toml
+```
+
+## Getting Started
+
+```bash
+# 1. Copy and configure your secrets
+cp .env.example .env
+# Edit .env — add your OPENAI_API_KEY
+
+# 2. Run the interactive assistant
+uv run python main.py
+```
+
+## Using Ollama (Local Models)
+
+```bash
+# Install Ollama: https://ollama.com
+ollama pull llama3.2
+
+# Update .env
+OLLAMA_MODEL=llama3.2
+```
+
+Then swap the LLM in `app/agents/assistant.py`:
+
+```python
+from langchain_ollama import ChatOllama
+self._llm = ChatOllama(model=settings.ollama_model, base_url=settings.ollama_base_url)
+```
+
+## Adding Tools
+
+Edit `app/tools/registry.py` and add your tools to `get_tools()`:
+
+```python
+from app.tools.my_tool import my_custom_tool
+
+def get_tools():
+    return [web_search_tool, my_custom_tool]
+```
+
+## Running Tests
+
+```bash
+uv run pytest
+```
+
+## LangSmith Tracing (optional)
+
+```bash
+# .env
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_API_KEY=ls__your_key
+LANGCHAIN_PROJECT={{ project_name }}
+```

app_generator/templates/ai/app/__init__.py

@@ -0,0 +1 @@
+"""{{ project_name }} AI application package."""

app_generator/templates/ai/app/agents/__init__.py

@@ -0,0 +1 @@
+"""Agent definitions."""

app_generator/templates/ai/app/agents/assistant.py

@@ -0,0 +1,100 @@
+"""
+AssistantAgent — a simple LangGraph ReAct agent wired to the configured LLM.
+
+Extend this class to add memory, tools, and custom graph nodes.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, START, MessagesState, StateGraph
+
+from app.config import settings
+from app.tools.registry import get_tools
+
+
+class AssistantAgent:
+    """A LangGraph-powered conversational agent."""
+
+    SYSTEM_PROMPT = (
+        "You are a helpful, concise, and accurate assistant. "
+        "Use the available tools when appropriate. "
+        "If you don't know something, say so honestly."
+    )
+
+    def __init__(self) -> None:
+        self._llm = ChatOpenAI(
+            model=settings.openai_model,
+            api_key=settings.openai_api_key,
+            temperature=0.2,
+        )
+        self._tools = get_tools()
+        self._llm_with_tools = self._llm.bind_tools(self._tools)
+        self._graph = self._build_graph()
+
+    # ------------------------------------------------------------------ #
+    #  Public
+    # ------------------------------------------------------------------ #
+
+    async def invoke(self, user_message: str, history: list[dict[str, str]] | None = None) -> str:
+        """Run the agent and return the assistant's reply."""
+        messages = [SystemMessage(content=self.SYSTEM_PROMPT)]
+
+        for msg in (history or []):
+            if msg["role"] == "user":
+                messages.append(HumanMessage(content=msg["content"]))
+            # assistant messages are added by LangGraph internally
+
+        messages.append(HumanMessage(content=user_message))
+
+        result = await self._graph.ainvoke({"messages": messages})
+        return result["messages"][-1].content  # type: ignore[index]
+
+    # ------------------------------------------------------------------ #
+    #  Graph construction
+    # ------------------------------------------------------------------ #
+
+    def _build_graph(self) -> Any:
+        """Build a minimal ReAct graph: call model → maybe call tools → end."""
+        builder = StateGraph(MessagesState)
+
+        builder.add_node("agent", self._call_model)
+        builder.add_node("tools", self._call_tools)
+
+        builder.add_edge(START, "agent")
+        builder.add_conditional_edges("agent", self._should_use_tools)
+        builder.add_edge("tools", "agent")
+
+        return builder.compile()
+
+    async def _call_model(self, state: MessagesState) -> dict[str, Any]:
+        response = await self._llm_with_tools.ainvoke(state["messages"])
+        return {"messages": [response]}
+
+    async def _call_tools(self, state: MessagesState) -> dict[str, Any]:
+        from langchain_core.messages import ToolMessage
+
+        last_message = state["messages"][-1]
+        tool_map = {t.name: t for t in self._tools}
+        results = []
+
+        for tool_call in last_message.tool_calls:  # type: ignore[attr-defined]
+            tool = tool_map.get(tool_call["name"])
+            if tool is None:
+                output = f"Error: unknown tool '{tool_call['name']}'"
+            else:
+                output = await tool.ainvoke(tool_call["args"])
+            results.append(
+                ToolMessage(content=str(output), tool_call_id=tool_call["id"])
+            )
+
+        return {"messages": results}
+
+    @staticmethod
+    def _should_use_tools(state: MessagesState) -> str:
+        last = state["messages"][-1]
+        if hasattr(last, "tool_calls") and last.tool_calls:  # type: ignore[attr-defined]
+            return "tools"
+        return END