rapidkit 0.11.3 → 0.12.0

package/dist/index.js

@@ -1,631 +1,443 @@
 #!/usr/bin/env node
-import {Command}from'commander';import i from'chalk';import {readFileSync,promises}from'fs';import*as y from'fs-extra';import h,{dirname,join}from'path';import oe from'inquirer';import z from'ora';import {execa}from'execa';import ee from'os';import le from'nunjucks';import {fileURLToPath}from'url';import Pe from'validate-npm-package-name';var G=class{debugEnabled=false;setDebug(e){this.debugEnabled=e;}debug(e,...o){this.debugEnabled&&console.log(i.gray(`[DEBUG] ${e}`),...o);}info(e,...o){console.log(i.blue(e),...o);}success(e,...o){console.log(i.green(e),...o);}warn(e,...o){console.log(i.yellow(e),...o);}error(e,...o){console.error(i.red(e),...o);}step(e,o,r){console.log(i.cyan(`
-[${e}/${o}]`),i.white(r));}},s=new G;var te=".rapidkitrc.json";async function W(){let t=h.join(ee.homedir(),te);try{let e=await promises.readFile(t,"utf-8"),o=JSON.parse(e);return s.debug(`Loaded config from ${t}`),o}catch{return s.debug("No user config found, using defaults"),{}}}function F(t){return process.env.RAPIDKIT_DEV_PATH||t.testRapidKitPath||void 0}var u=class extends Error{constructor(o,r,a){super(o);this.code=r;this.details=a;this.name="RapidKitError",Error.captureStackTrace(this,this.constructor);}},P=class extends u{constructor(e,o){let r=o?`Python ${e}+ required, found ${o}`:`Python ${e}+ not found`;super(r,"PYTHON_NOT_FOUND","Please install Python from https://www.python.org/downloads/");}},T=class extends u{constructor(){super("Poetry is not installed","POETRY_NOT_FOUND","Install Poetry from https://python-poetry.org/docs/#installation");}},N=class extends u{constructor(){super("pipx is not installed","PIPX_NOT_FOUND","Install pipx from https://pypa.github.io/pipx/installation/");}},M=class extends u{constructor(e){super(`Directory "${e}" already exists`,"DIRECTORY_EXISTS","Please choose a different name or remove the existing directory");}},k=class extends u{constructor(e,o){super(`Invalid project name: "${e}"`,"INVALID_PROJECT_NAME",o);}},j=class extends u{constructor(e,o){let r=`Installation failed at: ${e}`,a=`${o.message}
-
-Troubleshooting:
-- Check your internet connection
-- Verify Python/Poetry installation
-- Try running with --debug flag for more details`;super(r,"INSTALLATION_ERROR",a);}},I=class extends u{constructor(){super("RapidKit Python package is not yet available on PyPI","RAPIDKIT_NOT_AVAILABLE",`Available options:
-  1. Demo mode: npx rapidkit my-workspace --demo
-  2. Test mode: npx rapidkit my-workspace --test-mode (requires local RapidKit)
-  3. Wait for official PyPI release (coming soon)`);}};async function U(t,e){let{skipGit:o=false,testMode:r=false,demoMode:a=false,dryRun:m=false,userConfig:d={}}=e,n=t,c=h.resolve(process.cwd(),n);if(await y.pathExists(c))throw new M(n);if(m){await ce(c,n,a,d);return}if(a){await se(c,n,o);return}let f=await oe.prompt([{type:"list",name:"pythonVersion",message:"Select Python version for RapidKit:",choices:["3.10","3.11","3.12"],default:d.pythonVersion||"3.11"},{type:"list",name:"installMethod",message:"How would you like to install RapidKit?",choices:[{name:"\u{1F3AF} Poetry (Recommended - includes virtual env)",value:"poetry"},{name:"\u{1F4E6} pip with venv (Standard)",value:"venv"},{name:"\u{1F527} pipx (Global isolated install)",value:"pipx"}],default:d.defaultInstallMethod||"poetry"}]);s.step(1,3,"Setting up RapidKit environment");let g=z("Creating directory").start();try{if(await y.ensureDir(c),g.succeed("Directory created"),f.installMethod==="poetry"?await ie(c,f.pythonVersion,g,r,d):f.installMethod==="venv"?await re(c,f.pythonVersion,g,r,d):await ae(c,g,r,d),await ne(c,f.installMethod),g.succeed("RapidKit environment ready!"),!e.skipGit){g.start("Initializing git repository");try{await execa("git",["init"],{cwd:c}),await y.outputFile(h.join(c,".gitignore"),`.venv/
-__pycache__/
-*.pyc
+import {Command}from'commander';import a from'chalk';import P from'inquirer';import l,{dirname,join}from'path';import {execa}from'execa';import {readFileSync,promises}from'fs';import {fileURLToPath}from'url';import te from'os';import ae from'validate-npm-package-name';import*as k from'fs-extra';import N from'ora';var x=class{debugEnabled=false;setDebug(t){this.debugEnabled=t;}debug(t,...i){this.debugEnabled&&console.log(a.gray(`[DEBUG] ${t}`),...i);}info(t,...i){console.log(a.blue(t),...i);}success(t,...i){console.log(a.green(t),...i);}warn(t,...i){console.log(a.yellow(t),...i);}error(t,...i){console.error(a.red(t),...i);}step(t,i,o){console.log(a.cyan(`
+[${t}/${i}]`),a.white(o));}},c=new x;var z="rapidkit",V=fileURLToPath(import.meta.url),q=dirname(V),X=join(q,"..","package.json"),Q=JSON.parse(readFileSync(X,"utf-8")),S=Q.version;async function T(){try{c.debug("Checking for updates...");let{stdout:e}=await execa("npm",["view",z,"version"],{timeout:3e3}),t=e.trim();t&&t!==S?(console.log(a.yellow(`
+\u26A0\uFE0F  Update available: ${S} \u2192 ${t}`)),console.log(a.cyan(`Run: npm install -g rapidkit@latest
+`))):c.debug("You are using the latest version");}catch{c.debug("Could not check for updates");}}function w(){return S}var ie=".rapidkitrc.json";async function U(){let e=l.join(te.homedir(),ie);try{let t=await promises.readFile(e,"utf-8"),i=JSON.parse(t);return c.debug(`Loaded config from ${e}`),i}catch{return c.debug("No user config found, using defaults"),{}}}var v=class extends Error{constructor(i,o,n){super(i);this.code=o;this.details=n;this.name="RapidKitError",Error.captureStackTrace(this,this.constructor);}};var u=class extends v{constructor(t,i){super(`Invalid project name: "${t}"`,"INVALID_PROJECT_NAME",i);}};function O(e){let t=ae(e);if(!t.validForNewPackages){let o=t.errors||[],n=t.warnings||[],s=[...o,...n];throw new u(e,`NPM validation failed: ${s.join(", ")}`)}if(!/^[a-z][a-z0-9_-]*$/.test(e))throw new u(e,"Must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores");if(["test","tests","src","dist","build","lib","python","pip","poetry","node","npm","rapidkit","rapidkit"].includes(e.toLowerCase()))throw new u(e,`"${e}" is a reserved name. Please choose a different name.`);if(e.length<2)throw new u(e,"Name must be at least 2 characters long");if(e.length>214)throw new u(e,"Name must be less than 214 characters");return  true}async function F(e,t){let i=N("Creating RapidKit workspace...").start();try{await promises.mkdir(e,{recursive:!0}),await promises.mkdir(l.join(e,".rapidkit"),{recursive:!0});let o={workspace_name:t.name,author:t.author,rapidkit_version:w(),created_at:new Date().toISOString(),type:"workspace"};await promises.writeFile(l.join(e,".rapidkit","config.json"),JSON.stringify(o,null,2));let n=re();await promises.writeFile(l.join(e,"rapidkit"),n),await promises.chmod(l.join(e,"rapidkit"),493);let s=oe(t.name);if(await promises.writeFile(l.join(e,"README.md"),s),await promises.writeFile(l.join(e,".gitignore"),`# RapidKit workspace
 .env
-.rapidkit-workspace/
-`,"utf-8"),await execa("git",["add","."],{cwd:c}),await execa("git",["commit","-m","Initial commit: RapidKit environment"],{cwd:c}),g.succeed("Git repository initialized");}catch{g.warn("Could not initialize git repository");}}if(console.log(i.green(`
-\u2728 RapidKit environment created successfully!
-`)),console.log(i.cyan("\u{1F4C2} Location:"),i.white(c)),console.log(i.cyan(`\u{1F680} Get started:
-`)),console.log(i.white(`   cd ${n}`)),f.installMethod==="poetry"){let v="source $(poetry env info --path)/bin/activate";try{let{stdout:K}=await execa("poetry",["--version"]),b=K.match(/Poetry.*?(\d+)\.(\d+)/);b&&(parseInt(b[1])>=2?v="source $(poetry env info --path)/bin/activate":v="poetry shell");}catch{}console.log(i.white(`   ${v}  # Or: poetry run rapidkit`)),console.log(i.white("   rapidkit create  # Interactive mode")),console.log(i.white("   cd <project-name> && rapidkit init && rapidkit dev"));}else f.installMethod==="venv"?(console.log(i.white("   source .venv/bin/activate  # On Windows: .venv\\Scripts\\activate")),console.log(i.white("   rapidkit create  # Interactive mode")),console.log(i.white("   cd <project-name> && rapidkit init && rapidkit dev"))):(console.log(i.white("   rapidkit create  # Interactive mode")),console.log(i.white("   cd <project-name> && rapidkit init && rapidkit dev")));console.log(i.white(`
-\u{1F4A1} For more information, check the README.md file.`)),console.log(i.cyan(`
-\u{1F4DA} RapidKit commands:`)),console.log(i.white("   rapidkit create          - Create a new project (interactive)")),console.log(i.white("   rapidkit dev             - Run development server")),console.log(i.white("   rapidkit add module <name> - Add a module (e.g., settings)")),console.log(i.white("   rapidkit list            - List available kits")),console.log(i.white("   rapidkit modules         - List available modules")),console.log(i.white(`   rapidkit --help          - Show all commands
-`));}catch(v){g.fail("Failed to create RapidKit environment"),console.error(i.red(`
-\u274C Error:`),v);try{await y.remove(c);}catch{}process.exit(1);}}async function ie(t,e,o,r,a){o.start("Checking Poetry installation");try{await execa("poetry",["--version"]),o.succeed("Poetry found");}catch{throw new T}o.start("Initializing Poetry project"),await execa("poetry",["init","--no-interaction","--python",`^${e}`],{cwd:t});let m=h.join(t,"pyproject.toml"),n=(await promises.readFile(m,"utf-8")).replace("[tool.poetry]",`[tool.poetry]
-package-mode = false`);if(await promises.writeFile(m,n,"utf-8"),o.succeed("Poetry project initialized"),o.start("Installing RapidKit"),r){let c=F(a||{});if(!c)throw new j("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));s.debug(`Installing from local path: ${c}`),o.text="Installing RapidKit from local path (test mode)",await execa("poetry",["add",c],{cwd:t});}else {o.text="Installing RapidKit from PyPI";try{await execa("poetry",["add","rapidkit"],{cwd:t});}catch{throw new I}}o.succeed("RapidKit installed");}async function re(t,e,o,r,a){o.start(`Checking Python ${e}`);let m="python3";try{let{stdout:n}=await execa(m,["--version"]),c=n.match(/Python (\d+\.\d+)/)?.[1];if(c&&parseFloat(c)<parseFloat(e))throw new P(e,c);o.succeed(`Python ${c} found`);}catch(n){throw n instanceof P?n:new P(e)}o.start("Creating virtual environment"),await execa(m,["-m","venv",".venv"],{cwd:t}),o.succeed("Virtual environment created"),o.start("Installing RapidKit");let d=h.join(t,".venv","bin","pip");if(await execa(d,["install","--upgrade","pip"],{cwd:t}),r){let n=F(a||{});if(!n)throw new j("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));s.debug(`Installing from local path: ${n}`),o.text="Installing RapidKit from local path (test mode)",await execa(d,["install","-e",n],{cwd:t});}else {o.text="Installing RapidKit from PyPI";try{await execa(d,["install","rapidkit"],{cwd:t});}catch{throw new I}}o.succeed("RapidKit installed");}async function ae(t,e,o,r){e.start("Checking pipx installation");try{await execa("pipx",["--version"]),e.succeed("pipx found");}catch{throw new N}if(e.start("Installing RapidKit globally with pipx"),o){let a=F(r||{});if(!a)throw new j("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));s.debug(`Installing from local path: ${a}`),e.text="Installing RapidKit from local path (test mode)",await execa("pipx",["install","-e",a]);}else {e.text="Installing RapidKit from PyPI";try{await execa("pipx",["install","rapidkit"]);}catch{throw new I}}e.succeed("RapidKit installed globally"),await y.outputFile(h.join(t,".rapidkit-global"),`RapidKit installed globally with pipx
-`,"utf-8");}async function ne(t,e){let r=`# RapidKit Workspace
-
-This directory contains a RapidKit development environment.
-
-## Installation Method
-
-**${e==="poetry"?"Poetry":e==="venv"?"Python venv + pip":"pipx (global)"}**
-
-## Getting Started
-
-### 1. Activate Environment
-
-\`\`\`bash
-${e==="poetry"?`source $(poetry env info --path)/bin/activate
-# Or simply use: poetry run rapidkit <command>`:e==="venv"?"source .venv/bin/activate  # On Windows: .venv\\Scripts\\activate":"N/A (globally installed)"}
-\`\`\`
-
-### 2. Create Your First Project
-
-\`\`\`bash
-# Interactive mode (recommended):
-rapidkit create
-# Follow the prompts to choose kit and project name
-
-# Or specify directly:
-rapidkit create project fastapi.standard my-project
-
-# With poetry run (no activation needed):
-poetry run rapidkit create
-\`\`\`
-
-Interactive mode will guide you through selecting a kit and configuring your project.
-
-### 3. Navigate and Run
-
-\`\`\`bash
-cd my-project
-# Install dependencies (preferred):
-rapidkit init
-
-# Run the server (project-aware):
-rapidkit dev
-
-# Or with poetry run (manual / advanced):
-poetry run rapidkit dev
-
-# Or manually:
-uvicorn src.main:app --reload
-\`\`\`
-
-### 4. Add Modules (Optional)
-
-\`\`\`bash
-# Add common modules to your project:
-rapidkit add module settings
-rapidkit add module logging
-rapidkit add module database
-
-# List available modules:
-rapidkit modules list
-\`\`\`
-
-## Available Commands
-
-- \`rapidkit create\` - Create a new project (interactive)
-- \`rapidkit create project <kit> <name>\` - Create project with specific kit
-- \`rapidkit dev\` - Run development server
-- \`rapidkit add module <name>\` - Add a module (e.g., \`rapidkit add module settings\`)
-- \`rapidkit list\` - List available kits
-- \`rapidkit modules\` - List available modules
-- \`rapidkit upgrade\` - Upgrade RapidKit
-- \`rapidkit doctor\` - Check system requirements
-- \`rapidkit --help\` - Show all commands
+.env.*
+!.env.example
 
-## RapidKit Documentation
+# OS
+.DS_Store
+Thumbs.db
 
-For full documentation, visit: [RapidKit Docs](https://rapidkit.top) *(or appropriate URL)*
+# IDEs
+.vscode/
+.idea/
 
-## Workspace Structure
+# Logs
+*.log
+`),await ne(e),i.succeed("Workspace created!"),!t.skipGit){let d=N("Initializing git repository...").start();try{await execa("git",["init"],{cwd:e}),await execa("git",["add","."],{cwd:e}),await execa("git",["commit","-m","Initial commit: RapidKit workspace"],{cwd:e}),d.succeed("Git repository initialized");}catch{d.warn("Could not initialize git repository");}}console.log(`
+${a.green("\u2728 RapidKit workspace created successfully!")}
 
-\`\`\`
-${e==="venv"?".venv/          # Python virtual environment":""}
-${e==="poetry"?"pyproject.toml  # Poetry configuration":""}
-my-project/     # Your RapidKit projects go here
-README.md       # This file
-\`\`\`
+${a.bold("\u{1F4C2} Workspace structure:")}
+${e}/
+  \u251C\u2500\u2500 rapidkit            # Local CLI (add to PATH or use ./rapidkit)
+  \u251C\u2500\u2500 .rapidkit/          # Workspace configuration
+  \u2502   \u251C\u2500\u2500 config.json     # Workspace settings
+  \u2502   \u2514\u2500\u2500 templates/      # Project templates
+  \u2514\u2500\u2500 README.md
 
-## Troubleshooting
-
-If you encounter issues:
-
-1. Ensure Python 3.10+ is installed: \`python3 --version\`
-2. Check RapidKit installation: \`rapidkit --version\`
-3. Run diagnostics: \`rapidkit doctor\`
-4. Visit RapidKit documentation or GitHub issues
-`;await promises.writeFile(h.join(t,"README.md"),r,"utf-8");}async function se(t,e,o){let r=z("Creating demo workspace").start();try{await y.ensureDir(t),r.succeed("Directory created"),r.start("Setting up demo kit generator");let a=JSON.stringify({name:`${e}-workspace`,version:"1.0.0",private:!0,description:"RapidKit demo workspace",scripts:{generate:"node generate-demo.js"}},null,2);await promises.writeFile(h.join(t,"package.json"),a,"utf-8"),await promises.writeFile(h.join(t,"generate-demo.js"),`#!/usr/bin/env node
-/**
- * Demo Kit Generator - Create FastAPI demo projects
- * 
- * This workspace contains bundled RapidKit templates that you can use
- * to generate demo projects without installing Python RapidKit.
- * 
- * Usage:
- *   npm run generate <project-name>
- *   node generate-demo.js <project-name>
- * 
- * Example:
- *   npm run generate my-api
- */
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-const projectName = process.argv[2];
-
-if (!projectName) {
-  console.error('\\n\u274C Please provide a project name');
-  console.log('\\nUsage: npm run generate <project-name>\\n');
-  console.log('Example: npm run generate my-api\\n');
-  process.exit(1);
+${a.bold("\u{1F680} Get started:")}
+  ${a.cyan(`cd ${t.name}`)}
+  ${a.cyan('export PATH="$PWD:$PATH"')}  ${a.gray("# Add rapidkit to PATH")}
+  ${a.cyan("rapidkit create my-api --template fastapi")}
+  ${a.cyan("cd my-api")}
+  ${a.cyan("rapidkit dev")}
+
+${a.bold("\u{1F4E6} Available templates:")}
+  fastapi   - FastAPI + Python (default)
+  nestjs    - NestJS + TypeScript
+
+${a.bold("\u{1F4DA} Commands:")}
+  rapidkit create <name>       Create a new project
+  rapidkit create --help       Show create options
+  rapidkit help                Show all commands
+
+${a.gray("Tip: Add workspace to PATH for easier access:")}
+  ${a.cyan(`echo 'export PATH="${e}:$PATH"' >> ~/.bashrc`)}
+`);}catch(o){throw i.fail("Failed to create workspace"),o}}function re(){return `#!/usr/bin/env bash
+#
+# RapidKit CLI - Local workspace commands
+# This script provides rapidkit commands within the workspace
+#
+
+set -e
+
+# Find workspace root (where this script lives)
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+
+# Check if we're in a project directory (has .rapidkit/project.json)
+find_project_root() {
+    local dir="$PWD"
+    while [[ "$dir" != "/" ]]; do
+        if [[ -f "$dir/.rapidkit/project.json" ]]; then
+            echo "$dir"
+            return 0
+        fi
+        dir="$(dirname "$dir")"
+    done
+    return 1
 }
 
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-function ask(question, defaultValue) {
-  return new Promise((resolve) => {
-    rl.question(\`\${question} (\${defaultValue}): \`, (answer) => {
-      resolve(answer || defaultValue);
-    });
-  });
+# Check if we're in a workspace (has .rapidkit/config.json with type=workspace)
+find_workspace_root() {
+    local dir="$PWD"
+    while [[ "$dir" != "/" ]]; do
+        if [[ -f "$dir/.rapidkit/config.json" ]]; then
+            if grep -q '"type": "workspace"' "$dir/.rapidkit/config.json" 2>/dev/null; then
+                echo "$dir"
+                return 0
+            fi
+        fi
+        dir="$(dirname "$dir")"
+    done
+    return 1
 }
 
-async function main() {
-  const targetPath = path.join(process.cwd(), projectName);
-  
-  if (fs.existsSync(targetPath)) {
-    console.error(\`\\n\u274C Directory "\${projectName}" already exists\\n\`);
-    process.exit(1);
-  }
-
-  console.log(\`\\n\u{1F680} Creating FastAPI project: \${projectName}\\n\`);
-  
-  const snakeName = projectName.replace(/-/g, '_').toLowerCase();
-  const project_name = await ask('Project name (snake_case)', snakeName);
-  const author = await ask('Author name', process.env.USER || 'RapidKit User');
-  const description = await ask('Description', 'FastAPI service generated with RapidKit');
-  
-  rl.close();
-
-  // Create project structure
-  const dirs = [
-    '',
-    'src',
-    'src/routing',
-    'src/modules',
-    'tests',
-    '.rapidkit'
-  ];
-
-  for (const dir of dirs) {
-    fs.mkdirSync(path.join(targetPath, dir), { recursive: true });
-  }
-
-  // Template files with content
-  const files = {
-    'src/__init__.py': '"""' + project_name + ' package."""\\n',
-    'src/modules/__init__.py': '"""Modules package."""\\n',
-    'tests/__init__.py': '"""Tests package."""\\n',
-    'src/main.py': \`"""\${project_name} application entrypoint."""
-
-from __future__ import annotations
-
-from contextlib import asynccontextmanager
-from typing import AsyncIterator
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from .routing import api_router
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-    """Application lifespan context manager for startup/shutdown events."""
-    yield
-
-
-app = FastAPI(
-    title="\${project_name}",
-    description="\${description}",
-    version="0.1.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    lifespan=lifespan,
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(api_router, prefix="/api")
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("src.main:app", host="0.0.0.0", port=8001, reload=True)
-\`,
-    'src/routing/__init__.py': \`"""API routing configuration."""
-
-from fastapi import APIRouter
-
-from .health import router as health_router
-
-api_router = APIRouter()
-
-api_router.include_router(health_router)
-\`,
-    'src/routing/health.py': \`"""Health check endpoints."""
-
-from __future__ import annotations
-
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/health", tags=["health"])
-
-
-@router.get("/", summary="Health check")
-async def heartbeat() -> dict[str, str]:
-    """Return basic service heartbeat."""
-    return {"status": "ok"}
-\`,
-    'src/cli.py': \`"""CLI commands for \${project_name}."""
-
-import subprocess
-import sys
-from pathlib import Path
-
-
-def dev():
-    """Start development server with hot reload."""
-    print("\u{1F680} Starting development server...")
-    subprocess.run([
-        sys.executable, "-m", "uvicorn",
-        "src.main:app", "--reload",
-        "--host", "0.0.0.0", "--port", "8000"
-    ])
-
-
-def start():
-    """Start production server."""
-    print("\u26A1 Starting production server...")
-    subprocess.run([
-        sys.executable, "-m", "uvicorn",
-        "src.main:app",
-        "--host", "0.0.0.0", "--port", "8000"
-    ])
-
+# Colors
+RED='\\033[0;31m'
+GREEN='\\033[0;32m'
+YELLOW='\\033[0;33m'
+BLUE='\\033[0;34m'
+CYAN='\\033[0;36m'
+NC='\\033[0m' # No Color
+BOLD='\\033[1m'
+
+print_banner() {
+    echo -e "\${BLUE}\${BOLD}\u{1F680} RapidKit CLI\${NC}"
+    echo ""
+}
 
-def test():
-    """Run tests."""
-    print("\u{1F9EA} Running tests...")
-    subprocess.run([sys.executable, "-m", "pytest", "-q"])
+print_help() {
+    print_banner
+    echo -e "\${BOLD}Usage:\${NC} rapidkit <command> [options]"
+    echo ""
+    echo -e "\${BOLD}\u{1F3D7}\uFE0F  Workspace Commands:\${NC}"
+    echo "  create <name>         Create a new project from template"
+    echo "  create --help         Show create command options"
+    echo ""
+    echo -e "\${BOLD}\u{1F680} Project Commands\${NC} (run inside a project):"
+    echo "  init                  Install project dependencies"
+    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 ""
+    echo -e "\${BOLD}\u{1F4DA} Other Commands:\${NC}"
+    echo "  help                  Show this help message"
+    echo "  version               Show version"
+    echo ""
+    echo -e "\${BOLD}Examples:\${NC}"
+    echo -e "  \${CYAN}rapidkit create my-api --template fastapi\${NC}"
+    echo -e "  \${CYAN}rapidkit create my-app --template nestjs --yes\${NC}"
+    echo -e "  \${CYAN}cd my-api && rapidkit dev\${NC}"
+    echo ""
+}
 
+print_create_help() {
+    print_banner
+    echo -e "\${BOLD}Usage:\${NC} rapidkit create <project-name> [options]"
+    echo ""
+    echo -e "\${BOLD}Options:\${NC}"
+    echo "  -t, --template <name>   Template to use (fastapi, nestjs)"
+    echo "  -y, --yes               Skip prompts, use defaults"
+    echo "  --skip-git              Skip git initialization"
+    echo "  --skip-install          Skip dependency installation"
+    echo ""
+    echo -e "\${BOLD}Templates:\${NC}"
+    echo "  fastapi    FastAPI + Python (default)"
+    echo "  nestjs     NestJS + TypeScript"
+    echo ""
+    echo -e "\${BOLD}Examples:\${NC}"
+    echo -e "  \${CYAN}rapidkit create my-api\${NC}"
+    echo -e "  \${CYAN}rapidkit create my-api --template fastapi\${NC}"
+    echo -e "  \${CYAN}rapidkit create my-app --template nestjs --yes\${NC}"
+    echo ""
+}
 
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python -m src.cli <command>")
-        print("Commands: dev, start, test")
-        sys.exit(1)
+# Create project command
+cmd_create() {
+    local project_name=""
+    local template="fastapi"
+    local yes_flag=""
+    local skip_git=""
+    local skip_install=""
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            -h|--help)
+                print_create_help
+                exit 0
+                ;;
+            -t|--template)
+                template="$2"
+                shift 2
+                ;;
+            -y|--yes)
+                yes_flag="--yes"
+                shift
+                ;;
+            --skip-git)
+                skip_git="--skip-git"
+                shift
+                ;;
+            --skip-install)
+                skip_install="--skip-install"
+                shift
+                ;;
+            -*)
+                echo -e "\${RED}\u274C Unknown option: $1\${NC}"
+                print_create_help
+                exit 1
+                ;;
+            *)
+                if [[ -z "$project_name" ]]; then
+                    project_name="$1"
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    # Validate template
+    if [[ "$template" != "fastapi" && "$template" != "nestjs" ]]; then
+        echo -e "\${RED}\u274C Invalid template: $template\${NC}"
+        echo -e "Available templates: fastapi, nestjs"
+        exit 1
+    fi
+
+    # If no project name, prompt for it or show help
+    if [[ -z "$project_name" ]]; then
+        if [[ -n "$yes_flag" ]]; then
+            project_name="my-\${template}-project"
+        else
+            echo -e "\${YELLOW}Project name required\${NC}"
+            echo ""
+            print_create_help
+            exit 1
+        fi
+    fi
+
+    # Find workspace root
+    local workspace_root
+    workspace_root=$(find_workspace_root) || {
+        echo -e "\${RED}\u274C Not in a RapidKit workspace\${NC}"
+        echo -e "Run this command from within a RapidKit workspace."
+        exit 1
+    }
+
+    local project_path="$PWD/$project_name"
+
+    # Check if project already exists
+    if [[ -d "$project_path" ]]; then
+        echo -e "\${RED}\u274C Directory '$project_name' already exists\${NC}"
+        exit 1
+    fi
+
+    echo -e "\${BLUE}\${BOLD}\u{1F680} Creating $template project: $project_name\${NC}"
+    echo ""
+
+    # Use Node.js generator script
+    local generator_script="$workspace_root/.rapidkit/generator.js"
     
-    cmd = sys.argv[1]
-    if cmd == "dev":
-        dev()
-    elif cmd == "start":
-        start()
-    elif cmd == "test":
-        test()
-    else:
-        print(f"Unknown command: {cmd}")
-        sys.exit(1)
-\`,
-    'pyproject.toml': \`[tool.poetry]
-name = "\${project_name}"
-version = "0.1.0"
-description = "\${description}"
-authors = ["\${author}"]
-license = "MIT"
-readme = "README.md"
-package-mode = false
-
-[tool.poetry.dependencies]
-python = "^3.11"
-fastapi = "^0.115.0"
-uvicorn = {extras = ["standard"], version = "^0.32.0"}
-pydantic = "^2.0"
-pydantic-settings = "^2.0"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^8.0"
-pytest-asyncio = "^0.24.0"
-pytest-cov = "^6.0"
-httpx = "^0.27"
-black = "^24.0"
-ruff = "^0.8"
-mypy = "^1.0"
-
-[tool.poetry.scripts]
-dev = "src.cli:dev"
-start = "src.cli:start"
-test = "src.cli:test"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-testpaths = ["tests"]
-
-[tool.ruff]
-line-length = 100
-target-version = "py311"
-
-[tool.black]
-line-length = 100
-target-version = ["py311"]
-\`,
-    'README.md': \`# \${project_name}
-
-\${description}
-
-## Quick start
-
-\\\`\\\`\\\`bash
-rapidkit init       # Install dependencies
-rapidkit dev        # Start dev server
-\\\`\\\`\\\`
-
-## Available commands
-
-\\\`\\\`\\\`bash
-rapidkit init       # \u{1F527} Install dependencies
-rapidkit dev        # \u{1F680} Start development server with hot reload
-rapidkit start      # \u26A1 Start production server
-rapidkit test       # \u{1F9EA} Run tests
-rapidkit help       # \u{1F4DA} Show available commands
-\\\`\\\`\\\`
-
-## Project layout
-
-\\\`\\\`\\\`
-\${project_name}/
-\u251C\u2500\u2500 src/
-\u2502   \u251C\u2500\u2500 main.py           # FastAPI application
-\u2502   \u251C\u2500\u2500 cli.py            # CLI commands
-\u2502   \u251C\u2500\u2500 routing/          # API routes
-\u2502   \u2514\u2500\u2500 modules/          # Module system
-\u251C\u2500\u2500 tests/                # Test suite
-\u251C\u2500\u2500 pyproject.toml        # Poetry configuration
-\u2514\u2500\u2500 README.md
-\\\`\\\`\\\`
-\`,
-    '.rapidkit/project.json': JSON.stringify({
-      kit_name: "fastapi.standard",
-      profile: "fastapi/standard",
-      created_at: new Date().toISOString(),
-      rapidkit_version: "npm-demo"
-    }, null, 2),
-    '.rapidkit/cli.py': \`#!/usr/bin/env python3
-"""RapidKit CLI wrapper for demo projects."""
-
-import subprocess
-import sys
-from pathlib import Path
-
-
-def dev(port=8000, host="0.0.0.0"):
-    """Start development server."""
-    print("\u{1F680} Starting development server with hot reload...")
-    subprocess.run([
-        sys.executable, "-m", "uvicorn",
-        "src.main:app", "--reload",
-        "--host", host, "--port", str(port)
-    ])
-
-
-def start(port=8000, host="0.0.0.0"):
-    """Start production server."""
-    print("\u26A1 Starting production server...")
-    subprocess.run([
-        sys.executable, "-m", "uvicorn",
-        "src.main:app",
-        "--host", host, "--port", str(port)
-    ])
-
-
-def init():
-    """Install dependencies."""
-    print("\u{1F4E6} Installing dependencies...")
-    subprocess.run(["poetry", "install"])
-
-
-def test():
-    """Run tests."""
-    print("\u{1F9EA} Running tests...")
-    subprocess.run([sys.executable, "-m", "pytest", "-q"])
-
-
-def help_cmd():
-    """Show help."""
-    print("\u{1F4DA} Available commands:")
-    print("  init   - Install dependencies")
-    print("  dev    - Start dev server")
-    print("  start  - Start production server")
-    print("  test   - Run tests")
-
-
-if __name__ == "__main__":
-    cmd = sys.argv[1] if len(sys.argv) > 1 else "help"
-    cmds = {"dev": dev, "start": start, "init": init, "test": test, "help": help_cmd}
-    cmds.get(cmd, help_cmd)()
-\`,
-    '.rapidkit/rapidkit': '#!/usr/bin/env bash\\n# Local RapidKit launcher for demo projects\\nset -euo pipefail\\nSCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"\\nROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"\\ncd "$ROOT_DIR"\\n\\nif [ -f "pyproject.toml" ]; then\\n  if command -v poetry >/dev/null 2>&1; then\\n    exec poetry run python "$SCRIPT_DIR/cli.py" "$@"\\n  fi\\nfi\\n\\necho "Poetry not found. Install with: pip install poetry"\\nexit 1\\n',
-    '.gitignore': \`# Python
-__pycache__/
-*.py[cod]
-*.so
-.Python
-build/
-dist/
-*.egg-info/
-
-# Virtual environments
-.venv/
-venv/
-
-# IDEs
-.vscode/
-.idea/
-
-# OS
-.DS_Store
+    if [[ -f "$generator_script" ]]; then
+        node "$generator_script" "$project_path" "$template" "$yes_flag" "$skip_git" "$skip_install"
+    else
+        echo -e "\${RED}\u274C Generator script not found\${NC}"
+        exit 1
+    fi
+}
 
-# Project
-.env
-.env.local
-\`
-  };
-
-  for (const [filePath, content] of Object.entries(files)) {
-    fs.writeFileSync(path.join(targetPath, filePath), content);
-  }
-
-  // Make scripts executable
-  try {
-    fs.chmodSync(path.join(targetPath, '.rapidkit/cli.py'), 0o755);
-    fs.chmodSync(path.join(targetPath, '.rapidkit/rapidkit'), 0o755);
-  } catch (e) {
-    // Ignore on Windows
-  }
-
-  console.log(\`
-\u2728 Demo project created successfully!
-
-\u{1F4C2} Project: \${targetPath}
-
-\u{1F680} Get started:
-  cd \${projectName}
-  rapidkit init       # Install dependencies
-  rapidkit dev        # Start dev server
-
-\u{1F4DA} Available commands:
-  rapidkit init       # \u{1F527} Install dependencies
-  rapidkit dev        # \u{1F680} Start dev server with hot reload
-  rapidkit start      # \u26A1 Start production server
-  rapidkit test       # \u{1F9EA} Run tests
-  rapidkit help       # \u{1F4DA} Show help
-
-\u{1F4A1} For full RapidKit features: pipx install rapidkit
-\`);
+# Project commands (dev, build, test, etc.)
+cmd_project() {
+    local cmd="$1"
+    shift
+
+    # Find project root
+    local project_root
+    project_root=$(find_project_root) || {
+        echo -e "\${RED}\u274C Not in a RapidKit project\${NC}"
+        echo -e "Run this command from within a project directory."
+        echo -e "Use \${CYAN}rapidkit create <name>\${NC} to create a new project."
+        exit 1
+    }
+
+    # Read project type from project.json
+    local project_json="$project_root/.rapidkit/project.json"
+    local kit_name
+    kit_name=$(grep -o '"kit_name": *"[^"]*"' "$project_json" | cut -d'"' -f4)
+
+    cd "$project_root"
+
+    case "$kit_name" in
+        fastapi.standard|python)
+            # Python/FastAPI project
+            case "$cmd" in
+                init)
+                    echo -e "\${BLUE}\u{1F4E6} Installing dependencies...\${NC}"
+                    poetry install
+                    echo -e "\${GREEN}\u2705 Dependencies installed!\${NC}"
+                    ;;
+                dev)
+                    echo -e "\${BLUE}\u{1F680} Starting development server...\${NC}"
+                    poetry run dev "$@"
+                    ;;
+                start)
+                    echo -e "\${BLUE}\u26A1 Starting production server...\${NC}"
+                    poetry run start "$@"
+                    ;;
+                build)
+                    echo -e "\${BLUE}\u{1F4E6} Building project...\${NC}"
+                    poetry run build
+                    ;;
+                test)
+                    echo -e "\${BLUE}\u{1F9EA} Running tests...\${NC}"
+                    poetry run test
+                    ;;
+                lint)
+                    echo -e "\${BLUE}\u{1F527} Running linter...\${NC}"
+                    poetry run lint
+                    ;;
+                format)
+                    echo -e "\${BLUE}\u2728 Formatting code...\${NC}"
+                    poetry run format
+                    ;;
+                *)
+                    echo -e "\${RED}\u274C Unknown command: $cmd\${NC}"
+                    exit 1
+                    ;;
+            esac
+            ;;
+        nestjs.standard|node)
+            # Node/NestJS project
+            local pm="npm"
+            if command -v pnpm &>/dev/null && [[ -f "pnpm-lock.yaml" ]]; then
+                pm="pnpm"
+            elif command -v yarn &>/dev/null && [[ -f "yarn.lock" ]]; then
+                pm="yarn"
+            fi
+
+            case "$cmd" in
+                init)
+                    echo -e "\${BLUE}\u{1F4E6} Installing dependencies...\${NC}"
+                    $pm install
+                    echo -e "\${GREEN}\u2705 Dependencies installed!\${NC}"
+                    ;;
+                dev)
+                    echo -e "\${BLUE}\u{1F680} Starting development server...\${NC}"
+                    $pm run start:dev
+                    ;;
+                start)
+                    echo -e "\${BLUE}\u26A1 Starting production server...\${NC}"
+                    $pm run start:prod
+                    ;;
+                build)
+                    echo -e "\${BLUE}\u{1F4E6} Building project...\${NC}"
+                    $pm run build
+                    ;;
+                test)
+                    echo -e "\${BLUE}\u{1F9EA} Running tests...\${NC}"
+                    $pm test
+                    ;;
+                lint)
+                    echo -e "\${BLUE}\u{1F527} Running linter...\${NC}"
+                    $pm run lint
+                    ;;
+                format)
+                    echo -e "\${BLUE}\u2728 Formatting code...\${NC}"
+                    $pm run format
+                    ;;
+                *)
+                    echo -e "\${RED}\u274C Unknown command: $cmd\${NC}"
+                    exit 1
+                    ;;
+            esac
+            ;;
+        *)
+            echo -e "\${RED}\u274C Unknown project type: $kit_name\${NC}"
+            exit 1
+            ;;
+    esac
 }
 
-main().catch(console.error);
-`,"utf-8");try{await execa("chmod",["+x",h.join(t,"generate-demo.js")]);}catch{}let d=`# RapidKit Demo Workspace
+# Main command handler
+main() {
+    local cmd="\${1:-help}"
+    shift || true
+
+    case "$cmd" in
+        create)
+            cmd_create "$@"
+            ;;
+        init|dev|start|build|test|lint|format)
+            cmd_project "$cmd" "$@"
+            ;;
+        help|-h|--help)
+            print_help
+            ;;
+        version|-v|--version)
+            echo "RapidKit CLI (npm workspace) v${w()}"
+            ;;
+        *)
+            echo -e "\${RED}\u274C Unknown command: $cmd\${NC}"
+            echo ""
+            print_help
+            exit 1
+            ;;
+    esac
+}
 
-Welcome to your RapidKit demo workspace! This environment lets you generate FastAPI demo projects using bundled RapidKit templates, without needing to install Python RapidKit.
+main "$@"
+`}function oe(e){return `# ${e}
 
-## \u{1F680} Quick Start
+RapidKit workspace for building API projects.
 
-### Generate Your First Demo Project
+## Quick Start
 
 \`\`\`bash
-# Generate a demo project:
-node generate-demo.js my-api
-
-# Navigate to the project:
-cd my-api
+# Add rapidkit to PATH (or use ./rapidkit)
+export PATH="$PWD:$PATH"
 
-# Install dependencies:
-rapidkit init
+# Create a FastAPI project
+rapidkit create my-api --template fastapi
 
-# Run the development server:
-rapidkit dev
-\`\`\`
+# Or create a NestJS project
+rapidkit create my-app --template nestjs
 
-Your API will be available at \`http://localhost:8000\`
-
-## \u{1F4E6} Generate Multiple Projects
-
-You can create multiple demo projects in this workspace:
-
-\`\`\`bash
-node generate-demo.js api-service
-node generate-demo.js auth-service
-node generate-demo.js data-service
+# Enter project and start development
+cd my-api
+rapidkit init    # Install dependencies
+rapidkit dev     # Start dev server
 \`\`\`
 
-Each project is independent and has its own dependencies.
-
-## \u{1F3AF} What's Included
-
-Each generated demo project contains:
-
-- **FastAPI Application** - Modern async web framework
-- **Routing System** - Organized API routes
-- **Module System** - Extensible module architecture
-- **CLI Commands** - Built-in command system
-- **Testing Setup** - pytest configuration
-- **Poetry Configuration** - Dependency management
+## Available Templates
 
-## \u{1F4DA} Next Steps
+| Template | Stack | Description |
+|----------|-------|-------------|
+| \`fastapi\` | Python + FastAPI | High-performance Python API |
+| \`nestjs\` | TypeScript + NestJS | Enterprise Node.js framework |
 
-1. **Explore the Generated Code** - Check out \`src/main.py\` and \`src/routing/\`
-2. **Add Routes** - Create new endpoints in \`src/routing/\`
-3. **Install Full RapidKit** - For advanced features: \`pipx install rapidkit\`
-4. **Read the Documentation** - Visit [RapidKit Docs](https://rapidkit.top)
+## Commands
 
-## \u26A0\uFE0F Demo Mode Limitations
+### Workspace Commands
 
-This is a demo workspace with:
-- \u2705 Pre-built FastAPI templates
-- \u2705 Project generation without Python RapidKit
-- \u274C No RapidKit CLI commands (\`rapidkit create\`, \`rapidkit add module\`)
-- \u274C No interactive module system
+| Command | Description |
+|---------|-------------|
+| \`rapidkit create <name>\` | Create a new project |
+| \`rapidkit create --help\` | Show create options |
+| \`rapidkit help\` | Show all commands |
 
-For full RapidKit features, install the Python package:
+### Project Commands (run inside a project)
 
-\`\`\`bash
-pipx install rapidkit
-\`\`\`
-
-## \u{1F6E0}\uFE0F Workspace Structure
-
-\`\`\`
-${e}/
-  \u251C\u2500\u2500 generate-demo.js    # Demo project generator
-  \u251C\u2500\u2500 README.md           # This file
-  \u2514\u2500\u2500 my-api/             # Your generated projects go here
-\`\`\`
-
-## \u{1F4A1} Tips
-
-- Run \`node generate-demo.js --help\` for more options (coming soon)
-- Each project can have different configurations
-- Demo projects are production-ready FastAPI applications
-- You can copy and modify templates as needed
+| Command | Description |
+|---------|-------------|
+| \`rapidkit init\` | Install dependencies |
+| \`rapidkit dev\` | Start development server |
+| \`rapidkit start\` | Start production server |
+| \`rapidkit build\` | Build for production |
+| \`rapidkit test\` | Run tests |
+| \`rapidkit lint\` | Run linting |
+| \`rapidkit format\` | Format code |
 
----
+## Learn More
 
-**Generated with RapidKit** | [GitHub](https://github.com/getrapidkit/rapidkit-npm)
-`;if(await promises.writeFile(h.join(t,"README.md"),d,"utf-8"),r.succeed("Demo workspace setup complete"),!o){r.start("Initializing git repository");try{await execa("git",["init"],{cwd:t}),await y.outputFile(h.join(t,".gitignore"),`# Dependencies
-node_modules/
-
-# Generated projects
-*/
-!generate-demo.js
-!README.md
-
-# Python
-__pycache__/
-*.pyc
-.venv/
-.env
-`,"utf-8"),await execa("git",["add","."],{cwd:t}),await execa("git",["commit","-m","Initial commit: Demo workspace"],{cwd:t}),r.succeed("Git repository initialized");}catch{r.warn("Could not initialize git repository");}}console.log(i.green(`
-\u2728 Demo workspace created successfully!
-`)),console.log(i.cyan("\u{1F4C2} Location:"),i.white(t)),console.log(i.cyan(`\u{1F680} Get started:
-`)),console.log(i.white(`   cd ${e}`)),console.log(i.white("   node generate-demo.js my-api")),console.log(i.white("   cd my-api")),console.log(i.white("   rapidkit init")),console.log(i.white("   rapidkit dev")),console.log(),console.log(i.yellow("\u{1F4A1} Note:"),"This is a demo workspace. For full RapidKit features:"),console.log(i.cyan("   pipx install rapidkit")),console.log();}catch(a){throw r.fail("Failed to create demo workspace"),a}}async function ce(t,e,o,r){console.log(i.cyan(`
-\u{1F50D} Dry-run mode - showing what would be created:
-`)),console.log(i.white("\u{1F4C2} Project path:"),t),console.log(i.white("\u{1F4E6} Project type:"),o?"Demo workspace":"Full RapidKit environment"),o?(console.log(i.white(`
-\u{1F4DD} Files to create:`)),console.log(i.gray("  - package.json")),console.log(i.gray("  - generate-demo.js (project generator)")),console.log(i.gray("  - README.md")),console.log(i.gray("  - .gitignore")),console.log(i.white(`
-\u{1F3AF} Capabilities:`)),console.log(i.gray("  - Generate multiple FastAPI demo projects")),console.log(i.gray("  - No Python RapidKit installation required")),console.log(i.gray("  - Bundled templates included"))):(console.log(i.white(`
-\u2699\uFE0F  Configuration:`)),console.log(i.gray(`  - Python version: ${r.pythonVersion||"3.11"}`)),console.log(i.gray(`  - Install method: ${r.defaultInstallMethod||"poetry"}`)),console.log(i.gray(`  - Git initialization: ${r.skipGit?"No":"Yes"}`)),console.log(i.white(`
-\u{1F4DD} Files to create:`)),console.log(i.gray("  - pyproject.toml (Poetry) or .venv/ (venv)")),console.log(i.gray("  - README.md")),console.log(i.gray("  - .gitignore")),console.log(i.white(`
-\u{1F3AF} Next steps after creation:`)),console.log(i.gray("  1. Install RapidKit Python package")),console.log(i.gray("  2. Create projects with rapidkit CLI")),console.log(i.gray("  3. Add modules and customize"))),console.log(i.white(`
-\u{1F4A1} To proceed with actual creation, run without --dry-run flag
-`));}var me=fileURLToPath(import.meta.url),ue=h.dirname(me);async function q(t,e){let o=z("Generating FastAPI demo project...").start();try{let r=h.resolve(ue,".."),a=h.join(r,"templates","kits","fastapi-standard"),m=le.configure(a,{autoescape:!1,trimBlocks:!0,lstripBlocks:!0}),d={project_name:e.project_name,author:e.author||"RapidKit User",description:e.description||"FastAPI service generated with RapidKit",app_version:e.app_version||"0.1.0",license:e.license||"MIT"},n=["src/main.py.j2","src/__init__.py.j2","src/cli.py.j2","src/routing/__init__.py.j2","src/routing/health.py.j2","src/modules/__init__.py.j2","tests/__init__.py.j2","README.md.j2","pyproject.toml.j2",".rapidkit/project.json.j2",".rapidkit/cli.py.j2",".rapidkit/rapidkit.j2"];for(let f of n){let g=h.join(a,f),v=await promises.readFile(g,"utf-8"),K=m.renderString(v,d),b=f.replace(/\.j2$/,""),D=h.join(t,b);await promises.mkdir(h.dirname(D),{recursive:!0}),await promises.writeFile(D,K),(b===".rapidkit/rapidkit"||b===".rapidkit/cli.py")&&await promises.chmod(D,493);}await promises.writeFile(h.join(t,".gitignore"),`# Python
+- [RapidKit Documentation](https://rapidkit.dev)
+- [GitHub Repository](https://github.com/Baziar/rapidkit)
+`}async function ne(e){let{fileURLToPath:t}=await import('url'),i=t(import.meta.url),o=l.dirname(i),n=l.resolve(o,".."),s=l.join(n,"templates","kits"),p=l.join(e,".rapidkit","templates"),{default:d}=await import('fs-extra');await d.copy(s,p);let g=l.join(n,"templates","generator.js"),j=l.join(e,".rapidkit","generator.js");await d.copy(g,j);}async function B(e,t){let i=t.template==="fastapi",o=i?"FastAPI":"NestJS",n=N(`Creating ${o} project...`).start();try{let{fileURLToPath:s}=await import('url'),p=s(import.meta.url),d=l.dirname(p),g=l.resolve(d,".."),j=i?"fastapi-standard":"nestjs-standard",C=l.join(g,"templates","kits",j);await promises.mkdir(e,{recursive:!0});let _={project_name:i?t.name.replace(/-/g,"_").toLowerCase():t.name.replace(/_/g,"-").toLowerCase(),author:t.author,description:t.description||`${o} application generated with RapidKit`,app_version:"0.1.0",license:"MIT",package_manager:t.package_manager||"npm",created_at:new Date().toISOString(),rapidkit_version:w()};await K(C,e,_);let G=i?`# Python
 __pycache__/
 *.py[cod]
 *$py.class
@@ -667,15 +479,38 @@ Thumbs.db
 # Project specific
 .env
 .env.local
-`),o.succeed("FastAPI demo project generated!"),console.log(`
-${i.green("\u2728 Demo project created successfully!")}
-
-${i.bold("\u{1F4C2} Project structure:")}
-${t}/
-  \u251C\u2500\u2500 .rapidkit/           # RapidKit project config
-  \u2502   \u251C\u2500\u2500 project.json     # Project metadata
-  \u2502   \u251C\u2500\u2500 cli.py           # Local CLI handler
-  \u2502   \u2514\u2500\u2500 rapidkit         # Local launcher
+`:`# Node artifacts
+node_modules/
+dist/
+.tmp/
+.env
+.env.*
+!.env.example
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDEs
+.idea/
+.vscode/
+
+# Coverage
+coverage/
+`;if(await promises.writeFile(l.join(e,".gitignore"),G),n.succeed(`${o} project created!`),!t.skipGit){let y=N("Initializing git repository...").start();try{await execa("git",["init"],{cwd:e}),await execa("git",["add","."],{cwd:e}),await execa("git",["commit","-m",`Initial commit: ${o} project via RapidKit`],{cwd:e}),y.succeed("Git repository initialized");}catch{y.warn("Could not initialize git repository");}}if(!t.skipInstall&&!i){let y=t.package_manager||"npm",D=N(`Installing dependencies with ${y}...`).start();try{await execa(y,["install"],{cwd:e}),D.succeed("Dependencies installed");}catch{D.warn(`Could not install dependencies. Run '${y} install' manually.`);}}let A=l.basename(e);console.log(i?`
+${a.green("\u2728 FastAPI project created successfully!")}
+
+${a.bold("\u{1F4C2} Project structure:")}
+${e}/
+  \u251C\u2500\u2500 .rapidkit/           # RapidKit CLI module
   \u251C\u2500\u2500 src/
   \u2502   \u251C\u2500\u2500 main.py          # FastAPI application
   \u2502   \u251C\u2500\u2500 cli.py           # CLI commands
@@ -685,44 +520,76 @@ ${t}/
   \u251C\u2500\u2500 pyproject.toml       # Poetry configuration
   \u2514\u2500\u2500 README.md
 
-${i.bold("\u{1F680} Get started:")}
-  cd ${h.basename(t)}
-  poetry install
-  rapidkit dev             # or: poetry run python -m src.main
-
-${i.bold("\u{1F4DA} Available commands:")}
-  rapidkit init            # Install dependencies
-  rapidkit dev             # Start dev server with hot reload
-  rapidkit start           # Start production server
-  rapidkit test            # Run tests
-  rapidkit lint            # Lint code
-  rapidkit format          # Format code
-
-${i.yellow("Note:")} This is a standalone demo. For full RapidKit features and modules,
-install RapidKit Python package: ${i.cyan("pipx install rapidkit")}
-`);}catch(r){throw o.fail("Failed to generate demo project"),r}}var ve="rapidkit",ke=fileURLToPath(import.meta.url),_e=dirname(ke),Re=join(_e,"..","package.json"),be=JSON.parse(readFileSync(Re,"utf-8")),L=be.version;async function H(){try{s.debug("Checking for updates...");let{stdout:t}=await execa("npm",["view",ve,"version"],{timeout:3e3}),e=t.trim();e&&e!==L?(console.log(i.yellow(`
-\u26A0\uFE0F  Update available: ${L} \u2192 ${e}`)),console.log(i.cyan(`Run: npm install -g rapidkit@latest
-`))):s.debug("You are using the latest version");}catch{s.debug("Could not check for updates");}}function J(){return L}function V(t){let e=Pe(t);if(!e.validForNewPackages){let r=e.errors||[],a=e.warnings||[],m=[...r,...a];throw new k(t,`NPM validation failed: ${m.join(", ")}`)}if(!/^[a-z][a-z0-9_-]*$/.test(t))throw new k(t,"Must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores");if(["test","tests","src","dist","build","lib","python","pip","poetry","node","npm","rapidkit","rapidkit"].includes(t.toLowerCase()))throw new k(t,`"${t}" is a reserved name. Please choose a different name.`);if(t.length<2)throw new k(t,"Name must be at least 2 characters long");if(t.length>214)throw new k(t,"Name must be less than 214 characters");return  true}var w=null,O=false,Q=new Command;Q.name("rapidkit").description("Create a RapidKit development environment or workspace").version(J()).argument("[directory-name]","Name of the workspace or project directory").option("--skip-git","Skip git initialization").option("--test-mode","Install RapidKit from local path (for development/testing only)").option("--demo","Create workspace with demo kit templates (no Python installation required)").option("--demo-only","Generate a demo project in current directory (used by demo workspace)").option("--debug","Enable debug logging").option("--dry-run","Show what would be created without creating it").option("--no-update-check","Skip checking for updates").action(async(t,e)=>{try{e.debug&&(s.setDebug(!0),s.debug("Debug mode enabled"));let o=await W();if(s.debug("User config loaded",o),e.updateCheck!==!1&&await H(),console.log(i.blue.bold(`
+${a.bold("\u{1F680} Get started:")}
+  ${a.cyan(`cd ${A}`)}
+  ${a.cyan("source .rapidkit/activate")}   ${a.gray("# Enable rapidkit commands")}
+  ${a.cyan("rapidkit init")}               ${a.gray("# Install dependencies")}
+  ${a.cyan("rapidkit dev")}                ${a.gray("# Start dev server")}
+
+${a.bold("\u{1F4DA} Available commands:")}
+  rapidkit init      # Install dependencies (poetry install)
+  rapidkit dev       # Start dev server with hot reload
+  rapidkit start     # Start production server
+  rapidkit test      # Run tests
+  rapidkit lint      # Lint code
+  rapidkit format    # Format code
+
+${a.gray("Alternative: use make commands (make dev, make test, ...)")}
+`:`
+${a.green("\u2728 NestJS project created successfully!")}
+
+${a.bold("\u{1F4C2} Project structure:")}
+${e}/
+  \u251C\u2500\u2500 .rapidkit/           # RapidKit CLI module
+  \u251C\u2500\u2500 src/
+  \u2502   \u251C\u2500\u2500 main.ts          # Application entry point
+  \u2502   \u251C\u2500\u2500 app.module.ts    # Root module
+  \u2502   \u251C\u2500\u2500 config/          # Configuration
+  \u2502   \u2514\u2500\u2500 examples/        # Example module
+  \u251C\u2500\u2500 test/                # Test files
+  \u251C\u2500\u2500 package.json         # Dependencies
+  \u2514\u2500\u2500 README.md
+
+${a.bold("\u{1F680} Get started:")}
+  ${a.cyan(`cd ${A}`)}
+  ${a.cyan("source .rapidkit/activate")}   ${a.gray("# Enable rapidkit commands")}
+  ${t.skipInstall?a.cyan("rapidkit init")+a.gray("               # npm install")+`
+  `:""}${a.cyan("cp .env.example .env")}
+  ${a.cyan("rapidkit dev")}                ${a.gray("# Start dev server")}
+
+${a.bold("\u{1F4DA} Available commands:")}
+  rapidkit init      # Install dependencies
+  rapidkit dev       # Start dev server with hot reload
+  rapidkit start     # Start production server
+  rapidkit build     # Build for production
+  rapidkit test      # Run tests
+  rapidkit lint      # Lint code
+  rapidkit format    # Format code
+
+${a.bold("\u{1F310} API endpoints:")}
+  http://localhost:3000/health          # Health check
+  http://localhost:3000/docs            # Swagger docs
+  http://localhost:3000/examples/notes  # Example API
+`);}catch(s){throw n.fail(`Failed to create ${o} project`),s}}async function K(e,t,i){let o=await promises.readdir(e,{withFileTypes:true});for(let n of o){let s=l.join(e,n.name),p=n.name.replace(/\.j2$/,""),d=l.join(t,p);if(n.isDirectory())await promises.mkdir(d,{recursive:true}),await K(s,d,i);else {let g=await promises.readFile(s,"utf-8");n.name.endsWith(".j2")&&(g=se(g,i)),await promises.writeFile(d,g),(p==="rapidkit"||p==="activate"||p.endsWith(".py")&&d.includes(".rapidkit"))&&await promises.chmod(d,493);}}}function se(e,t){let i=e;for(let[o,n]of Object.entries(t)){let s=new RegExp(`\\{\\{\\s*${o}\\s*\\}\\}`,"g");i=i.replace(s,String(n));let p=new RegExp(`\\{\\{\\s*${o}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\}\\}`,"g");i=i.replace(p,(j,C,_)=>String(n).replace(new RegExp(C,"g"),_));let d=new RegExp(`\\{\\{\\s*${o}\\s*\\|\\s*lower\\s*\\}\\}`,"g");i=i.replace(d,String(n).toLowerCase());let g=new RegExp(`\\{\\{\\s*${o}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\|\\s*lower\\s*\\}\\}`,"g");i=i.replace(g,(j,C,_)=>String(n).replace(new RegExp(C,"g"),_).toLowerCase());}return i}var h=null,E=false,I=new Command;I.name("rapidkit").description("Create RapidKit workspaces and projects").version(w());I.argument("[name]","Name of the workspace or project directory").option("-t, --template <template>","Create project with template (fastapi, nestjs) instead of workspace").option("-y, --yes","Skip prompts and use defaults").option("--skip-git","Skip git initialization").option("--skip-install","Skip installing dependencies").option("--debug","Enable debug logging").option("--dry-run","Show what would be created without creating it").option("--no-update-check","Skip checking for updates").action(async(e,t)=>{try{t.debug&&(c.setDebug(!0),c.debug("Debug mode enabled"));let i=await U();c.debug("User config loaded",i),t.updateCheck!==!1&&await T(),console.log(a.blue.bold(`
 \u{1F680} Welcome to RapidKit!
-`)),e.demoOnly){let a=t||"my-fastapi-project";try{V(a);}catch(n){throw n instanceof u&&(s.error(`
-\u274C ${n.message}`),n.details&&s.warn(`\u{1F4A1} ${n.details}
-`),process.exit(1)),n}let m=h.resolve(process.cwd(),a);if(w=m,e.dryRun){console.log(i.cyan(`
+`)),e||(le(),process.exit(0));try{O(e);}catch(p){throw p instanceof v&&(c.error(`
+\u274C ${p.message}`),p.details&&c.warn(`\u{1F4A1} ${p.details}
+`),process.exit(1)),p}let o=l.resolve(process.cwd(),e);h=o,await k.pathExists(o)&&(c.error(`
+\u274C Directory "${e}" already exists`),console.log(a.cyan(`
+\u{1F4A1} Choose a different name or delete the existing directory.
+`)),process.exit(1));let n=!!t.template;if(n){let p=t.template.toLowerCase(),d=["fastapi","nestjs"];d.includes(p)||(c.error(`
+\u274C Invalid template: ${t.template}`),console.log(a.cyan(`
+\u{1F4E6} Available templates: ${d.join(", ")}
+`)),process.exit(1));}if(t.dryRun){console.log(a.cyan(`
 \u{1F50D} Dry-run mode - showing what would be created:
-`)),console.log(i.white("\u{1F4C2} Project path:"),m),console.log(i.white("\u{1F4E6} Project type:"),"FastAPI demo project"),console.log(i.white("\u{1F4DD} Files to create:")),console.log(i.gray("  - src/main.py")),console.log(i.gray("  - src/cli.py")),console.log(i.gray("  - src/routing/")),console.log(i.gray("  - tests/")),console.log(i.gray("  - pyproject.toml")),console.log(i.gray(`  - README.md
-`));return}let d=await oe.prompt([{type:"input",name:"project_name",message:"Project name (snake_case):",default:a.replace(/-/g,"_"),validate:n=>/^[a-z][a-z0-9_]*$/.test(n)?!0:"Please use snake_case (lowercase with underscores)"},{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"},{type:"input",name:"description",message:"Project description:",default:"FastAPI service generated with RapidKit"}]);await q(m,d);return}let r=t||"rapidkit-workspace";try{V(r);}catch(a){throw a instanceof u&&(s.error(`
-\u274C ${a.message}`),a.details&&s.warn(`\u{1F4A1} ${a.details}
-`),process.exit(1)),a}if(w=h.resolve(process.cwd(),r),e.demo){console.log(i.gray(`This will create a workspace with demo kit templates.
-You can generate demo projects inside without installing Python RapidKit.
-`)),await U(r,{skipGit:e.skipGit||o.skipGit,testMode:!1,demoMode:!0,dryRun:e.dryRun,userConfig:o});return}console.log(i.yellow.bold(`\u26A0\uFE0F  BETA NOTICE
-`)),console.log(i.yellow(`RapidKit Python package is not yet available on PyPI.
-Full installation mode will be available soon.
-`)),console.log(i.cyan(`For now, please use one of these options:
-`)),console.log(i.white("  1. Demo mode (recommended):")),console.log(i.gray(`     npx rapidkit my-workspace --demo
-`)),console.log(i.white("  2. Test mode (if you have local RapidKit):")),console.log(i.gray(`     npx rapidkit my-workspace --test-mode
-`)),e.testMode||(console.log(i.red(`\u274C Cannot proceed without --demo or --test-mode flag.
-`)),process.exit(1)),console.log(i.yellow(`\u26A0\uFE0F  Running in TEST MODE - Installing from local path
-`)),await U(r,{skipGit:e.skipGit||o.skipGit,testMode:e.testMode,demoMode:!1,dryRun:e.dryRun,userConfig:o});}catch(o){o instanceof u?(s.error(`
-\u274C ${o.message}`),o.details&&s.warn(`\u{1F4A1} ${o.details}`),s.debug("Error code:",o.code)):(s.error(`
-\u274C An unexpected error occurred:`),console.error(o)),process.exit(1);}finally{w=null;}});process.on("SIGINT",async()=>{if(!O){if(O=true,console.log(i.yellow(`
-
-\u26A0\uFE0F  Interrupted by user`)),w&&await y.pathExists(w)){console.log(i.gray("Cleaning up partial installation..."));try{await y.remove(w),console.log(i.green("\u2713 Cleanup complete"));}catch(t){s.debug("Cleanup failed:",t);}}process.exit(130);}});process.on("SIGTERM",async()=>{if(!O){if(O=true,s.debug("Received SIGTERM"),w&&await y.pathExists(w))try{await y.remove(w);}catch(t){s.debug("Cleanup failed:",t);}process.exit(143);}});Q.parse();
+`)),console.log(a.white("\u{1F4C2} Path:"),o),console.log(a.white("\u{1F4E6} Type:"),n?`Project (${t.template})`:"Workspace"),console.log();return}let s;t.yes?(s={author:process.env.USER||"RapidKit User",description:n?`${t.template==="nestjs"?"NestJS":"FastAPI"} application generated with RapidKit`:void 0,package_manager:"npm"},console.log(a.gray(`Using default values (--yes flag)
+`))):n?t.template.toLowerCase()==="fastapi"?s=await P.prompt([{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"},{type:"input",name:"description",message:"Project description:",default:"FastAPI service generated with RapidKit"}]):s=await P.prompt([{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"},{type:"input",name:"description",message:"Project description:",default:"NestJS application generated with RapidKit"},{type:"list",name:"package_manager",message:"Package manager:",choices:["npm","yarn","pnpm"],default:"npm"}]):s=await P.prompt([{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"}]),n?await B(o,{name:e,template:t.template.toLowerCase(),author:s.author,description:s.description,package_manager:s.package_manager,skipGit:t.skipGit,skipInstall:t.skipInstall}):await F(o,{name:e,author:s.author,skipGit:t.skipGit});}catch(i){i instanceof v?(c.error(`
+\u274C ${i.message}`),i.details&&c.warn(`\u{1F4A1} ${i.details}`),c.debug("Error code:",i.code)):(c.error(`
+\u274C An unexpected error occurred:`),console.error(i)),process.exit(1);}finally{h=null;}});function le(){console.log(a.white(`Usage: npx rapidkit <name> [options]
+`)),console.log(a.bold("Create a workspace (recommended):")),console.log(a.cyan("  npx rapidkit my-workspace")),console.log(a.cyan("  cd my-workspace")),console.log(a.cyan("  rapidkit create my-api --template fastapi")),console.log(a.cyan("  cd my-api")),console.log(a.cyan(`  rapidkit dev
+`)),console.log(a.bold("Or create a project directly:")),console.log(a.cyan("  npx rapidkit my-project --template fastapi")),console.log(a.cyan(`  npx rapidkit my-project --template nestjs
+`)),console.log(a.bold("Options:")),console.log(a.gray("  -t, --template <template>  Create project with template (fastapi, nestjs)")),console.log(a.gray("  -y, --yes                  Skip prompts and use defaults")),console.log(a.gray("  --skip-git                 Skip git initialization")),console.log(a.gray("  --skip-install             Skip installing dependencies")),console.log(a.gray("  --debug                    Enable debug logging")),console.log(a.gray(`  --dry-run                  Show what would be created
+`)),console.log(a.bold("Templates:")),console.log(a.gray("  fastapi    FastAPI + Python")),console.log(a.gray(`  nestjs     NestJS + TypeScript
+`));}process.on("SIGINT",async()=>{if(!E){if(E=true,console.log(a.yellow(`
+
+\u26A0\uFE0F  Interrupted by user`)),h&&await k.pathExists(h)){console.log(a.gray("Cleaning up partial installation..."));try{await k.remove(h),console.log(a.green("\u2713 Cleanup complete"));}catch(e){c.debug("Cleanup failed:",e);}}process.exit(130);}});process.on("SIGTERM",async()=>{if(!E){if(E=true,c.debug("Received SIGTERM"),h&&await k.pathExists(h))try{await k.remove(h);}catch(e){c.debug("Cleanup failed:",e);}process.exit(143);}});I.parse();