create-gramstax 0.0.1

package/dist/src/create.d.ts

@@ -0,0 +1,34 @@
+export declare class Create {
+    private projectDirectory?;
+    private version?;
+    private config;
+    constructor(projectDirectory?: string | undefined, version?: string | undefined);
+    printBanner(): void;
+    private getPackageManagerCommands;
+    /**
+     * Recursively copy directory structure
+     */
+    private copyDirectorySync;
+    /**
+     * Replace template variables in content
+     */
+    private replaceTemplateVariables;
+    private promptForProjectName;
+    private promptForConfiguration;
+    private installDependencies;
+    /**
+     * Step 1: Gather all project configuration through prompts
+     * NO EXECUTION - hanya mengumpulkan data dan validasi ringan
+     */
+    private gatherProjectConfig;
+    /**
+     * Step 2: Execute project generation based on gathered config
+     */
+    private executeProjectGeneration;
+    private setupEslintConfig;
+    /**
+     * Main public method: Prompt first, then execute
+     */
+    createProject(): Promise<void>;
+}
+//# sourceMappingURL=create.d.ts.map

package/dist/src/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/create.ts"],"names":[],"mappings":"AAgBA,qBAAa,MAAM;IAGE,OAAO,CAAC,gBAAgB,CAAC;IAAU,OAAO,CAAC,OAAO,CAAC;IAFtE,OAAO,CAAC,MAAM,CAA2B;gBAEd,gBAAgB,CAAC,EAAE,MAAM,YAAA,EAAU,OAAO,CAAC,EAAE,MAAM,YAAA;IAIvE,WAAW;IAelB,OAAO,CAAC,yBAAyB;IAkDjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4BzB;;OAEG;IACH,OAAO,CAAC,wBAAwB;YAQlB,oBAAoB;YAqBpB,sBAAsB;YAkDtB,mBAAmB;IA0BjC;;;OAGG;YACW,mBAAmB;IAiEjC;;OAEG;YACW,wBAAwB;YAuExB,iBAAiB;IAyB/B;;OAEG;IACU,aAAa;CAgB3B"}

package/dist/src/create.js

