stackinit 0.1.0

package/src/dependencies.ts

@@ -0,0 +1,120 @@
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import type { ProjectInfo, Options } from './types.js';
+
+const execAsync = promisify(exec);
+
+export async function addDependencies(projectInfo: ProjectInfo, options: Options): Promise<void> {
+  const packageJsonPath = join(projectInfo.rootPath, 'package.json');
+  
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    
+    // Initialize devDependencies if not present
+    if (!packageJson.devDependencies) {
+      packageJson.devDependencies = {};
+    }
+
+    // Core dependencies (always needed)
+    const coreDeps: Record<string, string> = {
+      eslint: '^8.57.0',
+      prettier: '^3.2.0',
+      husky: '^9.0.0',
+      'lint-staged': '^15.2.0',
+    };
+
+    // TypeScript dependencies
+    if (projectInfo.hasTypeScript) {
+      coreDeps['@typescript-eslint/parser'] = '^6.19.0';
+      coreDeps['@typescript-eslint/eslint-plugin'] = '^6.19.0';
+    }
+
+    // React dependencies
+    const isReact = projectInfo.type === 'react' || 
+                   projectInfo.type === 'nextjs' || 
+                   projectInfo.type === 'vite';
+    
+    if (isReact) {
+      coreDeps['eslint-plugin-react'] = '^7.33.0';
+      coreDeps['eslint-plugin-react-hooks'] = '^4.6.0';
+    }
+
+    // Next.js specific
+    if (projectInfo.type === 'nextjs') {
+      coreDeps['eslint-config-next'] = 'latest';
+    }
+
+    // Commitlint (strict mode)
+    if (options.strict) {
+      coreDeps['@commitlint/cli'] = '^18.6.0';
+      coreDeps['@commitlint/config-conventional'] = '^18.6.0';
+    }
+
+    // Add dependencies only if they don't already exist
+    let hasNewDeps = false;
+    for (const [dep, version] of Object.entries(coreDeps)) {
+      if (!packageJson.devDependencies[dep] && !packageJson.dependencies?.[dep]) {
+        packageJson.devDependencies[dep] = version;
+        hasNewDeps = true;
+      }
+    }
+
+    if (hasNewDeps) {
+      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+      console.log('  Updated package.json with dependencies');
+      
+      // Install dependencies
+      await installDependencies(projectInfo);
+    } else {
+      console.log('  All required dependencies already present');
+    }
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      console.warn('  Warning: package.json not found, skipping dependency installation');
+    } else {
+      throw error;
+    }
+  }
+}
+
+async function installDependencies(projectInfo: ProjectInfo): Promise<void> {
+  const { packageManager } = projectInfo;
+  const rootPath = projectInfo.rootPath;
+
+  console.log(`\n  Installing dependencies with ${packageManager}...`);
+
+  try {
+    let installCommand: string;
+    
+    switch (packageManager) {
+      case 'pnpm':
+        installCommand = 'pnpm install';
+        break;
+      case 'yarn':
+        installCommand = 'yarn install';
+        break;
+      case 'npm':
+      default:
+        installCommand = 'npm install';
+        break;
+    }
+
+    await execAsync(installCommand, {
+      cwd: rootPath,
+      maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+    });
+
+    console.log('  Dependencies installed successfully');
+  } catch {
+    console.error('  Failed to install dependencies automatically');
+    console.error('  Please run manually:', 
+      packageManager === 'pnpm' ? 'pnpm install' :
+      packageManager === 'yarn' ? 'yarn install' :
+      'npm install'
+    );
+    // Don't throw - let the user install manually if needed
+  }
+}
+

package/src/detect.ts

