strategic-intelligence-mcp
Version:
Strategic Intelligence MCP Server - connecting technical progress to business outcomes with systematic strategic planning
362 lines • 16.3 kB
JavaScript
// Technical milestone tracking and business impact correlation
import { v4 as uuidv4 } from 'uuid';
export class TechnicalMilestoneTracker {
milestones = new Map();
progressHistory = new Map();
storage;
constructor(storage) {
this.storage = storage;
}
async loadMilestones() {
if (this.storage) {
try {
const data = await this.storage.load();
if (data.milestones) {
this.milestones = new Map(Object.entries(data.milestones));
}
if (data.milestoneProgress) {
this.progressHistory = new Map(Object.entries(data.milestoneProgress));
}
}
catch (error) {
// Storage might not exist yet, that's ok
}
}
}
async saveMilestones() {
if (this.storage) {
const data = await this.storage.load();
data.milestones = Object.fromEntries(this.milestones);
data.milestoneProgress = Object.fromEntries(this.progressHistory);
await this.storage.save(data);
}
}
// Project-specific milestone detection patterns
static PROJECT_PATTERNS = {
architecture: [
{ pattern: /microservices?.*(?:migration|architecture|implementation)/i, importance: 90 },
{ pattern: /repository.*pattern.*implementation/i, importance: 75 },
{ pattern: /service.*(?:decoupling|factory|container)/i, importance: 80 },
{ pattern: /event.*(?:driven|bus|system)/i, importance: 85 }
],
privacy: [
{ pattern: /privacy.*(?:by.*design|first|enhancement)/i, importance: 95 },
{ pattern: /gdpr|ferpa|coppa.*compliance/i, importance: 90 },
{ pattern: /encryption.*(?:aes|implementation)/i, importance: 70 },
{ pattern: /audit.*(?:trail|logging)/i, importance: 65 }
],
ai: [
{ pattern: /bounded.*enhancement/i, importance: 100 },
{ pattern: /ai.*(?:boundary|detection|assistance)/i, importance: 85 },
{ pattern: /reflection.*(?:analysis|quality)/i, importance: 80 },
{ pattern: /cognitive.*load.*detection/i, importance: 75 }
],
innovation: [
{ pattern: /(?:ai|analytics|insights)/i, importance: 90 },
{ pattern: /trust.*through.*transparency/i, importance: 95 },
{ pattern: /process.*(?:visibility|analysis)/i, importance: 85 },
{ pattern: /integrity/i, importance: 80 }
]
};
async createMilestone(data) {
const milestoneId = uuidv4();
const now = new Date().toISOString();
// Auto-detect business context based on project patterns
const autoDetectedContext = this.detectBusinessContext(data.name, data.description);
const milestone = {
id: milestoneId,
name: data.name,
description: data.description,
category: data.category,
status: 'planned',
plannedDate: data.plannedDate,
effort: data.effort,
complexity: data.complexity,
dependencies: [],
technicalDetails: data.technicalDetails,
businessContext: {
...autoDetectedContext,
...data.businessContext
},
linkedGoals: [],
linkedConversations: [],
createdAt: now,
updatedAt: now
};
this.milestones.set(milestoneId, milestone);
this.progressHistory.set(milestoneId, []);
await this.saveMilestones();
return milestone;
}
detectBusinessContext(name, description) {
const text = `${name} ${description}`.toLowerCase();
let strategicImportance = 50;
let customerImpact = 'Technical improvement';
let revenueImplication = 0;
let competitiveAdvantage = 'Enhanced technical capability';
let marketTiming = 'competitive';
// Check against project-specific patterns
Object.entries(TechnicalMilestoneTracker.PROJECT_PATTERNS).forEach(([category, patterns]) => {
patterns.forEach(({ pattern, importance }) => {
if (pattern.test(text)) {
strategicImportance = Math.max(strategicImportance, importance);
// Set category-specific business context
switch (category) {
case 'architecture':
customerImpact = 'Improved platform scalability and reliability';
revenueImplication = 25000;
competitiveAdvantage = 'Enterprise-scale architecture enables institutional customers';
marketTiming = 'competitive';
break;
case 'privacy':
customerImpact = 'Enhanced data protection and institutional trust';
revenueImplication = 50000;
competitiveAdvantage = 'Only platform with native privacy protection vs retrofitted compliance';
marketTiming = 'early';
break;
case 'ai':
customerImpact = 'Revolutionary AI that builds independence vs dependency';
revenueImplication = 75000;
competitiveAdvantage = 'Unique bounded enhancement philosophy solves AI dependency crisis';
marketTiming = 'early';
break;
case 'innovation':
customerImpact = 'Transforms user experience through transparency';
revenueImplication = 40000;
competitiveAdvantage = 'Trust-based versus surveillance-based technology';
marketTiming = 'competitive';
break;
}
}
});
});
return {
strategicImportance,
customerImpact,
revenueImplication,
competitiveAdvantage,
marketTiming
};
}
async updateMilestoneProgress(milestoneId, progress) {
const milestone = this.milestones.get(milestoneId);
if (!milestone) {
throw new Error(`Milestone ${milestoneId} not found`);
}
const progressUpdate = {
milestoneId,
timestamp: new Date().toISOString(),
...progress
};
// Update milestone status based on completion
if (progress.completionPercentage >= 100) {
milestone.status = 'completed';
milestone.completionDate = progressUpdate.timestamp;
}
else if (progress.completionPercentage > 0 && milestone.status === 'planned') {
milestone.status = 'in-progress';
}
milestone.updatedAt = progressUpdate.timestamp;
// Add to progress history
const history = this.progressHistory.get(milestoneId) || [];
history.push(progressUpdate);
this.progressHistory.set(milestoneId, history);
await this.saveMilestones();
return progressUpdate;
}
generateBusinessImpactProjection(milestoneId) {
const milestone = this.milestones.get(milestoneId);
if (!milestone) {
throw new Error(`Milestone ${milestoneId} not found`);
}
const baseRevenue = milestone.businessContext.revenueImplication;
const importance = milestone.businessContext.strategicImportance / 100;
return {
milestoneId,
projectedRevenue: {
immediate: Math.round(baseRevenue * 0.1 * importance),
shortTerm: Math.round(baseRevenue * 0.6 * importance),
longTerm: Math.round(baseRevenue * importance)
},
customerBenefits: this.generateCustomerBenefits(milestone),
competitiveAdvantages: this.generateCompetitiveAdvantages(milestone),
operationalImpacts: this.generateOperationalImpacts(milestone),
riskMitigations: milestone.technicalDetails.risksMitigated || [],
marketOpportunities: this.generateMarketOpportunities(milestone)
};
}
generateCustomerBenefits(milestone) {
const benefits = [milestone.businessContext.customerImpact];
if (milestone.technicalDetails.performanceImpact) {
benefits.push(`${milestone.technicalDetails.performanceImpact.improvement} in ${milestone.technicalDetails.performanceImpact.metric}`);
}
switch (milestone.category) {
case 'architecture':
benefits.push('More reliable and scalable platform');
benefits.push('Faster feature development and deployment');
break;
case 'security':
benefits.push('Enhanced data protection and privacy');
benefits.push('Increased institutional trust and compliance');
break;
case 'performance':
benefits.push('Faster response times and better user experience');
benefits.push('Ability to serve more concurrent users');
break;
case 'feature':
benefits.push('Enhanced functionality and user capabilities');
benefits.push('Improved educational outcomes and engagement');
break;
}
return benefits;
}
generateCompetitiveAdvantages(milestone) {
const advantages = [milestone.businessContext.competitiveAdvantage];
if (milestone.businessContext.marketTiming === 'early') {
advantages.push('First-mover advantage in educational AI market');
}
switch (milestone.category) {
case 'architecture':
advantages.push('Scalable foundation that competitors cannot quickly replicate');
break;
case 'security':
advantages.push('Privacy-by-design vs competitors retrofitting compliance');
break;
case 'feature':
advantages.push('Unique functionality that differentiates from generic solutions');
break;
}
return advantages;
}
generateOperationalImpacts(milestone) {
const impacts = [];
switch (milestone.category) {
case 'architecture':
impacts.push('Improved development team productivity');
impacts.push('Reduced technical debt and maintenance overhead');
impacts.push('Easier scaling and feature additions');
break;
case 'infrastructure':
impacts.push('Lower operational costs and improved reliability');
impacts.push('Automated deployment and monitoring capabilities');
break;
case 'performance':
impacts.push('Reduced server costs through efficiency gains');
impacts.push('Improved user satisfaction and retention');
break;
}
return impacts;
}
generateMarketOpportunities(milestone) {
const opportunities = [];
if (milestone.businessContext.strategicImportance >= 80) {
opportunities.push('Opens enterprise market segment');
}
switch (milestone.category) {
case 'security':
opportunities.push('Privacy-conscious educational institutions');
opportunities.push('International markets with strict data protection laws');
break;
case 'architecture':
opportunities.push('Large-scale institutional deployments');
opportunities.push('Platform partnerships and integrations');
break;
case 'feature':
opportunities.push('New customer segments interested in specific capabilities');
opportunities.push('Premium pricing for advanced functionality');
break;
}
return opportunities;
}
getMilestone(milestoneId) {
return this.milestones.get(milestoneId);
}
getAllMilestones() {
return Array.from(this.milestones.values());
}
getMilestonesByStatus(status) {
return Array.from(this.milestones.values()).filter(m => m.status === status);
}
getMilestoneProgress(milestoneId) {
return this.progressHistory.get(milestoneId) || [];
}
getBusinessImpactSummary() {
const milestones = this.getAllMilestones();
const completed = milestones.filter(m => m.status === 'completed');
const totalProjectedRevenue = milestones.reduce((sum, m) => sum + m.businessContext.revenueImplication, 0);
const averageStrategicImportance = milestones.length > 0
? milestones.reduce((sum, m) => sum + m.businessContext.strategicImportance, 0) / milestones.length
: 0;
// Get top opportunities from high-importance milestones
const topOpportunities = milestones
.filter(m => m.businessContext.strategicImportance >= 80)
.map(m => m.businessContext.competitiveAdvantage)
.slice(0, 5);
return {
totalProjectedRevenue,
milestoneCount: milestones.length,
completionRate: milestones.length > 0 ? (completed.length / milestones.length) * 100 : 0,
averageStrategicImportance,
topOpportunities
};
}
generateAlignmentMapping(milestoneId) {
const milestone = this.milestones.get(milestoneId);
if (!milestone) {
throw new Error(`Milestone ${milestoneId} not found`);
}
const progress = this.getMilestoneProgress(milestoneId);
const latestProgress = progress[progress.length - 1];
return {
id: `alignment-${milestoneId}`,
technicalFeature: milestone.name,
codebaseEvidence: milestone.technicalDetails.codebaseChanges,
businessValue: {
primaryGoals: milestone.linkedGoals,
impact: this.mapImportanceToImpact(milestone.businessContext.strategicImportance),
revenueImplication: milestone.businessContext.revenueImplication,
userImpact: milestone.businessContext.customerImpact,
competitiveAdvantage: milestone.businessContext.competitiveAdvantage
},
progressMetrics: {
technicalCompletion: latestProgress?.completionPercentage || 0,
businessReadiness: this.calculateBusinessReadiness(milestone),
marketValidation: this.calculateMarketValidation(milestone)
},
insights: [`Technical milestone: ${milestone.description}`],
lastUpdated: milestone.updatedAt
};
}
mapImportanceToImpact(importance) {
if (importance >= 90)
return 'critical';
if (importance >= 75)
return 'high';
if (importance >= 50)
return 'medium';
return 'low';
}
calculateBusinessReadiness(milestone) {
let readiness = 30; // Base readiness
if (milestone.linkedGoals.length > 0)
readiness += 20;
if (milestone.businessContext.revenueImplication > 0)
readiness += 20;
if (milestone.businessContext.marketTiming === 'early')
readiness += 15;
if (milestone.businessContext.strategicImportance >= 80)
readiness += 15;
return Math.min(100, readiness);
}
calculateMarketValidation(milestone) {
let validation = 20; // Base validation
if (milestone.businessContext.marketTiming === 'early')
validation += 30;
if (milestone.businessContext.strategicImportance >= 90)
validation += 25;
if (milestone.status === 'completed')
validation += 25;
return Math.min(100, validation);
}
}
//# sourceMappingURL=technicalMilestoneTracker.js.map