stackkit-cli 0.1.0 → 0.1.2

package/src/commands/add.ts

@@ -1,261 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import inquirer from 'inquirer';
-import path from 'path';
-import { CreateFilePatch, ModuleMetadata } from '../types';
-import { detectProjectInfo, getLibPath, getRouterBasePath } from '../utils/detect';
-import { addEnvVariables } from '../utils/env-editor';
-import { createFile, fileExists } from '../utils/files';
-import { logger } from '../utils/logger';
-import { addDependencies } from '../utils/package-manager';
-
-interface AddOptions {
-  provider?: string;
-  force?: boolean;
-  dryRun?: boolean;
-  install?: boolean;
-}
-
-export async function addCommand(module: string, options: AddOptions): Promise<void> {
-  try {
-    const projectRoot = process.cwd();
-
-    // Detect project info
-    const spinner = logger.startSpinner('Detecting project...');
-    const projectInfo = await detectProjectInfo(projectRoot);
-    spinner.succeed(
-      `Detected ${projectInfo.framework} (${projectInfo.router} router, ${projectInfo.language})`
-    );
-
-    // Load module metadata
-    const modulesDir = path.join(__dirname, '..', '..', '..', '..', 'modules');
-    const moduleMetadata = await loadModuleMetadata(modulesDir, module, options.provider);
-
-    if (!moduleMetadata) {
-      logger.error(`Module "${module}" not found`);
-      process.exit(1);
-    }
-
-    // Check if framework is supported
-    if (!moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
-      logger.error(
-        `Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(', ')}`
-      );
-      process.exit(1);
-    }
-
-    // Check for conflicts
-    if (module === 'auth' && projectInfo.hasAuth && !options.force) {
-      logger.warn('Auth library already detected in this project');
-      const { proceed } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'proceed',
-          message: 'Continue anyway? (use --force to skip this prompt)',
-          default: false,
-        },
-      ]);
-
-      if (!proceed) {
-        logger.info('Cancelled');
-        process.exit(0);
-      }
-    }
-
-    if (options.dryRun) {
-      logger.warn('Dry run mode - no changes will be made');
-      logger.newLine();
-    }
-
-    // Apply module patches
-    await applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, module, options);
-
-    // Add dependencies
-    if (Object.keys(moduleMetadata.dependencies).length > 0 && options.install !== false) {
-      const deps = Object.entries(moduleMetadata.dependencies).map(
-        ([name, version]) => `${name}@${version}`
-      );
-
-      if (!options.dryRun) {
-        await addDependencies(projectRoot, projectInfo.packageManager, deps, false);
-      } else {
-        logger.info(`Would add dependencies: ${deps.join(', ')}`);
-      }
-    }
-
-    // Add dev dependencies
-    if (
-      moduleMetadata.devDependencies &&
-      Object.keys(moduleMetadata.devDependencies).length > 0 &&
-      options.install !== false
-    ) {
-      const devDeps = Object.entries(moduleMetadata.devDependencies).map(
-        ([name, version]) => `${name}@${version}`
-      );
-
-      if (!options.dryRun) {
-        await addDependencies(projectRoot, projectInfo.packageManager, devDeps, true);
-      } else {
-        logger.info(`Would add dev dependencies: ${devDeps.join(', ')}`);
-      }
-    }
-
-    // Add environment variables
-    if (moduleMetadata.envVars.length > 0) {
-      if (!options.dryRun) {
-        await addEnvVariables(projectRoot, moduleMetadata.envVars, { force: options.force });
-      } else {
-        logger.log(`  ${chalk.dim('~')} .env.example`);
-      }
-    }
-
-    logger.newLine();
-    logger.success(`Added ${chalk.bold(moduleMetadata.displayName)}`);
-    logger.newLine();
-
-    // Print next steps
-    if (moduleMetadata.envVars.some((v) => v.required)) {
-      logger.log('Next: Fill in environment variables in .env');
-    }
-    logger.newLine();
-  } catch (error) {
-    logger.error(`Failed to add module: ${(error as Error).message}`);
-    if (error instanceof Error && error.stack) {
-      logger.log(chalk.gray(error.stack));
-    }
-    process.exit(1);
-  }
-}
-
-async function loadModuleMetadata(
-  modulesDir: string,
-  moduleName: string,
-  provider?: string
-): Promise<ModuleMetadata | null> {
-  if (!(await fs.pathExists(modulesDir))) {
-    return null;
-  }
-
-  // Try to find module in any category
-  const categories = await fs.readdir(modulesDir);
-
-  for (const category of categories) {
-    const categoryPath = path.join(modulesDir, category);
-    const stat = await fs.stat(categoryPath);
-
-    if (!stat.isDirectory()) continue;
-
-    // Get all modules in this category
-    const moduleDirs = await fs.readdir(categoryPath);
-
-    for (const moduleDir of moduleDirs) {
-      const modulePath = path.join(categoryPath, moduleDir);
-      const moduleStat = await fs.stat(modulePath);
-
-      if (!moduleStat.isDirectory()) continue;
-
-      const metadataPath = path.join(modulePath, 'module.json');
-
-      if (await fs.pathExists(metadataPath)) {
-        const metadata = await fs.readJSON(metadataPath);
-
-        // Match by module name or provider
-        if (metadata.name === moduleName || (provider && moduleDir === provider)) {
-          return metadata;
-        }
-      }
-    }
-  }
-
-  return null;
-}
-
-async function applyModulePatches(
-  projectRoot: string,
-  projectInfo: any,
-  moduleMetadata: ModuleMetadata,
-  modulesDir: string,
-  moduleName: string,
-  options: AddOptions
-): Promise<void> {
-  const moduleBasePath = await findModulePath(modulesDir, moduleName, options.provider);
-
-  if (!moduleBasePath) {
-    throw new Error('Module files not found');
-  }
-
-  for (const patch of moduleMetadata.patches) {
-    if (patch.type === 'create-file') {
-      const filePatch = patch as CreateFilePatch;
-
-      // Check conditions
-      if (filePatch.condition) {
-        if (filePatch.condition.router && filePatch.condition.router !== projectInfo.router) {
-          continue; // Skip this patch
-        }
-        if (filePatch.condition.language && filePatch.condition.language !== projectInfo.language) {
-          continue; // Skip this patch
-        }
-      }
-
-      const sourceFile = path.join(moduleBasePath, 'files', filePatch.source);
-      let destFile = path.join(projectRoot, filePatch.destination);
-
-      // Replace placeholders in destination
-      destFile = destFile
-        .replace('{{router}}', getRouterBasePath(projectInfo))
-        .replace('{{lib}}', getLibPath(projectInfo));
-
-      if (!options.dryRun) {
-        if (await fileExists(sourceFile)) {
-          const content = await fs.readFile(sourceFile, 'utf-8');
-          await createFile(destFile, content, { force: options.force });
-          const relativePath = path.relative(projectRoot, destFile);
-          logger.log(`  ${chalk.green('+')} ${relativePath}`);
-        } else {
-          logger.warn(`Source file not found: ${filePatch.source}`);
-        }
-      } else {
-        const relativePath = path.relative(projectRoot, destFile);
-        logger.log(`  ${chalk.dim('+')} ${relativePath}`);
-      }
-    }
-  }
-}
-
-async function findModulePath(
-  modulesDir: string,
-  moduleName: string,
-  provider?: string
-): Promise<string | null> {
-  const categories = await fs.readdir(modulesDir);
-
-  for (const category of categories) {
-    const categoryPath = path.join(modulesDir, category);
-    const stat = await fs.stat(categoryPath);
-
-    if (!stat.isDirectory()) continue;
-
-    const moduleDirs = await fs.readdir(categoryPath);
-
-    for (const moduleDir of moduleDirs) {
-      const modulePath = path.join(categoryPath, moduleDir);
-      const moduleStat = await fs.stat(modulePath);
-
-      if (!moduleStat.isDirectory()) continue;
-
-      const metadataPath = path.join(modulePath, 'module.json');
-
-      if (await fs.pathExists(metadataPath)) {
-        const metadata = await fs.readJSON(metadataPath);
-
-        // Match by module name or provider
-        if (metadata.name === moduleName || (provider && moduleDir === provider)) {
-          return modulePath;
-        }
-      }
-    }
-  }
-
-  return null;
-}

