forgestack-os-cli 0.1.0

package/src/generators/index.ts

@@ -0,0 +1,64 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { StackConfig } from '../types';
+import { logger } from '../utils/logger';
+import { generateFrontend } from './frontend';
+import { generateBackend } from './backend';
+import { generateDatabase } from './database';
+import { generateAuth } from './auth';
+import { generateDocker } from './docker';
+import { generateCommon } from './common';
+
+export async function generateProject(config: StackConfig, targetDir: string) {
+    const spinner = logger.spinner('Creating project structure...');
+
+    try {
+        // Create project directory
+        await fs.ensureDir(targetDir);
+
+        // Create subdirectories
+        const frontendDir = path.join(targetDir, 'frontend');
+        const backendDir = path.join(targetDir, 'backend');
+
+        await fs.ensureDir(frontendDir);
+        await fs.ensureDir(backendDir);
+
+        spinner.succeed('Project structure created');
+
+        // Generate common files (root package.json, README, .gitignore, etc.)
+        const commonSpinner = logger.spinner('Generating common files...');
+        await generateCommon(config, targetDir);
+        commonSpinner.succeed('Common files generated');
+
+        // Generate frontend
+        const frontendSpinner = logger.spinner(`Generating ${config.frontend} frontend...`);
+        await generateFrontend(config, frontendDir);
+        frontendSpinner.succeed('Frontend generated');
+
+        // Generate backend
+        const backendSpinner = logger.spinner(`Generating ${config.backend} backend...`);
+        await generateBackend(config, backendDir);
+        backendSpinner.succeed('Backend generated');
+
+        // Generate database setup
+        const dbSpinner = logger.spinner(`Setting up ${config.database} database...`);
+        await generateDatabase(config, backendDir);
+        dbSpinner.succeed('Database setup complete');
+
+        // Generate auth integration
+        const authSpinner = logger.spinner(`Integrating ${config.auth} authentication...`);
+        await generateAuth(config, frontendDir, backendDir);
+        authSpinner.succeed('Authentication integrated');
+
+        // Generate Docker configuration if requested
+        if (config.docker) {
+            const dockerSpinner = logger.spinner('Generating Docker configuration...');
+            await generateDocker(config, targetDir);
+            dockerSpinner.succeed('Docker configuration generated');
+        }
+
+    } catch (error) {
+        spinner.fail('Failed to generate project');
+        throw error;
+    }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+
+import { createCommand } from './commands/create';
+
+const program = new Command();
+
+program
+    .name('forgestack')
+    .description('ForgeStack OS - One platform. Any stack. Production-ready.')
+    .version('0.1.0');
+
+program
+    .command('create <project-name>')
+    .description('Create a new full-stack SaaS application')
+    .action(createCommand)
+    .option('--frontend <framework>', 'Frontend framework')
+    .option('--backend <framework>', 'Backend framework')
+    .option('--auth <provider>', 'Auth provider')
+    .option('--database <db>', 'Database')
+    .option('--api <style>', 'API style')
+    .option('--docker', 'Include Docker configuration')
+    .option('--no-docker', 'Skip Docker configuration')
+    .option('--multi-tenant', 'Enable multi-tenancy');
+
+program.parse();

package/src/types.ts

@@ -0,0 +1,16 @@
+export interface StackConfig {
+    projectName: string;
+    frontend: 'react-vite' | 'nextjs' | 'vue-vite' | 'sveltekit';
+    backend: 'express' | 'fastify' | 'nestjs' | 'bun-elysia' | 'go-fiber';
+    auth: 'jwt' | 'clerk' | 'supabase' | 'authjs' | 'firebase';
+    database: 'postgresql' | 'mongodb' | 'mysql' | 'sqlite' | 'supabase-db';
+    apiStyle: 'rest' | 'graphql' | 'trpc';
+    docker: boolean;
+    multiTenant: boolean;
+}
+
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}

