context-forge
Version:
AI orchestration platform with autonomous teams, enhancement planning, migration tools, 25+ slash commands, checkpoints & hooks. Multi-IDE: Claude, Cursor, Windsurf, Cline, Copilot
328 lines (317 loc) ā¢ 13.6 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.runRetrofitPrompts = runRetrofitPrompts;
const projectInfo_1 = require("./projectInfo");
const ideSelection_1 = require("./ideSelection");
const prdInput_1 = require("./prdInput");
const projectConfig_1 = require("./projectConfig");
const inquirer_1 = __importDefault(require("inquirer"));
const chalk_1 = __importDefault(require("chalk"));
async function runRetrofitPrompts(basicAnalysis, detailedAnalysis, ideOverride) {
console.log(chalk_1.default.blue.bold('\nš§ Retrofitting Configuration\n'));
console.log(chalk_1.default.gray("Based on your project analysis, let's configure Context Forge.\n"));
console.log(chalk_1.default.gray('Step 1/5: Project information...'));
// Step 1: Confirm or adjust project info
const confirmedInfo = await confirmProjectInfo(basicAnalysis);
// Step 2: IDE selection (use override or ask)
console.log(chalk_1.default.gray('Step 2/5: IDE selection...'));
const targetIDEs = ideOverride || (await (0, ideSelection_1.ideSelection)());
// Step 3: PRD input (different flow for retrofit)
console.log(chalk_1.default.gray('Step 3/5: PRD configuration...'));
const prd = await retrofitPrdInput(basicAnalysis, detailedAnalysis);
// Step 4: Project configuration
console.log(chalk_1.default.gray('Step 4/5: Project settings...'));
const config = await (0, projectConfig_1.projectConfig)();
// Step 5: Feature selection based on analysis
console.log(chalk_1.default.gray('Step 5/5: Feature selection...'));
const selectedFeatures = await retrofitFeatures(basicAnalysis, detailedAnalysis);
return {
...confirmedInfo,
targetIDEs,
prd,
techStack: mapAnalysisToTechStack(basicAnalysis),
features: selectedFeatures,
...config,
isRetrofit: true,
plannedFeatures: prd.userStories || [],
};
}
async function confirmProjectInfo(analysis) {
console.log(chalk_1.default.cyan('š Project Information'));
console.log(chalk_1.default.gray('We detected the following about your project:\n'));
console.log(` ā¢ Type: ${analysis.projectType}`);
console.log(` ā¢ Tech Stack: ${analysis.techStack.join(', ')}`);
console.log(` ā¢ Files: ${analysis.fileStats.total} total, ${analysis.fileStats.components} components`);
const { confirmInfo } = await inquirer_1.default.prompt([
{
type: 'confirm',
name: 'confirmInfo',
message: 'Is this information correct?',
default: true,
},
]);
if (confirmInfo) {
// Use detected information and ask for basic details
const { projectName, description } = await inquirer_1.default.prompt([
{
type: 'input',
name: 'projectName',
message: 'Project name:',
default: process.cwd().split('/').pop(),
validate: (input) => input.trim().length > 0 || 'Project name is required',
},
{
type: 'input',
name: 'description',
message: 'Project description:',
validate: (input) => input.trim().length > 0 || 'Description is required',
},
]);
return {
projectName,
description,
projectType: analysis.projectType.toLowerCase(),
};
}
else {
// Fall back to manual entry
return await (0, projectInfo_1.projectInfo)();
}
}
async function retrofitPrdInput(basicAnalysis, detailedAnalysis) {
console.log(chalk_1.default.cyan('\nš Product Requirements'));
const hasExistingDocs = basicAnalysis.existingDocs.length > 0;
if (hasExistingDocs) {
// Limit displayed docs to first 5 for readability
const displayDocs = basicAnalysis.existingDocs.slice(0, 5);
const moreCount = basicAnalysis.existingDocs.length - 5;
const docsDisplay = moreCount > 0 ? `${displayDocs.join(', ')} (+${moreCount} more)` : displayDocs.join(', ');
console.log(chalk_1.default.gray(`Found existing documentation: ${docsDisplay}`));
const { useExistingDocs } = await inquirer_1.default.prompt([
{
type: 'confirm',
name: 'useExistingDocs',
message: 'Analyze existing documentation to understand current state?',
default: true,
},
]);
if (useExistingDocs) {
console.log(chalk_1.default.cyan('\nš Analyzing existing documentation...'));
// TODO: Actually read and analyze the existing docs
const existingContext = `Project has ${basicAnalysis.existingDocs.length} documentation files describing current implementation.`;
console.log(chalk_1.default.cyan('\nš Planning Future Development'));
console.log(chalk_1.default.gray('What features or improvements are you planning to add?\n'));
const { futureRequirements } = await inquirer_1.default.prompt([
{
type: 'editor',
name: 'futureRequirements',
message: 'Describe planned features and improvements:',
default: '## Planned Features\n\n- Feature 1: \n- Feature 2: \n- Feature 3: \n\n## Technical Improvements\n\n- \n\n## Timeline\n\n- ',
},
]);
// Parse features from the markdown
const featureLines = futureRequirements
.split('\n')
.filter((line) => line.trim().startsWith('- ') && line.includes(':'));
const userStories = featureLines.map((line) => line.trim().substring(2));
return {
content: `# Product Requirements Document - ${new Date().toLocaleDateString()}
## Current State
${existingContext}
## Future Development
${futureRequirements}
## Context
This is a retrofit of an existing project. The above requirements represent the next phase of development building upon the existing codebase.`,
userStories,
};
}
}
// Generate auto-PRD suggestion based on analysis
const suggestedPrd = generateAutoPrd(basicAnalysis, detailedAnalysis);
console.log(chalk_1.default.gray("\nBased on your codebase analysis, here's a suggested PRD:\n"));
console.log(chalk_1.default.dim(suggestedPrd.substring(0, 300) + '...'));
const { prdChoice } = await inquirer_1.default.prompt([
{
type: 'list',
name: 'prdChoice',
message: 'How would you like to handle the PRD?',
choices: [
{ name: 'Use AI-generated PRD based on analysis', value: 'auto' },
{ name: 'Write custom PRD', value: 'custom' },
{ name: 'Enhance AI-generated PRD', value: 'enhance' },
],
},
]);
switch (prdChoice) {
case 'auto':
return { content: suggestedPrd };
case 'custom':
return await (0, prdInput_1.prdInput)();
case 'enhance':
const { enhancedPrd } = await inquirer_1.default.prompt([
{
type: 'editor',
name: 'enhancedPrd',
message: 'Enhance the generated PRD:',
default: suggestedPrd,
},
]);
return { content: enhancedPrd };
default:
return { content: suggestedPrd };
}
}
async function retrofitFeatures(basicAnalysis, _detailedAnalysis) {
console.log(chalk_1.default.cyan('\nšÆ Feature Selection'));
// Suggest features based on analysis
const suggestedFeatures = detectFeaturesFromAnalysis(basicAnalysis);
if (suggestedFeatures.length > 0) {
console.log(chalk_1.default.gray('Detected features in your project:'));
suggestedFeatures.forEach((feature) => {
console.log(` ā¢ ${feature}`);
});
const { confirmFeatures } = await inquirer_1.default.prompt([
{
type: 'confirm',
name: 'confirmFeatures',
message: 'Include these detected features?',
default: true,
},
]);
if (confirmFeatures) {
return suggestedFeatures.map((featureName, index) => ({
id: `detected-${index}`,
name: featureName,
description: `Detected from project analysis: ${featureName}`,
priority: 'must-have',
complexity: 'medium',
category: 'integration',
}));
}
}
// Manual feature selection
const { features: manualFeatures } = await inquirer_1.default.prompt([
{
type: 'checkbox',
name: 'features',
message: 'Select features for your project:',
choices: [
'Authentication & Authorization',
'Database Integration',
'API Development',
'Frontend Components',
'State Management',
'Testing Framework',
'Deployment Pipeline',
'Monitoring & Analytics',
'File Upload/Storage',
'Real-time Features',
'Search Functionality',
'Payment Integration',
'Email/Notifications',
'Admin Dashboard',
'Mobile Responsive',
],
},
]);
return manualFeatures.map((featureName, index) => ({
id: `manual-${index}`,
name: featureName,
description: `Manually selected feature: ${featureName}`,
priority: 'must-have',
complexity: 'medium',
category: 'integration',
}));
}
function mapAnalysisToTechStack(analysis) {
// Map the detected tech stack to our expected format
const stack = {};
// Frontend
if (analysis.techStack.includes('React'))
stack.frontend = 'react';
else if (analysis.techStack.includes('Next.js'))
stack.frontend = 'nextjs';
else if (analysis.techStack.includes('Vue.js'))
stack.frontend = 'vue';
else if (analysis.techStack.includes('Angular'))
stack.frontend = 'angular';
// Backend
if (analysis.techStack.includes('Express.js'))
stack.backend = 'express';
else if (analysis.techStack.includes('Fastify'))
stack.backend = 'fastify';
else if (analysis.projectType.includes('Python'))
stack.backend = 'fastapi';
// Database
if (analysis.techStack.includes('MongoDB'))
stack.database = 'mongodb';
else if (analysis.techStack.includes('PostgreSQL'))
stack.database = 'postgresql';
else if (analysis.techStack.includes('MySQL'))
stack.database = 'mysql';
else if (analysis.techStack.includes('SQLite'))
stack.database = 'sqlite';
// Auth
stack.auth = 'jwt'; // Default assumption
return stack;
}
function generateAutoPrd(basicAnalysis, detailedAnalysis) {
const { projectType, techStack, fileStats } = basicAnalysis;
return `# Product Requirements Document
## Project Overview
This is a ${projectType} application built with ${techStack.join(', ')}.
## Current State Analysis
- **Total Files**: ${fileStats.total}
- **Components**: ${fileStats.components}
- **API Routes**: ${fileStats.routes}
- **Test Coverage**: ${fileStats.tests} test files
- **Configuration Files**: ${fileStats.config}
## Technology Stack
${techStack.map((tech) => `- ${tech}`).join('\n')}
## Key Features
Based on the codebase analysis, this application appears to include:
${detectFeaturesFromAnalysis(basicAnalysis)
.map((feature) => `- ${feature}`)
.join('\n')}
${detailedAnalysis
? `## AI Insights
${detailedAnalysis.insights.map((insight) => `- ${insight}`).join('\n')}
## Recommendations
${detailedAnalysis.recommendations.map((rec) => `- ${rec}`).join('\n')}`
: ''}
## Development Goals
1. Maintain existing functionality while improving code organization
2. Enhance documentation for better developer experience
3. Implement best practices for ${projectType} development
4. Ensure scalable architecture for future growth
## Success Criteria
- Clear, comprehensive documentation
- Well-organized codebase structure
- Improved developer onboarding experience
- Enhanced AI assistant integration`;
}
function detectFeaturesFromAnalysis(analysis) {
const features = [];
if (analysis.fileStats.routes > 0)
features.push('API Development');
if (analysis.fileStats.components > 0)
features.push('Frontend Components');
if (analysis.techStack.includes('MongoDB') || analysis.techStack.includes('PostgreSQL')) {
features.push('Database Integration');
}
if (analysis.fileStats.tests > 0)
features.push('Testing Framework');
if (analysis.techStack.includes('TypeScript'))
features.push('Type Safety');
if (analysis.techStack.includes('Tailwind CSS'))
features.push('Styling System');
if (analysis.techStack.includes('Prisma'))
features.push('ORM Integration');
if (analysis.techStack.includes('Docker'))
features.push('Containerization');
return features;
}
//# sourceMappingURL=retrofit.js.map