@@ -0,0 +1,367 @@
+import * as fs from "fs";
+import * as path from "path";
+import { log } from "./utils/logger";
+import { spawn } from "child_process";
+import enquirer from "enquirer";
+export class Create {
+    projectDirectory;
+    version;
+    config;
+    constructor(projectDirectory, version) {
+        this.projectDirectory = projectDirectory;
+        this.version = version;
+        // Constructor hanya menerima parameter, tidak melakukan execution
+    }
+    printBanner() {
+        const banner = `
+ $$$$$$\\                                               $$\\                         
+$$  __$$\\                                              $$ |                        
+$$ /  \\__| $$$$$$\\  $$$$$$\\  $$$$$$\\$$$$\\   $$$$$$$\\ $$$$$$\\    $$$$$$\\  $$\\   $$\\ 
+$$ |$$$$\\ $$  __$$\\ \\____$$\\ $$  _$$  _$$\\ $$  _____|\\_$$  _|   \\____$$\\ \\$$\\ $$  |
+$$ |\\_$$ |$$ |  \\__|$$$$$$$ |$$ / $$ / $$ |\\$$$$$$\\    $$ |     $$$$$$$ | \\$$$$  / 
+$$ |  $$ |$$ |     $$  __$$ |$$ | $$ | $$ | \\____$$\\   $$ |$$\\ $$  __$$ | $$  $$<  
+\\$$$$$$  |$$ |     \\$$$$$$$ |$$ | $$ | $$ |$$$$$$$  |  \\$$$$  |\\$$$$$$$ |$$  /\\$$\\ 
+ \\______/ \\__|      \\_______|\\__| \\__| \\__|\\_______/    \\____/  \\_______|\\__/  \\__|
+                                                                                                                                            
+`;
+        console.log(banner);
+    }
+    getPackageManagerCommands(packageManager) {
+        const commands = {
+            bun: {
+                install: `bun install`,
+                dev: `bun dev`,
+                start: `bun start`,
+                "pm2:start": `bun run pm2:start`,
+                "pm2:stop": `bun run pm2:stop`,
+                "pm2:restart": `bun run pm2:restart`,
+                "pm2:delete": `bun run pm2:delete`,
+                "pm2:logs": `bun run pm2:logs`,
+                "pm2:monit": `bun run pm2:monit`
+            },
+            npm: {
+                install: `npm install`,
+                dev: `npm run dev`,
+                start: `npm start`,
+                "pm2:start": `npm run pm2:start`,
+                "pm2:stop": `npm run pm2:stop`,
+                "pm2:restart": `npm run pm2:restart`,
+                "pm2:delete": `npm run pm2:delete`,
+                "pm2:logs": `npm run pm2:logs`,
+                "pm2:monit": `npm run pm2:monit`
+            },
+            pnpm: {
+                install: `pnpm install`,
+                dev: `pnpm dev`,
+                start: `pnpm start`,
+                "pm2:start": `pnpm pm2:start`,
+                "pm2:stop": `pnpm pm2:stop`,
+                "pm2:restart": `pnpm pm2:restart`,
+                "pm2:delete": `pnpm pm2:delete`,
+                "pm2:logs": `pnpm pm2:logs`,
+                "pm2:monit": `pnpm pm2:monit`
+            },
+            yarn: {
+                install: `yarn install`,
+                dev: `yarn dev`,
+                start: `yarn start`,
+                "pm2:start": `yarn pm2:start`,
+                "pm2:stop": `yarn pm2:stop`,
+                "pm2:restart": `yarn pm2:restart`,
+                "pm2:delete": `yarn pm2:delete`,
+                "pm2:logs": `yarn pm2:logs`,
+                "pm2:monit": `yarn pm2:monit`
+            }
+        };
+        return commands[packageManager];
+    }
+    /**
+     * Recursively copy directory structure
+     */
+    copyDirectorySync(source, destination, variables = {}) {
+        // Create destination directory if it doesn't exist
+        if (!fs.existsSync(destination)) {
+            fs.mkdirSync(destination, { recursive: true });
+        }
+        // Read all items in source directory
+        const items = fs.readdirSync(source, { withFileTypes: true });
+        for (const item of items) {
+            const sourcePath = path.join(source, item.name);
+            const destPath = path.join(destination, item.name);
+            if (item.isDirectory()) {
+                // Recursively copy subdirectories
+                this.copyDirectorySync(sourcePath, destPath, variables);
+            }
+            else if (item.isFile()) {
+                // Copy file and replace variables if needed
+                let content = fs.readFileSync(sourcePath, `utf-8`);
+                // Replace template variables in content
+                content = this.replaceTemplateVariables(content, variables);
+                fs.writeFileSync(destPath, content);
+            }
+        }
+    }
+    /**
+     * Replace template variables in content
+     */
+    replaceTemplateVariables(content, variables) {
+        let result = content;
+        for (const [key, value] of Object.entries(variables)) {
+            result = result.replace(new RegExp(`{{${key}}}`, `g`), value);
+        }
+        return result;
+    }
+    async promptForProjectName() {
+        const response = await enquirer.prompt({
+            type: `input`,
+            name: `projectName`,
+            message: `What is your project named?`,
+            initial: ``,
+            validate: (value) => {
+                if (value === ``) {
+                    return true;
+                }
+                if (!/^[a-z0-9-_]+$/i.test(value)) {
+                    return `Project name can only contain letters, numbers, hyphens, and underscores`;
+                }
+                return true;
+            }
+        });
+        return response.projectName;
+    }
+    async promptForConfiguration() {
+        const questions = [];
+        // Package manager selection
+        questions.push({
+            type: `select`,
+            name: `packageManager`,
+            message: `Which package manager would you like to use?`,
+            choices: [
+                { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+                { name: `npm`, message: `npm`, value: `npm` },
+                { name: `pnpm`, message: `pnpm`, value: `pnpm` },
+                { name: `yarn`, message: `Yarn`, value: `yarn` }
+            ],
+            initial: 0
+        });
+        // Runtime selection
+        questions.push({
+            type: `select`,
+            name: `runtime`,
+            message: `Which runtime would you like to use?`,
+            choices: [
+                { name: `bun`, message: `Bun (recommended)`, value: `bun` },
+                { name: `node`, message: `Node.js`, value: `node` }
+            ],
+            initial: 0
+        });
+        // ESLint
+        questions.push({
+            type: `confirm`,
+            name: `eslint`,
+            message: `Would you like to use ESLint?`,
+            initial: true
+        });
+        const answers = await enquirer.prompt(questions);
+        return {
+            packageManager: answers.packageManager,
+            runtime: answers.runtime,
+            eslint: answers.eslint
+        };
+    }
+    async installDependencies(projectPath, packageManager) {
+        return await new Promise((resolve, reject) => {
+            const installCommand = packageManager;
+            const installArgs = [`install`];
+            const installProcess = spawn(installCommand, installArgs, {
+                cwd: projectPath,
+                stdio: `inherit`,
+                shell: true
+            });
+            installProcess.on(`close`, (code) => {
+                if (code === 0) {
+                    resolve(true);
+                }
+                else {
+                    log.fail(`Dependencies installation failed`);
+                    resolve(false);
+                }
+            });
+            installProcess.on(`error`, (error) => {
+                log.fail(`Dependencies installation failed: ${error.message}`);
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Step 1: Gather all project configuration through prompts
+     * NO EXECUTION - hanya mengumpulkan data dan validasi ringan
+     */
+    async gatherProjectConfig() {
+        // Display ASCII art banner
+        this.printBanner();
+        // ========== PHASE 1: GET PROJECT NAME ==========
+        let projectName = this.projectDirectory;
+        let projectPath;
+        let useCurrentDir = false;
+        if (!projectName) {
+            // PROMPT untuk project name
+            projectName = await this.promptForProjectName();
+            if (projectName === ``) {
+                // Empty name means use current directory
+                projectName = path.basename(process.cwd());
+                projectPath = process.cwd();
+                useCurrentDir = true;
+            }
+            else {
+                projectPath = path.resolve(process.cwd(), projectName);
+                useCurrentDir = false;
+            }
+        }
+        else {
+            projectPath = path.resolve(process.cwd(), projectName);
+            useCurrentDir = false;
+        }
+        // PROMPT untuk configuration
+        const config = await this.promptForConfiguration();
+        const packageManager = config.packageManager;
+        const runtime = config.runtime;
+        const setupEslint = config.eslint;
+        // ========== SEMUA PROMPT SELESAI, SEKARANG VALIDASI ==========
+        log.info(`Create-gramstax v${this.version}`);
+        log.info(`Project: ${projectName}`);
+        log.info(`Location: ${projectPath}`);
+        log.info(`Package Manager: ${packageManager}`);
+        log.info(`Runtime: ${runtime}`);
+        log.info(`ESLint: ${setupEslint ? `Yes` : `No`}`);
+        // Validasi setelah semua prompt selesai
+        if (useCurrentDir) {
+            // Check if current directory is empty
+            const files = fs.readdirSync(projectPath);
+            if (files.length > 0) {
+                log.error(`Current directory is not empty!`);
+                process.exit(1);
+            }
+        }
+        else {
+            // Check if directory already exists
+            if (fs.existsSync(projectPath)) {
+                log.error(`Directory "${projectName}" already exists!`);
+                process.exit(1);
+            }
+        }
+        return {
+            projectName,
+            projectPath,
+            packageManager,
+            runtime,
+            setupEslint
+        };
+    }
+    /**
+     * Step 2: Execute project generation based on gathered config
+     */
+    async executeProjectGeneration(config) {
+        const { projectName, projectPath, packageManager, runtime, setupEslint } = config;
+        // Task 1: Create project directory
+        log.info(`Creating project directory..`);
+        if (!fs.existsSync(projectPath)) {
+            fs.mkdirSync(projectPath, { recursive: true });
+        }
+        // Task 2: Copy template files
+        log.info(`Copying template files..`);
+        const templatesPath = path.join(__dirname, `templates`);
+        const commands = this.getPackageManagerCommands(packageManager);
+        const variables = {
+            projectName,
+            installCmd: commands.install,
+            runDevCmd: commands.dev,
+            runStartCmd: commands.start,
+            runPm2StartCmd: commands[`pm2:start`],
+            runPm2StopCmd: commands[`pm2:stop`],
+            runPm2RestartCmd: commands[`pm2:restart`],
+            runPm2DeleteCmd: commands[`pm2:delete`],
+            runPm2LogsCmd: commands[`pm2:logs`],
+            runPm2MonitCmd: commands[`pm2:monit`]
+        };
+        this.copyDirectorySync(templatesPath, projectPath, variables);
+        // Task 3: Create logs directory
+        log.info(`Creating logs directory..`);
+        fs.mkdirSync(path.join(projectPath, `logs`), { recursive: true });
+        fs.writeFileSync(path.join(projectPath, `logs/.gitkeep`), ``);
+        // Task 4: Create .env.example
+        const envPath = path.join(projectPath, `.env`);
+        const envExamplePath = path.join(projectPath, `.env.example`);
+        if (fs.existsSync(envExamplePath)) {
+            log.info(`Creating .env file..`);
+            fs.renameSync(envExamplePath, envPath);
+        }
+        // Task 5: Remove bunfig.toml if runtime is NOT bun
+        if (runtime !== `bun`) {
+            log.info(`Removing bunfig.toml for Node.js runtime..`);
+            const bunfigPath = path.join(projectPath, `bunfig.toml`);
+            if (fs.existsSync(bunfigPath)) {
+                fs.unlinkSync(bunfigPath);
+            }
+        }
+        // Task 6: Install dependencies
+        log.info(`Installing dependencies..`);
+        if (!(await this.installDependencies(projectPath, packageManager))) {
+            log.fail(`Project created failed!`);
+            return process.exit();
+        }
+        // Task 7: Setup ESLint if requested
+        if (setupEslint) {
+            log.info(`Setting up ESLint..`);
+            await this.setupEslintConfig(projectPath, packageManager);
+        }
+        // Final success message
+        log.info(`Project created successfully!`);
+        log.info(`Next steps: ${config.projectPath !== process.cwd() ? `cd ${projectName} && ` : ` `}${commands.install} && ${commands.dev}`);
+        log.info(`For production: ${commands[`pm2:start`]}`);
+        log.info(`Done..`);
+    }
+    async setupEslintConfig(projectPath, packageManager) {
+        return new Promise((resolve) => {
+            const initProcess = spawn(`npm`, [`init`, `@eslint/config@latest`], {
+                cwd: projectPath,
+                stdio: `inherit`,
+                shell: true
+            });
+            initProcess.on(`close`, (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    log.fail(`ESLint setup failed. You can set it up later with: npm init @eslint/config`);
+                    resolve();
+                }
+            });
+            initProcess.on(`error`, (error) => {
+                log.fail(`ESLint setup failed: ${error.message}`);
+                log.info(`You can set it up later with: npm init @eslint/config`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Main public method: Prompt first, then execute
+     */
+    async createProject() {
+        try {
+            // Step 1: Gather all configuration through prompts
+            this.config = await this.gatherProjectConfig();
+            // Step 2: Execute project generation with the gathered config
+            await this.executeProjectGeneration(this.config);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Failed to create project: ${error.message}`);
+            }
+            else {
+                log.error(`Failed to create project: ${String(error)}`);
+            }
+            process.exit(1);
+        }
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":""}

package/dist/src/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import * as fs from "fs";
+import * as path from "path";
+import { log } from "./utils/logger";
+import { Create } from "./create";
+import { Command } from "commander";
+// Read version from package.json
+const packageJsonPath = path.join(__dirname, `../package.json`);
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, `utf-8`));
+const version = packageJson.version || `0.0.0`;
+const program = new Command();
+program
+    .name(`create-gramstax`)
+    .description(`CLI to create a new Gramstax Telegram bot project`)
+    .version(version)
+    .argument(`[project-directory]`, `Directory to create the project in`)
+    .action(async (projectDirectory) => {
+    try {
+        await new Create(projectDirectory, version).createProject();
+    }
+    catch (error) {
+        log.error(`Failed to create project: ${String(error)}`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/src/templates/.env.example

@@ -0,0 +1,17 @@
+# Telegram Bot Token
+BOT_TOKEN=your_bot_token_here
+
+# Bot Deployment Mode
+# Options: 
+#   - polling (default, recommended for development)
+#   - webhook:https://yourdomain.com (for production)
+BOT_DEPLOY=polling
+
+# Environment
+NODE_ENV=development
+
+# Cache configuration for session
+# Options: 
+#   - memory
+#   - redis://... (use redis)
+CACHE_SESSION=memory

package/dist/src/templates/.prettierignore

@@ -0,0 +1 @@
+*.html

package/dist/src/templates/.prettierrc

@@ -0,0 +1,23 @@
+{
+  "overrides": [
+    {
+      "files": "*.{json,sol}",
+      "options": {
+        "tabWidth": 2,
+        "printWidth": 200
+      }
+    },
+    {
+      "files": "*.{ts,js}",
+      "options": {
+        "printWidth": 300,
+        "tabWidth": 2,
+        "useTabs": false,
+        "semi": false,
+        "arrowParens": "always",
+        "trailingComma": "none",
+        "bracketSameLine": false
+      }
+    }
+  ]
+}

package/dist/src/templates/README.md

@@ -0,0 +1,121 @@
+# {{projectName}}
+
+A Telegram bot built with Gramstax framework.
+
+## Getting Started
+
+### Development
+
+1. Install dependencies:
+
+```bash
+{{installCmd}}
+```
+
+2. Set up your environment variables:
+
+Copy `.env.example` to `.env` and add your Telegram bot token:
+
+```bash
+BOT_TOKEN=your_bot_token_here
+```
+
+3. Run the development server:
+
+```bash
+{{runDevCmd}}
+```
+
+### Production
+
+#### Using PM2 (Recommended)
+
+PM2 is a production process manager for Node.js applications with built-in load balancer.
+
+1. Install dependencies:
+
+```bash
+{{installCmd}}
+```
+
+2. Set up production environment:
+
+```bash
+cp .env.example .env
+# Edit .env with your production BOT_TOKEN
+```
+
+3. Start with PM2:
+
+```bash
+{{runPm2StartCmd}}
+```
+
+4. PM2 Management Commands:
+
+```bash
+# View logs
+{{runPm2LogsCmd}}
+
+# Monitor processes
+{{runPm2MonitCmd}}
+
+# Restart bot
+{{runPm2RestartCmd}}
+
+# Stop bot
+{{runPm2StopCmd}}
+
+# Delete from PM2
+{{runPm2DeleteCmd}}
+```
+
+5. Setup PM2 to start on system boot:
+
+```bash
+pm2 startup
+pm2 save
+```
+
+#### Using Bun directly
+
+```bash
+{{runStartCmd}}
+```
+
+## Project Structure
+
+- `src/base/` - Base classes for your bot components
+- `src/core/` - Core bot configuration and hooks
+- `src/pages/` - Bot pages/screens
+- `src/guards/` - Route guards and middleware
+- `src/services/` - Business logic services
+- `src/repositories/` - Data access layer
+- `src/templates/` - Message templates
+- `src/utils/` - Utility functions
+- `logs/` - Application logs (created automatically)
+
+## Configuration
+
+### Environment Variables
+
+- `BOT_TOKEN` - Your Telegram bot token (required)
+- `NODE_ENV` - Environment mode (development/production)
+- `CACHE_SESSION` - Cache type configuration (optional)
+
+### PM2 Configuration
+
+The `ecosystem.config.cjs` file contains PM2 configuration:
+
+- **instances**: Number of instances (default: 1)
+- **exec_mode**: Execution mode (cluster/fork)
+- **max_memory_restart**: Auto-restart if memory exceeds limit
+- **autorestart**: Auto-restart on crash
+- **error_file/out_file**: Log file locations
+
+## Learn More
+
+- [Gramstax Documentation](https://github.com/gramstax/gramstax)
+- [Grammy Documentation](https://grammy.dev/)
+- [Telegram Bot API](https://core.telegram.org/bots/api)
+- [PM2 Documentation](https://pm2.keymetrics.io/)

package/dist/src/templates/bunfig.toml

@@ -0,0 +1,2 @@
+[run]
+console.depth = 4

package/dist/src/templates/ecosystem.config.cjs

@@ -0,0 +1,26 @@
+module.exports = {
+  apps: [
+    {
+      name: `{{projectName}}`, // Process name (appears in 'pm2 list')
+      script: `bun`, // Main command to run (using Bun runtime)
+      args: `src/index.ts`, // Arguments for the command (entry file)
+      instances: 1, // Number of instances (use 'max' for multi-core)
+      exec_mode: `fork`, // Cluster mode (PM2 will balance across cores)
+      autorestart: true, // Automatically restart if the process crashes
+      watch: false, // Disable auto-reload on file changes (set true for dev)
+      max_memory_restart: undefined, // Restart if memory usage exceeds (default undefined)
+      env: {
+        NODE_ENV: `production`, // Default environment variables
+      },
+      env_production: {
+        NODE_ENV: `production`, // Environment variables for production mode
+      },
+      error_file: `./logs/err.log`, // Error log file
+      out_file: `./logs/out.log`, // Standard output log file
+      log_file: `./logs/combined.log`, // Combined log file
+      time: false, // Add timestamps to logs
+      merge_logs: false, // Merge logs from multiple instances
+      log_date_format: `YYYY-MM-DD HH:mm:ss Z`, // Log date format
+    },
+  ],
+};