package/src/utils/logger.ts

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import ora, { Ora } from 'ora';
+
+export const logger = {
+    info: (message: string) => {
+        console.log(chalk.blue('ℹ'), message);
+    },
+
+    success: (message: string) => {
+        console.log(chalk.green('✔'), message);
+    },
+
+    error: (message: string) => {
+        console.log(chalk.red('✖'), message);
+    },
+
+    warning: (message: string) => {
+        console.log(chalk.yellow('⚠'), message);
+    },
+
+    title: (message: string) => {
+        console.log(chalk.bold.cyan(`\n${message}\n`));
+    },
+
+    spinner: (text: string): Ora => {
+        return ora({
+            text,
+            color: 'cyan',
+        }).start();
+    },
+};

package/src/utils/prompts.ts

@@ -0,0 +1,105 @@
+import inquirer from 'inquirer';
+import { StackConfig } from '../types';
+
+export async function promptForStack(projectName: string, options: any = {}): Promise<StackConfig> {
+    console.log('\n');
+
+    // If options are provided, merge them with defaults and return
+    // This allows non-interactive mode
+    if (options.frontend || options.backend || options.auth || options.database) {
+        return {
+            projectName,
+            frontend: options.frontend || 'react-vite',
+            backend: options.backend || 'express',
+            auth: options.auth || 'jwt',
+            database: options.database || 'postgresql',
+            apiStyle: options.api // 'api' option maps to 'apiStyle' in config
+                ? (options.api === 'trpc' ? 'trpc' : options.api === 'graphql' ? 'graphql' : 'rest')
+                : 'rest',
+            docker: options.docker !== false, // Default to true unless --no-docker
+            multiTenant: !!options.multiTenant,
+        } as StackConfig;
+    }
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'frontend',
+            message: 'Choose your frontend framework:',
+            choices: [
+                { name: 'React + Vite (Recommended)', value: 'react-vite' },
+                { name: 'Next.js (App Router)', value: 'nextjs' },
+                { name: 'Vue + Vite', value: 'vue-vite' },
+                { name: 'SvelteKit', value: 'sveltekit' },
+            ],
+            default: 'react-vite',
+        },
+        {
+            type: 'list',
+            name: 'backend',
+            message: 'Choose your backend framework:',
+            choices: [
+                { name: 'Node.js + Express (Recommended)', value: 'express' },
+                { name: 'Node.js + Fastify', value: 'fastify' },
+                { name: 'NestJS', value: 'nestjs' },
+                { name: 'Bun + Elysia', value: 'bun-elysia' },
+                { name: 'Go + Fiber (Experimental)', value: 'go-fiber' },
+            ],
+            default: 'express',
+        },
+        {
+            type: 'list',
+            name: 'auth',
+            message: 'Choose your authentication provider:',
+            choices: [
+                { name: 'Built-in JWT Auth (Free)', value: 'jwt' },
+                { name: 'Clerk', value: 'clerk' },
+                { name: 'Supabase Auth', value: 'supabase' },
+                { name: 'Auth.js (NextAuth)', value: 'authjs' },
+                { name: 'Firebase Auth', value: 'firebase' },
+            ],
+            default: 'jwt',
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Choose your database:',
+            choices: [
+                { name: 'PostgreSQL + Prisma (Recommended)', value: 'postgresql' },
+                { name: 'MongoDB + Mongoose', value: 'mongodb' },
+                { name: 'MySQL + Prisma', value: 'mysql' },
+                { name: 'SQLite (Local)', value: 'sqlite' },
+                { name: 'Supabase DB', value: 'supabase-db' },
+            ],
+            default: 'postgresql',
+        },
+        {
+            type: 'list',
+            name: 'apiStyle',
+            message: 'Choose your API style:',
+            choices: [
+                { name: 'REST (Recommended)', value: 'rest' },
+                { name: 'GraphQL', value: 'graphql' },
+                { name: 'tRPC (Type-safe)', value: 'trpc' },
+            ],
+            default: 'rest',
+        },
+        {
+            type: 'confirm',
+            name: 'docker',
+            message: 'Include Docker configuration?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'multiTenant',
+            message: 'Enable multi-tenancy support?',
+            default: false,
+        },
+    ]);
+
+    return {
+        projectName,
+        ...answers,
+    };
+}