package/src/commands/init.ts

@@ -1,182 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import inquirer from 'inquirer';
-import path from 'path';
-import validateNpmPackageName from 'validate-npm-package-name';
-import { TemplateMetadata } from '../types';
-import { copyTemplate } from '../utils/files';
-import { logger } from '../utils/logger';
-import { initGit, installDependencies, PackageManager } from '../utils/package-manager';
-
-interface InitOptions {
-  template?: string;
-  pm?: PackageManager;
-  install?: boolean;
-  git?: boolean;
-  yes?: boolean;
-}
-
-export async function initCommand(
-  projectName: string | undefined,
-  options: InitOptions
-): Promise<void> {
-  try {
-    // Validate package manager option
-    if (options.pm && !['npm', 'yarn', 'pnpm'].includes(options.pm)) {
-      logger.error(`Invalid package manager: ${options.pm}. Use npm, yarn, or pnpm.`);
-      process.exit(1);
-    }
-
-    // Get available templates
-    const templatesDir = path.join(__dirname, '..', '..', '..', '..', 'templates');
-    const templates = await getAvailableTemplates(templatesDir);
-
-    if (templates.length === 0) {
-      logger.error('No templates found');
-      process.exit(1);
-    }
-
-    // Prompt for project details if not using --yes
-    let answers: {
-      projectName: string;
-      template: string;
-      packageManager: PackageManager;
-      install: boolean;
-      git: boolean;
-    };
-
-    if (options.yes) {
-      answers = {
-        projectName: projectName || 'my-app',
-        template: options.template || templates[0].name,
-        packageManager: options.pm || 'pnpm',
-        install: options.install !== false,
-        git: options.git !== false,
-      };
-    } else {
-      const prompted = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'projectName',
-          message: 'Project name:',
-          default: projectName || 'my-app',
-          when: !projectName,
-          validate: (input: string) => {
-            const validation = validateNpmPackageName(input);
-            if (!validation.validForNewPackages) {
-              return validation.errors?.[0] || 'Invalid package name';
-            }
-            return true;
-          },
-        },
-        {
-          type: 'list',
-          name: 'template',
-          message: 'Select a template:',
-          choices: templates.map((t) => ({
-            name: `${t.displayName} - ${t.description}`,
-            value: t.name,
-          })),
-          when: !options.template,
-        },
-        {
-          type: 'list',
-          name: 'packageManager',
-          message: 'Select a package manager:',
-          choices: ['pnpm', 'npm', 'yarn'],
-          default: 'pnpm',
-          when: !options.pm,
-        },
-        {
-          type: 'confirm',
-          name: 'install',
-          message: 'Install dependencies?',
-          default: true,
-          when: options.install !== false,
-        },
-        {
-          type: 'confirm',
-          name: 'git',
-          message: 'Initialize git repository?',
-          default: true,
-          when: options.git !== false,
-        },
-      ]);
-
-      answers = {
-        projectName: projectName || prompted.projectName,
-        template: options.template || prompted.template,
-        packageManager: options.pm || prompted.packageManager,
-        install: options.install !== false && (prompted.install ?? true),
-        git: options.git !== false && (prompted.git ?? true),
-      };
-    }
-
-    const targetDir = path.join(process.cwd(), answers.projectName);
-
-    // Check if directory exists
-    if (await fs.pathExists(targetDir)) {
-      logger.error(`Directory "${answers.projectName}" already exists`);
-      logger.info('Please choose a different name or remove the existing directory.');
-      process.exit(1);
-    }
-
-    // Validate template exists
-    const selectedTemplate = templates.find((t) => t.name === answers.template);
-    if (!selectedTemplate) {
-      logger.error(`Template "${answers.template}" not found`);
-      process.exit(1);
-    }
-
-    logger.newLine();
-
-    // Copy template
-    const templatePath = path.join(templatesDir, answers.template);
-    await copyTemplate(templatePath, targetDir, answers.projectName);
-
-    // Install dependencies
-    if (answers.install) {
-      await installDependencies(targetDir, answers.packageManager);
-    }
-
-    // Initialize git
-    if (answers.git) {
-      await initGit(targetDir);
-    }
-
-    logger.newLine();
-    logger.success(`Created ${chalk.bold(answers.projectName)}`);
-    logger.newLine();
-    logger.log(`Next steps:`);
-    logger.log(`  ${chalk.cyan('cd')} ${answers.projectName}`);
-    if (!answers.install) {
-      logger.log(`  ${chalk.cyan(answers.packageManager)} install`);
-    }
-    logger.log(
-      `  ${chalk.cyan(answers.packageManager)} ${answers.packageManager === 'npm' ? 'run ' : ''}dev`
-    );
-    logger.newLine();
-  } catch (error) {
-    logger.error(`Failed to create project: ${(error as Error).message}`);
-    process.exit(1);
-  }
-}
-
-async function getAvailableTemplates(templatesDir: string): Promise<TemplateMetadata[]> {
-  if (!(await fs.pathExists(templatesDir))) {
-    return [];
-  }
-
-  const templateDirs = await fs.readdir(templatesDir);
-  const templates: TemplateMetadata[] = [];
-
-  for (const dir of templateDirs) {
-    const metadataPath = path.join(templatesDir, dir, 'template.json');
-    if (await fs.pathExists(metadataPath)) {
-      const metadata = await fs.readJSON(metadataPath);
-      templates.push(metadata);
-    }
-  }
-
-  return templates;
-}

