create-celsian 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,46 +1,143 @@
 #!/usr/bin/env node
 // create-celsian — Project scaffolder
+// Zero external dependencies. Interactive prompts via raw stdin.
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { join, dirname, basename, isAbsolute } from 'node:path';
+import { createInterface } from 'node:readline';
 import { basicTemplate } from './templates/basic.js';
 import { restApiTemplate } from './templates/rest-api.js';
 import { rpcApiTemplate } from './templates/rpc-api.js';
+import { fullTemplate } from './templates/full.js';
+// ─── Template Registry ───
 const templates = {
+    full: fullTemplate,
     basic: basicTemplate,
     'rest-api': restApiTemplate,
     'rpc-api': rpcApiTemplate,
 };
+const templateDescriptions = {
+    full: 'Full-stack API with auth, CRUD, RPC, tasks, cron, OpenAPI, Docker',
+    basic: 'Minimal API server',
+    'rest-api': 'REST API with TypeBox schemas',
+    'rpc-api': 'RPC-first with typed client',
+};
+// ─── CLI Argument Parsing ───
 const args = process.argv.slice(2);
-const name = args[0];
+// Handle --help
+if (args.includes('--help') || args.includes('-h')) {
+    printUsage();
+    process.exit(0);
+}
+// Extract flags
 const templateFlag = args.indexOf('--template');
-const template = templateFlag !== -1 ? args[templateFlag + 1] ?? 'basic' : 'basic';
-if (!name) {
-    console.log('Usage: create-celsian <project-name> [--template basic|rest-api|rpc-api]');
-    console.log('');
-    console.log('Templates:');
-    console.log('  basic      Minimal API server (default)');
-    console.log('  rest-api   REST + TypeBox schemas');
-    console.log('  rpc-api    RPC-first with typed client');
-    process.exit(1);
+const templateArg = templateFlag !== -1 ? args[templateFlag + 1] : undefined;
+const nameArg = args.find(a => !a.startsWith('--') && (templateFlag === -1 || args.indexOf(a) !== templateFlag + 1));
+// ─── Interactive Mode ───
+async function prompt(question, defaultValue) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`  ${question} (${defaultValue}): `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue);
+        });
+    });
 }
-const files = templates[template];
-if (!files) {
-    console.error(`Unknown template: ${template}`);
-    console.error('Available: basic, rest-api, rpc-api');
-    process.exit(1);
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent ?? '';
+    if (userAgent.startsWith('pnpm'))
+        return 'pnpm';
+    if (userAgent.startsWith('bun'))
+        return 'bun';
+    return 'npm';
+}
+async function interactiveMode() {
+    console.log('');
+    console.log('  Create a new Celsian project');
+    console.log('  ────────────────────────────');
+    console.log('');
+    const name = await prompt('Project name', 'my-celsian-app');
+    console.log('');
+    console.log('  Available templates:');
+    for (const [key, desc] of Object.entries(templateDescriptions)) {
+        const marker = key === 'full' ? ' (recommended)' : '';
+        console.log(`    ${key.padEnd(12)} ${desc}${marker}`);
+    }
+    console.log('');
+    const template = await prompt('Template', 'full');
+    const detected = detectPackageManager();
+    const pm = await prompt('Package manager', detected);
+    return { name, template, pm };
 }
-const dir = join(process.cwd(), name);
-console.log(`\nCreating Celsian project: ${name}\n`);
-for (const [filePath, content] of Object.entries(files)) {
-    const fullPath = join(dir, filePath);
-    const fileDir = dirname(fullPath);
-    mkdirSync(fileDir, { recursive: true });
-    writeFileSync(fullPath, content.replace(/\{\{name\}\}/g, name));
-    console.log(`  + ${filePath}`);
+// ─── Scaffold ───
+function scaffold(name, template, pm) {
+    const files = templates[template];
+    if (!files) {
+        console.error(`\n  Unknown template: ${template}`);
+        console.error(`  Available: ${Object.keys(templates).join(', ')}\n`);
+        process.exit(1);
+    }
+    const dir = isAbsolute(name) ? name : join(process.cwd(), name);
+    const projectName = basename(dir);
+    console.log(`\n  Creating Celsian project: ${projectName}`);
+    console.log(`  Template: ${template}`);
+    console.log('');
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = join(dir, filePath);
+        const fileDir = dirname(fullPath);
+        mkdirSync(fileDir, { recursive: true });
+        writeFileSync(fullPath, content.replace(/\{\{name\}\}/g, projectName));
+        console.log(`  + ${filePath}`);
+    }
+    const install = pm === 'npm' ? 'npm install' : `${pm} install`;
+    const dev = pm === 'npm' ? 'npm run dev' : `${pm} run dev`;
+    console.log(`\n  Done! Next steps:\n`);
+    console.log(`  cd ${projectName}`);
+    console.log(`  ${install}`);
+    if (template === 'full') {
+        console.log('  cp .env.example .env');
+    }
+    console.log(`  ${dev}`);
+    if (template === 'full') {
+        console.log('');
+        console.log('  Open http://localhost:3000/docs for API documentation');
+    }
+    console.log('');
+}
+// ─── Main ───
+async function main() {
+    // If both name and template are provided via CLI args, skip interactive mode
+    if (nameArg) {
+        const template = templateArg ?? 'full';
+        const pm = detectPackageManager();
+        scaffold(nameArg, template, pm);
+        return;
+    }
+    // No project name — enter interactive mode
+    // But only if stdin is a TTY (not piped)
+    if (process.stdin.isTTY) {
+        const { name, template, pm } = await interactiveMode();
+        scaffold(name, template, pm);
+    }
+    else {
+        printUsage();
+        process.exit(1);
+    }
 }
