proagents 1.0.11 → 1.0.13

package/lib/commands/init.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
+import { createInterface } from 'readline';
 import chalk from 'chalk';
 import yaml from 'js-yaml';
 import { selectPlatforms, copyPlatformFiles, savePlatformConfig, loadPlatformConfig } from './ai.js';
@@ -90,6 +91,559 @@ const FRAMEWORK_FILES = [
   'AI_INSTRUCTIONS.md',  // Universal instructions kept for reference
 ];
 
+// Project type definitions for detection
+const PROJECT_TYPES = [
+  {
+    id: 'nextjs',
+    name: 'Next.js (Full-stack)',
+    detect: {
+      files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+      deps: ['next']
+    }
+  },
+  {
+    id: 'react',
+    name: 'React (Frontend)',
+    detect: {
+      deps: ['react', 'react-dom'],
+      notDeps: ['next', 'react-native']
+    }
+  },
+  {
+    id: 'vue',
+    name: 'Vue.js (Frontend)',
+    detect: {
+      files: ['vue.config.js', 'vite.config.ts', 'vite.config.js'],
+      deps: ['vue']
+    }
+  },
+  {
+    id: 'angular',
+    name: 'Angular (Frontend)',
+    detect: {
+      files: ['angular.json'],
+      deps: ['@angular/core']
+    }
+  },
+  {
+    id: 'react-native',
+    name: 'React Native (Mobile)',
+    detect: {
+      deps: ['react-native']
+    }
+  },
+  {
+    id: 'express',
+    name: 'Express.js (Backend)',
+    detect: {
+      deps: ['express']
+    }
+  },
+  {
+    id: 'nestjs',
+    name: 'NestJS (Backend)',
+    detect: {
+      files: ['nest-cli.json'],
+      deps: ['@nestjs/core']
+    }
+  },
+  {
+    id: 'fastify',
+    name: 'Fastify (Backend)',
+    detect: {
+      deps: ['fastify']
+    }
+  },
+  {
+    id: 'nodejs',
+    name: 'Node.js (Backend)',
+    detect: {
+      files: ['package.json'],
+      notDeps: ['react', 'vue', '@angular/core', 'next']
+    }
+  },
+  {
+    id: 'python',
+    name: 'Python',
+    detect: {
+      files: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile']
+    }
+  },
+  {
+    id: 'django',
+    name: 'Django (Python)',
+    detect: {
+      files: ['manage.py'],
+      patterns: ['django']
+    }
+  },
+  {
+    id: 'flask',
+    name: 'Flask (Python)',
+    detect: {
+      patterns: ['flask']
+    }
+  },
+  {
+    id: 'other',
+    name: 'Other / Custom',
+    detect: {}
+  }
+];
+
+// Tech stack configuration options
+const TECH_STACK_OPTIONS = {
+  api_style: {
+    label: 'API Style',
+    options: [
+      { id: 'rest', name: 'REST' },
+      { id: 'graphql', name: 'GraphQL' },
+      { id: 'grpc', name: 'gRPC' },
+      { id: 'trpc', name: 'tRPC' }
+    ],
+    detect: {
+      'graphql': ['@apollo/client', 'graphql', 'apollo-server', 'urql'],
+      'grpc': ['@grpc/grpc-js', 'grpc'],
+      'trpc': ['@trpc/client', '@trpc/server']
+    },
+    default: 'rest'
+  },
+  state_management: {
+    label: 'State Management',
+    options: [
+      { id: 'zustand', name: 'Zustand' },
+      { id: 'redux', name: 'Redux' },
+      { id: 'jotai', name: 'Jotai' },
+      { id: 'recoil', name: 'Recoil' },
+      { id: 'mobx', name: 'MobX' },
+      { id: 'context', name: 'React Context' },
+      { id: 'none', name: 'None / Other' }
+    ],
+    detect: {
+      'zustand': ['zustand'],
+      'redux': ['redux', '@reduxjs/toolkit', 'react-redux'],
+      'jotai': ['jotai'],
+      'recoil': ['recoil'],
+      'mobx': ['mobx', 'mobx-react']
+    },
+    default: 'zustand'
+  },
+  styling: {
+    label: 'Styling',
+    options: [
+      { id: 'tailwind', name: 'Tailwind CSS' },
+      { id: 'css-modules', name: 'CSS Modules' },
+      { id: 'styled-components', name: 'Styled Components' },
+      { id: 'emotion', name: 'Emotion' },
+      { id: 'sass', name: 'Sass/SCSS' },
+      { id: 'css', name: 'Plain CSS' }
+    ],
+    detect: {
+      'tailwind': ['tailwindcss'],
+      'styled-components': ['styled-components'],
+      'emotion': ['@emotion/react', '@emotion/styled'],
+      'sass': ['sass', 'node-sass']
+    },
+    default: 'tailwind'
+  },
+  database: {
+    label: 'Database',
+    options: [
+      { id: 'postgresql', name: 'PostgreSQL' },
+      { id: 'mysql', name: 'MySQL' },
+      { id: 'mongodb', name: 'MongoDB' },
+      { id: 'sqlite', name: 'SQLite' },
+      { id: 'supabase', name: 'Supabase' },
+      { id: 'firebase', name: 'Firebase' },
+      { id: 'none', name: 'None / Other' }
+    ],
+    detect: {
+      'postgresql': ['pg', '@prisma/client', 'postgres'],
+      'mysql': ['mysql', 'mysql2'],
+      'mongodb': ['mongoose', 'mongodb'],
+      'sqlite': ['better-sqlite3', 'sqlite3'],
+      'supabase': ['@supabase/supabase-js'],
+      'firebase': ['firebase', 'firebase-admin']
+    },
+    default: 'postgresql'
+  },
+  orm: {
+    label: 'ORM',
+    options: [
+      { id: 'prisma', name: 'Prisma' },
+      { id: 'drizzle', name: 'Drizzle' },
+      { id: 'typeorm', name: 'TypeORM' },
+      { id: 'sequelize', name: 'Sequelize' },
+      { id: 'mongoose', name: 'Mongoose' },
+      { id: 'none', name: 'None / Raw SQL' }
+    ],
+    detect: {
+      'prisma': ['@prisma/client', 'prisma'],
+      'drizzle': ['drizzle-orm'],
+      'typeorm': ['typeorm'],
+      'sequelize': ['sequelize'],
+      'mongoose': ['mongoose']
+    },
+    default: 'prisma'
+  },
+  auth_method: {
+    label: 'Authentication',
+    options: [
+      { id: 'jwt', name: 'JWT' },
+      { id: 'session', name: 'Session-based' },
+      { id: 'oauth', name: 'OAuth' },
+      { id: 'nextauth', name: 'NextAuth.js' },
+      { id: 'clerk', name: 'Clerk' },
+      { id: 'auth0', name: 'Auth0' },
+      { id: 'supabase', name: 'Supabase Auth' },
+      { id: 'none', name: 'None / Custom' }
+    ],
+    detect: {
+      'nextauth': ['next-auth'],
+      'clerk': ['@clerk/nextjs', '@clerk/clerk-react'],
+      'auth0': ['@auth0/auth0-react', 'auth0'],
+      'supabase': ['@supabase/auth-helpers-nextjs']
+    },
+    default: 'jwt'
+  },
+  test_framework: {
+    label: 'Test Framework',
+    options: [
+      { id: 'vitest', name: 'Vitest' },
+      { id: 'jest', name: 'Jest' },
+      { id: 'mocha', name: 'Mocha' },
+      { id: 'playwright', name: 'Playwright' },
+      { id: 'cypress', name: 'Cypress' },
+      { id: 'pytest', name: 'Pytest (Python)' },
+      { id: 'none', name: 'None' }
+    ],
+    detect: {
+      'vitest': ['vitest'],
+      'jest': ['jest'],
+      'mocha': ['mocha'],
+      'playwright': ['@playwright/test', 'playwright'],
+      'cypress': ['cypress'],
+      'pytest': ['pytest']
+    },
+    default: 'vitest'
+  }
+};
+
+/**
+ * Detect tech stack from dependencies
+ */
+function detectTechStack(targetDir) {
+  const { allDeps = [] } = getPackageDeps(targetDir);
+  const pythonDeps = getPythonDeps(targetDir);
+  const allProjectDeps = [...allDeps, ...pythonDeps.map(d => d.toLowerCase())];
+
+  const detected = {};
+
+  for (const [key, config] of Object.entries(TECH_STACK_OPTIONS)) {
+    detected[key] = null;
+
+    if (config.detect) {
+      for (const [optionId, detectDeps] of Object.entries(config.detect)) {
+        const hasMatch = detectDeps.some(dep => allProjectDeps.includes(dep));
+        if (hasMatch) {
+          detected[key] = optionId;
+          break;
+        }
+      }
+    }
+
+    // Use default if not detected
+    if (!detected[key]) {
+      detected[key] = config.default;
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Detect project name from package.json or folder name
+ */
+function detectProjectName(targetDir) {
+  const packageJsonPath = join(targetDir, 'package.json');
+
+  if (existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+      if (packageJson.name) {
+        return packageJson.name;
+      }
+    } catch {
+      // Fall through to folder name
+    }
+  }
+
+  // Fallback to folder name
+  return basename(targetDir);
+}
+
+/**
+ * Read package.json dependencies
+ */
+function getPackageDeps(targetDir) {
+  const packageJsonPath = join(targetDir, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return { deps: [], devDeps: [] };
+  }
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const deps = Object.keys(packageJson.dependencies || {});
+    const devDeps = Object.keys(packageJson.devDependencies || {});
+    return { deps, devDeps, allDeps: [...deps, ...devDeps] };
+  } catch {
+    return { deps: [], devDeps: [], allDeps: [] };
+  }
+}
+
+/**
+ * Read requirements.txt for Python projects
+ */
+function getPythonDeps(targetDir) {
+  const requirementsPath = join(targetDir, 'requirements.txt');
+
+  if (!existsSync(requirementsPath)) {
+    return [];
+  }
+
+  try {
+    const content = readFileSync(requirementsPath, 'utf-8');
+    return content.split('\n')
+      .map(line => line.trim().split('==')[0].split('>=')[0].split('<=')[0])
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Detect project type based on files and dependencies
+ */
+function detectProjectType(targetDir) {
+  const { allDeps = [] } = getPackageDeps(targetDir);
+  const pythonDeps = getPythonDeps(targetDir);
+  const allProjectDeps = [...allDeps, ...pythonDeps.map(d => d.toLowerCase())];
+
+  const detectedTypes = [];
+
+  for (const projectType of PROJECT_TYPES) {
+    if (projectType.id === 'other') continue;
+
+    const { detect } = projectType;
+    let matches = true;
+    let score = 0;
+
+    // Check for required files
+    if (detect.files) {
+      const hasFile = detect.files.some(file => existsSync(join(targetDir, file)));
+      if (hasFile) {
+        score += 10;
+      }
+    }
+
+    // Check for required dependencies
+    if (detect.deps) {
+      const hasDep = detect.deps.some(dep => allProjectDeps.includes(dep));
+      if (hasDep) {
+        score += 5;
+      } else if (detect.deps.length > 0 && !detect.files) {
+        matches = false;
+      }
+    }
+
+    // Check for excluded dependencies
+    if (detect.notDeps && matches) {
+      const hasExcluded = detect.notDeps.some(dep => allProjectDeps.includes(dep));
+      if (hasExcluded) {
+        matches = false;
+      }
+    }
+
+    // Check for patterns in requirements.txt
+    if (detect.patterns && pythonDeps.length > 0) {
+      const hasPattern = detect.patterns.some(pattern =>
+        pythonDeps.some(dep => dep.toLowerCase().includes(pattern))
+      );
+      if (hasPattern) {
+        score += 5;
+      }
+    }
+
+    if (matches && score > 0) {
+      detectedTypes.push({ ...projectType, score });
+    }
+  }
+
+  // Sort by score descending
+  detectedTypes.sort((a, b) => b.score - a.score);
+
+  return detectedTypes;
+}
+
+/**
+ * Interactive prompt for project configuration
+ */
+async function promptProjectConfig(targetDir) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (prompt) => new Promise(resolve => rl.question(prompt, resolve));
+
+  // Detect project name
+  const detectedName = detectProjectName(targetDir);
+
+  // Detect project types
+  const detectedTypes = detectProjectType(targetDir);
+  const topDetectedType = detectedTypes.length > 0 ? detectedTypes[0] : null;
+
+  // Detect tech stack
+  const detectedTechStack = detectTechStack(targetDir);
+
+  console.log(chalk.bold('\nProject Configuration'));
+  console.log(chalk.gray('─'.repeat(40) + '\n'));
+
+  // Project Name
+  console.log(chalk.cyan('Project Name'));
+  if (detectedName) {
+    console.log(chalk.gray(`  Detected: ${detectedName}`));
+  }
+  const nameInput = await question(chalk.yellow(`  Enter name (press Enter for "${detectedName}"): `));
+  const projectName = nameInput.trim() || detectedName;
+
+  console.log('');
+
+  // Project Type
+  console.log(chalk.cyan('Project Type'));
+  if (topDetectedType) {
+    console.log(chalk.green(`  Detected: ${topDetectedType.name}`));
+  }
+
+  console.log(chalk.gray('\n  Available types:'));
+  PROJECT_TYPES.forEach((type, index) => {
+    const isDetected = topDetectedType && type.id === topDetectedType.id;
+    const marker = isDetected ? chalk.green(' ✓ (detected)') : '';
+    console.log(chalk.white(`    ${index + 1}. ${type.name}`) + marker);
+  });
+
+  const defaultTypeIndex = topDetectedType
+    ? PROJECT_TYPES.findIndex(t => t.id === topDetectedType.id) + 1
+    : PROJECT_TYPES.length;
+
+  const typeInput = await question(chalk.yellow(`\n  Enter number (press Enter for ${defaultTypeIndex}): `));
+  const typeIndex = parseInt(typeInput.trim()) || defaultTypeIndex;
+  const projectType = PROJECT_TYPES[Math.min(Math.max(typeIndex - 1, 0), PROJECT_TYPES.length - 1)];
+
+  console.log('');
+  console.log(chalk.green(`✓ Project: ${projectName} (${projectType.name})`));
+
+  // Tech Stack Configuration
+  console.log(chalk.bold('\nTech Stack Configuration'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log(chalk.gray('Press Enter to accept detected/default values\n'));
+
+  const techStack = {};
+
+  for (const [key, config] of Object.entries(TECH_STACK_OPTIONS)) {
+    const detected = detectedTechStack[key];
+    const detectedOption = config.options.find(o => o.id === detected);
+    const detectedName = detectedOption ? detectedOption.name : config.default;
+
+    console.log(chalk.cyan(config.label));
+    config.options.forEach((option, index) => {
+      const isDetected = option.id === detected;
+      const marker = isDetected ? chalk.green(' ✓') : '';
+      console.log(chalk.white(`  ${index + 1}. ${option.name}`) + marker);
+    });
+
+    const defaultIndex = config.options.findIndex(o => o.id === detected) + 1 || 1;
+    const input = await question(chalk.yellow(`  Select (Enter for ${defaultIndex}): `));
+    const selectedIndex = parseInt(input.trim()) || defaultIndex;
+    const selectedOption = config.options[Math.min(Math.max(selectedIndex - 1, 0), config.options.length - 1)];
+    techStack[key] = selectedOption.id;
+    console.log('');
+  }
+
+  rl.close();
+
+  // Summary
+  console.log(chalk.bold('\nConfiguration Summary'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log(chalk.white(`  Project: ${projectName} (${projectType.name})`));
+  for (const [key, value] of Object.entries(techStack)) {
+    const config = TECH_STACK_OPTIONS[key];
+    const option = config.options.find(o => o.id === value);
+    console.log(chalk.white(`  ${config.label}: ${option ? option.name : value}`));
+  }
+  console.log('');
+
+  return {
+    name: projectName,
+    type: projectType.id,
+    typeName: projectType.name,
+    techStack
+  };
+}
+
+/**
+ * Save project config to proagents.config.yaml
+ */
+function saveProjectConfig(projectConfig, configPath) {
+  let config = {};
+
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, 'utf-8');
+      config = yaml.load(content) || {};
+    } catch {
+      config = {};
+    }
+  }
+
+  // Save project info
+  config.project = {
+    name: projectConfig.name,
+    type: projectConfig.type
+  };
+
+  // Save tech stack under automation.decisions
+  if (projectConfig.techStack) {
+    if (!config.automation) {
+      config.automation = {};
+    }
+    if (!config.automation.decisions) {
+      config.automation.decisions = {};
+    }
+
+    // Architecture decisions
+    config.automation.decisions.architecture = {
+      api_style: projectConfig.techStack.api_style,
+      state_management: projectConfig.techStack.state_management,
+      styling: projectConfig.techStack.styling,
+      database: projectConfig.techStack.database,
+      orm: projectConfig.techStack.orm,
+      auth_method: projectConfig.techStack.auth_method
+    };
+
+    // Testing decisions
+    config.automation.decisions.testing = {
+      framework: projectConfig.techStack.test_framework,
+      coverage_target: 80,
+      location: 'colocated'
+    };
+  }
+
+  const yamlContent = yaml.dump(config, { indent: 2, lineWidth: 120 });
+  writeFileSync(configPath, yamlContent);
+}
+
 /**
  * Initialize ProAgents in the current project
  */
@@ -223,6 +777,9 @@ No releases yet. Use \`pa:release\` to generate release notes.
       console.log(chalk.green('✓ Created RELEASE_NOTES.md'));
     }
 
+    // Interactive project configuration
+    const projectConfig = await promptProjectConfig(targetDir);
+
     // Add ProAgents section to README.md (AI tools auto-read this)
     const readmePath = join(targetDir, 'README.md');
     const proagentsSection = `
@@ -251,25 +808,29 @@ For detailed commands, see \`./proagents/PROAGENTS.md\`
         console.log(chalk.green('✓ Added ProAgents commands to README.md'));
       }
     } else {
-      writeFileSync(readmePath, proagentsSection + `# Project Name\n\nProject description.\n`);
+      writeFileSync(readmePath, proagentsSection + `# ${projectConfig.name}\n\nProject description.\n`);
       console.log(chalk.green('✓ Created README.md with ProAgents commands'));
     }
 
     // Interactive AI platform selection
     const selectedPlatforms = await selectPlatforms();
 
-    // Copy AI instruction files for selected platforms
+    // Copy AI instruction files for selected platforms (merges with existing files)
     const aiResults = copyPlatformFiles(selectedPlatforms, sourceDir, targetDir);
 
     if (aiResults.created.length > 0) {
       console.log(chalk.green(`✓ Created AI files: ${aiResults.created.join(', ')}`));
     }
-    if (aiResults.skipped.length > 0) {
-      console.log(chalk.yellow(`⚠️  Skipped (already exist): ${aiResults.skipped.join(', ')}`));
+    if (aiResults.updated.length > 0) {
+      console.log(chalk.green(`✓ Updated AI files: ${aiResults.updated.join(', ')}`));
+    }
+    if (aiResults.merged.length > 0) {
+      console.log(chalk.green(`✓ Merged with existing: ${aiResults.merged.join(', ')}`));
     }
 
-    // Save selected platforms to config
+    // Save project and platform config
     const configPath = join(proagentsDir, 'proagents.config.yaml');
+    saveProjectConfig(projectConfig, configPath);
     savePlatformConfig(selectedPlatforms, configPath);
 
     // Success message
@@ -383,7 +944,7 @@ async function smartUpdate(sourceDir, targetDir) {
     }
   }
 
-  // Copy AI instruction files for configured platforms (only if they don't exist)
+  // Copy AI instruction files for configured platforms (merges with existing files)
   const projectRoot = join(targetDir, '..');
   const configPath = join(targetDir, 'proagents.config.yaml');
   const selectedPlatforms = loadPlatformConfig(configPath);
@@ -394,8 +955,11 @@ async function smartUpdate(sourceDir, targetDir) {
     if (aiResults.created.length > 0) {
       console.log(chalk.green(`✓ Created new AI files: ${aiResults.created.join(', ')}`));
     }
-    if (aiResults.skipped.length > 0) {
-      console.log(chalk.gray(`ℹ️  Preserved existing: ${aiResults.skipped.join(', ')}`));
+    if (aiResults.updated.length > 0) {
+      console.log(chalk.green(`✓ Updated AI files: ${aiResults.updated.join(', ')}`));
+    }
+    if (aiResults.merged.length > 0) {
+      console.log(chalk.green(`✓ Merged with existing: ${aiResults.merged.join(', ')}`));
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proagents",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "AI-agnostic development workflow framework that automates the full software development lifecycle",
   "type": "module",
   "main": "lib/index.js",