package/src/commands/list.ts

@@ -1,124 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'path';
-import { ModuleMetadata, TemplateMetadata } from '../types';
-import { logger } from '../utils/logger';
-
-interface ListOptions {
-  templates?: boolean;
-  modules?: boolean;
-}
-
-export async function listCommand(options: ListOptions): Promise<void> {
-  const showTemplates = !options.modules || options.templates;
-  const showModules = !options.templates || options.modules;
-
-  try {
-    // List templates
-    if (showTemplates) {
-      const templatesDir = path.join(__dirname, '..', '..', '..', '..', 'templates');
-      const templates = await getAvailableTemplates(templatesDir);
-
-      logger.log(chalk.bold('📦 Templates'));
-      logger.newLine();
-
-      if (templates.length === 0) {
-        logger.warn('  No templates found');
-      } else {
-        for (const template of templates) {
-          logger.log(chalk.bold(`  ${template.displayName}`));
-          logger.log(chalk.gray(`    ${template.description}`));
-          logger.log(chalk.blue(`    Command: stackkit init --template ${template.name}`));
-          logger.log(chalk.gray(`    Features: ${template.features.join(', ')}`));
-          logger.newLine();
-        }
-      }
-    }
-
-    // List modules
-    if (showModules) {
-      const modulesDir = path.join(__dirname, '..', '..', '..', '..', 'modules');
-      const modules = await getAvailableModules(modulesDir);
-
-      logger.log(chalk.bold('🔧 Modules'));
-      logger.newLine();
-
-      if (modules.length === 0) {
-        logger.warn('  No modules found');
-      } else {
-        // Group by category
-        const grouped = modules.reduce(
-          (acc, mod) => {
-            if (!acc[mod.category]) {
-              acc[mod.category] = [];
-            }
-            acc[mod.category].push(mod);
-            return acc;
-          },
-          {} as Record<string, ModuleMetadata[]>
-        );
-
-        for (const [category, mods] of Object.entries(grouped)) {
-          logger.log(chalk.yellow(`  ${category.toUpperCase()}:`));
-          for (const mod of mods) {
-            logger.log(chalk.bold(`    ${mod.displayName}`));
-            logger.log(chalk.gray(`      ${mod.description}`));
-            logger.log(chalk.blue(`      Command: stackkit add ${mod.name}`));
-            logger.log(chalk.gray(`      Supports: ${mod.supportedFrameworks.join(', ')}`));
-            logger.newLine();
-          }
-        }
-      }
-    }
-  } catch (error) {
-    logger.error(`Failed to list resources: ${(error as Error).message}`);
-    process.exit(1);
-  }
-}
-
-async function getAvailableTemplates(templatesDir: string): Promise<TemplateMetadata[]> {
-  if (!(await fs.pathExists(templatesDir))) {
-    return [];
-  }
-
-  const templateDirs = await fs.readdir(templatesDir);
-  const templates: TemplateMetadata[] = [];
-
-  for (const dir of templateDirs) {
-    const metadataPath = path.join(templatesDir, dir, 'template.json');
-    if (await fs.pathExists(metadataPath)) {
-      const metadata = await fs.readJSON(metadataPath);
-      templates.push(metadata);
-    }
-  }
-
-  return templates;
-}
-
-async function getAvailableModules(modulesDir: string): Promise<ModuleMetadata[]> {
-  if (!(await fs.pathExists(modulesDir))) {
-    return [];
-  }
-
-  const modules: ModuleMetadata[] = [];
-  const categories = await fs.readdir(modulesDir);
-
-  for (const category of categories) {
-    const categoryPath = path.join(modulesDir, category);
-    const stat = await fs.stat(categoryPath);
-
-    if (!stat.isDirectory()) continue;
-
-    const moduleDirs = await fs.readdir(categoryPath);
-
-    for (const moduleDir of moduleDirs) {
-      const metadataPath = path.join(categoryPath, moduleDir, 'module.json');
-      if (await fs.pathExists(metadataPath)) {
-        const metadata = await fs.readJSON(metadataPath);
-        modules.push(metadata);
-      }
-    }
-  }
-
-  return modules;
-}