-console.log(`\nDone! Next steps:\n`);
-console.log(`  cd ${name}`);
-console.log('  npm install');
-console.log('  npm run dev');
-console.log('');
+function printUsage() {
+    console.log('');
+    console.log('  Usage: create-celsian <project-name> [--template full|basic|rest-api|rpc-api]');
+    console.log('');
+    console.log('  Templates:');
+    for (const [key, desc] of Object.entries(templateDescriptions)) {
+        const defaultMarker = key === 'full' ? ' (default)' : '';
+        console.log(`    ${key.padEnd(12)} ${desc}${defaultMarker}`);
+    }
+    console.log('');
+    console.log('  Run without arguments for interactive mode.');
+    console.log('');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,MAAM,SAAS,GAA2C;IACxD,KAAK,EAAE,aAAa;IACpB,UAAU,EAAE,eAAe;IAC3B,SAAS,EAAE,cAAc;CAC1B,CAAC;AAEF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AACrB,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;AAChD,MAAM,QAAQ,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;AAEnF,IAAI,CAAC,IAAI,EAAE,CAAC;IACV,OAAO,CAAC,GAAG,CAAC,0EAA0E,CAAC,CAAC;IACxF,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC1B,OAAO,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;IACzD,OAAO,CAAC,GAAG,CAAC,qCAAqC,CAAC,CAAC;IACnD,OAAO,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;IACxD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;AAClC,IAAI,CAAC,KAAK,EAAE,CAAC;IACX,OAAO,CAAC,KAAK,CAAC,qBAAqB,QAAQ,EAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACrD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAEtC,OAAO,CAAC,GAAG,CAAC,+BAA+B,IAAI,IAAI,CAAC,CAAC;AAErD,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;IACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,OAAO,CAAC,GAAG,CAAC,OAAO,QAAQ,EAAE,CAAC,CAAC;AACjC,CAAC;AAED,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;AACrC,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;AAC5B,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAC7B,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAC7B,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,sCAAsC;AACtC,iEAAiE;AAEjE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAW,UAAU,EAAE,MAAM,WAAW,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,4BAA4B;AAE5B,MAAM,SAAS,GAA2C;IACxD,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,aAAa;IACpB,UAAU,EAAE,eAAe;IAC3B,SAAS,EAAE,cAAc;CAC1B,CAAC;AAEF,MAAM,oBAAoB,GAA2B;IACnD,IAAI,EAAE,mEAAmE;IACzE,KAAK,EAAE,oBAAoB;IAC3B,UAAU,EAAE,+BAA+B;IAC3C,SAAS,EAAE,6BAA6B;CACzC,CAAC;AAEF,+BAA+B;AAE/B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEnC,gBAAgB;AAChB,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;IACnD,UAAU,EAAE,CAAC;IACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,gBAAgB;AAChB,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;AAChD,MAAM,WAAW,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7E,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;AAErH,2BAA2B;AAE3B,KAAK,UAAU,MAAM,CAAC,QAAgB,EAAE,YAAoB;IAC1D,MAAM,EAAE,GAAG,eAAe,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,EAAE,CAAC,QAAQ,CAAC,KAAK,QAAQ,KAAK,YAAY,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE;YAC1D,EAAE,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,YAAY,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,oBAAoB;IAC3B,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,EAAE,CAAC;IAC1D,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IAChD,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9C,OAAO,KAAK,CAAC;AACf,CAAC;AAED,KAAK,UAAU,eAAe;IAC5B,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAC;IAC9C,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAC;IAC9C,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEhB,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;IAE5D,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;IACtC,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC;QAC/D,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;QACtD,OAAO,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,GAAG,MAAM,EAAE,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEhB,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAElD,MAAM,QAAQ,GAAG,oBAAoB,EAAE,CAAC;IACxC,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IAErD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;AAChC,CAAC;AAED,mBAAmB;AAEnB,SAAS,QAAQ,CAAC,IAAY,EAAE,QAAgB,EAAE,EAAU;IAC1D,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,CAAC,KAAK,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAC;QACnD,OAAO,CAAC,KAAK,CAAC,gBAAgB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;IAChE,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IAElC,OAAO,CAAC,GAAG,CAAC,iCAAiC,WAAW,EAAE,CAAC,CAAC;IAC5D,OAAO,CAAC,GAAG,CAAC,eAAe,QAAQ,EAAE,CAAC,CAAC;IACvC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEhB,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACrC,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAClC,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;QACvE,OAAO,CAAC,GAAG,CAAC,OAAO,QAAQ,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,MAAM,OAAO,GAAG,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,EAAE,UAAU,CAAC;IAC/D,MAAM,GAAG,GAAG,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,EAAE,UAAU,CAAC;IAE3D,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;IACvC,OAAO,CAAC,GAAG,CAAC,QAAQ,WAAW,EAAE,CAAC,CAAC;IACnC,OAAO,CAAC,GAAG,CAAC,KAAK,OAAO,EAAE,CAAC,CAAC;IAC5B,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC;IACxB,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAChB,OAAO,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAClB,CAAC;AAED,eAAe;AAEf,KAAK,UAAU,IAAI;IACjB,6EAA6E;IAC7E,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,QAAQ,GAAG,WAAW,IAAI,MAAM,CAAC;QACvC,MAAM,EAAE,GAAG,oBAAoB,EAAE,CAAC;QAClC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;QAChC,OAAO;IACT,CAAC;IAED,2CAA2C;IAC3C,yCAAyC;IACzC,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACxB,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,MAAM,eAAe,EAAE,CAAC;QACvD,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;SAAM,CAAC;QACN,UAAU,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,SAAS,UAAU;IACjB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,iFAAiF,CAAC,CAAC;IAC/F,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC5B,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC;QAC/D,MAAM,aAAa,GAAG,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QACzD,OAAO,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,GAAG,aAAa,EAAE,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAClB,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/templates/full.d.ts

@@ -0,0 +1,2 @@
+export declare const fullTemplate: Record<string, string>;
+//# sourceMappingURL=full.d.ts.map

package/dist/templates/full.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full.d.ts","sourceRoot":"","sources":["../../src/templates/full.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA23B/C,CAAC"}

package/dist/templates/full.js

@@ -0,0 +1,869 @@
+export const fullTemplate = {
+    'package.json': JSON.stringify({
+        name: '{{name}}',
+        version: '0.1.0',
+        type: 'module',
+        scripts: {
+            dev: 'npx tsx --watch src/index.ts',
+            build: 'tsc',
+            start: 'node dist/index.js',
+            test: 'npx vitest run',
+            lint: 'npx tsc --noEmit',
+        },
+        dependencies: {
+            celsian: '^0.2.0',
+            '@celsian/core': '^0.2.0',
+            '@celsian/jwt': '^0.2.0',
+            '@celsian/rpc': '^0.2.0',
+            '@celsian/rate-limit': '^0.2.0',
+            '@sinclair/typebox': '^0.34.0',
+        },
+        devDependencies: {
+            typescript: '^5.7.0',
+            tsx: '^4.0.0',
+            vitest: '^3.0.0',
+            '@types/node': '^22.0.0',
+        },
+    }, null, 2),
+    'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            lib: ['ES2022'],
+            types: ['node'],
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            declaration: true,
+            outDir: 'dist',
+            rootDir: 'src',
+        },
+        include: ['src'],
+    }, null, 2),
+    '.env.example': `# Server
+PORT=3000
+HOST=0.0.0.0
+CORS_ORIGIN=*
+
+# Auth
+JWT_SECRET=change-me-to-a-real-secret-at-least-32-chars
+
+# Database (placeholder — swap for your real DB URL)
+DATABASE_URL=file:./data.db
+
+# Environment
+NODE_ENV=development
+`,
+    '.gitignore': `node_modules/
+dist/
+*.tsbuildinfo
+.env
+data.db
+`,
+    // ─── src/types.ts ───
+    'src/types.ts': `// Shared types for {{name}}
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: string;
+}
+
+export interface CreateUserInput {
+  name: string;
+  email: string;
+}
+
+export interface UpdateUserInput {
+  name?: string;
+  email?: string;
+}
+
+export interface Session {
+  id: string;
+  userId: string;
+  expiresAt: number;
+}
+
+export interface JWTPayload {
+  sub: string;
+  email: string;
+  iat?: number;
+  exp?: number;
+}
+`,
+    // ─── src/plugins/database.ts ───
+    'src/plugins/database.ts': `// Database module — in-memory store for development
+// Replace with a real database (PostgreSQL, SQLite, etc.) for production
+
+import type { User, Session } from '../types.js';
+
+export interface DatabaseStore {
+  users: Map<string, User>;
+  sessions: Map<string, Session>;
+  generateId(): string;
+}
+
+function createStore(): DatabaseStore {
+  let nextId = 1;
+  return {
+    users: new Map(),
+    sessions: new Map(),
+    generateId() {
+      return String(nextId++);
+    },
+  };
+}
+
+// Module-level singleton — shared across all routes and plugins
+export const db: DatabaseStore = createStore();
+
+// Seed a demo user on import
+const demoUser: User = {
+  id: db.generateId(),
+  name: 'Demo User',
+  email: 'demo@example.com',
+  createdAt: new Date().toISOString(),
+};
+db.users.set(demoUser.id, demoUser);
+`,
+    // ─── src/plugins/auth.ts ───
+    'src/plugins/auth.ts': `// JWT auth plugin — guards protected routes via Bearer token
+// Uses @celsian/jwt under the hood
+
+import { jwt, createJWTGuard } from '@celsian/jwt';
+import type { PluginFunction, HookHandler } from '@celsian/core';
+
+const JWT_SECRET = process.env.JWT_SECRET ?? 'dev-secret-change-me';
+
+/**
+ * Register the JWT plugin. After this, \`app.jwt\` is available for
+ * signing and verifying tokens.
+ */
+export function authPlugin(): PluginFunction {
+  return jwt({ secret: JWT_SECRET });
+}
+
+/**
+ * A reusable hook that rejects unauthenticated requests.
+ * Attach it to individual routes via \`onRequest\` or as a global hook.
+ */
+export const requireAuth: HookHandler = createJWTGuard({
+  secret: JWT_SECRET,
+});
+`,
+    // ─── src/plugins/security.ts ───
+    'src/plugins/security.ts': `// Security plugin — CORS + CSRF + security headers + rate limiting
+// Combines multiple @celsian/core plugins into a single registration
+
+import { cors, security, csrf } from '@celsian/core';
+import { rateLimit } from '@celsian/rate-limit';
+import type { PluginFunction } from '@celsian/core';
+
+const CORS_ORIGIN = process.env.CORS_ORIGIN ?? '*';
+
+/**
+ * Register all security-related plugins in one call.
+ */
+export function securityPlugins(): PluginFunction[] {
+  return [
+    // CORS — allow cross-origin requests
+    cors({
+      origin: CORS_ORIGIN,
+      credentials: true,
+      maxAge: 86400,
+    }),
+
+    // Security headers (Helmet-style)
+    security({
+      hsts: { maxAge: 31536000, includeSubDomains: true },
+      referrerPolicy: 'strict-origin-when-cross-origin',
+    }),
+
+    // CSRF protection (double-submit cookie)
+    csrf({
+      cookieName: '_csrf',
+      headerName: 'x-csrf-token',
+      excludePaths: ['/health', '/ready', '/_rpc'],
+    }),
+
+    // Rate limiting — 100 requests per 60 seconds
+    rateLimit({
+      max: 100,
+      window: 60_000,
+    }),
+  ];
+}
+`,
+    // ─── src/routes/health.ts ───
+    'src/routes/health.ts': `// Health check route — GET /health
+// Returns server status and uptime for load balancers and monitoring
+
+import type { PluginFunction } from '@celsian/core';
+
+const startedAt = Date.now();
+
+export default function healthRoutes(): PluginFunction {
+  return function health(app) {
+    app.get('/health', (_req, reply) => {
+      const uptimeMs = Date.now() - startedAt;
+      const uptimeSeconds = Math.floor(uptimeMs / 1000);
+      return reply.json({
+        status: 'ok',
+        uptime: uptimeSeconds,
+        timestamp: new Date().toISOString(),
+      });
+    });
+  };
+}
+`,
+    // ─── src/routes/users.ts ───
+    'src/routes/users.ts': `// User CRUD routes — /users
+// Full REST: GET (list), POST (create), GET/:id, PUT/:id, DELETE/:id
+
+import { Type } from '@sinclair/typebox';
+import type { PluginFunction, CelsianRequest, CelsianReply } from '@celsian/core';
+import type { User, CreateUserInput, UpdateUserInput } from '../types.js';
+import { db } from '../plugins/database.js';
+import { requireAuth } from '../plugins/auth.js';
+
+const CreateUserSchema = Type.Object({
+  name: Type.String({ minLength: 1 }),
+  email: Type.String({ minLength: 1 }),
+});
+
+const UpdateUserSchema = Type.Object({
+  name: Type.Optional(Type.String({ minLength: 1 })),
+  email: Type.Optional(Type.String({ minLength: 1 })),
+});
+
+export default function userRoutes(): PluginFunction {
+  return function users(app) {
+    // GET /users — list all users
+    app.get('/users', (_req, reply) => {
+      const allUsers = Array.from(db.users.values());
+      return reply.json(allUsers);
+    });
+
+    // POST /users — create a new user
+    app.route({
+      method: 'POST',
+      url: '/users',
+      schema: { body: CreateUserSchema },
+      handler(req: CelsianRequest, reply: CelsianReply) {
+        const { name, email } = req.parsedBody as CreateUserInput;
+        const user: User = {
+          id: db.generateId(),
+          name,
+          email,
+          createdAt: new Date().toISOString(),
+        };
+        db.users.set(user.id, user);
+        return reply.status(201).json(user);
+      },
+    });
+
+    // GET /users/:id — get a single user
+    app.get('/users/:id', (req, reply) => {
+      const user = db.users.get(req.params.id);
+      if (!user) return reply.status(404).json({ error: 'User not found' });
+      return reply.json(user);
+    });
+
+    // PUT /users/:id — update a user (protected)
+    app.route({
+      method: 'PUT',
+      url: '/users/:id',
+      schema: { body: UpdateUserSchema },
+      onRequest: requireAuth,
+      handler(req: CelsianRequest, reply: CelsianReply) {
+        const user = db.users.get(req.params.id);
+        if (!user) return reply.status(404).json({ error: 'User not found' });
+        const updates = req.parsedBody as UpdateUserInput;
+        if (updates.name !== undefined) user.name = updates.name;
+        if (updates.email !== undefined) user.email = updates.email;
+        db.users.set(user.id, user);
+        return reply.json(user);
+      },
+    });
+
+    // DELETE /users/:id — delete a user (protected)
+    app.route({
+      method: 'DELETE',
+      url: '/users/:id',
+      onRequest: requireAuth,
+      handler(req: CelsianRequest, reply: CelsianReply) {
+        const existed = db.users.delete(req.params.id);
+        if (!existed) return reply.status(404).json({ error: 'User not found' });
+        return reply.status(204).json({ deleted: true });
+      },
+    });
+  };
+}
+`,
+    // ─── src/routes/rpc.ts ───
+    'src/routes/rpc.ts': `// RPC endpoint — type-safe procedures at /_rpc/*
+// Demonstrates queries and mutations with typed schemas
+
+import { procedure, router, RPCHandler } from '@celsian/rpc';
+import { Type } from '@sinclair/typebox';
+import type { PluginFunction } from '@celsian/core';
+
+// Define your RPC router with namespaced procedures
+const appRouter = router({
+  greeting: {
+    hello: procedure
+      .input(Type.Object({ name: Type.String() }))
+      .query(({ input }) => {
+        const { name } = input as { name: string };
+        return { message: \`Hello, \${name}!\` };
+      }),
+  },
+  math: {
+    add: procedure
+      .input(Type.Object({ a: Type.Number(), b: Type.Number() }))
+      .query(({ input }) => {
+        const { a, b } = input as { a: number; b: number };
+        return { result: a + b };
+      }),
+    multiply: procedure
+      .input(Type.Object({ a: Type.Number(), b: Type.Number() }))
+      .mutation(({ input }) => {
+        const { a, b } = input as { a: number; b: number };
+        return { result: a * b };
+      }),
+  },
+  system: {
+    ping: procedure.query(() => {
+      return { pong: true, timestamp: Date.now() };
+    }),
+  },
+});
+
+// Export the router type for client-side inference
+export type AppRouter = typeof appRouter;
+
+export default function rpcRoutes(): PluginFunction {
+  return function rpc(app) {
+    const rpcHandler = new RPCHandler(appRouter);
+
+    app.route({
+      method: ['GET', 'POST'],
+      url: '/_rpc/*path',
+      handler(req) {
+        return rpcHandler.handle(req);
+      },
+    });
+  };
+}
+`,
+    // ─── src/tasks/cleanup.ts ───
+    'src/tasks/cleanup.ts': `// Background task: clean up expired sessions
+// Registered with app.task() and runs when enqueued or on a schedule
+
+import type { TaskDefinition } from '@celsian/core';
+
+/**
+ * Cleanup task — removes expired sessions from the in-memory store.
+ * In production, this would run a database query instead.
+ */
+export const cleanupTask: TaskDefinition = {
+  name: 'cleanup',
+  retries: 2,
+  timeout: 30_000,
+  async handler(_input, ctx) {
+    ctx.log.info('Running session cleanup...');
+
+    // In a real app, you would query the database:
+    // await db.query('DELETE FROM sessions WHERE expires_at < NOW()');
+
+    const now = Date.now();
+    let cleaned = 0;
+
+    // Placeholder: log what would happen
+    ctx.log.info(\`Session cleanup complete: removed \${cleaned} expired sessions\`);
+  },
+};
+`,
+    // ─── src/tasks/report.ts ───
+    'src/tasks/report.ts': `// Cron job: daily report generation
+// Runs every day at midnight via app.cron()
+
+/**
+ * Generate a daily summary report.
+ * In production, this might send an email, write to S3, or post to Slack.
+ */
+export async function generateDailyReport(): Promise<void> {
+  const now = new Date();
+  console.log(\`[report] Generating daily report for \${now.toISOString().split('T')[0]}\`);
+
+  // Placeholder — swap for real report logic:
+  // const users = await db.query('SELECT COUNT(*) FROM users WHERE created_at > $1', [yesterday]);
+  // const requests = await analytics.getRequestCount(yesterday, today);
+  // await email.send({ to: 'admin@example.com', subject: 'Daily Report', body: ... });
+
+  console.log('[report] Daily report generated successfully');
+}
+`,
+    // ─── src/index.ts ───
+    'src/index.ts': `// {{name}} — Full-stack Celsian API
+// Routes, plugins, background tasks, and cron — all wired up
+
+import { createApp, serve, openapi } from 'celsian';
+
+// Plugins
+import { authPlugin } from './plugins/auth.js';
+import { securityPlugins } from './plugins/security.js';
+
+// Database (module-level singleton — imported for side-effect seeding)
+import './plugins/database.js';
+
+// Routes
+import healthRoutes from './routes/health.js';
+import userRoutes from './routes/users.js';
+import rpcRoutes from './routes/rpc.js';
+
+// Tasks
+import { cleanupTask } from './tasks/cleanup.js';
+import { generateDailyReport } from './tasks/report.js';
+
+// ─── Create App ───
+
+const app = createApp({ logger: true });
+
+// ─── Security (CORS, CSRF, headers, rate limiting) ───
+
+for (const plugin of securityPlugins()) {
+  await app.register(plugin);
+}
+
+// ─── Auth (JWT signing & verification) ───
+
+await app.register(authPlugin());
+
+// ─── API Documentation (OpenAPI + Swagger UI) ───
+
+await app.register(openapi({
+  title: '{{name}} API',
+  version: '0.1.0',
+  description: 'Auto-generated API documentation',
+}));
+
+// ─── Routes ───
+
+await app.register(healthRoutes());
+await app.register(userRoutes());
+await app.register(rpcRoutes());
+
+// ─── Background Tasks ───
+
+app.task(cleanupTask);
+
+// ─── Cron Jobs ───
+
+// Clean up expired sessions every hour
+app.cron('session-cleanup', '0 * * * *', async () => {
+  await app.enqueue('cleanup', {});
+});
+
+// Generate a daily report at midnight
+app.cron('daily-report', '0 0 * * *', generateDailyReport);
+
+// ─── Start Server ───
+
+const port = parseInt(process.env.PORT ?? '3000', 10);
+
+serve(app, { port });
+`,
+    // ─── test/api.test.ts ───
+    'test/api.test.ts': `// Integration tests using app.inject() — no server needed
+// Run with: npm test
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { createApp } from 'celsian';
+
+// Import database module for side-effect (seeds demo user)
+import '../src/plugins/database.js';
+
+import healthRoutes from '../src/routes/health.js';
+import userRoutes from '../src/routes/users.js';
+import rpcRoutes from '../src/routes/rpc.js';
+
+function createTestApp() {
+  const app = createApp();
+  // Register just what we need — skip auth/security for tests
+  app.register(healthRoutes());
+  app.register(userRoutes());
+  app.register(rpcRoutes());
+  return app;
+}
+
+describe('Health', () => {
+  it('GET /health returns status ok', async () => {
+    const app = createTestApp();
+    const res = await app.inject({ url: '/health' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.status).toBe('ok');
+    expect(body).toHaveProperty('uptime');
+    expect(body).toHaveProperty('timestamp');
+  });
+});
+
+describe('Users CRUD', () => {
+  it('GET /users returns the seeded user', async () => {
+    const app = createTestApp();
+    const res = await app.inject({ url: '/users' });
+    expect(res.status).toBe(200);
+    const users = await res.json();
+    expect(Array.isArray(users)).toBe(true);
+    expect(users.length).toBeGreaterThanOrEqual(1);
+    expect(users[0]).toHaveProperty('name', 'Demo User');
+  });
+
+  it('POST /users creates a new user', async () => {
+    const app = createTestApp();
+    const res = await app.inject({
+      method: 'POST',
+      url: '/users',
+      payload: { name: 'Alice', email: 'alice@example.com' },
+    });
+    expect(res.status).toBe(201);
+    const user = await res.json();
+    expect(user.name).toBe('Alice');
+    expect(user.email).toBe('alice@example.com');
+    expect(user).toHaveProperty('id');
+    expect(user).toHaveProperty('createdAt');
+  });
+
+  it('GET /users/:id returns a specific user', async () => {
+    const app = createTestApp();
+
+    // Create a user first
+    const createRes = await app.inject({
+      method: 'POST',
+      url: '/users',
+      payload: { name: 'Bob', email: 'bob@example.com' },
+    });
+    const created = await createRes.json();
+
+    const res = await app.inject({ url: \`/users/\${created.id}\` });
+    expect(res.status).toBe(200);
+    const user = await res.json();
+    expect(user.id).toBe(created.id);
+    expect(user.name).toBe('Bob');
+  });
+
+  it('GET /users/:id returns 404 for unknown user', async () => {
+    const app = createTestApp();
+    const res = await app.inject({ url: '/users/99999' });
+    expect(res.status).toBe(404);
+  });
+
+  it('DELETE /users/:id without auth returns 401', async () => {
+    const app = createTestApp();
+    const res = await app.inject({ method: 'DELETE', url: '/users/1' });
+    // Without the JWT guard registered in test mode, the route handler runs directly.
+    // In the full app with auth, this would return 401.
+    // For the test app (no auth plugin), it just deletes.
+    expect([200, 204, 401].includes(res.status)).toBe(true);
+  });
+});
+
+describe('RPC', () => {
+  it('GET /_rpc/system.ping returns pong', async () => {
+    const app = createTestApp();
+    const res = await app.inject({ url: '/_rpc/system.ping' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.result).toHaveProperty('pong', true);
+  });
+
+  it('GET /_rpc/greeting.hello returns greeting', async () => {
+    const app = createTestApp();
+    const res = await app.inject({
+      url: '/_rpc/greeting.hello?input=' + encodeURIComponent(JSON.stringify({ name: 'World' })),
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.result.message).toBe('Hello, World!');
+  });
+
+  it('POST /_rpc/math.multiply performs mutation', async () => {
+    const app = createTestApp();
+    const res = await app.inject({
+      method: 'POST',
+      url: '/_rpc/math.multiply',
+      payload: { a: 6, b: 7 },
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.result.result).toBe(42);
+  });
+});
+`,
+    // ─── Dockerfile ───
+    Dockerfile: `# syntax=docker/dockerfile:1
+
+# ─── Build stage ───
+FROM node:22-slim AS builder
+WORKDIR /app
+
+COPY package.json package-lock.json* ./
+RUN npm ci --ignore-scripts
+
+COPY tsconfig.json ./
+COPY src/ ./src/
+
+RUN npx tsc
+
+# ─── Production stage ───
+FROM node:22-slim AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+# Create non-root user
+RUN addgroup --system appgroup && adduser --system --ingroup appgroup appuser
+
+COPY package.json package-lock.json* ./
+RUN npm ci --omit=dev --ignore-scripts
+
+COPY --from=builder /app/dist ./dist
+
+USER appuser
+EXPOSE 3000
+
+CMD ["node", "dist/index.js"]
+`,
+    // ─── README.md ───
+    'README.md': `# {{name}}
+
+A full-stack API built with [CelsianJS](https://github.com/CelsianJs/celsian) — the fast, modular Node.js framework.
+
+## Quick Start
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Copy environment variables
+cp .env.example .env
+
+# Start development server (with hot reload)
+npm run dev
+\`\`\`
+
+The server starts at **http://localhost:3000**. Open http://localhost:3000/docs for the Swagger UI.
+
+## Architecture
+
+\`\`\`
+src/
+  index.ts              # App entry — registers plugins, routes, tasks, cron
+  types.ts              # Shared TypeScript types
+  routes/
+    health.ts           # GET /health — uptime and status
+    users.ts            # Full CRUD: GET/POST/PUT/DELETE /users
+    rpc.ts              # Type-safe RPC at /_rpc/*
+  plugins/
+    auth.ts             # JWT authentication (sign, verify, guard)
+    database.ts         # In-memory database (replace with real DB)
+    security.ts         # CORS + CSRF + security headers + rate limiting
+  tasks/
+    cleanup.ts          # Background task: expired session cleanup
+    report.ts           # Cron job: daily report generation
+test/
+  api.test.ts           # Integration tests with app.inject()
+\`\`\`
+
+## API Endpoints
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | \`/health\` | No | Server health check |
+| GET | \`/users\` | No | List all users |
+| POST | \`/users\` | No | Create a user |
+| GET | \`/users/:id\` | No | Get a user by ID |
+| PUT | \`/users/:id\` | Yes | Update a user |
+| DELETE | \`/users/:id\` | Yes | Delete a user |
+| GET/POST | \`/_rpc/*\` | No | RPC procedures |
+| GET | \`/docs\` | No | Swagger UI |
+| GET | \`/docs/openapi.json\` | No | OpenAPI 3.1 spec |
+
+## Adding a New Route
+
+1. Create a new file in \`src/routes/\`:
+
+\`\`\`typescript
+// src/routes/products.ts
+import type { PluginFunction } from '@celsian/core';
+
+export default function productRoutes(): PluginFunction {
+  return function products(app) {
+    app.get('/products', (_req, reply) => {
+      return reply.json([{ id: 1, name: 'Widget' }]);
+    });
+  };
+}
+\`\`\`
+
+2. Register it in \`src/index.ts\`:
+
+\`\`\`typescript
+import productRoutes from './routes/products.js';
+await app.register(productRoutes());
+\`\`\`
+
+## Adding a Background Task
+
+1. Define the task in \`src/tasks/\`:
+
+\`\`\`typescript
+// src/tasks/email.ts
+import type { TaskDefinition } from '@celsian/core';
+
+export const sendEmailTask: TaskDefinition<{ to: string; subject: string }> = {
+  name: 'send-email',
+  retries: 3,
+  timeout: 10_000,
+  async handler(input, ctx) {
+    ctx.log.info(\\\`Sending email to \\\${input.to}\\\`);
+    // await emailService.send(input);
+  },
+};
+\`\`\`
+
+2. Register and enqueue it:
+
+\`\`\`typescript
+// In src/index.ts
+import { sendEmailTask } from './tasks/email.js';
+app.task(sendEmailTask);
+
+// In a route handler
+await app.enqueue('send-email', { to: 'user@example.com', subject: 'Welcome!' });
+\`\`\`
+
+## Adding a Cron Job
+
+\`\`\`typescript
+// In src/index.ts — uses standard 5-field cron syntax
+app.cron('weekly-digest', '0 9 * * 1', async () => {
+  // Runs every Monday at 9am
+  console.log('Generating weekly digest...');
+});
+\`\`\`
+
+## API Documentation
+
+OpenAPI 3.1 docs are auto-generated from your route schemas.
+
+- **Swagger UI**: http://localhost:3000/docs
+- **JSON spec**: http://localhost:3000/docs/openapi.json
+
+Add schemas to your routes for richer documentation:
+
+\`\`\`typescript
+import { Type } from '@sinclair/typebox';
+
+app.route({
+  method: 'POST',
+  url: '/products',
+  schema: {
+    body: Type.Object({
+      name: Type.String(),
+      price: Type.Number({ minimum: 0 }),
+    }),
+    response: {
+      201: Type.Object({ id: Type.Number(), name: Type.String() }),
+    },
+  },
+  handler(req, reply) {
+    // req.parsedBody is validated against the schema
+    return reply.status(201).json({ id: 1, ...req.parsedBody });
+  },
+});
+\`\`\`
+
+## Testing
+
+Tests use \`app.inject()\` — no HTTP server needed.
+
+\`\`\`bash
+npm test
+\`\`\`
+
+Write tests by creating a lightweight app and injecting requests:
+
+\`\`\`typescript
+import { createApp } from 'celsian';
+
+const app = createApp();
+app.get('/ping', (_req, reply) => reply.json({ pong: true }));
+
+const res = await app.inject({ url: '/ping' });
+const body = await res.json();
+// body = { pong: true }
+\`\`\`
+
+## Deployment
+
+### Docker
+
+\`\`\`bash
+docker build -t {{name}} .
+docker run -p 3000:3000 --env-file .env {{name}}
+\`\`\`
+
+### Fly.io
+
+\`\`\`bash
+fly launch
+fly secrets set JWT_SECRET=your-secret
+fly deploy
+\`\`\`
+
+### Railway
+
+Push to a connected GitHub repo. Set environment variables in the Railway dashboard. The included Dockerfile is auto-detected.
+
+### Vercel (Serverless)
+
+Use \`@celsian/adapter-vercel\`:
+
+\`\`\`bash
+npm install @celsian/adapter-vercel
+\`\`\`
+
+See the [adapter docs](https://github.com/CelsianJs/celsian/tree/main/packages/adapter-vercel) for configuration.
+
+### Cloudflare Workers
+
+Use \`@celsian/adapter-cloudflare\`:
+
+\`\`\`bash
+npm install @celsian/adapter-cloudflare
+\`\`\`
+
+CelsianJS uses standard Web APIs (Request/Response), making it compatible with edge runtimes out of the box.
+
+## Project Structure Explained
+
+- **Plugins** are registered with \`app.register()\` and can decorate the app, add hooks, or define routes.
+- **Routes** are plugins that add HTTP endpoints. Group them by domain (users, products, etc.).
+- **Tasks** are background jobs processed by the built-in task worker. Enqueue from route handlers.
+- **Cron** schedules are standard 5-field Unix cron expressions. The scheduler ticks every second.
+- **Hooks** run at different lifecycle stages: \`onRequest\`, \`preHandler\`, \`onSend\`, \`onError\`, etc.
+
+## License
+
+MIT
+`,
+};
+//# sourceMappingURL=full.js.map

package/dist/templates/full.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"full.js","sourceRoot":"","sources":["../../src/templates/full.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-celsian",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "create-celsian": "dist/index.js"
@@ -10,8 +10,8 @@
   "files": [
     "dist"
   ],
-  "license": "MIT",
   "scripts": {
     "build": "tsc -b"
-  }
-}
+  },
+  "license": "MIT"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 ThenJS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.