stackkit-cli 0.1.0

package/src/commands/list.ts

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,53 @@
+#!/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

@@ -0,0 +1,71 @@
+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';
+}

package/src/utils/code-inject.ts

@@ -0,0 +1,85 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+const CODE_MARKER_START = (id: string) => `// StackKit:${id}:start`;
+const CODE_MARKER_END = (id: string) => `// StackKit:${id}:end`;
+
+export interface CodeInjection {
+  id: string;
+  code: string;
+  description: string;
+}
+
+export async function injectCode(
+  filePath: string,
+  injection: CodeInjection,
+  position: 'append' | 'prepend' | { after: string } | { before: string },
+  options: { force?: boolean } = {}
+): Promise<void> {
+  if (!await fs.pathExists(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  let content = await fs.readFile(filePath, 'utf-8');
+  
+  // Check if already injected
+  const startMarker = CODE_MARKER_START(injection.id);
+  if (content.includes(startMarker) && !options.force) {
+    return; // Already injected, skip
+  }
+
+  // Remove old injection if force is true
+  if (options.force) {
+    content = removeInjection(content, injection.id);
+  }
+
+  // Prepare the code block with markers
+  const markedCode = `\n${startMarker}\n${injection.code}\n${CODE_MARKER_END(injection.id)}\n`;
+
+  // Inject based on position
+  if (position === 'append') {
+    content += markedCode;
+  } else if (position === 'prepend') {
+    content = markedCode + content;
+  } else if ('after' in position) {
+    const index = content.indexOf(position.after);
+    if (index === -1) {
+      throw new Error(`Could not find marker: ${position.after}`);
+    }
+    const insertPos = index + position.after.length;
+    content = content.slice(0, insertPos) + markedCode + content.slice(insertPos);
+  } else if ('before' in position) {
+    const index = content.indexOf(position.before);
+    if (index === -1) {
+      throw new Error(`Could not find marker: ${position.before}`);
+    }
+    content = content.slice(0, index) + markedCode + content.slice(index);
+  }
+
+  await fs.writeFile(filePath, content, 'utf-8');
+}
+
+export function removeInjection(content: string, id: string): string {
+  const startMarker = CODE_MARKER_START(id);
+  const endMarker = CODE_MARKER_END(id);
+  
+  const startIndex = content.indexOf(startMarker);
+  if (startIndex === -1) {
+    return content;
+  }
+  
+  const endIndex = content.indexOf(endMarker, startIndex);
+  if (endIndex === -1) {
+    return content;
+  }
+  
+  // Remove everything from start marker to end marker (inclusive)
+  const before = content.slice(0, startIndex);
+  const after = content.slice(endIndex + endMarker.length);
+  
+  return before + after;
+}
+
+export function hasInjection(content: string, id: string): boolean {
+  return content.includes(CODE_MARKER_START(id));
+}

package/src/utils/detect.ts

@@ -0,0 +1,89 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { ProjectInfo } from '../types';
+
+export async function detectProjectInfo(targetDir: string): Promise<ProjectInfo> {
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  
+  if (!await fs.pathExists(packageJsonPath)) {
+    throw new Error('No package.json found. This does not appear to be a Node.js project.');
+  }
+
+  const packageJson = await fs.readJSON(packageJsonPath);
+  
+  // Detect framework
+  const isNextJs = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+  const framework = isNextJs ? 'nextjs' : 'unknown';
+  
+  if (framework === 'unknown') {
+    throw new Error('Only Next.js projects are currently supported.');
+  }
+
+  // Detect router type
+  const appDirExists = await fs.pathExists(path.join(targetDir, 'app'));
+  const pagesDirExists = await fs.pathExists(path.join(targetDir, 'pages'));
+  const srcAppDirExists = await fs.pathExists(path.join(targetDir, 'src', 'app'));
+  const srcPagesDirExists = await fs.pathExists(path.join(targetDir, 'src', 'pages'));
+  
+  let router: 'app' | 'pages' | 'unknown' = 'unknown';
+  if (appDirExists || srcAppDirExists) {
+    router = 'app';
+  } else if (pagesDirExists || srcPagesDirExists) {
+    router = 'pages';
+  }
+
+  // Detect TypeScript vs JavaScript
+  const tsconfigExists = await fs.pathExists(path.join(targetDir, 'tsconfig.json'));
+  const language = tsconfigExists ? 'ts' : 'js';
+
+  // Detect package manager
+  const yarnLockExists = await fs.pathExists(path.join(targetDir, 'yarn.lock'));
+  const pnpmLockExists = await fs.pathExists(path.join(targetDir, 'pnpm-lock.yaml'));
+  let packageManager: 'npm' | 'yarn' | 'pnpm' = 'npm';
+  
+  if (pnpmLockExists) {
+    packageManager = 'pnpm';
+  } else if (yarnLockExists) {
+    packageManager = 'yarn';
+  }
+
+  // Check for existing integrations
+  const hasAuth = !!(
+    packageJson.dependencies?.['next-auth'] ||
+    packageJson.dependencies?.['@auth/core'] ||
+    packageJson.dependencies?.['@clerk/nextjs'] ||
+    packageJson.dependencies?.['@kinde-oss/kinde-auth-nextjs']
+  );
+
+  const hasPrisma = !!(
+    packageJson.dependencies?.['@prisma/client'] ||
+    packageJson.devDependencies?.['prisma']
+  );
+
+  return {
+    framework,
+    router,
+    language,
+    packageManager,
+    hasAuth,
+    hasPrisma,
+    rootDir: targetDir,
+  };
+}
+
+export function getRouterBasePath(projectInfo: ProjectInfo): string {
+  const srcExists = fs.existsSync(path.join(projectInfo.rootDir, 'src'));
+  
+  if (projectInfo.router === 'app') {
+    return srcExists ? 'src/app' : 'app';
+  } else if (projectInfo.router === 'pages') {
+    return srcExists ? 'src/pages' : 'pages';
+  }
+  
+  throw new Error('Unknown router type');
+}
+
+export function getLibPath(projectInfo: ProjectInfo): string {
+  const srcExists = fs.existsSync(path.join(projectInfo.rootDir, 'src'));
+  return srcExists ? 'src/lib' : 'lib';
+}

package/src/utils/env-editor.ts

@@ -0,0 +1,127 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger';
+
+const ENV_MARKER_START = '# StackKit:';
+const ENV_MARKER_END = '# End StackKit';
+
+export interface EnvVariable {
+  key: string;
+  value?: string;
+  description: string;
+  required: boolean;
+}
+
+export async function addEnvVariables(
+  projectRoot: string,
+  variables: EnvVariable[],
+  options: { force?: boolean } = {}
+): Promise<void> {
+  const envExamplePath = path.join(projectRoot, '.env.example');
+  const envPath = path.join(projectRoot, '.env');
+
+  // Add to .env.example
+  await appendToEnvFile(envExamplePath, variables, 'example', options);
+
+  // Add to .env if it exists or create it
+  const envExists = await fs.pathExists(envPath);
+  if (envExists || options.force) {
+    await appendToEnvFile(envPath, variables, 'local', options);
+  }
+
+  logger.success('Environment variables added');
+}
+
+async function appendToEnvFile(
+  filePath: string,
+  variables: EnvVariable[],
+  fileType: 'example' | 'local',
+  options: { force?: boolean } = {}
+): Promise<void> {
+  let content = '';
+  
+  if (await fs.pathExists(filePath)) {
+    content = await fs.readFile(filePath, 'utf-8');
+  }
+
+  // Check if variables already exist
+  const existingKeys = new Set<string>();
+  const lines = content.split('\n');
+  
+  for (const line of lines) {
+    const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+    if (match) {
+      existingKeys.add(match[1]);
+    }
+  }
+
+  const newVariables = variables.filter((v) => {
+    if (existingKeys.has(v.key)) {
+      if (!options.force) {
+        logger.warn(`Variable ${v.key} already exists in ${filePath}`);
+        return false;
+      }
+    }
+    return true;
+  });
+
+  if (newVariables.length === 0) {
+    return;
+  }
+
+  // Ensure file ends with newline
+  if (content && !content.endsWith('\n')) {
+    content += '\n';
+  }
+
+  // Add marker and variables
+  content += '\n';
+  content += `${ENV_MARKER_START} Added by StackKit\n`;
+  
+  for (const variable of newVariables) {
+    if (variable.description) {
+      content += `# ${variable.description}\n`;
+    }
+    
+    const value = fileType === 'example' ? (variable.value || '') : (variable.value || '');
+    content += `${variable.key}=${value}\n`;
+  }
+  
+  content += `${ENV_MARKER_END}\n`;
+
+  await fs.writeFile(filePath, content, 'utf-8');
+}
+
+export async function removeEnvVariables(
+  projectRoot: string,
+  keys: string[]
+): Promise<void> {
+  const envExamplePath = path.join(projectRoot, '.env.example');
+  const envPath = path.join(projectRoot, '.env');
+
+  await removeFromEnvFile(envExamplePath, keys);
+  
+  if (await fs.pathExists(envPath)) {
+    await removeFromEnvFile(envPath, keys);
+  }
+}
+
+async function removeFromEnvFile(filePath: string, keys: string[]): Promise<void> {
+  if (!await fs.pathExists(filePath)) {
+    return;
+  }
+
+  let content = await fs.readFile(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const newLines: string[] = [];
+
+  for (const line of lines) {
+    const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+    if (match && keys.includes(match[1])) {
+      continue; // Skip this line
+    }
+    newLines.push(line);
+  }
+
+  await fs.writeFile(filePath, newLines.join('\n'), 'utf-8');
+}

package/src/utils/files.ts

@@ -0,0 +1,59 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger';
+
+export async function copyTemplate(
+  templatePath: string,
+  targetPath: string,
+  projectName: string
+): Promise<void> {
+  if (!await fs.pathExists(templatePath)) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+
+  // Create target directory
+  await fs.ensureDir(targetPath);
+
+  // Copy all files
+  await fs.copy(templatePath, targetPath, {
+    filter: (src) => {
+      const basename = path.basename(src);
+      // Skip template.json metadata file and node_modules
+      return basename !== 'template.json' && basename !== 'node_modules';
+    },
+  });
+
+  // Update package.json with project name
+  const packageJsonPath = path.join(targetPath, 'package.json');
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await fs.readJSON(packageJsonPath);
+    packageJson.name = projectName;
+    await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+  }
+
+  logger.success(`Template copied to ${targetPath}`);
+}
+
+export async function createFile(
+  targetPath: string,
+  content: string,
+  options: { force?: boolean } = {}
+): Promise<void> {
+  const exists = await fs.pathExists(targetPath);
+  
+  if (exists && !options.force) {
+    logger.warn(`File already exists: ${targetPath} (use --force to overwrite)`);
+    return;
+  }
+
+  await fs.ensureDir(path.dirname(targetPath));
+  await fs.writeFile(targetPath, content, 'utf-8');
+}
+
+export async function readFile(filePath: string): Promise<string> {
+  return fs.readFile(filePath, 'utf-8');
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  return fs.pathExists(filePath);
+}

package/src/utils/json-editor.ts

@@ -0,0 +1,64 @@
+import fs from 'fs-extra';
+import { logger } from './logger';
+
+export async function modifyJson(
+  filePath: string,
+  modifier: (json: any) => any,
+  options: { create?: boolean; force?: boolean } = {}
+): Promise<void> {
+  const exists = await fs.pathExists(filePath);
+
+  if (!exists && !options.create) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  let json = {};
+  if (exists) {
+    json = await fs.readJSON(filePath);
+  }
+
+  const modified = modifier(json);
+  await fs.writeJSON(filePath, modified, { spaces: 2 });
+}
+
+export async function addToPackageJson(
+  filePath: string,
+  section: 'dependencies' | 'devDependencies' | 'scripts',
+  additions: Record<string, string>
+): Promise<void> {
+  await modifyJson(filePath, (json) => {
+    json[section] = json[section] || {};
+    Object.assign(json[section], additions);
+    return json;
+  });
+}
+
+export async function setJsonValue(
+  filePath: string,
+  path: string,
+  value: any,
+  options: { merge?: boolean } = {}
+): Promise<void> {
+  await modifyJson(filePath, (json) => {
+    const keys = path.split('.');
+    let current = json;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key]) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+
+    const lastKey = keys[keys.length - 1];
+    
+    if (options.merge && typeof current[lastKey] === 'object' && typeof value === 'object') {
+      current[lastKey] = { ...current[lastKey], ...value };
+    } else {
+      current[lastKey] = value;
+    }
+
+    return json;
+  });
+}