package/src/index.ts

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-import chalk from 'chalk';
-import { Command } from 'commander';
-import { addCommand } from './commands/add';
-import { initCommand } from './commands/init';
-import { listCommand } from './commands/list';
-
-const program = new Command();
-
-program
-  .name('stackkit')
-  .description('Production-ready project generator and module CLI')
-  .version('0.1.0');
-
-// Init command
-program
-  .command('init [project-name]')
-  .description('Create a new project from a template')
-  .option('-t, --template <template>', 'Template to use')
-  .option('--pm <pm>', 'Package manager to use (npm, yarn, pnpm)')
-  .option('--no-install', 'Skip installing dependencies')
-  .option('--no-git', 'Skip git initialization')
-  .option('-y, --yes', 'Skip prompts and use defaults')
-  .action(initCommand);
-
-// List command
-program
-  .command('list')
-  .description('List available templates and modules')
-  .option('-t, --templates', 'List only templates')
-  .option('-m, --modules', 'List only modules')
-  .action(listCommand);
-
-// Add command
-program
-  .command('add <module>')
-  .description('Add a module to your existing project')
-  .option('--provider <provider>', 'Specific provider/variant to use')
-  .option('--force', 'Overwrite existing files')
-  .option('--dry-run', 'Show what would be changed without making changes')
-  .option('--no-install', 'Skip installing dependencies')
-  .action(addCommand);
-
-// Error handling
-program.on('command:*', () => {
-  console.error(
-    chalk.red(`\nInvalid command: ${program.args.join(' ')}\n`)
-  );
-  console.log(chalk.yellow('Run stackkit --help for a list of available commands.\n'));
-  process.exit(1);
-});
-
-program.parse();

