rapidkit 0.11.2 → 0.12.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapidkit",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "type": "module",
   "description": "Create RapidKit projects with a single command - The official CLI for RapidKit framework",
   "keywords": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapidkit",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "type": "module",
   "description": "Create RapidKit projects with a single command - The official CLI for RapidKit framework",
   "keywords": [

package/templates/generator.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * RapidKit Project Generator
+ * This script is called by the rapidkit CLI to generate projects
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { execSync } = require('child_process');
+
+const TEMPLATES_DIR = path.join(__dirname, 'templates');
+
+async function generateProject(projectPath, template, useDefaults, skipGit, skipInstall) {
+  const projectName = path.basename(projectPath);
+  const templateDir = template === 'nestjs' ? 'nestjs-standard' : 'fastapi-standard';
+  const templatePath = path.join(TEMPLATES_DIR, templateDir);
+
+  // Check template exists
+  try {
+    await fs.access(templatePath);
+  } catch {
+    console.error('❌ Template not found:', templateDir);
+    process.exit(1);
+  }
+
+  // Create project directory
+  await fs.mkdir(projectPath, { recursive: true });
+
+  // Build context
+  const context = {
+    project_name: template === 'nestjs' 
+      ? projectName.replace(/_/g, '-').toLowerCase() 
+      : projectName.replace(/-/g, '_').toLowerCase(),
+    author: process.env.USER || 'RapidKit User',
+    description: template === 'nestjs' 
+      ? 'NestJS application generated with RapidKit' 
+      : 'FastAPI service generated with RapidKit',
+    app_version: '0.1.0',
+    license: 'MIT',
+    package_manager: 'npm',
+    created_at: new Date().toISOString(),
+    rapidkit_version: require('./config.json').rapidkit_version || '0.12.0',
+  };
+
+  // Copy and render template files
+  await copyTemplateDir(templatePath, projectPath, context);
+
+  console.log('✅ Project files created!');
+
+  // Git initialization
+  if (!skipGit) {
+    try {
+      execSync('git init', { cwd: projectPath, stdio: 'pipe' });
+      execSync('git add .', { cwd: projectPath, stdio: 'pipe' });
+      const commitMsg = 'Initial commit: ' + (template === 'nestjs' ? 'NestJS' : 'FastAPI') + ' project via RapidKit';
+      execSync(`git commit -m "${commitMsg}"`, { cwd: projectPath, stdio: 'pipe' });
+      console.log('✅ Git repository initialized');
+    } catch (e) {
+      console.log('⚠️  Could not initialize git');
+    }
+  }
+
+  // Install dependencies
+  if (!skipInstall) {
+    if (template === 'nestjs') {
+      console.log('📦 Installing dependencies...');
+      try {
+        execSync('npm install', { cwd: projectPath, stdio: 'inherit' });
+        console.log('✅ Dependencies installed');
+      } catch {
+        console.log('⚠️  Could not install dependencies. Run npm install manually.');
+      }
+    }
+  }
+
+  // Success message
+  const templateName = template === 'nestjs' ? 'NestJS' : 'FastAPI';
+  console.log('');
+  console.log('✨ ' + templateName + ' project created successfully!');
+  console.log('');
+  console.log('🚀 Get started:');
+  console.log('  cd ' + projectName);
+  if (template === 'fastapi') {
+    console.log('  rapidkit init    # poetry install');
+    console.log('  rapidkit dev     # Start dev server');
+  } else {
+    if (skipInstall) {
+      console.log('  rapidkit init    # npm install');
+    }
+    console.log('  cp .env.example .env');
+    console.log('  rapidkit dev     # Start dev server');
+  }
+  console.log('');
+}
+
+function renderTemplate(content, context) {
+  let result = content;
+  
+  for (const [key, value] of Object.entries(context)) {
+    // Simple variable replacement: {{ key }}
+    const simpleRegex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g');
+    result = result.replace(simpleRegex, String(value));
+    
+    // With replace filter: {{ key | replace('a', 'b') }}
+    const replaceRegex = new RegExp(
+      `\\{\\{\\s*${key}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\}\\}`,
+      'g'
+    );
+    result = result.replace(replaceRegex, (match, from, to) => {
+      return String(value).replace(new RegExp(from, 'g'), to);
+    });
+    
+    // With lower filter: {{ key | lower }}
+    const lowerRegex = new RegExp(`\\{\\{\\s*${key}\\s*\\|\\s*lower\\s*\\}\\}`, 'g');
+    result = result.replace(lowerRegex, String(value).toLowerCase());
+    
+    // Combined: {{ key | replace('a', 'b') | lower }}
+    const combinedRegex = new RegExp(
+      `\\{\\{\\s*${key}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\|\\s*lower\\s*\\}\\}`,
+      'g'
+    );
+    result = result.replace(combinedRegex, (match, from, to) => {
+      return String(value).replace(new RegExp(from, 'g'), to).toLowerCase();
+    });
+  }
+  
+  return result;
+}
+
+async function copyTemplateDir(src, dest, context) {
+  const entries = await fs.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destName = entry.name.replace(/\.j2$/, '');
+    const destPath = path.join(dest, destName);
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(destPath, { recursive: true });
+      await copyTemplateDir(srcPath, destPath, context);
+    } else {
+      let content = await fs.readFile(srcPath, 'utf-8');
+
+      // Render template if it's a .j2 file
+      if (entry.name.endsWith('.j2')) {
+        content = renderTemplate(content, context);
+      }
+
+      await fs.writeFile(destPath, content);
+
+      // Make scripts executable
+      if (destName === 'rapidkit' || (destName.endsWith('.py') && destPath.includes('.rapidkit'))) {
+        await fs.chmod(destPath, 0o755);
+      }
+    }
+  }
+}
+
+// Main
+const args = process.argv.slice(2);
+const projectPath = args[0];
+const template = args[1] || 'fastapi';
+const useDefaults = args.includes('--yes');
+const skipGit = args.includes('--skip-git');
+const skipInstall = args.includes('--skip-install');
+
+if (!projectPath) {
+  console.error('Usage: node generator.js <project-path> <template> [--yes] [--skip-git] [--skip-install]');
+  process.exit(1);
+}
+
+generateProject(projectPath, template, useDefaults, skipGit, skipInstall).catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});