package/src/utils/validators.ts

@@ -0,0 +1,50 @@
+import { StackConfig, ValidationResult } from '../types';
+import validateNpmPackageName from 'validate-npm-package-name';
+
+export function validateStackConfig(config: StackConfig): ValidationResult {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Validate project name
+    const nameValidation = validateNpmPackageName(config.projectName);
+    if (!nameValidation.validForNewPackages) {
+        errors.push(`Invalid project name: ${nameValidation.errors?.join(', ')}`);
+    }
+
+    // tRPC requires TypeScript backend
+    if (config.apiStyle === 'trpc') {
+        if (config.backend === 'go-fiber') {
+            errors.push('tRPC is not compatible with Go backend. Please choose a TypeScript backend.');
+        }
+    }
+
+    // GraphQL compatibility
+    if (config.apiStyle === 'graphql') {
+        if (config.backend === 'bun-elysia' || config.backend === 'go-fiber') {
+            warnings.push('GraphQL support for this backend is experimental.');
+        }
+    }
+
+    // Supabase auth requires Supabase DB
+    if (config.auth === 'supabase' && config.database !== 'supabase-db') {
+        warnings.push('Supabase Auth works best with Supabase DB. Consider using Supabase DB for full integration.');
+    }
+
+    // Go backend is experimental
+    if (config.backend === 'go-fiber') {
+        warnings.push('Go + Fiber backend is experimental and may have limited features.');
+    }
+
+    // Multi-tenancy warnings
+    if (config.multiTenant) {
+        if (config.database === 'sqlite') {
+            warnings.push('SQLite with multi-tenancy is not recommended for production use.');
+        }
+    }
+
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/tests/validators.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { validateStackConfig } from '../src/utils/validators';
+
+describe('Stack Validation', () => {
+    it('should validate compatible stacks', () => {
+        const config = {
+            projectName: 'test-app',
+            frontend: 'react-vite' as const,
+            backend: 'express' as const,
+            auth: 'jwt' as const,
+            database: 'postgresql' as const,
+            apiStyle: 'rest' as const,
+            docker: true,
+            multiTenant: false,
+        };
+
+        const result = validateStackConfig(config);
+        expect(result.valid).toBe(true);
+    });
+
+    it('should reject Next.js with Express (incompatible)', () => {
+        const config = {
+            projectName: 'test-app',
+            frontend: 'nextjs' as const,
+            backend: 'express' as const,
+            auth: 'jwt' as const,
+            database: 'postgresql' as const,
+            apiStyle: 'rest' as const,
+            docker: true,
+            multiTenant: false,
+        };
+
+        const result = validateStackConfig(config);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('Next.js works best with NestJS backend');
+    });
+
+    it('should validate GraphQL API style', () => {
+        const config = {
+            projectName: 'test-app',
+            frontend: 'react-vite' as const,
+            backend: 'express' as const,
+            auth: 'jwt' as const,
+            database: 'postgresql' as const,
+            apiStyle: 'graphql' as const,
+            docker: true,
+            multiTenant: false,
+        };
+
+        const result = validateStackConfig(config);
+        expect(result.valid).toBe(true);
+    });
+
+    it('should validate tRPC API style', () => {
+        const config = {
+            projectName: 'test-app',
+            frontend: 'nextjs' as const,
+            backend: 'nestjs' as const,
+            auth: 'clerk' as const,
+            database: 'postgresql' as const,
+            apiStyle: 'trpc' as const,
+            docker: true,
+            multiTenant: true,
+        };
+
+        const result = validateStackConfig(config);
+        expect(result.valid).toBe(true);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "types": [
+            "node",
+            "vitest/globals"
+        ],
+        "noUnusedLocals": false,
+        "noUnusedParameters": false
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}