@@ -0,0 +1,132 @@
+import { readFile, access } from 'fs/promises';
+import { join } from 'path';
+import type { ProjectInfo, ProjectType, PackageManager } from './types.js';
+
+export async function detectProject(): Promise<ProjectInfo> {
+  const rootPath = process.cwd();
+  
+  const [type, packageManager, hasTypeScript, isMonorepo] = await Promise.all([
+    detectProjectType(rootPath),
+    detectPackageManager(rootPath),
+    detectTypeScript(rootPath),
+    detectMonorepo(rootPath),
+  ]);
+
+  return {
+    type,
+    packageManager,
+    hasTypeScript,
+    isMonorepo,
+    rootPath,
+  };
+}
+
+async function detectProjectType(rootPath: string): Promise<ProjectType> {
+  try {
+    const packageJsonPath = join(rootPath, 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+    // Check for Next.js
+    if (deps.next || deps['nextjs']) {
+      return 'nextjs';
+    }
+
+    // Check for Vite
+    if (deps.vite || deps['@vitejs/plugin-react']) {
+      return 'vite';
+    }
+
+    // Check for React
+    if (deps.react || deps['react-dom']) {
+      return 'react';
+    }
+
+    // Default to Node backend
+    return 'node';
+  } catch {
+    return 'unknown';
+  }
+}
+
+async function detectPackageManager(rootPath: string): Promise<PackageManager> {
+  // Check for lock files
+  const lockFiles = [
+    { file: 'pnpm-lock.yaml', manager: 'pnpm' as PackageManager },
+    { file: 'yarn.lock', manager: 'yarn' as PackageManager },
+    { file: 'package-lock.json', manager: 'npm' as PackageManager },
+  ];
+
+  for (const { file, manager } of lockFiles) {
+    try {
+      await access(join(rootPath, file));
+      return manager;
+    } catch {
+      // Continue checking
+    }
+  }
+
+  // Check for packageManager field in package.json
+  try {
+    const packageJsonPath = join(rootPath, 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    if (packageJson.packageManager) {
+      if (packageJson.packageManager.startsWith('pnpm')) return 'pnpm';
+      if (packageJson.packageManager.startsWith('yarn')) return 'yarn';
+      if (packageJson.packageManager.startsWith('npm')) return 'npm';
+    }
+  } catch {
+    // Fall through
+  }
+
+  // Default to npm
+  return 'npm';
+}
+
+async function detectTypeScript(rootPath: string): Promise<boolean> {
+  try {
+    const tsConfigPath = join(rootPath, 'tsconfig.json');
+    await access(tsConfigPath);
+    return true;
+  } catch {
+    // Check for TypeScript in dependencies
+    try {
+      const packageJsonPath = join(rootPath, 'package.json');
+      const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+      const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      return 'typescript' in deps;
+    } catch {
+      return false;
+    }
+  }
+}
+
+async function detectMonorepo(rootPath: string): Promise<boolean> {
+  // Check for common monorepo indicators
+  const indicators = [
+    'pnpm-workspace.yaml',
+    'lerna.json',
+    'nx.json',
+    'turbo.json',
+    'rush.json',
+  ];
+
+  for (const indicator of indicators) {
+    try {
+      await access(join(rootPath, indicator));
+      return true;
+    } catch {
+      // Continue checking
+    }
+  }
+
+  // Check package.json for workspaces
+  try {
+    const packageJsonPath = join(rootPath, 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    return !!(packageJson.workspaces || packageJson.workspace);
+  } catch {
+    return false;
+  }
+}
+

package/src/docker.ts

@@ -0,0 +1,107 @@
+import { writeFile, access } from 'fs/promises';
+import { join } from 'path';
+import type { ProjectInfo } from './types.js';
+
+export async function generateDocker(projectInfo: ProjectInfo): Promise<void> {
+  const dockerfile = generateDockerfile(projectInfo);
+  const dockerCompose = generateDockerCompose();
+
+  const dockerfilePath = join(projectInfo.rootPath, 'Dockerfile');
+  const dockerComposePath = join(projectInfo.rootPath, 'docker-compose.yml');
+
+  // Check if files exist
+  try {
+    await access(dockerfilePath);
+    console.log('  Skipping Dockerfile (already exists)');
+  } catch {
+    await writeFile(dockerfilePath, dockerfile, 'utf-8');
+    console.log('  Generated Dockerfile');
+  }
+
+  try {
+    await access(dockerComposePath);
+    console.log('  Skipping docker-compose.yml (already exists)');
+  } catch {
+    await writeFile(dockerComposePath, dockerCompose, 'utf-8');
+    console.log('  Generated docker-compose.yml');
+  }
+}
+
+function generateDockerfile(projectInfo: ProjectInfo): string {
+  const packageManager = projectInfo.packageManager;
+  const installCmd = packageManager === 'pnpm' 
+    ? 'RUN pnpm install --frozen-lockfile'
+    : packageManager === 'yarn'
+    ? 'RUN yarn install --frozen-lockfile'
+    : 'RUN npm ci';
+
+  const lockFileName = packageManager === 'pnpm'
+    ? 'pnpm-lock.yaml'
+    : packageManager === 'yarn'
+    ? 'yarn.lock'
+    : 'package-lock.json';
+
+  return `# Build stage
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json .
+COPY ${lockFileName} .
+
+${installCmd}
+
+# Copy source files
+COPY . .
+
+# Build the application (adjust as needed)
+${projectInfo.hasTypeScript ? 'RUN npm run build' : '# Add build command if needed'}
+
+# Production stage
+FROM node:20-alpine AS production
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json .
+COPY ${lockFileName} .
+
+# Install production dependencies only
+${packageManager === 'pnpm'
+  ? 'RUN pnpm install --frozen-lockfile --prod'
+  : packageManager === 'yarn'
+  ? 'RUN yarn install --frozen-lockfile --production'
+  : 'RUN npm ci --only=production'}
+
+# Copy built application from builder
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/public ./public 2>/dev/null || true
+
+# Expose port (adjust as needed)
+EXPOSE 3000
+
+# Start the application
+CMD ["node", "dist/index.js"]
+`;
+}
+
+function generateDockerCompose(): string {
+  return `version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: production
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+    restart: unless-stopped
+    # volumes:
+    #   - ./data:/app/data
+`;
+}
+

package/src/generate.ts

@@ -0,0 +1,81 @@
+import { writeFile, readFile, access } from 'fs/promises';
+import { join } from 'path';
+import type { ProjectInfo, Options } from './types.js';
+import { getTemplates } from './templates.js';
+
+export async function generateFiles(projectInfo: ProjectInfo, options: Options): Promise<void> {
+  const templates = getTemplates(projectInfo, options);
+  const filesToGenerate = [
+    { name: '.eslintrc.json', content: templates.eslint },
+    { name: '.prettierrc.json', content: templates.prettier },
+    { name: '.prettierignore', content: templates.prettierIgnore },
+    { name: '.gitignore', content: templates.gitignore },
+    { name: '.editorconfig', content: templates.editorconfig },
+    { name: '.env.example', content: templates.envExample },
+  ];
+
+  for (const file of filesToGenerate) {
+    const filePath = join(projectInfo.rootPath, file.name);
+    
+    // Skip if file exists (don't overwrite)
+    try {
+      await access(filePath);
+      console.log(`  Skipping ${file.name} (already exists)`);
+      continue;
+    } catch {
+      // File doesn't exist, proceed
+    }
+
+    await writeFile(filePath, file.content, 'utf-8');
+    console.log(`  Generated ${file.name}`);
+  }
+
+  // Update package.json scripts
+  await updatePackageJson(projectInfo);
+}
+
+async function updatePackageJson(projectInfo: ProjectInfo): Promise<void> {
+  const packageJsonPath = join(projectInfo.rootPath, 'package.json');
+  
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    
+    // Initialize scripts if not present
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+
+    // Add scripts only if they don't exist
+    const scriptsToAdd: Record<string, string> = {
+      lint: projectInfo.hasTypeScript 
+        ? 'eslint . --ext .js,.jsx,.ts,.tsx'
+        : 'eslint . --ext .js,.jsx',
+      'lint:fix': projectInfo.hasTypeScript
+        ? 'eslint . --ext .js,.jsx,.ts,.tsx --fix'
+        : 'eslint . --ext .js,.jsx --fix',
+      format: 'prettier --write "**/*.{js,jsx,ts,tsx,json,md}"',
+      'format:check': 'prettier --check "**/*.{js,jsx,ts,tsx,json,md}"',
+    };
+
+    if (projectInfo.hasTypeScript) {
+      scriptsToAdd['type-check'] = 'tsc --noEmit';
+    }
+
+    // Only add scripts that don't already exist
+    for (const [key, value] of Object.entries(scriptsToAdd)) {
+      if (!packageJson.scripts[key]) {
+        packageJson.scripts[key] = value;
+      }
+    }
+
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+    console.log('  Updated package.json scripts');
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      console.warn('  Warning: package.json not found, skipping script updates');
+    } else {
+      throw error;
+    }
+  }
+}
+

package/src/husky.ts

@@ -0,0 +1,107 @@
+import { writeFile, mkdir, access, readFile } from 'fs/promises';
+import { join } from 'path';
+import type { ProjectInfo, Options } from './types.js';
+
+export async function setupHusky(projectInfo: ProjectInfo, options: Options): Promise<void> {
+  const huskyDir = join(projectInfo.rootPath, '.husky');
+  
+  // Check if .git exists
+  try {
+    await access(join(projectInfo.rootPath, '.git'));
+  } catch {
+    console.warn('  Warning: .git directory not found, skipping Husky setup');
+    return;
+  }
+
+  // Create .husky directory
+  try {
+    await mkdir(huskyDir, { recursive: true });
+  } catch {
+    // Directory might already exist
+  }
+
+  // Create pre-commit hook
+  const preCommitHook = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${projectInfo.packageManager === 'pnpm' ? 'pnpm' : 'npx'} lint-staged
+`;
+
+  const preCommitPath = join(huskyDir, 'pre-commit');
+  await writeFile(preCommitPath, preCommitHook, 'utf-8');
+  
+  // Make it executable (Unix-like systems)
+  if (process.platform !== 'win32') {
+    const { chmod } = await import('fs/promises');
+    await chmod(preCommitPath, 0o755);
+  }
+
+  // Create commit-msg hook if commitlint is enabled
+  if (options.strict) {
+    const commitMsgHook = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${projectInfo.packageManager === 'pnpm' ? 'pnpm' : 'npx'} commitlint --edit "$1"
+`;
+
+    const commitMsgPath = join(huskyDir, 'commit-msg');
+    await writeFile(commitMsgPath, commitMsgHook, 'utf-8');
+    
+    if (process.platform !== 'win32') {
+      const { chmod } = await import('fs/promises');
+      await chmod(commitMsgPath, 0o755);
+    }
+  }
+
+  // Update package.json with husky and lint-staged config
+  await updatePackageJsonForHusky(projectInfo, options);
+}
+
+async function updatePackageJsonForHusky(projectInfo: ProjectInfo, options: Options): Promise<void> {
+  const packageJsonPath = join(projectInfo.rootPath, 'package.json');
+  
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    
+    // Add prepare script for husky
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    
+    if (!packageJson.scripts.prepare) {
+      packageJson.scripts.prepare = 'husky install';
+    }
+
+    // Add lint-staged configuration
+    if (!packageJson['lint-staged']) {
+      const lintStagedConfig: Record<string, string | string[]> = {
+        '*.{js,jsx,ts,tsx}': [
+          'eslint --fix',
+          'prettier --write',
+        ],
+        '*.{json,md,yml,yaml}': [
+          'prettier --write',
+        ],
+      };
+
+      packageJson['lint-staged'] = lintStagedConfig;
+    }
+
+    // Add commitlint config if strict mode
+    if (options.strict && !packageJson.commitlint) {
+      packageJson.commitlint = {
+        extends: ['@commitlint/config-conventional'],
+      };
+    }
+
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+    console.log('  Configured Husky git hooks');
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      console.warn('  Warning: package.json not found, skipping Husky configuration');
+    } else {
+      throw error;
+    }
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { detectProject } from './detect.js';
+import { generateFiles } from './generate.js';
+import { setupHusky } from './husky.js';
+import { generateCI } from './ci.js';
+import { generateDocker } from './docker.js';
+import { addDependencies } from './dependencies.js';
+import { printBanner } from './banner.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import type { Options, ProjectInfo } from './types.js';
+
+const execAsync = promisify(exec);
+
+const program = new Command();
+
+program
+  .name('stackinit')
+  .description('Initialize a consistent development environment for Node-based projects')
+  .version('0.1.0')
+  .option('--strict', 'Enable stricter lint rules and CI failure on warnings')
+  .option('--docker', 'Generate Dockerfile and docker-compose.yml')
+  .option('--ci-only', 'Generate only GitHub Actions')
+  .option('--dry-run', 'Show what files would be created without writing')
+  .action(async (options: Options) => {
+    try {
+      if (!options.dryRun && !options.ciOnly) {
+        printBanner();
+      }
+      
+      const projectInfo = await detectProject();
+      
+      if (options.dryRun) {
+        console.log('\nDRY RUN MODE - No files will be written\n');
+        console.log('Detected project:');
+        console.log(`  Type: ${projectInfo.type}`);
+        console.log(`  Package Manager: ${projectInfo.packageManager}`);
+        console.log(`  TypeScript: ${projectInfo.hasTypeScript ? 'Yes' : 'No'}`);
+        console.log(`  Monorepo: ${projectInfo.isMonorepo ? 'Yes' : 'No'}\n`);
+        console.log('Files that would be generated:');
+        console.log('  - .eslintrc.json');
+        console.log('  - .prettierrc.json');
+        console.log('  - .prettierignore');
+        console.log('  - .gitignore');
+        console.log('  - .editorconfig');
+        console.log('  - .env.example');
+        console.log('  - .husky/pre-commit');
+        if (options.strict) {
+          console.log('  - .husky/commit-msg');
+        }
+        console.log('  - .github/workflows/ci.yml');
+        if (options.docker) {
+          console.log('  - Dockerfile');
+          console.log('  - docker-compose.yml');
+        }
+        console.log('\nPackage.json scripts that would be added:');
+        console.log('  - lint');
+        console.log('  - lint:fix');
+        console.log('  - format');
+        console.log('  - format:check');
+        if (projectInfo.hasTypeScript) {
+          console.log('  - type-check');
+        }
+        console.log('  - prepare (for Husky)');
+        console.log('\nDependencies that would be installed:');
+        console.log('  - eslint, prettier, husky, lint-staged');
+        if (projectInfo.hasTypeScript) {
+          console.log('  - @typescript-eslint/parser, @typescript-eslint/eslint-plugin');
+        }
+        if (projectInfo.type === 'react' || projectInfo.type === 'nextjs' || projectInfo.type === 'vite') {
+          console.log('  - eslint-plugin-react, eslint-plugin-react-hooks');
+        }
+        if (projectInfo.type === 'nextjs') {
+          console.log('  - eslint-config-next');
+        }
+        if (options.strict) {
+          console.log('  - @commitlint/cli, @commitlint/config-conventional');
+        }
+        return;
+      }
+
+      if (options.ciOnly) {
+        await generateCI(projectInfo, options);
+        console.log('\n✓ GitHub Actions CI generated successfully');
+        return;
+      }
+
+      console.log('\nInitializing development environment...\n');
+
+      // Generate core config files
+      await generateFiles(projectInfo, options);
+
+      // Add and install dependencies
+      await addDependencies(projectInfo, options);
+
+      // Setup Husky and lint-staged
+      await setupHusky(projectInfo, options);
+
+      // Initialize Husky (if git repo exists)
+      await initializeHusky(projectInfo);
+
+      // Generate CI
+      await generateCI(projectInfo, options);
+
+      // Generate Docker files if requested
+      if (options.docker) {
+        await generateDocker(projectInfo);
+      }
+
+      console.log('\n✓ Development environment initialized successfully\n');
+      console.log('Next steps:');
+      console.log('  1. Review the generated configuration files');
+      console.log('  2. Start developing!\n');
+    } catch (error) {
+      console.error('\nERROR:', error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+async function initializeHusky(projectInfo: ProjectInfo): Promise<void> {
+  try {
+    const { access } = await import('fs/promises');
+    await access(projectInfo.rootPath + '/.git');
+    
+    // Husky install
+    const huskyCommand = projectInfo.packageManager === 'pnpm'
+      ? 'pnpm exec husky install'
+      : 'npx husky install';
+    
+    try {
+      await execAsync(huskyCommand, { cwd: projectInfo.rootPath });
+      console.log('✓ Husky initialized');
+    } catch {
+      // Husky install might fail if not in git repo or already installed
+      // This is okay, user can run manually if needed
+    }
+  } catch {
+    // Not a git repo, skip husky init
+  }
+}
+
+program.parse();
+