create-gramstax 0.0.1 → 0.0.3

package/src/create.ts

@@ -1,415 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { log } from "./utils/logger"
-import { spawn } from "child_process"
-import enquirer from "enquirer"
-
-type Runtime = `bun` | `node`
-type PackageManager = `bun` | `npm` | `pnpm` | `yarn`
-type ProjectConfig = {
-  projectName: string
-  projectPath: string
-  packageManager: PackageManager
-  runtime: Runtime
-  setupEslint: boolean
-}
-
-export class Create {
-  private config: ProjectConfig | undefined
-
-  public constructor(private projectDirectory?: string, private version?: string) {
-    // Constructor hanya menerima parameter, tidak melakukan execution
-  }
-
-  public printBanner() {
-    const banner = `
- $$$$$$\\                                               $$\\                         
-$$  __$$\\                                              $$ |                        
-$$ /  \\__| $$$$$$\\  $$$$$$\\  $$$$$$\\$$$$\\   $$$$$$$\\ $$$$$$\\    $$$$$$\\  $$\\   $$\\ 
-$$ |$$$$\\ $$  __$$\\ \\____$$\\ $$  _$$  _$$\\ $$  _____|\\_$$  _|   \\____$$\\ \\$$\\ $$  |
-$$ |\\_$$ |$$ |  \\__|$$$$$$$ |$$ / $$ / $$ |\\$$$$$$\\    $$ |     $$$$$$$ | \\$$$$  / 
-$$ |  $$ |$$ |     $$  __$$ |$$ | $$ | $$ | \\____$$\\   $$ |$$\\ $$  __$$ | $$  $$<  
-\\$$$$$$  |$$ |     \\$$$$$$$ |$$ | $$ | $$ |$$$$$$$  |  \\$$$$  |\\$$$$$$$ |$$  /\\$$\\ 
- \\______/ \\__|      \\_______|\\__| \\__| \\__|\\_______/    \\____/  \\_______|\\__/  \\__|
-                                                                                                                                            
-`
-    console.log(banner)
-  }
-
-  private getPackageManagerCommands(packageManager: 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
-   */
-  private copyDirectorySync(source: string, destination: string, variables: Record<string, string> = {}) {
-    // 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
-   */
-  private replaceTemplateVariables(content: string, variables: Record<string, string>): string {
-    let result = content
-    for (const [key, value] of Object.entries(variables)) {
-      result = result.replace(new RegExp(`{{${key}}}`, `g`), value)
-    }
-    return result
-  }
-
-  private async promptForProjectName(): Promise<string> {
-    const response = await enquirer.prompt<{ projectName: string }>({
-      type: `input`,
-      name: `projectName`,
-      message: `What is your project named?`,
-      initial: ``,
-      validate: (value: string) => {
-        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
-  }
-
-  private async promptForConfiguration(): Promise<{ packageManager: PackageManager; runtime: Runtime; eslint: boolean }> {
-    const questions: any[] = []
-
-    // 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<{
-      packageManager?: PackageManager
-      runtime: Runtime
-      eslint?: boolean
-    }>(questions)
-
-    return {
-      packageManager: answers.packageManager as any,
-      runtime: answers.runtime,
-      eslint: answers.eslint as boolean
-    }
-  }
-
-  private async installDependencies(projectPath: string, packageManager: PackageManager): Promise<boolean> {
-    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
-   */
-  private async gatherProjectConfig(): Promise<ProjectConfig> {
-    // Display ASCII art banner
-    this.printBanner()
-
-    // ========== PHASE 1: GET PROJECT NAME ==========
-    let projectName = this.projectDirectory
-    let projectPath: string
-    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
-   */
-  private async executeProjectGeneration(config: ProjectConfig): Promise<void> {
-    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..`)
-  }
-
-  private async setupEslintConfig(projectPath: string, packageManager: PackageManager): Promise<void> {
-    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
-   */
-  public 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/src/index.ts

@@ -1,28 +0,0 @@
-#!/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?: string) => {
-    try {
-      await new Create(projectDirectory, version).createProject()
-    } catch (error) {
-      log.error(`Failed to create project: ${String(error)}`)
-      process.exit(1)
-    }
-  })
-
-program.parse()

package/src/templates/.env.example

@@ -1,17 +0,0 @@
-# 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/src/templates/.prettierignore

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

package/src/templates/.prettierrc

@@ -1,23 +0,0 @@
-{
-  "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/src/templates/README.md

@@ -1,121 +0,0 @@
-# {{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/src/templates/bunfig.toml

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

package/src/templates/ecosystem.config.cjs

@@ -1,26 +0,0 @@
-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
-    },
-  ],
-};

package/src/templates/package.json

@@ -1,55 +0,0 @@
-{
-  "name": "{{projectName}}",
-  "version": "0.1.0",
-  "private": true,
-  "description": "",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": ""
-  },
-  "bugs": {
-    "url": ""
-  },
-  "homepage": "",
-  "author": "",
-  "license": "MIT",
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js",
-      "default": "./dist/src/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "dev": "bun --watch src/index.ts",
-    "start": "bun src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target bun",
-    "lint": "eslint '**/*.ts'",
-    "lint:fix": "eslint '**/*.ts' --fix",
-    "pm2:start": "pm2 start ecosystem.config.cjs",
-    "pm2:stop": "pm2 stop ecosystem.config.cjs",
-    "pm2:restart": "pm2 restart ecosystem.config.cjs",
-    "pm2:delete": "pm2 delete ecosystem.config.cjs",
-    "pm2:logs": "pm2 logs",
-    "pm2:monit": "pm2 monit"
-  },
-  "dependencies": {
-    "gramstax": "latest",
-    "grammy": "^1.38.3",
-    "logging-pretty": "^3.0.0"
-  },
-  "peerDependencies": {
-    "typescript": "latest"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "pm2": "^5.3.0"
-  }
-}

package/src/templates/src/base/general.ts

@@ -1,3 +0,0 @@
-import { BaseGeneral } from "gramstax"
-
-export abstract class GeneralBase extends BaseGeneral {}