rapidkit 0.14.1 → 0.15.1

package/dist/index.js

@@ -1,449 +1,699 @@
 #!/usr/bin/env node
-import {Command}from'commander';import r from'chalk';import O from'inquirer';import l,{dirname,join}from'path';import {spawn}from'child_process';import {execa}from'execa';import k,{readFileSync,promises}from'fs';import {fileURLToPath}from'url';import le from'os';import me from'validate-npm-package-name';import*as h from'fs-extra';import A from'ora';var F=class{debugEnabled=false;setDebug(t){this.debugEnabled=t;}debug(t,...i){this.debugEnabled&&console.log(r.gray(`[DEBUG] ${t}`),...i);}info(t,...i){console.log(r.blue(t),...i);}success(t,...i){console.log(r.green(t),...i);}warn(t,...i){console.log(r.yellow(t),...i);}error(t,...i){console.error(r.red(t),...i);}step(t,i,n){console.log(r.cyan(`
-[${t}/${i}]`),r.white(n));}},m=new F;var ne="rapidkit",oe=fileURLToPath(import.meta.url),ae=dirname(oe),re=join(ae,"..","package.json"),se=JSON.parse(readFileSync(re,"utf-8")),V=se.version;async function J(){try{m.debug("Checking for updates...");let{stdout:e}=await execa("npm",["view",ne,"version"],{timeout:3e3}),t=e.trim();t&&t!==V?(console.log(r.yellow(`
-\u26A0\uFE0F  Update available: ${V} \u2192 ${t}`)),console.log(r.cyan(`Run: npm install -g rapidkit@latest
-`))):m.debug("You are using the latest version");}catch{m.debug("Could not check for updates");}}function N(){return V}var de=".rapidkitrc.json";async function W(){let e=l.join(le.homedir(),de);try{let t=await promises.readFile(e,"utf-8"),i=JSON.parse(t);return m.debug(`Loaded config from ${e}`),i}catch{return m.debug("No user config found, using defaults"),{}}}var S=class extends Error{constructor(i,n,a){super(i);this.code=n;this.details=a;this.name="RapidKitError",Error.captureStackTrace(this,this.constructor);}};var v=class extends S{constructor(t,i){super(`Invalid project name: "${t}"`,"INVALID_PROJECT_NAME",i);}};function M(e){let t=me(e);if(!t.validForNewPackages){let n=t.errors||[],a=t.warnings||[],s=[...n,...a];throw new v(e,`NPM validation failed: ${s.join(", ")}`)}if(!/^[a-z][a-z0-9_-]*$/.test(e))throw new v(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 v(e,`"${e}" is a reserved name. Please choose a different name.`);if(e.length<2)throw new v(e,"Name must be at least 2 characters long");if(e.length>214)throw new v(e,"Name must be less than 214 characters");return  true}async function H(e,t){let i=A("Creating RapidKit workspace...").start();try{await promises.mkdir(e,{recursive:!0}),await promises.mkdir(l.join(e,".rapidkit"),{recursive:!0});let n={workspace_name:t.name,author:t.author,rapidkit_version:N(),created_at:new Date().toISOString(),type:"workspace"};await promises.writeFile(l.join(e,".rapidkit","config.json"),JSON.stringify(n,null,2));let a=ge();await promises.writeFile(l.join(e,"rapidkit"),a),await promises.chmod(l.join(e,"rapidkit"),493);let s=ue(t.name);if(await promises.writeFile(l.join(e,"README.md"),s),await promises.writeFile(l.join(e,".gitignore"),`# RapidKit workspace
+import {Command,Option}from'commander';import d from'chalk';import lt from'inquirer';import y from'path';import {spawn}from'child_process';import {execa}from'execa';import {createRequire}from'module';import Q,{promises}from'fs';import*as Qt from'os';import Qt__default from'os';import Zt from'validate-npm-package-name';import*as x from'fs-extra';import ut from'ora';import ye from'nunjucks';import {fileURLToPath}from'url';var rt=class{debugEnabled=false;setDebug(e){this.debugEnabled=e;}debug(e,...i){this.debugEnabled&&console.log(d.gray(`[DEBUG] ${e}`),...i);}info(e,...i){console.log(d.blue(e),...i);}success(e,...i){console.log(d.green(e),...i);}warn(e,...i){console.log(d.yellow(e),...i);}error(e,...i){console.error(d.red(e),...i);}step(e,i,n){console.log(d.cyan(`
+[${e}/${i}]`),d.white(n));}},u=new rt;var Bt="rapidkit",Jt=createRequire(import.meta.url),Yt=Jt("../package.json"),at=Yt?.version??"0.0.0";async function wt(){try{u.debug("Checking for updates...");let{stdout:t}=await execa("npm",["view",Bt,"version"],{timeout:3e3}),e=t.trim();e&&e!==at?(console.log(d.yellow(`
+\u26A0\uFE0F  Update available: ${at} \u2192 ${e}`)),console.log(d.cyan(`Run: npm install -g rapidkit@latest
+`))):u.debug("You are using the latest version");}catch{u.debug("Could not check for updates");}}function V(){return at}var Xt=".rapidkitrc.json";async function J(){let t=y.join(Qt__default.homedir(),Xt);try{let e=await promises.readFile(t,"utf-8"),i=JSON.parse(e);return u.debug(`Loaded config from ${t}`),i}catch{return u.debug("No user config found, using defaults"),{}}}function X(t){return process.env.RAPIDKIT_DEV_PATH||t.testRapidKitPath||void 0}var _=class extends Error{constructor(i,n,o){super(i);this.code=n;this.details=o;this.name="RapidKitError",Error.captureStackTrace(this,this.constructor);}},F=class extends _{constructor(e,i){let n=i?`Python ${e}+ required, found ${i}`:`Python ${e}+ not found`;super(n,"PYTHON_NOT_FOUND","Please install Python from https://www.python.org/downloads/");}},Y=class extends _{constructor(){super("Poetry is not installed","POETRY_NOT_FOUND","Install Poetry from https://python-poetry.org/docs/#installation");}},z=class extends _{constructor(){super("pipx is not installed","PIPX_NOT_FOUND","Install pipx from https://pypa.github.io/pipx/installation/");}},Z=class extends _{constructor(e){super(`Directory "${e}" already exists`,"DIRECTORY_EXISTS","Please choose a different name or remove the existing directory");}},T=class extends _{constructor(e,i){super(`Invalid project name: "${e}"`,"INVALID_PROJECT_NAME",i);}},S=class extends _{constructor(e,i){let n=`Installation failed at: ${e}`,o=`${i.message}
+
+Troubleshooting:
+- Check your internet connection
+- Verify Python/Poetry installation
+- Try running with --debug flag for more details`;super(n,"INSTALLATION_ERROR",o);}},M=class extends _{constructor(){super("RapidKit Python package is not yet available on PyPI","RAPIDKIT_NOT_AVAILABLE",`Available options:
+  1. Install Python 3.10+ and retry the same command
+  2. Use the core workflow: npx rapidkit create workspace <name>
+  3. Offline fallback (limited): npx rapidkit create project fastapi.standard <name> --output .
+
+Legacy: set RAPIDKIT_SHOW_LEGACY=1 to reveal template-mode flags in help.`);}};function kt(t){let e=Zt(t);if(!e.validForNewPackages){let n=e.errors||[],o=e.warnings||[],r=[...n,...o];throw new T(t,`NPM validation failed: ${r.join(", ")}`)}if(!/^[a-z][a-z0-9_-]*$/.test(t))throw new T(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 T(t,`"${t}" is a reserved name. Please choose a different name.`);if(t.length<2)throw new T(t,"Name must be at least 2 characters long");if(t.length>214)throw new T(t,"Name must be less than 214 characters");return  true}function ee(t){return typeof t=="object"&&t!==null}async function ie(t,e,i,n=8e3){try{let o=await execa(t,e,{cwd:i,timeout:n,reject:!1,stdio:"pipe"});return {ok:o.exitCode===0,exitCode:o.exitCode,stdout:o.stdout,stderr:o.stderr}}catch(o){return {ok:false,exitCode:void 0,stdout:"",stderr:o instanceof Error?o.message:String(o)}}}async function ne(t,e){let i=["-m","rapidkit",...t],n=["python3","python"];for(let o of n){let r=await ie(o,i,e?.cwd,e?.timeoutMs);if(!r.ok)continue;let c=(r.stdout??"").trim();try{let a=JSON.parse(c);return ee(a)?{ok:!0,command:o,exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr,data:a}:{ok:!1,command:o,exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch{return {ok:false,command:o,exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}}return {ok:false}}async function vt(t,e){let i=await ne(["project","detect","--path",t,"--json"],e);return !i.ok||!i.data||i.data.schema_version!==1?{ok:false,command:i.command,exitCode:i.exitCode,stdout:i.stdout,stderr:i.stderr}:i}var G=class extends Error{code;constructor(e,i){super(i),this.code=e;}};function Rt(t){return t instanceof G?t.code==="PYTHON_NOT_FOUND"?"RapidKit (npm) could not find Python (python3/python) on your PATH.\nInstall Python 3.10+ and ensure `python3` is available, then retry.\nTip: if you are inside a RapidKit project, use the local ./rapidkit launcher.":`RapidKit (npm) bridge error: ${t.message}`:`RapidKit (npm) failed to run the Python core engine: ${t instanceof Error?t.message:String(t)}`}function re(){let t=process.env.RAPIDKIT_CORE_PYTHON_PACKAGE;return t&&t.trim()?t.trim():"rapidkit-core"}function jt(){let t=process.env.XDG_CACHE_HOME;return t&&t.trim()?t:y.join(Qt__default.homedir(),".cache")}function st(){return y.join(jt(),"rapidkit","npm-bridge","venv")}function xt(t){return process.platform==="win32"?y.join(t,"Scripts","python.exe"):y.join(t,"bin","python")}function bt(t){return process.platform==="win32"?y.join(t,"Scripts","rapidkit.exe"):y.join(t,"bin","rapidkit")}function ae(){return y.join(jt(),"rapidkit","npm-bridge","core-commands.json")}async function se(t){let e=!!process.env.RAPIDKIT_DEBUG,i=n=>{e&&process.stderr.write(`[DEBUG] tryRapidkit(${t}): ${n}
+`);};try{i("probing interpreter-specific rapidkit script");let o=((await execa(t,["-c","import sysconfig, os; print(os.path.join(sysconfig.get_path('scripts'), 'rapidkit'))"],{reject:!1,stdio:"pipe",timeout:2e3})).stdout??"").toString().trim();if(i(`script path: ${o}`),o)try{if(await x.pathExists(o)){i(`found script at ${o}; invoking --version --json`);let r=await execa(o,["--version","--json"],{reject:!1,stdio:"pipe",timeout:4e3});if(i(`script exitCode=${r.exitCode}`),r.exitCode===0){let c=(r.stdout??"").toString().trim();try{let a=JSON.parse(c),s=!!a&&typeof a=="object"&&a!==null&&"version"in a;if(i(`script JSON parse ok=${s}`),s)return !0}catch{i("script output not valid JSON");}}}}catch(r){i(`interpreter-specific script probe failed: ${String(r)}`);}}catch(n){i(`interpreter-specific script probe error: ${String(n)}`);}try{i('probing importlib.find_spec("rapidkit")');let n=await execa(t,["-c","import importlib.util; print(1 if importlib.util.find_spec('rapidkit') else 0)"],{reject:!1,stdio:"pipe",timeout:2e3});if(i(`import probe exitCode=${n.exitCode} stdout=${(n.stdout??"").toString().trim()}`),n.exitCode===0&&(n.stdout??"").toString().trim()==="1")return !0}catch(n){i(`import probe error: ${String(n)}`);}try{i("probing python -m rapidkit");let n=await execa(t,["-m","rapidkit","--version","--json"],{reject:!1,stdio:"pipe",timeout:8e3});if(i(`-m probe exitCode=${n.exitCode}`),n.exitCode===0)return !0}catch(n){i(`-m probe error: ${String(n)}`);}try{i("probing PATH for rapidkit executables");let n=(process.env.PATH??"").split(y.delimiter).filter(Boolean);for(let o of n){let r=y.join(o,process.platform==="win32"?"rapidkit.exe":"rapidkit");try{if(await x.pathExists(r)){i(`found candidate on PATH: ${r}; invoking --version --json`);let c=await execa(r,["--version","--json"],{reject:!1,stdio:"pipe",timeout:4e3});if(i(`candidate exitCode=${c.exitCode}`),c.exitCode===0){let a=(c.stdout??"").toString().trim();try{let s=JSON.parse(a);if(s&&typeof s=="object"&&s!==null&&"version"in s)return !0}catch{i("candidate output not valid JSON, skipping");}}}}catch(c){i(`error probing candidate ${r}: ${String(c)}`);}}return i("no valid rapidkit found on PATH"),!1}catch(n){return i(`PATH probe error: ${String(n)}`),false}}async function ct(t){let e=(t??"").toString().trim();if(!e)return  false;try{let i=JSON.parse(e);return !!i&&typeof i=="object"&&i!==null&&"version"in i}catch{return  false}}async function ce(t){let e=process.platform==="win32",i=e?y.join(".venv","Scripts","rapidkit.exe"):y.join(".venv","bin","rapidkit"),n=e?y.join(".venv","Scripts","python.exe"):y.join(".venv","bin","python"),o=t;for(let r=0;r<25;r+=1){let c=y.join(o,i);if(await x.pathExists(c)){let p=await execa(c,["--version","--json"],{reject:false,stdio:"pipe",timeout:1500,cwd:o});if(p.exitCode===0&&await ct(p.stdout))return {cmd:c,baseArgs:[]}}let a=y.join(o,n);if(await x.pathExists(a)){let p=await execa(a,["-m","rapidkit","--version","--json"],{reject:false,stdio:"pipe",timeout:1500,cwd:o});if(p.exitCode===0&&await ct(p.stdout))return {cmd:a,baseArgs:["-m","rapidkit"]}}let s=y.dirname(o);if(s===o)break;o=s;}return null}async function pe(t){if(t&&t.trim())try{let r=await ce(t);if(r)return r}catch{}let e=await tt();if(e.kind==="venv"){let r=st(),c=bt(r);return await x.pathExists(c)?{cmd:c,baseArgs:[]}:{cmd:e.pythonPath,baseArgs:["-m","rapidkit"]}}try{if((await execa(e.cmd,["-m","rapidkit","--version","--json"],{reject:!1,stdio:"pipe",timeout:4e3})).exitCode===0)return {cmd:e.cmd,baseArgs:["-m","rapidkit"]}}catch{}try{let c=((await execa(e.cmd,["-c","import sysconfig, os; print(os.path.join(sysconfig.get_path('scripts'), 'rapidkit'))"],{reject:!1,stdio:"pipe",timeout:2e3})).stdout??"").toString().trim();if(c&&await x.pathExists(c))try{let a=await execa(c,["--version","--json"],{reject:!1,stdio:"pipe",timeout:4e3});if(a.exitCode===0&&await ct(a.stdout))return {cmd:c,baseArgs:[]}}catch{}}catch{}let i=st(),n=await pt(e.cmd),o=bt(i);return await x.pathExists(o)?{cmd:o,baseArgs:[]}:{cmd:n,baseArgs:["-m","rapidkit"]}}async function Pt(){for(let t of ["python3","python"])try{return await execa(t,["--version"],{reject:!1,stdio:"pipe",timeout:2e3}),t}catch{}return null}async function pt(t){let e=st(),i=xt(e);if(await x.pathExists(i))return i;let n={...process.env,PIP_DISABLE_PIP_VERSION_CHECK:"1",PIP_NO_PYTHON_VERSION_WARNING:"1"},o=async(r,c)=>{let a=await execa(r,c,{reject:false,stdio:["ignore","pipe","inherit"],env:n});if(a.exitCode===0)return;let s=(a.stdout??"").toString(),p=(a.stderr??"").toString(),f=[s,p].filter(Boolean).join(`
+`),m=f?`${r} ${c.join(" ")}
+${f}`:`${r} ${c.join(" ")}`;throw new Error(m)};try{await x.ensureDir(y.dirname(e)),await o(t,["-m","venv",e]);let r=xt(e);return process.env.RAPIDKIT_BRIDGE_UPGRADE_PIP==="1"&&await o(r,["-m","pip","install","-U","pip"]),await o(r,["-m","pip","install","-U",re()]),r}catch(r){throw new G("BRIDGE_VENV_BOOTSTRAP_FAILED",Rt(r))}}async function tt(){if(process.env.RAPIDKIT_BRIDGE_FORCE_VENV==="1"){let i=await Pt();if(!i)throw new G("PYTHON_NOT_FOUND","No Python interpreter found (python3/python).");return {kind:"venv",pythonPath:await pt(i)}}for(let i of ["python3","python"])if(await se(i))return {kind:"system",cmd:i};let t=await Pt();if(!t)throw new G("PYTHON_NOT_FOUND","No Python interpreter found (python3/python).");return {kind:"venv",pythonPath:await pt(t)}}async function $(t,e){try{let i=await pe(e?.cwd),n=i.cmd,o=[...i.baseArgs,...t],r=await execa(n,o,{cwd:e?.cwd,env:{...process.env,...e?.env},reject:!1,stdio:"inherit"});return typeof r.exitCode=="number"?r.exitCode:1}catch(i){return process.stderr.write(`${Rt(i)}
+`),1}}async function de(){let t=ae();if(!await x.pathExists(t))return null;try{let e=await x.readJson(t);if(e&&e.schema_version===1&&Array.isArray(e.commands))return e}catch{}return null}async function _t(){let e=Date.now(),i=await de();return !i||e-i.fetched_at>=864e5||!i.commands?.length?null:new Set(i.commands)}var le=["version","project","create","init","dev","start","build","test","lint","format","add","list","info","upgrade","diff","doctor","license","reconcile","rollback","uninstall","checkpoint","optimize","snapshot","frameworks","modules","merge"],Ct=new Set(le);function dt(){return process.platform==="win32"?"python":"python3"}async function It(t,e){let i=y.join(t,".rapidkit-workspace"),n={signature:"RAPIDKIT_VSCODE_WORKSPACE",createdBy:"rapidkit-npm",version:V(),createdAt:new Date().toISOString(),name:e};await x.outputFile(i,JSON.stringify(n,null,2)+`
+`,"utf-8");}async function St(t){await x.outputFile(y.join(t,".gitignore"),`.venv/
+__pycache__/
+*.pyc
 .env
-.env.*
-!.env.example
+.rapidkit-workspace/
 
-# OS
-.DS_Store
-Thumbs.db
+`,"utf-8");}function q(){let t=y.join(Qt.homedir(),".local","bin"),i=(process.env.PATH||"").split(y.delimiter).filter(Boolean);i.includes(t)||(process.env.PATH=[t,...i].join(y.delimiter));}async function $t(t,e){q(),t.start("Checking pipx installation");try{return await execa("pipx",["--version"]),t.succeed("pipx found"),{kind:"binary"}}catch{}let i=dt();try{return await execa(i,["-m","pipx","--version"]),t.succeed("pipx found"),{kind:"python-module",pythonCmd:i}}catch{}if(e)throw new z;let{installPipx:n}=await lt.prompt([{type:"confirm",name:"installPipx",message:"pipx is not installed. Install it now (user install via python -m pip)?",default:true}]);if(!n)throw new z;t.start("Installing pipx (user install)");try{try{await execa(i,["-m","pip","install","--user","--upgrade","pip"]);}catch{}await execa(i,["-m","pip","install","--user","--upgrade","pipx"]);}catch(o){let r=o,c=String(r?.stderr||r?.shortMessage||r?.message||"");throw new S("Install pipx with python -m pip",o instanceof Error?o:new Error(c))}t.succeed("pipx installed"),q();try{return await execa(i,["-m","pipx","--version"]),{kind:"python-module",pythonCmd:i}}catch(o){let r=o,c=String(r?.stderr||r?.shortMessage||r?.message||"pipx not runnable after install");throw new S("Verify pipx after install",new Error(`${c}
 
-# IDEs
-.vscode/
-.idea/
+Try reopening your terminal or run: python3 -m pipx ensurepath`))}}async function et(t,e){return t.kind==="binary"?execa("pipx",e):execa(t.pythonCmd,["-m","pipx",...e])}async function ue(t,e){q(),t.start("Checking Poetry installation");try{await execa("poetry",["--version"]),t.succeed("Poetry found");return}catch{}if(e)throw new Y;let{installPoetry:i}=await lt.prompt([{type:"confirm",name:"installPoetry",message:"Poetry is not installed. Install it now using pipx?",default:true}]);if(!i)throw new Y;let n=await $t(t,e);t.start("Installing Poetry with pipx");try{await et(n,["install","poetry"]);}catch(o){let r=o,c=String(r?.stderr||r?.shortMessage||r?.message||"");if(/already\s+installed|already\s+seems\s+to\s+be\s+installed|exists/i.test(c))try{await et(n,["upgrade","poetry"]);}catch{}else throw new S("Install Poetry with pipx",o instanceof Error?o:new Error(c))}t.succeed("Poetry installed"),q();try{await execa("poetry",["--version"]);}catch(o){let r=o,c=String(r?.stderr||r?.shortMessage||r?.message||"Poetry not found on PATH");throw new S("Verify Poetry after pipx install",new Error(`${c}
 
-# Logs
-*.log
-`),await fe(e),i.succeed("Workspace created!"),!t.skipGit){let o=A("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}),o.succeed("Git repository initialized");}catch{o.warn("Could not initialize git repository");}}console.log(`
-${r.green("\u2728 RapidKit workspace created successfully!")}
+Poetry may be installed but not on PATH yet. Try reopening your terminal or run: pipx ensurepath`))}}function me(t){let e=t==="poetry";return `#!/usr/bin/env sh
+set -eu
 
-${r.bold("\u{1F4C2} Workspace structure:")}
-${e}/
-  \u251C\u2500\u2500 rapidkit            # Local CLI wrapper
-  \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
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
 
-${r.bold("\u{1F680} Get started:")}
-  ${r.cyan(`cd ${t.name}`)}
-  ${r.cyan("npx rapidkit my-api --template fastapi")}
-  ${r.cyan("cd my-api")}
-  ${r.cyan("npx rapidkit init")}
-  ${r.cyan("npx rapidkit dev")}
-
-${r.bold("\u{1F4E6} Available templates:")}
-  fastapi   - FastAPI + Python (default)
-  nestjs    - NestJS + TypeScript
-
-${r.bold("\u{1F4DA} Commands:")}
-  npx rapidkit <name> --template <type>   Create a new project
-  npx rapidkit init                       Install dependencies
-  npx rapidkit dev                        Start dev server
-  npx rapidkit help                       Show all commands
-
-${r.gray("Alternative: ./rapidkit dev, make dev")}
-${r.gray("\u{1F4A1} Tip: Install globally (npm i -g rapidkit) to use without npx")}
-`);}catch(n){throw i.fail("Failed to create workspace"),n}}function ge(){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
-}
+VENV_RAPIDKIT="$SCRIPT_DIR/.venv/bin/rapidkit"
+if [ -x "$VENV_RAPIDKIT" ]; then
+  exec "$VENV_RAPIDKIT" "$@"
+fi
 
-# 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
-}
+${e?`if command -v poetry >/dev/null 2>&1 && [ -f "$SCRIPT_DIR/pyproject.toml" ]; then
+  exec poetry run rapidkit "$@"
+fi
 
-# 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 ""
-}
+`:""}echo "RapidKit launcher could not find a local Python CLI." 1>&2
+echo "- If you used venv: ensure .venv exists (or re-run the installer)." 1>&2
+${e?`echo "- If you used Poetry: run 'poetry install' and retry, or activate the env." 1>&2
+`:""}echo "Tip: you can also run: ./.venv/bin/rapidkit --help" 1>&2
+exit 1
+`}function ge(t){return `@echo off
+setlocal
+
+set "SCRIPT_DIR=%~dp0"
+
+if exist "%SCRIPT_DIR%\\.venv\\Scripts\\rapidkit.exe" (
+  "%SCRIPT_DIR%\\.venv\\Scripts\\rapidkit.exe" %*
+  exit /b %ERRORLEVEL%
+)
+
+${t==="poetry"?`where poetry >nul 2>nul
+if %ERRORLEVEL%==0 if exist "%SCRIPT_DIR%\\pyproject.toml" (
+  poetry run rapidkit %*
+  exit /b %ERRORLEVEL%
+)
+
+`:""}echo RapidKit launcher could not find a local Python CLI. 1>&2
+echo Tip: run .venv\\Scripts\\rapidkit.exe --help 1>&2
+exit /b 1
+`}async function At(t,e){await x.outputFile(y.join(t,"rapidkit"),me(e),{encoding:"utf-8",mode:493}),await x.outputFile(y.join(t,"rapidkit.cmd"),ge(e),"utf-8");}async function Tt(t,e){let{skipGit:i=false,testMode:n=false,demoMode:o=false,dryRun:r=false,yes:c=false,userConfig:a={}}=e,s=t||"rapidkit",p=y.resolve(process.cwd(),s);if(await x.pathExists(p))throw new Z(s);if(r){await he(p,s,o,a);return}if(o){await fe(p,s,i);return}let f=c?{pythonVersion:a.pythonVersion||"3.10",installMethod:a.defaultInstallMethod||"venv"}:await lt.prompt([{type:"list",name:"pythonVersion",message:"Select Python version for RapidKit:",choices:["3.10","3.11","3.12"],default:a.pythonVersion||"3.10"},{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:a.defaultInstallMethod||"venv"}]);u.step(1,3,"Setting up RapidKit environment");let m=ut("Creating directory").start();try{if(await x.ensureDir(p),m.succeed("Directory created"),await It(p,s),await St(p),f.installMethod==="poetry"?await Ot(p,f.pythonVersion,m,n,a,c):f.installMethod==="venv"?await Dt(p,f.pythonVersion,m,n,a):await Nt(p,m,n,a,c),await At(p,f.installMethod),await Kt(p,f.installMethod),m.succeed("RapidKit environment ready!"),!e.skipGit){m.start("Initializing git repository");try{await execa("git",["init"],{cwd:p}),await execa("git",["add","."],{cwd:p}),await execa("git",["commit","-m","Initial commit: RapidKit environment"],{cwd:p}),m.succeed("Git repository initialized");}catch{m.warn("Could not initialize git repository");}}if(console.log(d.green(`
+\u2728 RapidKit environment created successfully!
+`)),console.log(d.cyan("\u{1F4C2} Location:"),d.white(p)),console.log(d.cyan(`\u{1F680} Get started:
+`)),console.log(d.white(`   cd ${s}`)),f.installMethod==="poetry"){let P="source $(poetry env info --path)/bin/activate";try{q();let{stdout:A}=await execa("poetry",["--version"]),w=A.match(/Poetry.*?(\d+)\.(\d+)/);w&&(parseInt(w[1])>=2?P="source $(poetry env info --path)/bin/activate":P="poetry shell");}catch{}console.log(d.white(`   ${P}  # Or: poetry run rapidkit`)),console.log(d.white("   rapidkit create  # Interactive mode")),console.log(d.white("   cd <project-name> && rapidkit init && rapidkit dev"));}else f.installMethod==="venv"?(console.log(d.white("   source .venv/bin/activate  # On Windows: .venv\\Scripts\\activate")),console.log(d.white("   rapidkit create  # Interactive mode")),console.log(d.white("   cd <project-name> && rapidkit init && rapidkit dev"))):(console.log(d.white("   rapidkit create  # Interactive mode")),console.log(d.white("   cd <project-name> && rapidkit init && rapidkit dev")));console.log(d.white(`
+\u{1F4A1} For more information, check the README.md file.`)),console.log(d.cyan(`
+\u{1F4DA} RapidKit commands:`)),console.log(d.white("   rapidkit create          - Create a new project (interactive)")),console.log(d.white("   rapidkit dev             - Run development server")),console.log(d.white("   rapidkit add module <name> - Add a module (e.g., settings)")),console.log(d.white("   rapidkit list            - List available kits")),console.log(d.white("   rapidkit modules         - List available modules")),console.log(d.white(`   rapidkit --help          - Show all commands
+`));}catch(P){m.fail("Failed to create RapidKit environment"),console.error(d.red(`
+\u274C Error:`),P);try{await x.remove(p);}catch{}throw P}}async function Ot(t,e,i,n,o,r=false){await ue(i,r),i.start("Initializing Poetry project"),await execa("poetry",["init","--no-interaction","--python",`^${e}`],{cwd:t});let c=y.join(t,"pyproject.toml"),s=(await promises.readFile(c,"utf-8")).replace("[tool.poetry]",`[tool.poetry]
+package-mode = false`);await promises.writeFile(c,s,"utf-8"),i.succeed("Poetry project initialized"),i.start("Configuring Poetry to create in-project virtualenv");try{await execa("poetry",["config","virtualenvs.in-project","true"],{cwd:t}),i.succeed("Poetry configured");}catch{i.warn("Could not configure Poetry virtualenvs.in-project");}if(i.start("Installing RapidKit"),n){let p=X(o||{});if(!p)throw new S("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));u.debug(`Installing from local path: ${p}`),i.text="Installing RapidKit from local path (test mode)",await execa("poetry",["add",p],{cwd:t});}else {i.text="Installing RapidKit from PyPI";try{await execa("poetry",["add","rapidkit-core"],{cwd:t});}catch{throw new M}}i.succeed("RapidKit installed");}async function Dt(t,e,i,n,o){i.start(`Checking Python ${e}`);let r=dt();try{let{stdout:a}=await execa(r,["--version"]),s=a.match(/Python (\d+\.\d+)/)?.[1];if(s&&parseFloat(s)<parseFloat(e))throw new F(e,s);i.succeed(`Python ${s} found`);}catch(a){throw a instanceof F?a:new F(e)}i.start("Creating virtual environment"),await execa(r,["-m","venv",".venv"],{cwd:t}),i.succeed("Virtual environment created"),i.start("Installing RapidKit");let c=y.join(t,".venv",process.platform==="win32"?"Scripts":"bin",process.platform==="win32"?"python.exe":"python");if(await execa(c,["-m","pip","install","--upgrade","pip"],{cwd:t}),n){let a=X(o||{});if(!a)throw new S("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));u.debug(`Installing from local path: ${a}`),i.text="Installing RapidKit from local path (test mode)",await execa(c,["-m","pip","install","-e",a],{cwd:t});}else {i.text="Installing RapidKit from PyPI";try{await execa(c,["-m","pip","install","rapidkit-core"],{cwd:t});}catch{throw new M}}i.succeed("RapidKit installed");}async function Nt(t,e,i,n,o=false){let r=await $t(e,o);if(e.start("Installing RapidKit globally with pipx"),i){let c=X(n||{});if(!c)throw new S("Test mode installation",new Error("No local RapidKit path configured. Set RAPIDKIT_DEV_PATH environment variable."));u.debug(`Installing from local path: ${c}`),e.text="Installing RapidKit from local path (test mode)",await et(r,["install","-e",c]);}else {e.text="Installing RapidKit from PyPI";try{await et(r,["install","rapidkit-core"]);}catch{throw new M}}e.succeed("RapidKit installed globally"),await x.outputFile(y.join(t,".rapidkit-global"),`RapidKit installed globally with pipx
+`,"utf-8");}async function K(t,e){let{skipGit:i=false,testMode:n=false,userConfig:o={},yes:r=false,installMethod:c,pythonVersion:a="3.10"}=e||{};await It(t,y.basename(t)),await St(t);let s=ut("Registering workspace").start();try{let p=c||o.defaultInstallMethod||"venv";if(p==="poetry"?await Ot(t,a,s,n,o,r):p==="venv"?await Dt(t,a,s,n,o):await Nt(t,s,n,o,r),await At(t,p),await Kt(t,p),s.succeed("Workspace registered"),!i){s.start("Initializing git repository");try{await execa("git",["init"],{cwd:t}),await execa("git",["add","."],{cwd:t}),await execa("git",["commit","-m","Initial commit: RapidKit workspace"],{cwd:t}),s.succeed("Git repository initialized");}catch{s.warn("Could not initialize git repository");}}}catch(p){throw s.fail("Failed to register workspace"),p}}async function Kt(t,e){let o=`# RapidKit Workspace
+
+This directory contains a RapidKit development environment.
+
+## Installation Method
+
+**${e==="poetry"?"Poetry":e==="venv"?"Python venv + pip":"pipx (global)"}**
+
+## Getting Started
+
+### 0. Run Without Activation (Recommended)
+
+This workspace includes a local launcher script so you can run the Python Core CLI without activating the environment:
+
+\`\`\`bash
+${e==="poetry"?`# No activation needed (recommended):
+./rapidkit --help
+# or:
+poetry run rapidkit --help`:e==="venv"?`# No activation needed (recommended):
+./rapidkit --help
+# or direct:
+./.venv/bin/rapidkit --help`:`# Optional: use the local launcher
+./rapidkit --help
+# (pipx installs may require Poetry/venv to be present in this folder)`}
+\`\`\`
+
+### 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
 
-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 ""
+# 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
+
+## RapidKit Documentation
+
+For full documentation, visit: [RapidKit Docs](https://getrapidkit.com) *(or appropriate URL)*
+
+## Workspace Structure
+
+\`\`\`
+${e==="venv"?".venv/          # Python virtual environment":""}
+${e==="poetry"?"pyproject.toml  # Poetry configuration":""}
+my-project/     # Your RapidKit projects go here
+README.md       # This file
+\`\`\`
+
+## 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(y.join(t,"README.md"),o,"utf-8");}async function fe(t,e,i){let n=ut("Creating demo workspace").start();try{await x.ensureDir(t),n.succeed("Directory created"),n.start("Setting up demo kit generator");let o=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(y.join(t,"package.json"),o,"utf-8"),await promises.writeFile(y.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);
 }
 
-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 ""
+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);
+    });
+  });
 }
 
-# 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"
+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"
+    ])
+
+
+def test():
+    """Run tests."""
+    print("\u{1F9EA} Running tests...")
+    subprocess.run([sys.executable, "-m", "pytest", "-q"])
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python -m src.cli <command>")
+        print("Commands: dev, start, test")
+        sys.exit(1)
     
-    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
-}
+    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.10.14"
+fastapi = "^0.128.0"
+uvicorn = {extras = ["standard"], version = "^0.40.0"}
+pydantic = "^2.12.5"
+pydantic-settings = "^2.12.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^9.0.2"
+pytest-asyncio = "^1.3.0"
+pytest-cov = "^7.0.0"
+httpx = "^0.28.1"
+black = "^25.12.0"
+ruff = "^0.14.10"
+mypy = "^1.19.1"
+
+[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
+npx rapidkit init       # Install dependencies
+npx rapidkit dev        # Start dev server
+\\\`\\\`\\\`
+
+## Available commands
+
+\\\`\\\`\\\`bash
+npx rapidkit init       # \u{1F527} Install dependencies
+npx rapidkit dev        # \u{1F680} Start development server with hot reload
+npx rapidkit start      # \u26A1 Start production server
+npx rapidkit test       # \u{1F9EA} Run tests
+npx 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/
 
-# 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}"
-                    
-                    # Source activate script first to ensure Poetry is available
-                    if [[ -f ".rapidkit/activate" ]]; then
-                        source .rapidkit/activate
-                    fi
-                    
-                    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}"
-                    
-                    # Source activate script first to ensure environment is ready
-                    if [[ -f ".rapidkit/activate" ]]; then
-                        source .rapidkit/activate
-                    fi
-                    
-                    $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
-}
+# Virtual environments
+.venv/
+venv/
+
+# IDEs
+.vscode/
+.idea/
+
+# OS
+.DS_Store
 
-# 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${N()}"
-            ;;
-        *)
-            echo -e "\${RED}\u274C Unknown command: $cmd\${NC}"
-            echo ""
-            print_help
-            exit 1
-            ;;
-    esac
+# 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}
+  npx rapidkit init   # Install dependencies
+  npx rapidkit dev    # Start dev server
+
+\u{1F4DA} Available commands:
+  npx rapidkit init   # \u{1F527} Install dependencies
+  npx rapidkit dev    # \u{1F680} Start dev server with hot reload
+  npx rapidkit start  # \u26A1 Start production server
+  npx rapidkit test   # \u{1F9EA} Run tests
+  npx rapidkit help   # \u{1F4DA} Show help
+
+\u{1F4A1} For full RapidKit features: pipx install rapidkit
+\`);
 }
 
-main "$@"
-`}function ue(e){return `# ${e}
+main().catch(console.error);
+`,"utf-8");try{await execa("chmod",["+x",y.join(t,"generate-demo.js")]);}catch{}let c=`# RapidKit Demo Workspace
+
+Welcome to your RapidKit demo workspace! This environment lets you generate FastAPI demo projects using bundled RapidKit templates, without needing to install Python RapidKit.
 
-RapidKit workspace for building API projects.
+## \u{1F680} Quick Start
 
-## Quick Start
+### Generate Your First Demo Project
 
 \`\`\`bash
-# Add rapidkit to PATH (or use ./rapidkit)
-export PATH="$PWD:$PATH"
+# Generate a demo project:
+node generate-demo.js my-api
 
-# Create a FastAPI project
-npx rapidkit my-api --template fastapi
+# Navigate to the project:
+cd my-api
 
-# Or create a NestJS project
-npx rapidkit my-app --template nestjs
+# Install dependencies:
+rapidkit init
 
-# Enter project and start development
-cd my-api
-npx rapidkit init    # Install dependencies
-npx rapidkit dev     # Start dev server
+# Run the development server:
+rapidkit dev
 \`\`\`
 
-## Available Templates
+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
+\`\`\`
 
-| Template | Stack | Description |
-|----------|-------|-------------|
-| \`fastapi\` | Python + FastAPI | High-performance Python API |
-| \`nestjs\` | TypeScript + NestJS | Enterprise Node.js framework |
+Each project is independent and has its own dependencies.
 
-## Commands
+## \u{1F3AF} What's Included
 
-### Commands
+Each generated demo project contains:
 
-| Command | Description |
-|---------|-------------|
-| \`npx rapidkit <name> --template <type>\` | Create a new project |
-| \`npx rapidkit init\` | Install dependencies |
-| \`npx rapidkit dev\` | Start development server |
-| \`npx rapidkit start\` | Start production server |
-| \`npx rapidkit build\` | Build for production |
-| \`npx rapidkit test\` | Run tests |
-| \`npx rapidkit lint\` | Run linting |
-| \`npx rapidkit format\` | Format code |
+- **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
 
-## Learn More
+## \u{1F4DA} Next Steps
 
-- [RapidKit Documentation](https://rapidkit.dev)
-- [GitHub Repository](https://github.com/Baziar/rapidkit)
-`}async function fe(e){let{fileURLToPath:t}=await import('url'),i=t(import.meta.url),n=l.dirname(i),a=l.resolve(n,".."),s=l.join(a,"templates","kits"),c=l.join(e,".rapidkit","templates"),{default:o}=await import('fs-extra');await o.copy(s,c);let d=l.join(a,"templates","generator.js"),f=l.join(e,".rapidkit","generator.js");await o.copy(d,f);}async function Y(e,t){let i=t.template==="fastapi",n=i?"FastAPI":"NestJS",a=A(`Creating ${n} project...`).start();try{let{fileURLToPath:s}=await import('url'),c=s(import.meta.url),o=l.dirname(c),d=l.resolve(o,".."),f=i?"fastapi-standard":"nestjs-standard",$=l.join(d,"templates","kits",f);await promises.mkdir(e,{recursive:!0});let j={project_name:i?t.name.replace(/-/g,"_").toLowerCase():t.name.replace(/_/g,"-").toLowerCase(),author:t.author,description:t.description||`${n} application generated with RapidKit`,app_version:"0.1.0",license:"MIT",package_manager:t.package_manager||"npm",created_at:new Date().toISOString(),rapidkit_version:N()};await z($,e,j);let _=i?`# Python
+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://getrapidkit.com)
+
+## \u26A0\uFE0F Demo Mode Limitations
+
+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
+
+For full RapidKit features, install the Python package:
+
+\`\`\`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
+
+---
+
+**Generated with RapidKit** | [GitHub](https://github.com/getrapidkit/rapidkit-npm)
+`;if(await promises.writeFile(y.join(t,"README.md"),c,"utf-8"),n.succeed("Demo workspace setup complete"),!i){n.start("Initializing git repository");try{await execa("git",["init"],{cwd:t}),await x.outputFile(y.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}),n.succeed("Git repository initialized");}catch{n.warn("Could not initialize git repository");}}console.log(d.green(`
+\u2728 Demo workspace created successfully!
+`)),console.log(d.cyan("\u{1F4C2} Location:"),d.white(t)),console.log(d.cyan(`\u{1F680} Get started:
+`)),console.log(d.white(`   cd ${e}`)),console.log(d.white("   node generate-demo.js my-api")),console.log(d.white("   cd my-api")),console.log(d.white("   rapidkit init")),console.log(d.white("   rapidkit dev")),console.log(),console.log(d.yellow("\u{1F4A1} Note:"),"This is a demo workspace. For full RapidKit features:"),console.log(d.cyan("   pipx install rapidkit")),console.log();}catch(o){throw n.fail("Failed to create demo workspace"),o}}async function he(t,e,i,n){console.log(d.cyan(`
+\u{1F50D} Dry-run mode - showing what would be created:
+`)),console.log(d.white("\u{1F4C2} Project path:"),t),console.log(d.white("\u{1F4E6} Project type:"),i?"Demo workspace":"Full RapidKit environment"),i?(console.log(d.white(`
+\u{1F4DD} Files to create:`)),console.log(d.gray("  - package.json")),console.log(d.gray("  - generate-demo.js (project generator)")),console.log(d.gray("  - README.md")),console.log(d.gray("  - .gitignore")),console.log(d.white(`
+\u{1F3AF} Capabilities:`)),console.log(d.gray("  - Generate multiple FastAPI demo projects")),console.log(d.gray("  - No Python RapidKit installation required")),console.log(d.gray("  - Bundled templates included"))):(console.log(d.white(`
+\u2699\uFE0F  Configuration:`)),console.log(d.gray(`  - Python version: ${n.pythonVersion||"3.10"}`)),console.log(d.gray(`  - Install method: ${n.defaultInstallMethod||"poetry"}`)),console.log(d.gray(`  - Git initialization: ${n.skipGit?"No":"Yes"}`)),console.log(d.white(`
+\u{1F4DD} Files to create:`)),console.log(d.gray("  - pyproject.toml (Poetry) or .venv/ (venv)")),console.log(d.gray("  - README.md")),console.log(d.gray("  - .gitignore")),console.log(d.white(`
+\u{1F3AF} Next steps after creation:`)),console.log(d.gray("  1. Install RapidKit Python package")),console.log(d.gray("  2. Create projects with rapidkit CLI")),console.log(d.gray("  3. Add modules and customize"))),console.log(d.white(`
+\u{1F4A1} To proceed with actual creation, run without --dry-run flag
+`));}var ke=fileURLToPath(import.meta.url),ve=y.dirname(ke);async function Vt(t,e){let n=(e.template||"fastapi")==="fastapi",o=n?"FastAPI":"NestJS",r=ut(`Generating ${o} project...`).start();try{let c=y.resolve(ve,".."),a=n?"fastapi-standard":"nestjs-standard",s=y.join(c,"templates","kits",a),p=ye.configure(s,{autoescape:!1,trimBlocks:!0,lstripBlocks:!0}),f={project_name:e.project_name,author:e.author||"RapidKit User",description:e.description||(n?"FastAPI service generated with RapidKit":"NestJS application generated with RapidKit"),app_version:e.app_version||"0.1.0",license:e.license||"MIT",package_manager:e.package_manager||"npm",created_at:new Date().toISOString(),rapidkit_version:V()},m;n?m=["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","Makefile.j2",".rapidkit/__init__.py.j2",".rapidkit/project.json.j2",".rapidkit/cli.py.j2",".rapidkit/rapidkit.j2",".rapidkit/activate.j2","rapidkit.j2","rapidkit.cmd.j2"]:m=["src/main.ts.j2","src/app.module.ts.j2","src/app.controller.ts.j2","src/app.service.ts.j2","src/config/configuration.ts.j2","src/config/validation.ts.j2","src/config/index.ts.j2","src/modules/index.ts.j2","src/examples/examples.module.ts.j2","src/examples/examples.controller.ts.j2","src/examples/examples.service.ts.j2","src/examples/dto/create-note.dto.ts.j2","test/app.controller.spec.ts.j2","test/examples.controller.spec.ts.j2","test/app.e2e-spec.ts.j2","test/jest-e2e.json.j2","package.json.j2","tsconfig.json.j2","tsconfig.build.json.j2","nest-cli.json.j2","jest.config.ts.j2",".eslintrc.js.j2",".prettierrc.j2",".nvmrc.j2",".node-version.j2",".env.example.j2","README.md.j2",".rapidkit/project.json.j2",".rapidkit/rapidkit.j2",".rapidkit/rapidkit.cmd.j2",".rapidkit/activate.j2","rapidkit.j2","rapidkit.cmd.j2"];for(let w of m){let C=y.join(s,w);try{await promises.access(C);}catch{continue}let ht=await promises.readFile(C,"utf-8"),Wt=p.renderString(ht,f),B=w.replace(/\.j2$/,""),ot=y.join(t,B);await promises.mkdir(y.dirname(ot),{recursive:!0}),await promises.writeFile(ot,Wt),(B.endsWith(".rapidkit/rapidkit")||B.endsWith(".rapidkit/cli.py")||B.endsWith(".rapidkit/activate")||B==="rapidkit")&&await promises.chmod(ot,493);}let P=n?`# Python
 __pycache__/
 *.py[cod]
 *$py.class
@@ -511,11 +761,11 @@ Thumbs.db
 
 # Coverage
 coverage/
-`;if(await promises.writeFile(l.join(e,".gitignore"),_),a.succeed(`${n} project created!`),!t.skipGit){let w=A("Initializing git repository...").start();try{await execa("git",["init"],{cwd:e}),await execa("git",["add","."],{cwd:e}),await execa("git",["commit","-m",`Initial commit: ${n} project via RapidKit`],{cwd:e}),w.succeed("Git repository initialized");}catch{w.warn("Could not initialize git repository");}}if(!t.skipInstall&&!i){let w=t.package_manager||"npm",D=A(`Installing dependencies with ${w}...`).start();try{await execa(w,["install"],{cwd:e}),D.succeed("Dependencies installed");}catch{D.warn(`Could not install dependencies. Run '${w} install' manually.`);}}let L=l.basename(e);console.log(i?`
-${r.green("\u2728 FastAPI project created successfully!")}
+`;if(await promises.writeFile(y.join(t,".gitignore"),P),r.succeed(`${o} project generated!`),!e.skipGit){let w=ut("Initializing git repository...").start();try{await execa("git",["init"],{cwd:t}),await execa("git",["add","."],{cwd:t}),await execa("git",["commit","-m",`Initial commit: ${o} project via RapidKit`],{cwd:t}),w.succeed("Git repository initialized");}catch{w.warn("Could not initialize git repository");}}if(!n&&!e.skipInstall){let w=e.package_manager||"npm",C=ut(`Installing dependencies with ${w}...`).start();try{await execa(w,w==="yarn"?["install"]:w==="pnpm"?["install"]:["install"],{cwd:t}),C.succeed("Dependencies installed");}catch{C.warn(`Could not install dependencies. Run '${w} install' manually.`);}}let A=y.basename(t);console.log(n?`
+${d.green("\u2728 FastAPI project created successfully!")}
 
-${r.bold("\u{1F4C2} Project structure:")}
-${e}/
+${d.bold("\u{1F4C2} Project structure:")}
+${t}/
   \u251C\u2500\u2500 .rapidkit/           # RapidKit CLI module
   \u251C\u2500\u2500 src/
   \u2502   \u251C\u2500\u2500 main.py          # FastAPI application
@@ -526,12 +776,12 @@ ${e}/
   \u251C\u2500\u2500 pyproject.toml       # Poetry configuration
   \u2514\u2500\u2500 README.md
 
-${r.bold("\u{1F680} Get started:")}
-  ${r.cyan(`cd ${L}`)}
-  ${r.cyan("npx rapidkit init")}          ${r.gray("# Install dependencies")}
-  ${r.cyan("npx rapidkit dev")}           ${r.gray("# Start dev server")}
+${d.bold("\u{1F680} Get started:")}
+  ${d.cyan(`cd ${A}`)}
+  ${d.cyan("npx rapidkit init")}          ${d.gray("# Install dependencies")}
+  ${d.cyan("npx rapidkit dev")}           ${d.gray("# Start dev server")}
 
-${r.bold("\u{1F4DA} Available commands:")}
+${d.bold("\u{1F4DA} Available commands:")}
   npx rapidkit init    # Install dependencies (poetry install)
   npx rapidkit dev     # Start dev server with hot reload
   npx rapidkit start   # Start production server
@@ -539,30 +789,30 @@ ${r.bold("\u{1F4DA} Available commands:")}
   npx rapidkit lint    # Lint code
   npx rapidkit format  # Format code
 
-${r.gray("Alternative: make dev, ./rapidkit dev, poetry run dev")}
-${r.gray("\u{1F4A1} Tip: Install globally (npm i -g rapidkit) to use without npx")}
+${d.gray("Alternative: make dev, ./rapidkit dev, poetry run dev")}
+${d.gray("\u{1F4A1} Tip: Install globally (npm i -g rapidkit) to use without npx")}
 `:`
-${r.green("\u2728 NestJS project created successfully!")}
+${d.green("\u2728 NestJS project created successfully!")}
 
-${r.bold("\u{1F4C2} Project structure:")}
-${e}/
+${d.bold("\u{1F4C2} Project structure:")}
+${t}/
   \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
+  \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
 
-${r.bold("\u{1F680} Get started:")}
-  ${r.cyan(`cd ${L}`)}
-  ${t.skipInstall?r.cyan("npx rapidkit init")+r.gray("         # npm install")+`
-  `:""}${r.cyan("cp .env.example .env")}
-  ${r.cyan("npx rapidkit dev")}           ${r.gray("# Start dev server")}
+${d.bold("\u{1F680} Get started:")}
+  ${d.cyan(`cd ${A}`)}
+  ${d.cyan("npx rapidkit init")}          ${d.gray("# Install dependencies")}
+  ${d.cyan("cp .env.example .env")}
+  ${d.cyan("npx rapidkit dev")}           ${d.gray("# Start dev server")}
 
-${r.bold("\u{1F4DA} Available commands:")}
+${d.bold("\u{1F4DA} Available commands:")}
   npx rapidkit init    # Install dependencies
   npx rapidkit dev     # Start dev server with hot reload
   npx rapidkit start   # Start production server
@@ -571,16 +821,28 @@ ${r.bold("\u{1F4DA} Available commands:")}
   npx rapidkit lint    # Lint code
   npx rapidkit format  # Format code
 
-${r.bold("\u{1F310} API endpoints:")}
+${d.bold("\u{1F310} API endpoints:")}
   http://localhost:8000/health          # Health check
   http://localhost:8000/docs            # Swagger docs
   http://localhost:8000/examples/notes  # Example API
 
-${r.gray("\u{1F4A1} Tip: Install globally (npm i -g rapidkit) to use without npx")}
-`);}catch(s){throw a.fail(`Failed to create ${n} project`),s}}async function z(e,t,i){let n=await promises.readdir(e,{withFileTypes:true});for(let a of n){let s=l.join(e,a.name),c=a.name.replace(/\.j2$/,""),o=l.join(t,c);if(a.isDirectory())await promises.mkdir(o,{recursive:true}),await z(s,o,i);else {let d=await promises.readFile(s,"utf-8");a.name.endsWith(".j2")&&(d=he(d,i)),await promises.writeFile(o,d),(c==="rapidkit"||c==="activate"||c.endsWith(".py")&&o.includes(".rapidkit"))&&await promises.chmod(o,493);}}}function he(e,t){let i=e;for(let[n,a]of Object.entries(t)){let s=new RegExp(`\\{\\{\\s*${n}\\s*\\}\\}`,"g");i=i.replace(s,String(a));let c=new RegExp(`\\{\\{\\s*${n}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\}\\}`,"g");i=i.replace(c,(f,$,j)=>String(a).replace(new RegExp($,"g"),j));let o=new RegExp(`\\{\\{\\s*${n}\\s*\\|\\s*lower\\s*\\}\\}`,"g");i=i.replace(o,String(a).toLowerCase());let d=new RegExp(`\\{\\{\\s*${n}\\s*\\|\\s*replace\\s*\\(\\s*['"]([^'"]+)['"]\\s*,\\s*['"]([^'"]*)['"]\\s*\\)\\s*\\|\\s*lower\\s*\\}\\}`,"g");i=i.replace(d,(f,$,j)=>String(a).replace(new RegExp($,"g"),j).toLowerCase());}return i}var B=["init","dev","start","build","test","lint","format","create","help","--help","-h"];function ke(e){let t=e;for(;;){let i=l.join(t,".rapidkit","context.json");if(k.existsSync(i))return i;let n=l.dirname(t);if(n===t)break;t=n;}return null}function $e(e){let t=process.platform==="win32",i=e;for(;;){if(t){let c=l.join(i,"rapidkit.cmd"),o=l.join(i,".rapidkit","rapidkit.cmd");if(k.existsSync(c))return c;if(k.existsSync(o))return o}let n=l.join(i,"rapidkit"),a=l.join(i,".rapidkit","rapidkit");if(k.existsSync(n))return n;if(k.existsSync(a))return a;let s=l.dirname(i);if(s===i)break;i=s;}return null}(()=>{try{let e=process.cwd(),i=process.argv.slice(2)[0],n=ke(e);if(n&&k.existsSync(n)){let a=k.readFileSync(n,"utf8");try{let s=JSON.parse(a),c=i==="shell"&&process.argv.slice(2)[1]==="activate",d=$e(e)&&i&&B.includes(i);s?.engine==="pip"&&!c&&!d&&i!=="init"&&(console.log(r.yellow(`
-\u26A0\uFE0F  This project uses the Python RapidKit engine (pip). The global npm RapidKit CLI will not operate on this project.
-\u{1F4A1} To prepare this project run: 'rapidkit init' (it uses the project's Python toolchain)
-`)),process.exit(0));}catch{}}}catch{}})();function X(e){let t=e;for(;;){let i=l.join(t,".rapidkit","context.json");if(k.existsSync(i))return i;let n=l.dirname(t);if(n===t)break;t=n;}return null}async function we(){let e=process.cwd(),t=X(e),i=process.platform==="win32",n=i?[l.join(e,"rapidkit.cmd"),l.join(e,"rapidkit"),l.join(e,".rapidkit","rapidkit.cmd"),l.join(e,".rapidkit","rapidkit")]:[l.join(e,"rapidkit"),l.join(e,".rapidkit","rapidkit")],a=null;for(let o of n)if(await h.pathExists(o)){a=o;break}let s=process.argv.slice(2),c=s[0];if(a&&c&&B.includes(c)){m.debug(`Delegating to local CLI: ${a} ${s.join(" ")}`);let o=spawn(a,s,{stdio:"inherit",cwd:e,shell:i});return o.on("close",d=>{process.exit(d??0);}),o.on("error",d=>{m.error(`Failed to run local rapidkit: ${d.message}`),process.exit(1);}),true}if(t&&await h.pathExists(t))try{if((await h.readJson(t)).engine==="pip"){let d=process.argv.slice(2),f=d[0],j=process.platform==="win32"?[l.join(e,"rapidkit.cmd"),l.join(e,"rapidkit"),l.join(e,".rapidkit","rapidkit.cmd"),l.join(e,".rapidkit","rapidkit")]:[l.join(e,"rapidkit"),l.join(e,".rapidkit","rapidkit")],_=null;for(let g of j)if(await h.pathExists(g)){_=g;break}if(_&&f&&B.includes(f)){m.debug(`Delegating to local CLI (early detection): ${_} ${d.join(" ")}`);let g=spawn(_,d,{stdio:"inherit",cwd:e});return g.on("close",E=>process.exit(E??0)),g.on("error",E=>{m.error(`Failed to run local rapidkit: ${E.message}`),process.exit(1);}),!0}if(f==="shell"&&d[1]==="activate"){let g=`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
+${d.gray("Alternative: npm run start:dev, ./rapidkit dev")}
+${d.gray("\u{1F4A1} Tip: Install globally (npm i -g rapidkit) to use without npx")}
+`);}catch(c){throw r.fail(`Failed to generate ${o} project`),c}}function Mt(t){if(!t||typeof t!="object")return null;let e=t.code;return e==="PYTHON_NOT_FOUND"||e==="BRIDGE_VENV_BOOTSTRAP_FAILED"?e:null}function be(t){let e=t.trim().toLowerCase();return e?e.startsWith("fastapi")?"fastapi":e.startsWith("nestjs")?"nestjs":null:null}function Pe(t,e){let i=t.indexOf(e);if(i>=0&&i+1<t.length)return t[i+1];let n=t.find(o=>o.startsWith(`${e}=`));if(n)return n.slice(e.length+1)}async function Gt(t,e){if(t.includes("--json"))return process.stderr.write("RapidKit (npm) offline fallback does not support --json for `create` commands.\nInstall Python 3.10+ and retry the same command.\n"),1;if(t[0]!=="create")return 1;if(t[1]!=="project")return process.stderr.write(`RapidKit (npm) could not run the Python core engine for \`create\`.
+Reason: ${e}.
+Install Python 3.10+ to use the interactive wizard and full kit catalog.
+`),1;let o=t[2],r=t[3];if(!o||!r)return process.stderr.write(`Usage: rapidkit create project <kit> <name> [--output <dir>]
+Tip: offline fallback supports only fastapi* and nestjs* kits.
+`),1;let c=be(o);if(!c)return process.stderr.write(`RapidKit (npm) could not run the Python core engine to create this kit.
+Reason: ${e}.
+Requested kit: ${o}
+Offline fallback only supports: fastapi.standard, nestjs.standard (and their shorthands).
+Install Python 3.10+ to access all kits.
+`),1;let a=Pe(t,"--output")||process.cwd(),s=y.resolve(a,r),p=t.includes("--skip-git")||t.includes("--no-git"),f=t.includes("--skip-install");try{return await x.ensureDir(y.dirname(s)),await x.pathExists(s)?(process.stderr.write(`\u274C Directory "${s}" already exists
+`),1):(await x.ensureDir(s),await Vt(s,{project_name:r,template:c,skipGit:p,skipInstall:f}),0)}catch(m){return process.stderr.write(`RapidKit (npm) offline fallback failed: ${m?.message??m}
+`),1}}async function Re(t){let e=new Set(["--yes","-y","--skip-git","--skip-install","--debug","--dry-run","--no-update-check","--create-workspace","--no-workspace"]);try{if(t[0]==="create"&&t[1]==="project"){let i=t.includes("--create-workspace"),n=t.includes("--no-workspace"),o=t.includes("--yes")||t.includes("-y"),r=t.includes("--skip-git")||t.includes("--no-git");if(!!!ft(process.cwd())){if(i)await K(process.cwd(),{skipGit:r,yes:o,userConfig:await J()});else if(!n)if(o)await K(process.cwd(),{skipGit:r,yes:!0,userConfig:await J()});else {let{createWs:s}=await lt.prompt([{type:"confirm",name:"createWs",message:"This project will be created outside a RapidKit workspace. Create and register a workspace here?",default:!0}]);s&&await K(process.cwd(),{skipGit:r,yes:!1,userConfig:await J()});}}let a=t.filter(s=>{let p=s.split("=")[0];return !e.has(s)&&!e.has(p)});try{return await tt(),await $(a,{cwd:process.cwd()})}catch(s){let p=Mt(s);return p?await Gt(a,p):(process.stderr.write(`RapidKit (npm) failed to run the Python core engine: ${s?.message??s}
+`),1)}}return await tt(),await $(t,{cwd:process.cwd()})}catch(i){let n=Mt(i);return n?await Gt(t,n):(process.stderr.write(`RapidKit (npm) failed to run the Python core engine: ${i?.message??i}
+`),1)}}var Lt=["init","dev","start","build","test","lint","format","create","help","--help","-h"];function je(t){let e=t;for(;;){let i=y.join(e,".rapidkit","context.json");if(Q.existsSync(i))return i;let n=y.dirname(e);if(n===e)break;e=n;}return null}function ft(t){let e=t;for(;;){let i=y.join(e,".rapidkit-workspace");if(Q.existsSync(i))return i;let n=y.dirname(e);if(n===e)break;e=n;}return null}async function _e(){let t=process.cwd();try{let s=process.argv.slice(2)[0],p=!s||s==="--help"||s==="-h"||s==="help";if(ft(t)&&p){let m=await $(s?["--help"]:[],{cwd:t});process.exit(m);}}catch{}try{let a=process.argv.slice(2),p=a[0]==="shell"&&a[1]==="activate",f=await vt(t,{cwd:t,timeoutMs:1200});if(f.ok&&f.data?.isRapidkitProject&&f.data.engine==="python"&&!p){let m=await $(process.argv.slice(2),{cwd:t});process.exit(m);}}catch{}let e=je(t),i=process.platform==="win32",n=i?[y.join(t,"rapidkit.cmd"),y.join(t,"rapidkit"),y.join(t,".rapidkit","rapidkit.cmd"),y.join(t,".rapidkit","rapidkit")]:[y.join(t,"rapidkit"),y.join(t,".rapidkit","rapidkit")],o=null;for(let a of n)if(await x.pathExists(a)){o=a;break}let r=process.argv.slice(2),c=r[0];if(o&&c&&Lt.includes(c)){u.debug(`Delegating to local CLI: ${o} ${r.join(" ")}`);let a=spawn(o,r,{stdio:"inherit",cwd:t,shell:i});return a.on("close",s=>{process.exit(s??0);}),a.on("error",s=>{u.error(`Failed to run local rapidkit: ${s.message}`),process.exit(1);}),true}if(e&&await x.pathExists(e))try{if((await x.readJson(e)).engine==="pip"){let s=process.argv.slice(2),p=s[0],m=process.platform==="win32"?[y.join(t,"rapidkit.cmd"),y.join(t,"rapidkit"),y.join(t,".rapidkit","rapidkit.cmd"),y.join(t,".rapidkit","rapidkit")]:[y.join(t,"rapidkit"),y.join(t,".rapidkit","rapidkit")],P=null;for(let w of m)if(await x.pathExists(w)){P=w;break}if(P&&p&&Lt.includes(p)){u.debug(`Delegating to local CLI (early detection): ${P} ${s.join(" ")}`);let w=spawn(P,s,{stdio:"inherit",cwd:t});return w.on("close",C=>process.exit(C??0)),w.on("error",C=>{u.error(`Failed to run local rapidkit: ${C.message}`),process.exit(1);}),!0}if(p==="shell"&&s[1]==="activate"){let w=`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
 VENV='.venv'
 if [ -f "$VENV/bin/activate" ]; then
   . "$VENV/bin/activate"
@@ -589,45 +851,37 @@ elif [ -f "$VENV/bin/activate.fish" ]; then
 fi
 export RAPIDKIT_PROJECT_ROOT="$(pwd)"
 export PATH="$(pwd)/.rapidkit:$(pwd):$PATH"
-`;console.log(r.green.bold(`
+`;console.log(d.green.bold(`
 \u2705 Activation snippet \u2014 run the following to activate this project in your current shell:
-`)),console.log(g),console.log(r.gray(`
+`)),console.log(w),console.log(d.gray(`
 \u{1F4A1} After activation you can run: rapidkit dev
-`)),process.exit(0);}if(f!=="init"){let g=(await import('chalk')).default;console.log(g.yellow(`
-\u26A0\uFE0F  This project uses the Python RapidKit engine (pip). The global npm RapidKit CLI will not operate on this project.
-\u{1F4A1} To prepare this project run: 'rapidkit init' (it uses the project's Python toolchain)
-
-`)),process.exit(0);}let L=(await import('chalk')).default;console.log(L.yellow(`
-\u26A0\uFE0F  This project was created with the Python engine (pip). RapidKit (npm) will try to install the Python CLI for you...
-`));let{spawnSync:w}=await import('child_process'),D=[["python3",["-m","pip","install","rapidkit-core"]],["python",["-m","pip","install","rapidkit-core"]],["pip",["install","rapidkit-core"]]],P=!0;if(process.stdin.isTTY)try{P=!!(await O.prompt([{type:"confirm",name:"confirm",message:"This project needs the Python RapidKit CLI (rapidkit). Do you want to try installing it now using pip?",default:!0}])).confirm;}catch{P=!1;}else P=!1;if(!P){let g=(await import('chalk')).default;console.log(g.yellow(`
-\u26A0\uFE0F  Skipping automatic installation of the Python RapidKit CLI (rapidkit-core).
-\u{1F4A1} To continue, either run 'rapidkit init' locally after installing rapidkit-core: \`python3 -m pip install rapidkit-core\`
-`)),process.exit(0);}let R={status:1,stderr:null,stdout:null};if(P)for(let[g,E]of D)try{if(console.log(r.gray(`Running: ${g} ${E.join(" ")}
-`)),R=w(g,E,{stdio:"inherit"}),R&&R.status===0)break}catch{}if(R&&R.status===0){let g=(await import('chalk')).default;console.log(g.green(`
-\u2705 RapidKit Python CLI (rapidkit) installed successfully!
-Please re-run your command.
-`));}else {let g=(await import('chalk')).default;console.log(g.red(`
-\u274C Failed to install RapidKit Python CLI automatically.
-\u{1F4A1} Manual install options:
-  python3 -m pip install rapidkit
-  python -m pip install rapidkit
-  pip install rapidkit
-`));}process.exit(R.status??1);}}catch{}return  false}var x=null,U=false,K=new Command;K.name("rapidkit").description("Create RapidKit workspaces and projects").version(N());K.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&&(m.setDebug(!0),m.debug("Debug mode enabled"));let i=await W();m.debug("User config loaded",i),t.updateCheck!==!1&&await J(),console.log(r.blue.bold(`
+`)),process.exit(0);}let A=await $(s,{cwd:t});process.exit(A);}}catch{}return  false}var D=null,nt=false,H=new Command;async function Ee(t){if(t.length===0)return  false;let e=t[0],i=t[1];if(e==="shell"&&i==="activate")return  false;if(t.includes("--tui"))return  true;if(e==="--help"||e==="-h"||e==="help"||e==="--version"||e==="-V"||t.includes("--template")||t.includes("-t"))return  false;let n=new Set(["--yes","-y","--skip-git","--skip-install","--debug","--dry-run","--no-update-check","--create-workspace","--no-workspace"]);if(t.some(r=>n.has(r)))return  false;let o=await _t();return o?o.has(e):!!(Ct.has(e)||t.length>1)}H.name("rapidkit").description("Create RapidKit workspaces and projects").version(V());H.addHelpText("beforeAll",`RapidKit
+
+Global CLI
+Create RapidKit workspaces and projects
+
+Global Engine Commands
+Access engine-level commands when inside a RapidKit workspace or via the core bridge
+`);H.addHelpText("afterAll",`
+Project Commands
+  rapidkit create
+  rapidkit init
+  rapidkit dev
+
+Use "rapidkit help <command>" for more information.
+`);H.argument("[name]","Name of the workspace or project directory").addOption(new Option("-t, --template <template>","Legacy: create a project with template (fastapi, nestjs) instead of a workspace").hideHelp()).option("-y, --yes","Skip prompts and use defaults").addOption(new Option("--skip-git","Skip git initialization").hideHelp()).addOption(new Option("--skip-install","Legacy: skip installing dependencies (template mode)").hideHelp()).option("--debug","Enable debug logging").addOption(new Option("--dry-run","Show what would be created without creating it").hideHelp()).addOption(new Option("--create-workspace","When creating a project outside a workspace: create and register a workspace in the current directory").hideHelp()).addOption(new Option("--no-workspace","When creating a project outside a workspace: do not create a workspace").hideHelp()).option("--no-update-check","Skip checking for updates").action(async(t,e)=>{try{e.debug&&(u.setDebug(!0),u.debug("Debug mode enabled"));let i=await J();u.debug("User config loaded",i),e.updateCheck!==!1&&await wt(),console.log(d.blue.bold(`
 \u{1F680} Welcome to RapidKit!
-`)),e||(ve(),process.exit(0));try{M(e);}catch(c){throw c instanceof S&&(m.error(`
-\u274C ${c.message}`),c.details&&m.warn(`\u{1F4A1} ${c.details}
-`),process.exit(1)),c}let n=l.resolve(process.cwd(),e);x=n,await h.pathExists(n)&&(m.error(`
-\u274C Directory "${e}" already exists`),console.log(r.cyan(`
+`)),t||(Ie(),process.exit(0));try{kt(t);}catch(r){throw r instanceof _&&(u.error(`
+\u274C ${r.message}`),r.details&&u.warn(`\u{1F4A1} ${r.details}
+`),process.exit(1)),r}let n=y.resolve(process.cwd(),t);D=n,await x.pathExists(n)&&(u.error(`
+\u274C Directory "${t}" already exists`),console.log(d.cyan(`
 \u{1F4A1} Choose a different name or delete the existing directory.
-`)),process.exit(1));let a=!!t.template;if(a){let c=t.template.toLowerCase(),o=["fastapi","nestjs"];o.includes(c)||(m.error(`
-\u274C Invalid template: ${t.template}`),console.log(r.cyan(`
-\u{1F4E6} Available templates: ${o.join(", ")}
-`)),process.exit(1));}if(t.dryRun){console.log(r.cyan(`
+`)),process.exit(1));let o=!!e.template;if(e.dryRun){console.log(d.cyan(`
 \u{1F50D} Dry-run mode - showing what would be created:
-`)),console.log(r.white("\u{1F4C2} Path:"),n),console.log(r.white("\u{1F4E6} Type:"),a?`Project (${t.template})`:"Workspace"),console.log();return}let s;t.yes?(s={author:process.env.USER||"RapidKit User",description:a?`${t.template==="nestjs"?"NestJS":"FastAPI"} application generated with RapidKit`:void 0,package_manager:"npm"},console.log(r.gray(`Using default values (--yes flag)
-`))):a?t.template.toLowerCase()==="fastapi"?s=await O.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 O.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 O.prompt([{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"}]),a?await Y(n,{name:e,template:t.template.toLowerCase(),author:s.author,description:s.description,package_manager:s.package_manager,skipGit:t.skipGit,skipInstall:t.skipInstall}):await H(n,{name:e,author:s.author,skipGit:t.skipGit});}catch(i){i instanceof S?(m.error(`
-\u274C ${i.message}`),i.details&&m.warn(`\u{1F4A1} ${i.details}`),m.debug("Error code:",i.code)):(m.error(`
-\u274C An unexpected error occurred:`),console.error(i)),process.exit(1);}finally{x=null;}});K.command("shell <action>").description("Shell helpers (activate virtualenv in current shell)").action(async e=>{e!=="activate"&&(console.log(r.red(`Unknown shell command: ${e}`)),process.exit(1));let t=process.cwd();function i(c){let o=c;for(;;){let d=l.join(o,".rapidkit","context.json");if(k.existsSync(d))return d;let f=l.dirname(o);if(f===o)break;o=f;}return null}let n=i(t);function a(c){let o=c;for(;;){let d=l.join(o,".venv"),f=l.join(o,".rapidkit","activate");if(k.existsSync(f)||k.existsSync(d))return {venv:d,activateFile:f};let $=l.dirname(o);if($===o)break;o=$;}return null}let s=a(t);if(!n&&!s&&(console.log(r.red("No RapidKit project found to activate")),process.exit(1)),s){let c=`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
+`)),console.log(d.white("\u{1F4C2} Path:"),n),console.log(d.white("\u{1F4E6} Type:"),o?`Project (${e.template})`:"Workspace"),console.log();return}if(!e.yes&&!o?await lt.prompt([{type:"input",name:"author",message:"Author name:",default:process.env.USER||"RapidKit User"}]):e.yes&&console.log(d.gray(`Using default values (--yes flag)
+`)),o){let r=String(e.template||"").trim(),c=r.toLowerCase(),a=c==="fastapi"?"fastapi.standard":c==="nestjs"?"nestjs.standard":r;if(!!!ft(process.cwd())){if(e.createWorkspace)await K(process.cwd(),{skipGit:e.skipGit,yes:e.yes,userConfig:i});else if(!e.noWorkspace)if(e.yes)await K(process.cwd(),{skipGit:e.skipGit,yes:!0,userConfig:i});else {let{createWs:m}=await lt.prompt([{type:"confirm",name:"createWs",message:"This project will be created outside a RapidKit workspace. Create and register a workspace here?",default:!0}]);m&&await K(process.cwd(),{skipGit:e.skipGit,yes:!1,userConfig:i});}}let p=["create","project",a,t,"--output",process.cwd(),"--install-essentials"],f=await $(p,{cwd:process.cwd()});if(f!==0&&process.exit(f),!e.skipInstall){let m=await $(["init",n],{cwd:process.cwd()});m!==0&&process.exit(m);}}else await Tt(t,{skipGit:e.skipGit,dryRun:e.dryRun,yes:e.yes,userConfig:i});}catch(i){i instanceof _?(u.error(`
+\u274C ${i.message}`),i.details&&u.warn(`\u{1F4A1} ${i.details}`),u.debug("Error code:",i.code)):(u.error(`
+\u274C An unexpected error occurred:`),console.error(i)),process.exit(1);}finally{D=null;}});H.command("shell <action>").description("Shell helpers (activate virtualenv in current shell)").action(async t=>{t!=="activate"&&(console.log(d.red(`Unknown shell command: ${t}`)),process.exit(1));let e=process.cwd();function i(c){let a=c;for(;;){let s=y.join(a,".rapidkit","context.json");if(Q.existsSync(s))return s;let p=y.dirname(a);if(p===a)break;a=p;}return null}let n=i(e);function o(c){let a=c;for(;;){let s=y.join(a,".venv"),p=y.join(a,".rapidkit","activate");if(Q.existsSync(p)||Q.existsSync(s))return {venv:s,activateFile:p};let f=y.dirname(a);if(f===a)break;a=f;}return null}let r=o(e);if(!n&&!r&&(console.log(d.red("No RapidKit project found to activate")),process.exit(1)),r){let c=`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
 VENV='.venv'
 if [ -f "$VENV/bin/activate" ]; then
   . "$VENV/bin/activate"
@@ -636,11 +890,11 @@ elif [ -f "$VENV/bin/activate.fish" ]; then
 fi
 export RAPIDKIT_PROJECT_ROOT="$(pwd)"
 export PATH="$(pwd)/.rapidkit:$(pwd):$PATH"
-`;console.log(r.green.bold(`
+`;console.log(d.green.bold(`
 \u2705 Activation snippet \u2014 run the following to activate this project in your current shell:
-`)),console.log(c),console.log(r.gray(`
+`)),console.log(c),console.log(d.gray(`
 \u{1F4A1} After activation you can run: rapidkit dev
-`)),process.exit(0);}try{(await h.readJson(n)).engine!=="pip"&&(console.log(r.yellow("This project is not a pip-based RapidKit project.")),process.exit(1)),console.log(`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
+`)),process.exit(0);}try{(await x.readJson(n)).engine!=="pip"&&(console.log(d.yellow("This project is not a pip-based RapidKit project.")),process.exit(1)),console.log(`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
 VENV='.venv'
 if [ -f "$VENV/bin/activate" ]; then
   . "$VENV/bin/activate"
@@ -649,7 +903,7 @@ elif [ -f "$VENV/bin/activate.fish" ]; then
 fi
 export RAPIDKIT_PROJECT_ROOT="$(pwd)"
 export PATH="$(pwd)/.rapidkit:$(pwd):$PATH"
-`),process.exit(0);}catch{console.log(r.yellow("Could not read project context but found a venv or activation file \u2014 printing activation snippet")),console.log(`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
+`),process.exit(0);}catch{console.log(d.yellow("Could not read project context but found a venv or activation file \u2014 printing activation snippet")),console.log(`# RapidKit: activation snippet - eval "$(rapidkit shell activate)"
 VENV='.venv'
 if [ -f "$VENV/bin/activate" ]; then
   . "$VENV/bin/activate"
@@ -658,15 +912,13 @@ elif [ -f "$VENV/bin/activate.fish" ]; then
 fi
 export RAPIDKIT_PROJECT_ROOT="$(pwd)"
 export PATH="$(pwd):$PATH"
-`),process.exit(0);}});function ve(){console.log(r.white(`Usage: npx rapidkit <name> [options]
-`)),console.log(r.bold("Create a workspace (recommended):")),console.log(r.cyan("  npx rapidkit my-workspace")),console.log(r.cyan("  cd my-workspace")),console.log(r.cyan("  rapidkit create my-api --template fastapi")),console.log(r.cyan("  cd my-api")),console.log(r.cyan(`  rapidkit dev
-`)),console.log(r.bold("Or create a project directly:")),console.log(r.cyan("  npx rapidkit my-project --template fastapi")),console.log(r.cyan(`  npx rapidkit my-project --template nestjs
-`)),console.log(r.bold("Options:")),console.log(r.gray("  -t, --template <template>  Create project with template (fastapi, nestjs)")),console.log(r.gray("  -y, --yes                  Skip prompts and use defaults")),console.log(r.gray("  --skip-git                 Skip git initialization")),console.log(r.gray("  --skip-install             Skip installing dependencies")),console.log(r.gray("  --debug                    Enable debug logging")),console.log(r.gray(`  --dry-run                  Show what would be created
-`)),console.log(r.bold("Templates:")),console.log(r.gray("  fastapi    FastAPI + Python")),console.log(r.gray(`  nestjs     NestJS + TypeScript
-`));}process.on("SIGINT",async()=>{if(!U){if(U=true,console.log(r.yellow(`
-
-\u26A0\uFE0F  Interrupted by user`)),x&&await h.pathExists(x)){console.log(r.gray("Cleaning up partial installation..."));try{await h.remove(x),console.log(r.green("\u2713 Cleanup complete"));}catch(e){m.debug("Cleanup failed:",e);}}process.exit(130);}});process.on("SIGTERM",async()=>{if(!U){if(U=true,m.debug("Received SIGTERM"),x&&await h.pathExists(x))try{await h.remove(x);}catch(e){m.debug("Cleanup failed:",e);}process.exit(143);}});we().then(async e=>{if(!e){let t=process.cwd();try{let i=X(t);if(i&&await h.pathExists(i)){let n=await h.readJson(i),a=process.argv.slice(2)[0];if(n?.engine==="pip"&&a!=="init"){let s=(await import('chalk')).default;console.log(s.yellow(`
-\u26A0\uFE0F  This project uses the Python RapidKit engine (pip). The global npm RapidKit CLI will not operate on this project.
-\u{1F4A1} To prepare this project run: 'rapidkit init' (it uses the project's Python toolchain)
-
-`)),process.exit(0);}}}catch{}K.parse();}});
+`),process.exit(0);}});function Ie(){console.log(d.white(`Usage:
+`)),console.log(d.cyan("  npx rapidkit <workspace-name> [options]")),console.log(d.cyan(`  npx rapidkit create <...>
+`)),console.log(d.bold("Recommended workflow:")),console.log(d.cyan("  npx rapidkit my-workspace")),console.log(d.cyan("  cd my-workspace")),console.log(d.cyan("  npx rapidkit create project fastapi.standard my-api --output .")),console.log(d.cyan("  cd my-api")),console.log(d.cyan(`  npx rapidkit init && npx rapidkit dev
+`)),console.log(d.bold("Options (workspace creation):")),console.log(d.gray("  -y, --yes                  Skip prompts and use defaults")),console.log(d.gray("  --skip-git                 Skip git initialization")),console.log(d.gray("  --debug                    Enable debug logging")),console.log(d.gray("  --dry-run                  Show what would be created")),console.log(d.gray("  --create-workspace         When creating a project outside a workspace: create and register a workspace in the current directory")),console.log(d.gray("  --no-workspace             When creating a project outside a workspace: do not create a workspace")),console.log(d.gray(`  --no-update-check          Skip checking for updates
+`)),console.log(d.gray(`Tip: set RAPIDKIT_SHOW_LEGACY=1 to show legacy template flags in help.
+`));}process.on("SIGINT",async()=>{if(!nt){if(nt=true,console.log(d.yellow(`
+
+\u26A0\uFE0F  Interrupted by user`)),D&&await x.pathExists(D)){console.log(d.gray("Cleaning up partial installation..."));try{await x.remove(D),console.log(d.green("\u2713 Cleanup complete"));}catch(t){u.debug("Cleanup failed:",t);}}process.exit(130);}});process.on("SIGTERM",async()=>{if(!nt){if(nt=true,u.debug("Received SIGTERM"),D&&await x.pathExists(D))try{await x.remove(D);}catch(t){u.debug("Cleanup failed:",t);}process.exit(143);}});_e().then(async t=>{if(!t){let e=process.argv.slice(2);if(process.env.RAPIDKIT_NPM_DEBUG_ARGS==="1"&&process.stderr.write(`[rapidkit-npm] argv=${JSON.stringify(e)}
+`),e[0]==="create"){let n=await Re(e);process.exit(n);}let i=await Ee(e);if(process.env.RAPIDKIT_NPM_DEBUG_ARGS==="1"&&process.stderr.write(`[rapidkit-npm] shouldForwardToCore=${i}
+`),i){let n=await $(e,{cwd:process.cwd()});process.exit(n);}H.parse();}});export{Re as handleCreateOrFallback};