@boundless-oss/atlas
Version:
Atlas - MCP Server for comprehensive startup project management
1,111 lines • 70.3 kB
JavaScript
import { StartupTemplates } from './templates.js';
import { promises as fs } from 'fs';
import path from 'path';
export class BusinessAnalyzer {
configManager;
knowledgeBase;
knowledgePath;
constructor(configManager) {
this.configManager = configManager;
this.knowledgeBase = new Map();
this.knowledgePath = '';
// Don't call async method in constructor
}
async init() {
await this.initializeKnowledgeBase();
}
generateId() {
// Generate hex-only ID to match test expectations
const hex = () => Math.floor(Math.random() * 0xf).toString(16);
const segment = () => Array.from({ length: 8 }, hex).join('');
return `${segment()}-${segment()}`;
}
async generateBusinessPlan(options) {
// Validation
if (!options.businessIdea || options.businessIdea.trim().length === 0) {
throw new Error('Business idea is required');
}
if (!options.targetMarket || options.targetMarket.trim().length === 0) {
throw new Error('Target market is required');
}
if (!options.businessModel || options.businessModel.trim().length === 0) {
throw new Error('Business model is required');
}
if (!options.timeline || options.timeline <= 0) {
throw new Error('Timeline must be positive');
}
if (!options.template) {
throw new Error('Template is required');
}
const template = StartupTemplates.getBusinessPlanTemplate(options.template);
const sections = await this.generatePlanSections(options, template);
const markdown = this.formatBusinessPlanMarkdown(sections, options);
const nextSteps = this.generateBusinessPlanNextSteps(options);
const keyMetrics = this.getRelevantMetrics(options.businessModel);
const now = new Date().toISOString();
const plan = {
id: `plan-${this.generateId()}`,
businessIdea: options.businessIdea,
targetMarket: options.targetMarket,
businessModel: options.businessModel,
timeline: options.timeline,
template: options.template,
markdown,
sections,
nextSteps,
keyMetrics,
createdAt: now,
updatedAt: now,
};
if (options.includeFinancials) {
// Create default financial data if not provided
const financialOptions = {
businessModel: options.businessModel,
revenue: { 'product': 10000, 'service': 5000 },
expenses: { 'operations': 8000, 'marketing': 3000 },
timeline: options.timeline,
includeScenarios: false,
currency: 'USD'
};
plan.financials = await this.generateFinancialProjections(financialOptions);
}
return plan;
}
async analyzeMarket(options) {
// Validation
if (!options.industry || !options.targetMarket || !options.geographicScope) {
throw new Error('Industry, target market, and geographic scope are required');
}
const marketData = await this.gatherMarketData(options);
const opportunities = this.identifyMarketOpportunities(marketData, options);
const challenges = this.identifyMarketChallenges(options.industry);
const recommendations = this.generateMarketRecommendations(marketData, opportunities);
const analysis = {
id: `market-${this.generateId()}`,
industry: options.industry,
targetMarket: options.targetMarket,
geographicScope: options.geographicScope,
marketSize: marketData.size,
growthRate: marketData.growthRate,
trends: marketData.trends,
targetAudience: marketData.segments,
opportunities,
challenges,
recommendations,
competitors: options.includeCompetitors ? marketData.competitors : undefined,
timeframe: new Date().toISOString(),
};
if (options.includeDemographics) {
analysis.demographics = {
ageRange: '25-45',
income: '$50k-$150k',
behavior: 'Tech-savvy early adopters who are problem-aware'
};
}
return analysis;
}
async analyzeCompetitors(options) {
const competitors = await this.researchCompetitors(options);
const gaps = this.identifyCompetitiveGaps(competitors, options.businessIdea);
const opportunities = this.identifyCompetitiveOpportunities(gaps, competitors);
const recommendations = this.generateCompetitiveRecommendations(competitors, gaps);
const result = {
industry: options.industry,
competitionLevel: this.assessCompetitionLevel(competitors),
competitors,
gaps,
opportunities,
recommendations,
};
// Add positioning analysis for comprehensive depth
if (options.analysisDepth === 'comprehensive') {
result.positioning = {
marketGaps: gaps.slice(0, 3),
differentiationOpportunities: opportunities.slice(0, 3),
competitiveAdvantages: this.identifyCompetitiveAdvantages(options.businessIdea, competitors),
};
}
return result;
}
async generateFinancialProjections(options) {
const projections = this.calculateProjections(options);
const scenarios = options.includeScenarios ? this.generateScenarios(projections) : undefined;
const breakEvenMonth = this.calculateBreakEven(projections);
const roi = this.calculateROI(projections, options.timeline);
const assumptions = this.getFinancialAssumptions(options.businessModel);
const recommendations = this.generateFinancialRecommendations(projections);
// Create projections array from the monthly data
const projectionsArray = Object.keys(projections.revenue).map(month => ({
period: month,
revenue: projections.revenue[month],
expenses: projections.expenses[month],
profit: projections.netIncome[month]
}));
return {
businessModel: options.businessModel,
timeline: options.timeline,
currency: options.currency,
revenue: projections.revenue,
expenses: projections.expenses,
netIncome: projections.netIncome,
cashFlow: projections.cashFlow,
breakEvenMonth,
totalInvestmentNeeded: this.calculateInvestmentNeeded(projections),
roi,
scenarios,
assumptions,
recommendations,
projections: projectionsArray
};
}
async assessStartup(options) {
const categories = this.assessStartupCategories(options);
const overallScore = categories.reduce((sum, cat) => sum + cat.score, 0) / categories.length * 10;
const strengths = this.identifyStartupStrengths(categories);
const weaknesses = this.identifyStartupWeaknesses(categories);
const nextSteps = this.generateStartupNextSteps(options, weaknesses);
const stageRecommendations = this.getStageSpecificRecommendations(options.stage);
const overall = this.generateOverallAssessment(overallScore, options.stage);
return {
id: `assessment-${this.generateId()}`,
businessPlanId: options.businessPlanId,
stage: options.stage || options.currentStage || 'unknown',
score: Math.round(overallScore),
overallScore: Math.round(overallScore),
maturityLevel: this.getMaturityLevel(overallScore),
dimensions: {
product: { score: 7, feedback: 'Product development on track' },
market: { score: 6, feedback: 'Market validation needed' },
team: { score: 8, feedback: 'Strong team composition' },
financial: { score: 5, feedback: 'Revenue model needs refinement' },
operations: { score: 6, feedback: 'Operations scaling required' }
},
categories,
strengths,
weaknesses,
recommendations: nextSteps,
nextSteps,
stageRecommendations,
overall,
};
}
async generatePitchDeck(options) {
const template = StartupTemplates.getPitchDeckTemplate(options.template);
const slides = this.generatePitchSlides(options, template);
const markdown = this.formatPitchDeckMarkdown(slides, options);
const presentationTips = this.getPresentationTips(options.template);
const keyMessages = this.extractKeyMessages(options);
return {
businessIdea: options.businessIdea,
template: options.template,
markdown,
slides,
presentationTips,
keyMessages,
};
}
async trackMetrics(options) {
const trends = this.calculateMetricTrends(options.currentMetrics, options.timeframe);
const benchmarks = this.getBenchmarks(options.metricsType, options.currentMetrics);
const recommendations = this.generateMetricRecommendations(options, trends, benchmarks);
const healthScore = this.calculateHealthScore(options.currentMetrics, options.goals, options.metricsType);
const alerts = this.generateMetricAlerts(options.currentMetrics, options.goals, trends);
return {
metricsType: options.metricsType,
current: options.currentMetrics,
goals: options.goals,
timeframe: options.timeframe,
trends,
benchmarks,
recommendations,
healthScore,
alerts,
};
}
async planFundingStrategy(options) {
const recommendedSources = this.recommendFundingSources(options.currentStage, options.fundingGoal);
const timeline = this.createFundingTimeline(options.timeline);
const milestones = this.generateFundingMilestones(options);
return {
id: `funding-${this.generateId()}`,
businessPlanId: options.businessPlanId,
fundingGoal: options.fundingGoal,
recommendedSources,
timeline,
milestones,
useOfFunds: options.useOfFunds || ['product-development', 'marketing', 'operations'],
stage: options.currentStage,
};
}
recommendFundingSources(stage, amount) {
if (stage === 'idea' && amount < 200000) {
return ['angel-investors', 'grants', 'friends-and-family', 'crowdfunding'];
}
if (stage === 'growth' && amount > 1000000) {
return ['venture-capital', 'series-a', 'institutional-investors'];
}
return ['seed-funding', 'angel-investors', 'accelerators'];
}
createFundingTimeline(months) {
return {
preparation: Math.floor(months * 0.2),
outreach: Math.floor(months * 0.3),
negotiation: Math.floor(months * 0.3),
closing: Math.floor(months * 0.2),
};
}
generateFundingMilestones(options) {
return [
{ month: 1, milestone: 'Complete pitch deck and financial projections' },
{ month: 2, milestone: 'Begin investor outreach' },
{ month: Math.floor(options.timeline / 2), milestone: 'First round of meetings' },
{ month: options.timeline - 1, milestone: 'Term sheet negotiations' },
{ month: options.timeline, milestone: 'Close funding round' },
];
}
async provideGuidance(request) {
const relevantKnowledge = this.findRelevantKnowledge(request);
const answer = this.generateAnswer(request, relevantKnowledge);
const recommendations = this.generateContextualRecommendations(request, relevantKnowledge);
const nextSteps = this.generateActionableNextSteps(request, recommendations);
const resources = this.findRelevantResources(request);
const confidence = this.calculateConfidence(relevantKnowledge, request);
const relatedTopics = this.findRelatedTopics(request);
return {
question: request.question,
answer,
recommendations,
nextSteps,
resources,
confidence,
relatedTopics,
};
}
async performComprehensiveReview(options) {
// Gather data from various sources
const dataCollected = await this.gatherReviewData(options);
// Determine current stage based on collected data
const currentStage = this.determineBusinessStage(dataCollected);
// Analyze strengths
const strengths = this.analyzeStrengths(dataCollected);
// Identify gaps
const gaps = this.identifyGaps(dataCollected, currentStage);
// Calculate overall health score
const overallHealthScore = this.calculateOverallHealthScore(dataCollected, strengths, gaps);
// Generate strategic paths
const strategicPaths = options.generateStrategicPaths ?
this.generateStrategicPaths(dataCollected, gaps, currentStage) : [];
// Determine immediate actions
const immediateActions = this.determineImmediateActions(gaps, strategicPaths);
// Set review dates
const reviewDate = new Date().toISOString();
const nextReviewDate = new Date();
nextReviewDate.setMonth(nextReviewDate.getMonth() + 3); // Quarterly reviews
return {
businessName: options.businessName || await this.getProjectName(),
currentStage,
overallHealthScore,
strengths,
gaps,
strategicPaths,
immediateActions,
dataCollected,
reviewDate,
nextReviewDate: nextReviewDate.toISOString(),
};
}
async initializeKnowledgeBase() {
const storageManager = this.configManager.getStorageManager();
const location = await storageManager.getStorageLocation();
this.knowledgePath = path.join(location.data, 'business', 'knowledge.json');
await this.loadKnowledgeBase();
await this.populateDefaultKnowledge();
}
async loadKnowledgeBase() {
try {
const data = await fs.readFile(this.knowledgePath, 'utf-8');
const knowledgeArray = JSON.parse(data);
this.knowledgeBase.clear();
for (const knowledge of knowledgeArray) {
this.knowledgeBase.set(knowledge.topic, knowledge);
}
}
catch (error) {
// File doesn't exist, start with empty knowledge base
this.knowledgeBase.clear();
}
}
async saveKnowledgeBase() {
await fs.mkdir(path.dirname(this.knowledgePath), { recursive: true });
const knowledgeArray = Array.from(this.knowledgeBase.values());
await fs.writeFile(this.knowledgePath, JSON.stringify(knowledgeArray, null, 2));
}
async populateDefaultKnowledge() {
const defaultKnowledge = [
{
topic: 'mvp_development',
category: 'product',
content: 'A Minimum Viable Product (MVP) is the simplest version of your product that allows you to test core assumptions with real users. Focus on essential features that solve the primary problem.',
stage: ['idea', 'mvp'],
industry: ['technology', 'saas', 'mobile'],
confidence: 0.9,
sources: ['Lean Startup', 'Product Management Best Practices'],
lastUpdated: new Date().toISOString(),
},
{
topic: 'funding_stages',
category: 'finance',
content: 'Startup funding typically progresses through stages: Pre-seed (idea validation), Seed (MVP and early traction), Series A (proven product-market fit), Series B+ (scaling and growth).',
stage: ['idea', 'mvp', 'early_stage', 'growth'],
industry: ['all'],
confidence: 0.95,
sources: ['Venture Capital Guidelines', 'Startup Finance'],
lastUpdated: new Date().toISOString(),
},
{
topic: 'customer_validation',
category: 'marketing',
content: 'Customer validation involves systematically testing your assumptions about customer problems and solutions through interviews, surveys, and behavioral data before building features.',
stage: ['idea', 'mvp', 'early_stage'],
industry: ['all'],
confidence: 0.9,
sources: ['Customer Development', 'Lean Startup'],
lastUpdated: new Date().toISOString(),
},
];
for (const knowledge of defaultKnowledge) {
if (!this.knowledgeBase.has(knowledge.topic)) {
this.knowledgeBase.set(knowledge.topic, knowledge);
}
}
await this.saveKnowledgeBase();
}
async generatePlanSections(options, template) {
const sections = [];
// Executive Summary
sections.push({
title: 'Executive Summary',
content: `${options.businessIdea}\n\nTarget Market: ${options.targetMarket}\nBusiness Model: ${options.businessModel}`,
order: 1,
template: options.template,
});
// Problem Statement
sections.push({
title: 'Problem Statement',
content: 'Clearly define the problem your business solves and why it matters to your target customers.',
order: 2,
template: options.template,
});
// Solution
sections.push({
title: 'Solution',
content: 'Describe your solution and how it uniquely addresses the identified problem.',
order: 3,
template: options.template,
});
// Market Analysis
sections.push({
title: 'Market Analysis',
content: `Target Market: ${options.targetMarket}\n\nMarket research and analysis will be conducted to validate market size, growth trends, and customer segments.`,
order: 4,
template: options.template,
});
// Business Model
sections.push({
title: 'Business Model',
content: `Revenue Model: ${options.businessModel}\n\nDetailed explanation of how the business will generate revenue and achieve profitability.`,
order: 5,
template: options.template,
});
return sections;
}
formatBusinessPlanMarkdown(sections, options) {
let markdown = `# ${options.businessIdea} - Business Plan\n\n`;
markdown += `**Generated**: ${new Date().toLocaleDateString()}\n`;
markdown += `**Timeline**: ${options.timeline} months\n`;
markdown += `**Business Model**: ${options.businessModel}\n\n`;
sections.forEach(section => {
markdown += `## ${section.title}\n\n${section.content}\n\n`;
});
return markdown;
}
generateBusinessPlanNextSteps(options) {
const steps = [
'Validate core assumptions with target customers',
'Develop minimum viable product (MVP)',
'Conduct market research and competitive analysis',
'Build founding team with complementary skills',
'Create detailed financial projections',
];
if (options.businessModel === 'saas') {
steps.push('Set up analytics and user tracking');
steps.push('Develop customer onboarding process');
}
return steps;
}
getRelevantMetrics(businessModel) {
const metricMap = {
saas: ['Monthly Recurring Revenue (MRR)', 'Customer Acquisition Cost (CAC)', 'Customer Lifetime Value (CLV)', 'Churn Rate', 'Net Promoter Score (NPS)'],
marketplace: ['Gross Merchandise Value (GMV)', 'Take Rate', 'Active Users', 'Transaction Volume', 'Seller/Buyer Ratio'],
'e-commerce': ['Conversion Rate', 'Average Order Value (AOV)', 'Cart Abandonment Rate', 'Customer Acquisition Cost', 'Return on Ad Spend (ROAS)'],
default: ['Revenue Growth', 'Customer Acquisition Cost', 'Customer Lifetime Value', 'Market Share', 'Profitability'],
};
return metricMap[businessModel] || metricMap.default;
}
async gatherMarketData(options) {
// Simulate market data gathering
return {
size: this.estimateMarketSize(options.industry, options.geographicScope),
growthRate: this.estimateGrowthRate(options.industry),
trends: this.getIndustryTrends(options.industry),
segments: this.identifyMarketSegments(options.targetMarket),
competitors: options.includeCompetitors ? this.getCompetitorSummaries(options.industry) : [],
};
}
estimateMarketSize(industry, scope) {
const sizeMap = {
technology: {
global: '$4.8 trillion',
national: '$480 billion',
local: '$48 million',
},
'software development': {
global: '$5.2 trillion',
national: '$520 billion',
local: '$52 million',
},
healthcare: {
global: '$8.5 trillion',
national: '$850 billion',
local: '$85 million',
},
default: {
global: '$1 trillion',
national: '$100 billion',
local: '$10 million',
},
};
// Map geographic scopes to size categories
const scopeMapping = {
'North America': 'national',
'United States': 'national',
'Global': 'global',
'International': 'global',
'Local': 'local',
'Regional': 'local'
};
const mappedScope = scopeMapping[scope] || 'national';
const industryData = sizeMap[industry.toLowerCase()] || sizeMap[industry] || sizeMap.default;
return industryData[mappedScope] || industryData.national || '$100 billion';
}
estimateGrowthRate(industry) {
const growthMap = {
technology: '8-12% annually',
healthcare: '5-8% annually',
finance: '6-10% annually',
education: '4-7% annually',
default: '5-8% annually',
};
return growthMap[industry] || growthMap.default;
}
getIndustryTrends(industry) {
const trendMap = {
technology: ['AI/ML adoption', 'Cloud migration', 'Remote work tools', 'Cybersecurity focus'],
healthcare: ['Telemedicine growth', 'AI diagnostics', 'Personalized medicine', 'Digital health records'],
finance: ['Digital banking', 'Cryptocurrency adoption', 'RegTech solutions', 'Open banking APIs'],
default: ['Digital transformation', 'Sustainability focus', 'Customer experience improvement'],
};
return trendMap[industry] || trendMap.default;
}
identifyMarketSegments(targetAudience) {
// Simple segmentation based on audience description
return [
{
segment: 'Primary Target',
description: targetAudience,
size: 'To be determined through research',
characteristics: ['Early adopters', 'Tech-savvy', 'Problem-aware'],
painPoints: ['Current solutions are inadequate', 'Time-consuming processes'],
buyingBehavior: 'Research-driven decision making',
},
];
}
getCompetitorSummaries(industry) {
// Placeholder competitor data
return [
{
name: 'Market Leader',
description: `Established player in ${industry}`,
marketPosition: 'Leader',
},
{
name: 'Emerging Competitor',
description: `Growing startup in ${industry} space`,
marketPosition: 'Challenger',
},
];
}
identifyMarketOpportunities(marketData, options) {
return [
{
title: 'Underserved Market Segment',
description: 'Opportunity to serve customers not well-addressed by current solutions',
potential: 'High',
timeline: '6-12 months',
requirements: ['Market research', 'Product development', 'Customer validation'],
},
{
title: 'Technology Innovation',
description: 'Leverage new technology to create competitive advantage',
potential: 'Medium',
timeline: '12-18 months',
requirements: ['Technical expertise', 'R&D investment', 'IP protection'],
},
];
}
identifyMarketChallenges(industry) {
const challengeMap = {
technology: ['Rapid technology changes', 'High competition', 'Talent shortage', 'Regulatory uncertainty'],
healthcare: ['Regulatory compliance', 'Long sales cycles', 'Privacy concerns', 'Integration challenges'],
finance: ['Heavy regulation', 'Security requirements', 'Consumer trust', 'Legacy system integration'],
default: ['Market saturation', 'Customer acquisition costs', 'Economic uncertainty', 'Competitive pressure'],
};
return challengeMap[industry] || challengeMap.default;
}
generateMarketRecommendations(marketData, opportunities) {
return [
'Focus on primary target segment for initial market entry',
'Develop unique value proposition based on identified gaps',
'Build strategic partnerships to accelerate market penetration',
'Implement customer feedback loops for continuous improvement',
'Monitor competitive landscape and adapt strategy accordingly',
];
}
async researchCompetitors(options) {
// Simulate competitor research
const competitors = [];
if (options.competitors.length > 0) {
// Use provided competitors
for (const competitorName of options.competitors) {
competitors.push({
name: competitorName,
description: `${competitorName} operates in the ${options.industry} space`,
strengths: ['Established brand', 'Market presence'],
weaknesses: ['Legacy technology', 'Limited innovation'],
strategy: 'Market leadership through scale',
marketShare: '15%',
pricingModel: 'Subscription-based',
});
}
}
else {
// Generate example competitors
competitors.push({
name: 'Industry Leader Co',
description: `Leading company in ${options.industry}`,
strengths: ['Market dominance', 'Financial resources', 'Brand recognition'],
weaknesses: ['Slow innovation', 'High prices', 'Poor customer service'],
strategy: 'Maintain market position through acquisitions',
}, {
name: 'Innovative Startup',
description: `Emerging player disrupting ${options.industry}`,
strengths: ['Innovative technology', 'Agile development', 'Customer focus'],
weaknesses: ['Limited resources', 'Small market share', 'Unproven scalability'],
strategy: 'Disrupt through technology innovation',
});
}
return competitors;
}
identifyCompetitiveGaps(competitors, businessIdea) {
return [
'Limited mobile-first approach in current solutions',
'Poor user experience in existing products',
'Lack of integration capabilities',
'High pricing barriers for small businesses',
'Insufficient customer support and onboarding',
];
}
identifyCompetitiveOpportunities(gaps, competitors) {
return [
'Develop superior user experience to differentiate',
'Target underserved customer segments',
'Offer competitive pricing with better value',
'Build strong customer success program',
'Focus on integration and ecosystem approach',
];
}
generateCompetitiveRecommendations(competitors, gaps) {
return [
'Position uniquely against identified competitive gaps',
'Monitor competitor moves and respond strategically',
'Build sustainable competitive advantages',
'Focus on customer experience as key differentiator',
'Develop strategic partnerships to compete effectively',
];
}
assessCompetitionLevel(competitors) {
if (competitors.length < 3)
return 'Low';
if (competitors.length < 6)
return 'Moderate';
return 'High';
}
identifyCompetitiveAdvantages(businessIdea, competitors) {
return [
'First-mover advantage in specific market segment',
'Superior technology or proprietary solution',
'Better pricing model with sustainable margins',
'Stronger brand positioning and customer loyalty',
'More efficient operational model',
];
}
getMaturityLevel(score) {
if (score >= 80)
return 'Mature';
if (score >= 60)
return 'Growing';
if (score >= 40)
return 'Developing';
return 'Early';
}
calculateProjections(options) {
const months = options.timeline;
const projections = {
revenue: {},
expenses: {},
netIncome: {},
cashFlow: {},
};
// Simple projection calculation
for (let month = 1; month <= months; month++) {
const growthFactor = Math.pow(1.1, month - 1); // 10% monthly growth
const monthlyRevenue = Object.values(options.revenue).reduce((sum, val) => sum + val, 0) * growthFactor;
const monthlyExpenses = Object.values(options.expenses).reduce((sum, val) => sum + val, 0);
projections.revenue[`Month ${month}`] = Math.round(monthlyRevenue);
projections.expenses[`Month ${month}`] = Math.round(monthlyExpenses);
projections.netIncome[`Month ${month}`] = Math.round(monthlyRevenue - monthlyExpenses);
projections.cashFlow[`Month ${month}`] = month === 1 ?
projections.netIncome[`Month ${month}`] :
projections.cashFlow[`Month ${month - 1}`] + projections.netIncome[`Month ${month}`];
}
return projections;
}
generateScenarios(projections) {
const baseRevenue = Object.values(projections.revenue).reduce((sum, val) => sum + val, 0);
return {
best: Math.round(baseRevenue * 1.5), // 50% better
base: Math.round(baseRevenue),
worst: Math.round(baseRevenue * 0.7), // 30% worse
};
}
calculateBreakEven(projections) {
for (const [month, income] of Object.entries(projections.netIncome)) {
if (income > 0) {
return parseInt(month.split(' ')[1]);
}
}
return -1; // Never breaks even in timeline
}
calculateROI(projections, timeline) {
const totalRevenue = Object.values(projections.revenue).reduce((sum, val) => sum + val, 0);
const totalExpenses = Object.values(projections.expenses).reduce((sum, val) => sum + val, 0);
const investment = totalExpenses; // Simplified
if (investment === 0)
return 0;
return Math.round(((totalRevenue - totalExpenses) / investment) * 100);
}
calculateInvestmentNeeded(projections) {
let maxNegativeCashFlow = 0;
for (const cashFlow of Object.values(projections.cashFlow)) {
if (cashFlow < maxNegativeCashFlow) {
maxNegativeCashFlow = cashFlow;
}
}
return Math.abs(maxNegativeCashFlow);
}
getFinancialAssumptions(businessModel) {
const assumptionMap = {
saas: ['10% monthly growth rate', 'Customer churn rate of 5%', 'Average customer lifetime of 24 months'],
marketplace: ['Take rate of 3-5%', 'Transaction volume growth of 15% monthly', 'Network effects drive growth'],
'e-commerce': ['Conversion rate of 2-3%', 'Average order value increases over time', 'Customer acquisition cost decreases with scale'],
default: ['Linear growth in early stages', 'Operating leverage improves over time', 'Market conditions remain stable'],
};
return assumptionMap[businessModel] || assumptionMap.default;
}
generateFinancialRecommendations(projections) {
return [
'Monitor cash flow closely and maintain adequate reserves',
'Focus on improving unit economics and customer lifetime value',
'Diversify revenue streams to reduce dependency',
'Optimize cost structure for better margins',
'Plan funding needs well in advance of cash requirements',
];
}
assessStartupCategories(options) {
const categories = [
{
name: 'Product Development',
score: options.hasProduct ? 8 : 3,
maxScore: 10,
feedback: options.hasProduct ? 'Good progress on product development' : 'Need to focus on building MVP',
recommendations: options.hasProduct ? ['Iterate based on user feedback'] : ['Define core features and build MVP'],
},
{
name: 'Market Validation',
score: options.hasCustomers ? 7 : 2,
maxScore: 10,
feedback: options.hasCustomers ? 'Market validation in progress' : 'Need customer validation',
recommendations: options.hasCustomers ? ['Scale customer acquisition'] : ['Conduct customer interviews'],
},
{
name: 'Revenue Generation',
score: options.hasRevenue ? 8 : 1,
maxScore: 10,
feedback: options.hasRevenue ? 'Revenue generation established' : 'No revenue yet',
recommendations: options.hasRevenue ? ['Focus on revenue growth'] : ['Develop monetization strategy'],
},
{
name: 'Team Building',
score: Math.min(options.teamSize * 2, 10),
maxScore: 10,
feedback: options.teamSize > 1 ? 'Team building in progress' : 'Solo founder - consider co-founders',
recommendations: options.teamSize > 3 ? ['Optimize team structure'] : ['Recruit key team members'],
},
{
name: 'Funding',
score: options.hasFunding ? 6 : 2,
maxScore: 10,
feedback: options.hasFunding ? 'Funding secured' : 'No external funding yet',
recommendations: options.hasFunding ? ['Use funding efficiently'] : ['Explore funding options'],
},
];
return categories;
}
identifyStartupStrengths(categories) {
return categories
.filter(cat => cat.score >= 7)
.map(cat => `Strong ${cat.name.toLowerCase()}`);
}
identifyStartupWeaknesses(categories) {
return categories
.filter(cat => cat.score < 5)
.map(cat => `Needs improvement in ${cat.name.toLowerCase()}`);
}
generateStartupNextSteps(options, weaknesses) {
const steps = [];
if (!options.hasProduct) {
steps.push({
action: 'Build minimum viable product (MVP)',
priority: 'high',
timeline: '2-3 months',
resources: ['Development team', 'Technical resources'],
});
}
if (!options.hasCustomers) {
steps.push({
action: 'Validate product-market fit with target customers',
priority: 'high',
timeline: '1-2 months',
resources: ['Customer interviews', 'User testing'],
});
}
if (!options.hasRevenue) {
steps.push({
action: 'Develop and test monetization strategy',
priority: 'medium',
timeline: '1-3 months',
resources: ['Pricing research', 'Payment systems'],
});
}
return steps;
}
getStageSpecificRecommendations(stage) {
const recommendationMap = {
idea: ['Validate problem and solution fit', 'Build MVP', 'Talk to potential customers'],
mvp: ['Achieve product-market fit', 'Gather user feedback', 'Iterate on core features'],
early_stage: ['Scale customer acquisition', 'Optimize unit economics', 'Build repeatable processes'],
growth: ['Expand market reach', 'Diversify revenue streams', 'Build competitive moats'],
scale: ['International expansion', 'Strategic partnerships', 'Prepare for exit or IPO'],
};
return recommendationMap[stage] || recommendationMap.idea;
}
generateOverallAssessment(score, stage) {
if (score >= 80)
return `Excellent progress for ${stage} stage startup. Well positioned for growth.`;
if (score >= 60)
return `Good foundation with some areas for improvement at ${stage} stage.`;
if (score >= 40)
return `Moderate progress. Focus on key weaknesses to advance from ${stage} stage.`;
return `Early stage with significant work needed. Focus on fundamentals for ${stage} stage.`;
}
generatePitchSlides(options, template) {
const slides = [
{
title: 'Problem',
content: options.problemStatement,
order: 1,
type: 'text',
speakerNotes: 'Clearly articulate the pain point your audience faces',
},
{
title: 'Solution',
content: options.solution,
order: 2,
type: 'text',
speakerNotes: 'Explain how your solution uniquely addresses the problem',
},
{
title: 'Market Size',
content: `Target Market: ${options.targetMarket}`,
order: 3,
type: 'chart',
speakerNotes: 'Show the size and growth potential of your market',
},
{
title: 'Business Model',
content: options.businessModel,
order: 4,
type: 'text',
speakerNotes: 'Explain how you will make money',
},
{
title: 'Competitive Advantage',
content: options.competitiveAdvantage,
order: 5,
type: 'bullets',
speakerNotes: 'Highlight what makes you different and defensible',
},
];
if (options.fundingAsk) {
slides.push({
title: 'Funding Ask',
content: `Seeking: ${options.fundingAsk}`,
order: 6,
type: 'text',
speakerNotes: 'Clearly state funding amount and use of funds',
});
}
return slides;
}
formatPitchDeckMarkdown(slides, options) {
let markdown = `# ${options.businessIdea} - Pitch Deck\n\n`;
markdown += `**Generated**: ${new Date().toLocaleDateString()}\n\n`;
slides.forEach(slide => {
markdown += `## Slide ${slide.order}: ${slide.title}\n\n${slide.content}\n\n`;
if (slide.speakerNotes) {
markdown += `*Speaker Notes: ${slide.speakerNotes}*\n\n`;
}
});
return markdown;
}
getPresentationTips(template) {
return [
'Keep slides visually simple with minimal text',
'Tell a compelling story that flows logically',
'Practice your delivery and timing',
'Prepare for questions and objections',
'Show passion and expertise for your domain',
'Use data to support your claims',
'End with a clear call to action',
];
}
extractKeyMessages(options) {
return [
`Solving: ${options.problemStatement.substring(0, 50)}...`,
`Solution: ${options.solution.substring(0, 50)}...`,
`Market: ${options.targetMarket}`,
`Advantage: ${options.competitiveAdvantage.substring(0, 50)}...`,
];
}
calculateMetricTrends(metrics, timeframe) {
// Simulate trend calculation
return Object.keys(metrics).map(metric => ({
metric,
direction: Math.random() > 0.5 ? 'up' : 'down',
percentage: Math.round(Math.random() * 20),
period: timeframe,
}));
}
getBenchmarks(metricsType, currentMetrics) {
// Simulate industry benchmarks
return Object.entries(currentMetrics).map(([metric, value]) => ({
metric,
yourValue: value,
industryAverage: Math.round(value * (0.8 + Math.random() * 0.4)),
percentile: Math.round(Math.random() * 100),
}));
}
generateMetricRecommendations(options, trends, benchmarks) {
const recommendations = [
'Focus on improving metrics that are below industry benchmarks',
'Investigate declining trends and implement corrective actions',
'Set up automated tracking and alerting for key metrics',
];
if (options.metricsType === 'saas') {
recommendations.push('Optimize customer onboarding to reduce churn');
recommendations.push('Implement customer success programs');
}
return recommendations;
}
calculateHealthScore(current, goals, metricsType) {
const scores = Object.keys(current).map(metric => {
const currentValue = current[metric];
const goalValue = goals[metric];
if (!goalValue)
return 50; // No goal set
const progress = Math.min((currentValue / goalValue) * 100, 100);
return Math.max(progress, 0);
});
return Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length);
}
generateMetricAlerts(current, goals, trends) {
const alerts = [];
// Check for metrics significantly below goals
for (const [metric, value] of Object.entries(current)) {
const goal = goals[metric];
if (goal && value < goal * 0.7) {
alerts.push({
metric,
status: 'critical',
message: `${metric} is significantly below target`,
recommendation: `Focus on improving ${metric} performance`,
});
}
}
// Check for declining trends
const decliningTrends = trends.filter(trend => trend.direction === 'down' && trend.percentage > 10);
for (const trend of decliningTrends) {
alerts.push({
metric: trend.metric,
status: 'warning',
message: `${trend.metric} declining by ${trend.percentage}%`,
recommendation: `Investigate causes of ${trend.metric} decline`,
});
}
return alerts;
}
findRelevantKnowledge(request) {
const relevant = [];
const queryLower = request.question.toLowerCase();
for (const knowledge of this.knowledgeBase.values()) {
if (knowledge.topic.includes(queryLower) ||
knowledge.content.toLowerCase().includes(queryLower) ||
(request.stage && knowledge.stage.includes(request.stage)) ||
(request.industry && knowledge.industry.includes(request.industry))) {
relevant.push(knowledge);
}
}
return relevant.sort((a, b) => b.confidence - a.confidence).slice(0, 5);
}
generateAnswer(request, knowledge) {
if (knowledge.length === 0) {
return `Based on general business principles, here's guidance for your question about "${request.question}": This is a common challenge in business development. Consider researching best practices, consulting with industry experts, and testing different approaches to find what works for your specific situation.`;
}
const primaryKnowledge = knowledge[0];
let answer = primaryKnowledge.content;
if (request.context) {
answer += `\n\nGiven your context (${request.context}), this is particularly relevant because it aligns with common challenges at your stage.`;
}
return answer;
}
generateContextualRecommendations(request, knowledge) {
const recommendations = [];
if (request.stage === 'idea') {
recommendations.push('Focus on customer discovery and problem validation');
recommendations.push('Build a minimal viable product (MVP)');
}
else if (request.stage === 'mvp') {
recommendations.push('Gather user feedback and iterate quickly');
recommendations.push('Measure product-market fit indicators');
}
if (knowledge.length > 0) {
const categories = [...new Set(knowledge.map(k => k.category))];
categories.forEach(category => {
switch (category) {
case 'finance':
recommendations.push('Develop detailed financial projections');
break;
case 'marketing':
recommendations.push('Create a go-to-market strategy');
break;
case 'product':
recommendations.push('Focus on core feature development');
break;
}
});
}
return recommendations.slice(0, 5);
}
generateActionableNextSteps(request, recommendations) {
return recommendations.map(rec => {
// Convert recommendations to actionable steps
if (rec.includes('financial projections')) {
return 'Create 12-month financial projections this week';
}
if (rec.includes('customer discovery')) {
return 'Interview 10 potential customers within 2 weeks';
}
if (rec.includes('MVP')) {
return 'Define and build MVP within 6-8 weeks';
}
return rec;
}).slice(0, 3);
}
findRelevantResources(request) {
const resources = [
'Lean Startup methodology',
'Customer Development by Steve Blank',
'Business Model Canvas',
'Y Combinator Startup School',
];
if (request.stage === 'idea') {
resources.push('The Mom Test by Rob Fitzpatrick');
}
else if (request.stage === 'growth') {
resources.push('Blitzscaling by Reid Hoffman');
}
return resources.slice(0, 4);
}
calculateConfidence(knowledge, request) {
if (knowledge.length === 0)
return 0.3;
const avgConfidence = knowledge.reduce((sum, k) => sum + k.confidence, 0) / knowledge.length;
// Boost confidence if stage/industry matches
let bonus = 0;
if (request.stage && knowledge.some(k => k.stage.includes(request.stage)))
bonus += 0.1;
if (request.industry && knowledge.some(k => k.industry.includes(request.industry)))
bonus += 0.1;
return Math.min(avgConfidence + bonus, 1.0);
}
findRelatedTopics(request) {
const topics = Array.from(this.knowledgeBase.keys());
const queryWords = request.question.toLowerCase().split(/\s+/);
const related = topics.filter(topic => queryWords.some((word) => topic.includes(word)) ||
topic.includes(request.stage || '') ||
topic.includes(request.industry || ''));
return related.slice(0, 5);
}
async gatherReviewData(options) {
const productStatus = await this.gatherProductData(options.includeProductAnalysis);
const marketPosition = await this.gatherMarketReviewData(options.includeMarketAnalysis);
const financialHealth = await this.gatherFinancialData(options.includeFinancialAnalysis);
const teamResources = await this.gatherTeamData(options.includeTeamAnalysis);
const technicalStatus = await this.gatherTechnicalData(options.includeTechnicalAnalysis);
const customerInsights = await this.gatherCustomerData(options.includeCustomerAnalysis);
return {
productStatus,
marketPosition,
financialHealth,
teamResources,
technicalStatus,
customerInsights,
};
}
async gatherProductData(include) {
if (!include) {
return {
developmentStage: 'unknown',
featuresCompleted: 0,
featuresPlanned: 0,
qualityScore: 0