create-paljs 1.0.0

package/bin/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { CreatePal } from '../dist/index.js';
+
+const app = new CreatePal();
+app.run().catch((error) => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export declare class CreatePal {
+    private projectName;
+    private projectDir;
+    private selectedTemplate;
+    private packageManager;
+    private gitInit;
+    private skipInstall;
+    private verbose;
+    run(): Promise<void>;
+    private detectPackageManager;
+    private showHelp;
+    private printBanner;
+    private prompt;
+    private promptChoice;
+    private downloadTemplate;
+    private prepareProject;
+    private installDependencies;
+    private initGit;
+    private printSuccess;
+    private spinner;
+}

package/dist/index.js

@@ -0,0 +1,271 @@
+import gradient from 'gradient-string';
+import { downloadTemplate } from 'giget';
+import { execa } from 'execa';
+import { existsSync, readFileSync, writeFileSync, cpSync, rmSync, readdirSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { templates, getTemplateByAlias } from './templates.js';
+const VERSION = '1.0.0';
+export class CreatePal {
+    constructor() {
+        this.projectName = '';
+        this.projectDir = '';
+        this.selectedTemplate = '';
+        this.packageManager = 'npm';
+        this.gitInit = false;
+        this.skipInstall = false;
+        this.verbose = false;
+    }
+    async run() {
+        const args = process.argv.slice(2);
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg === '--template' || arg === '-t') {
+                this.selectedTemplate = args[++i];
+            }
+            else if (arg === '--git' || arg === '-g') {
+                this.gitInit = true;
+            }
+            else if (arg === '--skip-install') {
+                this.skipInstall = true;
+            }
+            else if (arg === '--verbose' || arg === '-v') {
+                this.verbose = true;
+            }
+            else if (arg === '--help' || arg === '-h') {
+                this.showHelp();
+                process.exit(0);
+            }
+            else if (!arg.startsWith('-')) {
+                this.projectName = arg;
+            }
+        }
+        this.packageManager = this.detectPackageManager();
+        this.printBanner();
+        if (!this.projectName) {
+            this.projectName = await this.prompt('project name', 'my-pal-app');
+        }
+        this.projectDir = isAbsolute(this.projectName)
+            ? this.projectName
+            : join(process.cwd(), this.projectName);
+        if (!this.selectedTemplate) {
+            this.selectedTemplate = await this.promptChoice('Select a starter kit', templates.map((t) => ({ name: `${t.name} - ${t.hint}`, value: t.alias })));
+        }
+        const template = getTemplateByAlias(this.selectedTemplate);
+        if (!template) {
+            throw new Error(`Unknown template: ${this.selectedTemplate}`);
+        }
+        await this.downloadTemplate(template.source);
+        await this.prepareProject();
+        if (!this.skipInstall) {
+            await this.installDependencies();
+        }
+        if (this.gitInit) {
+            await this.initGit();
+        }
+        this.printSuccess();
+    }
+    detectPackageManager() {
+        const npmExecPath = process.env['npm_execpath'];
+        const npmConfig = process.env['npm_config_user_agent'];
+        if (npmConfig?.includes('pnpm'))
+            return 'pnpm';
+        if (npmConfig?.includes('yarn'))
+            return 'yarn';
+        if (npmConfig?.includes('bun'))
+            return 'bun';
+        if (npmExecPath?.includes('pnpm'))
+            return 'pnpm';
+        if (npmExecPath?.includes('yarn'))
+            return 'yarn';
+        if (npmExecPath?.includes('bun'))
+            return 'bun';
+        return 'npm';
+    }
+    showHelp() {
+        console.log(`
+Usage: create-pal [project-name] [options]
+
+Options:
+  -t, --template <name>  Starter kit template (api, admin, client)
+  -g, --git              Initialize git repository
+  --skip-install         Skip installing dependencies
+  -v, --verbose          Enable verbose mode
+  -h, --help             Show this help message
+
+Examples:
+  create-pal my-project
+  create-pal my-project --template api
+  create-pal my-project --git
+  create-pal my-project --skip-install
+    `);
+    }
+    printBanner() {
+        const title = `
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ███████╗██╗   ██╗███████╗████████╗███████╗███╗   ███╗ ║
+║   ██╔════╝╚██╗ ██╔╝██╔════╝╚══██╔══╝██╔════╝████╗ ████║ ║
+║   ███████╗ ╚████╔╝ ███████╗   ██║   █████╗  ██╔████╔██║ ║
+║   ╚════██║  ╚██╔╝  ╚════██║   ██║   ██╔══╝  ██║╚██╔╝██║ ║
+║   ███████║   ██║   ███████║   ██║   ███████╗██║ ╚═╝ ██║ ║
+║   ╚══════╝   ╚═╝   ╚══════╝   ╚═╝   ╚══════╝╚═╝     ╚═╝ ║
+║                                                           ║
+║   The batteries-included full-stack framework             ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+    `.trim();
+        console.log(gradient.pastel.multiline(title));
+        console.log();
+    }
+    async prompt(question, defaultValue) {
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${question} (${defaultValue}): `, (answer) => {
+                rl.close();
+                resolve(answer.trim() || defaultValue);
+            });
+        });
+    }
+    async promptChoice(question, choices) {
+        console.log(`\n${question}:`);
+        choices.forEach((choice, index) => {
+            console.log(`  ${index + 1}. ${choice.name}`);
+        });
+        console.log();
+        const answer = await this.prompt('Enter choice number', '1');
+        const index = parseInt(answer, 10) - 1;
+        if (index >= 0 && index < choices.length) {
+            return choices[index].value;
+        }
+        return choices[0].value;
+    }
+    async downloadTemplate(source) {
+        console.log(`\n📦 Downloading template from: ${source}`);
+        if (existsSync(this.projectDir)) {
+            const files = readdirSync(this.projectDir);
+            if (files.length > 0) {
+                rmSync(this.projectDir, { recursive: true, force: true });
+            }
+        }
+        await downloadTemplate(source, {
+            dir: this.projectDir,
+            registry: false,
+        });
+        console.log('✅ Template downloaded successfully');
+    }
+    async prepareProject() {
+        console.log('\n🔧 Preparing project...');
+        const pkgJsonPath = join(this.projectDir, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            pkgJson.name = this.projectName.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+            writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        }
+        const envExample = join(this.projectDir, '.env.example');
+        const envFile = join(this.projectDir, '.env');
+        if (existsSync(envExample) && !existsSync(envFile)) {
+            cpSync(envExample, envFile);
+        }
+        const gitignore = join(this.projectDir, '.gitignore');
+        const gitignoreContent = `
+node_modules/
+dist/
+build/
+.turbo/
+.env
+*.log
+coverage/
+.vscode/
+.idea/
+`;
+        if (existsSync(gitignore)) {
+            const existing = readFileSync(gitignore, 'utf-8');
+            if (!existing.includes('node_modules/')) {
+                writeFileSync(gitignore, existing + gitignoreContent);
+            }
+        }
+        else {
+            writeFileSync(gitignore, gitignoreContent.trim() + '\n');
+        }
+        const lockFiles = [
+            join(this.projectDir, 'package-lock.json'),
+            join(this.projectDir, 'pnpm-lock.yaml'),
+            join(this.projectDir, 'yarn.lock'),
+        ];
+        lockFiles.forEach((file) => {
+            if (existsSync(file)) {
+                rmSync(file);
+            }
+        });
+        console.log('✅ Project prepared successfully');
+    }
+    async installDependencies() {
+        if (!existsSync(join(this.projectDir, 'package.json'))) {
+            console.log('⚠️  No package.json found, skipping install');
+            return;
+        }
+        console.log(`\n📦 Installing dependencies using ${this.packageManager}...`);
+        const spinner = this.spinner('Installing');
+        try {
+            await execa(this.packageManager, ['install'], {
+                cwd: this.projectDir,
+                stdio: this.verbose ? 'inherit' : 'pipe',
+            });
+            spinner.stop();
+            console.log('✅ Dependencies installed successfully');
+        }
+        catch (error) {
+            spinner.stop();
+            throw new Error(`Failed to install dependencies: ${error.message}`);
+        }
+    }
+    async initGit() {
+        console.log('\n📂 Initializing git repository...');
+        try {
+            await execa('git', ['init'], {
+                cwd: this.projectDir,
+                stdio: this.verbose ? 'inherit' : 'pipe',
+            });
+            console.log('✅ Git repository initialized');
+        }
+        catch {
+            console.log('⚠️  Failed to initialize git (git may not be installed)');
+        }
+    }
+    printSuccess() {
+        const message = `
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ✅ Your Pal project has been created successfully!       ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+Next steps:
+  cd ${this.projectName}
+  npm run dev
+
+Documentation: https://github.com/paljs/paljs
+    `.trim();
+        console.log(gradient.pastel.multiline(message));
+    }
+    spinner(message) {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        const interval = setInterval(() => {
+            process.stdout.write(`\r${frames[i++ % frames.length]} ${message}`);
+        }, 80);
+        return {
+            stop: () => {
+                clearInterval(interval);
+                process.stdout.write('\r' + ' '.repeat(50) + '\r');
+            },
+            update: (msg) => {
+                process.stdout.write(`\r${msg}`);
+            },
+        };
+    }
+}

package/dist/templates.d.ts

@@ -0,0 +1,9 @@
+export interface Template {
+    name: string;
+    alias: string;
+    hint: string;
+    source: string;
+}
+export declare const templates: Template[];
+export declare function getTemplateByAlias(alias: string): Template | undefined;
+export declare function getTemplateByName(name: string): Template | undefined;

package/dist/templates.js

@@ -0,0 +1,26 @@
+export const templates = [
+    {
+        name: 'API',
+        alias: 'api',
+        hint: 'Type-safe REST API with authentication and database',
+        source: 'github:paljs/starter-kits#main:api',
+    },
+    {
+        name: 'Admin',
+        alias: 'admin',
+        hint: 'Admin dashboard with authentication and UI components',
+        source: 'github:paljs/starter-kits#main:admin',
+    },
+    {
+        name: 'Client',
+        alias: 'client',
+        hint: 'Full-stack client application with frontend and API',
+        source: 'github:paljs/starter-kits#main:client',
+    },
+];
+export function getTemplateByAlias(alias) {
+    return templates.find((t) => t.alias === alias);
+}
+export function getTemplateByName(name) {
+    return templates.find((t) => t.name.toLowerCase() === name.toLowerCase());
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "create-paljs",
+  "version": "1.0.0",
+  "description": "Scaffold a new PalJS project",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-paljs": "./bin/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paljs/paljs.git"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "dependencies": {
+    "gradient-string": "^3.0.0",
+    "giget": "^3.1.2",
+    "execa": "^9.5.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "paljs",
+    "framework",
+    "scaffold",
+    "create",
+    "boilerplate",
+    "rpal"
+  ]
+}