package/src/types/index.ts

@@ -1,71 +0,0 @@
-export interface TemplateMetadata {
-  name: string;
-  displayName: string;
-  description: string;
-  tags: string[];
-  defaultPackageManager: 'pnpm' | 'npm' | 'yarn';
-  features: string[];
-}
-
-export interface ModuleMetadata {
-  name: string;
-  displayName: string;
-  description: string;
-  category: 'auth' | 'database' | 'ui' | 'other';
-  supportedFrameworks: string[];
-  dependencies: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  envVars: EnvVar[];
-  patches: ModulePatch[];
-}
-
-export interface EnvVar {
-  key: string;
-  value?: string;
-  description: string;
-  required: boolean;
-}
-
-export interface ModulePatch {
-  type: 'create-file' | 'modify-json' | 'append-env' | 'inject-code';
-  description: string;
-  [key: string]: any;
-}
-
-export interface CreateFilePatch extends ModulePatch {
-  type: 'create-file';
-  source: string;
-  destination: string;
-  condition?: {
-    router?: 'app' | 'pages';
-    language?: 'ts' | 'js';
-  };
-}
-
-export interface ModifyJsonPatch extends ModulePatch {
-  type: 'modify-json';
-  file: string;
-  operations: {
-    path: string;
-    value: any;
-    merge?: boolean;
-  }[];
-}
-
-export interface ProjectInfo {
-  framework: 'nextjs' | 'unknown';
-  router: 'app' | 'pages' | 'unknown';
-  language: 'ts' | 'js';
-  packageManager: 'npm' | 'yarn' | 'pnpm';
-  hasAuth: boolean;
-  hasPrisma: boolean;
-  rootDir: string;
-}
-
-export interface CLIOptions {
-  force?: boolean;
-  dryRun?: boolean;
-  yes?: boolean;
-  noInstall?: boolean;
-  pm?: 'npm' | 'yarn' | 'pnpm';
-}