package/templates/kits/fastapi-standard/.rapidkit/__init__.py.j2

@@ -0,0 +1 @@
+# RapidKit local CLI module

package/templates/kits/fastapi-standard/.rapidkit/activate.j2

@@ -0,0 +1,24 @@
+#!/bin/bash
+# RapidKit Environment Activation
+# Usage: source .rapidkit/activate
+
+# Get the directory where this script is located
+RAPIDKIT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$RAPIDKIT_DIR")"
+
+# Add project root to PATH (where rapidkit script lives)
+if [[ ":$PATH:" != *":$PROJECT_ROOT:"* ]]; then
+    export PATH="$PROJECT_ROOT:$PATH"
+    echo "✅ RapidKit activated! You can now use 'rapidkit' commands directly."
+else
+    echo "ℹ️  RapidKit already activated."
+fi
+
+# Show available commands
+echo ""
+echo "📚 Available commands:"
+echo "   rapidkit dev      - Start development server"
+echo "   rapidkit init     - Install dependencies"
+echo "   rapidkit test     - Run tests"
+echo "   rapidkit --help   - Show all commands"
+echo ""

package/templates/kits/fastapi-standard/.rapidkit/cli.py.j2

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""RapidKit CLI wrapper (npm demo template)
+
+This file provides local project commands for demo projects generated
+via npx rapidkit --demo. It mimics the behavior of the full RapidKit
+engine for dev, start, test, lint, and format commands.
+"""
+
+import subprocess
+import shutil
+import sys
+from pathlib import Path
+import socket
+from typing import Any
+
+
+def _print_banner(emoji: str, message: str) -> None:
+    print(f"{emoji} {message}")
+
+
+def _run(*cmd: Any, cwd: Path | str | None = None, env: dict | None = None) -> int:
+    try:
+        run_env = None
+        if env is not None:
+            import os as _os
+            run_env = _os.environ.copy()
+            run_env.update(env)
+
+        proc = subprocess.run([str(c) for c in cmd], cwd=str(cwd) if cwd else None, env=run_env)
+        return proc.returncode
+    except KeyboardInterrupt:
+        print("\n🛑 Command interrupted by user")
+        return 130
+    except Exception as exc:
+        print(f"❌ Error running command: {exc}")
+        return 1
+
+
+def _project_type(root: Path) -> str:
+    if (root / "pyproject.toml").exists():
+        return "python"
+    if (root / "package.json").exists():
+        return "node"
+    return "unknown"
+
+
+def _python_module(module: str, *module_args: str) -> int:
+    return _run(sys.executable, "-m", module, *module_args)
+
+
+def _python_code_targets(root: Path) -> list[str]:
+    targets: list[str] = []
+    for name in ("src", "tests"):
+        if (root / name).exists():
+            targets.append(name)
+    return targets or ["src"]
+
+
+def _venv_has_uvicorn(venv_path: Path) -> bool:
+    if (venv_path / "bin" / "uvicorn").exists():
+        return True
+    for p in venv_path.rglob("site-packages/*"):
+        name = p.name.lower()
+        if "uvicorn" in name or "fastapi" in name:
+            return True
+    return False
+
+
+def dev(port: int = 8000, host: str = "0.0.0.0", allow_global_runtime: bool = False) -> None:
+    """Start development server with reload"""
+    _print_banner("🚀", "Starting development server with hot reload...")
+    root = Path.cwd()
+    ptype = _project_type(root)
+
+    if ptype == "python":
+        venv_dir = root / ".venv"
+        _print_banner("📁", f"Working directory: {root}")
+        _print_banner("🌐", f"Server will be available at: http://{host}:{port}")
+
+        if venv_dir.exists():
+            if not _venv_has_uvicorn(venv_dir):
+                print("❌ Project .venv was found but uvicorn/fastapi doesn't appear installed.")
+                print("💡 Run 'rapidkit init' to install dependencies.")
+                sys.exit(1)
+        else:
+            if not allow_global_runtime:
+                print("❌ Project environment not bootstrapped (no .venv found).")
+                print("")
+                print("💡 Initialize and install dependencies with:")
+                print("")
+                print("  rapidkit init")
+                print("")
+                print("If you intentionally want to use the system Python, run:")
+                print("")
+                print("  rapidkit dev --allow-global-runtime")
+                print("")
+                sys.exit(1)
+
+            if shutil.which("uvicorn") is None:
+                print("❌ No uvicorn executable found on PATH and no .venv present.")
+                print("")
+                print("💡 Install dependencies with: rapidkit init")
+                print("")
+                sys.exit(1)
+            print("⚠️  Running with system/global Python runtime.")
+
+        rc = _run(sys.executable, "-m", "uvicorn", "src.main:app", "--reload", "--reload-dir", "src", "--host", host, "--port", str(port))
+        if rc != 0:
+            sys.exit(rc)
+    else:
+        print("❌ Unknown project type. Ensure pyproject.toml exists.")
+        sys.exit(1)
+
+
+def init() -> None:
+    """Bootstrap project: install dependencies"""
+    _print_banner("🚀", "Bootstrapping project (installing dependencies)")
+    root = Path.cwd()
+    ptype = _project_type(root)
+    
+    if ptype == "python":
+        if shutil.which("poetry"):
+            rc = _run("poetry", "install")
+            if rc != 0:
+                print("❌ Failed to install dependencies via poetry.")
+                sys.exit(rc)
+            print("✅ Dependencies installed successfully!")
+        else:
+            print("❌ Poetry not found. Install it with: pip install poetry")
+            sys.exit(1)
+    else:
+        print("❌ Unknown project type. Ensure pyproject.toml exists.")
+        sys.exit(1)
+
+
+def start(port: int = 8000, host: str = "0.0.0.0", allow_global_runtime: bool = False) -> None:
+    """Start production server"""
+    _print_banner("⚡", "Starting production server...")
+    root = Path.cwd()
+    ptype = _project_type(root)
+    
+    if ptype == "python":
+        venv_dir = root / ".venv"
+        if venv_dir.exists():
+            if not _venv_has_uvicorn(venv_dir):
+                print("❌ Project .venv was found but uvicorn/fastapi doesn't appear installed.")
+                print("💡 Run 'poetry install' to install dependencies.")
+                sys.exit(1)
+        else:
+            if not allow_global_runtime:
+                print("❌ Project environment not bootstrapped (no .venv found).")
+                print("💡 Run 'poetry install' to install dependencies.")
+                sys.exit(1)
+
+        rc = _run(sys.executable, "-m", "uvicorn", "src.main:app", "--host", host, "--port", str(port))
+        if rc != 0:
+            sys.exit(rc)
+    else:
+        print("❌ Unknown project type.")
+        sys.exit(1)
+
+
+def build() -> None:
+    """Build project"""
+    _print_banner("📦", "Building project")
+    rc = _python_module("build")
+    if rc != 0:
+        sys.exit(rc)
+
+
+def test() -> None:
+    """Run tests"""
+    _print_banner("🧪", "Running tests")
+    rc = _python_module("pytest", "-q")
+    if rc != 0:
+        sys.exit(rc)
+
+
+def lint() -> None:
+    """Run linting"""
+    _print_banner("🔧", "Running lint")
+    root = Path.cwd()
+    targets = _python_code_targets(root)
+    rc = _python_module("ruff", "check", *targets)
+    if rc == 0:
+        rc = _python_module("black", "--check", *targets)
+    if rc != 0:
+        sys.exit(rc)
+
+
+def format_code() -> None:
+    """Format code"""
+    _print_banner("✨", "Formatting")
+    root = Path.cwd()
+    targets = _python_code_targets(root)
+    rc = _python_module("ruff", "check", *targets, "--fix")
+    if rc == 0:
+        rc = _python_module("black", *targets)
+    if rc != 0:
+        sys.exit(rc)
+
+
+def help_cmd() -> None:
+    """Show help"""
+    _print_banner("📚", "Project Commands")
+    print("Usage: rapidkit <command> [args...]\n")
+    print("  init     📦 Initialize project (install deps)")
+    print("  dev      🚀 Start development server")
+    print("  start    ⚡ Start production server")
+    print("  build    📦 Build for production")
+    print("  test     🧪 Run tests")
+    print("  lint     🔧 Lint code")
+    print("  format   ✨ Format code")
+    print("  help     📚 Show help")
+    print("")
+    print("💡 Note: This is a demo project. For full RapidKit features:")
+    print("   pipx install rapidkit")
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        help_cmd()
+        return
+
+    command = sys.argv[1]
+    args = sys.argv[2:]
+
+    commands = {
+        "init": init,
+        "dev": dev,
+        "start": start,
+        "build": build,
+        "test": test,
+        "lint": lint,
+        "format": format_code,
+        "help": help_cmd,
+    }
+
+    if command not in commands:
+        print(f"❌ Unknown command: {command}")
+        help_cmd()
+        sys.exit(1)
+
+    if command in ("dev", "start"):
+        import argparse as _arg
+        _parser = _arg.ArgumentParser(prog=f"rapidkit {command}")
+        _parser.add_argument("-p", "--port", dest="port", type=int, default=8000)
+        _parser.add_argument("--host", dest="host", default="0.0.0.0")
+        _parser.add_argument("--allow-global-runtime", action="store_true", dest="allow_global_runtime")
+        _ns, _extra = _parser.parse_known_args(args)
+        commands[command](port=_ns.port, host=_ns.host, allow_global_runtime=_ns.allow_global_runtime)
+    else:
+        commands[command]()
+
+
+if __name__ == "__main__":
+    main()

package/templates/kits/fastapi-standard/.rapidkit/project.json.j2

@@ -0,0 +1,7 @@
+{
+  "kit_name": "fastapi.standard",
+  "profile": "fastapi/standard",
+  "project_name": "{{ project_name }}",
+  "created_at": "{{ created_at }}",
+  "rapidkit_version": "npm-{{ rapidkit_version }}"
+}

package/templates/kits/fastapi-standard/.rapidkit/rapidkit.j2

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# Local RapidKit project launcher (npm demo template)
+# This script provides local project commands for demo projects.
+
+set -euo pipefail
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+
+show_help() {
+  cat << 'EOF'
+📚 RapidKit FastAPI Project Commands
+
+Usage: rapidkit <command> [options]
+
+Commands:
+  init         📦 Initialize project (poetry install)
+  dev          🚀 Start development server with hot reload
+  start        ⚡ Start production server
+  test         🧪 Run tests
+  lint         🔧 Lint code
+  format       ✨ Format code
+  help         📚 Show this help
+
+Examples:
+  rapidkit init      # Install dependencies
+  rapidkit dev       # Start dev server
+
+💡 Note: Commands are run through Poetry.
+EOF
+}
+
+# Handle help
+case "${1:-}" in
+  help|--help|-h|"")
+    show_help
+    exit 0
+    ;;
+esac
+
+# Detect project type
+if [ -f "$ROOT_DIR/pyproject.toml" ]; then
+  PKG_TYPE="python"
+elif [ -f "$ROOT_DIR/package.json" ]; then
+  PKG_TYPE="node"
+else
+  PKG_TYPE="unknown"
+fi
+
+VENV_PY="${ROOT_DIR}/.venv/bin/python"
+VENV_POETRY="${ROOT_DIR}/.venv/bin/poetry"
+
+case "$PKG_TYPE" in
+  python)
+    # prefer project-local poetry
+    if [ -x "$VENV_POETRY" ]; then
+      if [ "${1:-}" = "init" ]; then
+        exec "$VENV_POETRY" "install"
+      else
+        exec "$VENV_POETRY" "run" "$@"
+      fi
+    fi
+
+    # then prefer poetry on PATH
+    if command -v poetry >/dev/null 2>&1; then
+      if [ "${1:-}" = "init" ]; then
+        exec poetry "install"
+      else
+        exec poetry "run" "$@"
+      fi
+    fi
+
+    # If venv python exists, try installing poetry into it
+    if [ -x "$VENV_PY" ]; then
+      echo "⚠️  Poetry not found. Installing poetry into project .venv..."
+      "$VENV_PY" -m pip install --upgrade pip >/dev/null 2>&1 || true
+      "$VENV_PY" -m pip install poetry >/dev/null 2>&1 || true
+      if [ -x "$VENV_POETRY" ]; then
+        if [ "${1:-}" = "init" ]; then
+          exec "$VENV_POETRY" "install"
+        else
+          exec "$VENV_POETRY" "run" "$@"
+        fi
+      else
+        echo "❌ Failed to locate poetry after installation."
+        exit 1
+      fi
+    fi
+
+    echo "❌ Poetry is not available and no project .venv exists."
+    echo "💡 Run: 'poetry install' to bootstrap the project, or install poetry: 'pip install poetry'"
+    exit 127
+    ;;
+
+  *)
+    echo "❌ Could not detect project type (pyproject.toml missing)."
+    echo "💡 This appears to be a demo project. Run 'poetry install' to set up."
+    exit 127
+    ;;
+esac

package/templates/kits/fastapi-standard/Makefile.j2

@@ -0,0 +1,41 @@
+# RapidKit Project Commands
+# Usage: make <command>
+
+.PHONY: init dev start build test lint format help
+
+# Default target
+help:
+	@echo "🚀 RapidKit Commands"
+	@echo ""
+	@echo "Usage: make <command>"
+	@echo ""
+	@echo "Commands:"
+	@echo "  init      📦 Install dependencies (poetry install)"
+	@echo "  dev       🔥 Start development server"
+	@echo "  start     ⚡ Start production server"
+	@echo "  build     📦 Build for production"
+	@echo "  test      🧪 Run tests"
+	@echo "  lint      🔧 Run linting"
+	@echo "  format    ✨ Format code"
+	@echo ""
+
+init:
+	@poetry install
+
+dev:
+	@poetry run dev
+
+start:
+	@poetry run start
+
+build:
+	@poetry run build
+
+test:
+	@poetry run test
+
+lint:
+	@poetry run lint
+
+format:
+	@poetry run format

package/templates/kits/fastapi-standard/README.md.j2

@@ -12,11 +12,11 @@ rapidkit dev
 ## Available commands
 
 ```bash
-rapidkit init       # 🔧 Bootstrap the project (create local launcher & install deps)
+rapidkit init       # 🔧 Install dependencies
 rapidkit dev        # 🚀 Start development server with hot reload
-poetry run start    # ⚡ Advanced: start production server via poetry
-poetry run build    # 📦 Advanced: build via poetry
-poetry run test     # 🧪 Run tests
+rapidkit start      # ⚡ Start production server
+rapidkit test       # 🧪 Run tests
+rapidkit help       # 📚 Show available commands
 ```
 
 ## Project layout

package/templates/kits/fastapi-standard/pyproject.toml.j2

@@ -7,6 +7,7 @@ license = "{{ license }}"
 packages = [{ include = "src" }]
 
 [tool.poetry.scripts]
+rapidkit = ".rapidkit.cli:main"
 dev = "src.cli:dev"
 start = "src.cli:start"
 build = "src.cli:build"