lean-claudient-core 0.1.0

package/src/intelligence/competitorScoring.ts

@@ -0,0 +1,292 @@
+/**
+ * Competitor Threat Assessment & Scoring
+ * Combines all signals to calculate threat levels
+ */
+
+import {
+  CompetitorThreat,
+  GithubEvent,
+  HiringSignal,
+  UserComplaint,
+  CompetitorIntelligence,
+} from './competitorTypes.js';
+
+export interface ScoringFactors {
+  feature_velocity: number; // 0-100: releases per month
+  hiring_velocity: number; // 0-100: hiring increase rate
+  market_sentiment: number; // 0-100: inverse of complaint negativity
+  funding_signal: number; // 0-100: estimated from hiring & GitHub activity
+  market_traction: number; // 0-100: estimated from GitHub stars, adoption
+}
+
+/**
+ * Calculate threat score (0-100) based on competitive signals
+ */
+export function scoreCompetitor(
+  competitor_id: string,
+  competitor_name: string,
+  github_activity: GithubEvent[],
+  hiring_signals: HiringSignal[],
+  user_feedback: UserComplaint[],
+): CompetitorThreat {
+  const factors = calculateScoringFactors(
+    github_activity,
+    hiring_signals,
+    user_feedback,
+  );
+
+  // Weighted score calculation
+  const threat_score =
+    factors.feature_velocity * 0.25 +
+    factors.hiring_velocity * 0.25 +
+    factors.market_sentiment * 0.2 +
+    factors.funding_signal * 0.15 +
+    factors.market_traction * 0.15;
+
+  const threat_level = getThreatLevel(threat_score);
+
+  // Identify strategic strengths and weaknesses
+  const strengths = identifyStrengths(factors, user_feedback);
+  const weaknesses = identifyWeaknesses(factors, user_feedback);
+  const opportunities = identifyOpportunities(weaknesses, user_feedback);
+  const risks = identifyRisks(factors, hiring_signals);
+
+  return {
+    competitor_id,
+    competitor_name,
+    threat_score: Math.round(threat_score),
+    threat_level,
+    feature_velocity: factors.feature_velocity,
+    hiring_velocity: factors.hiring_velocity,
+    market_sentiment: mapSentimentToLabel(factors.market_sentiment),
+    strengths,
+    weaknesses,
+    opportunities,
+    risks,
+    confidence: Math.min(
+      100,
+      (github_activity.length + hiring_signals.length + user_feedback.length) * 5,
+    ),
+    updated: new Date().toISOString(),
+  };
+}
+
+function calculateScoringFactors(
+  github_activity: GithubEvent[],
+  hiring_signals: HiringSignal[],
+  user_feedback: UserComplaint[],
+): ScoringFactors {
+  // Feature velocity: high-impact commits/releases per month
+  const thirtyDaysAgo = new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+  const recentHighImpact = github_activity.filter(
+    (e) =>
+      new Date(e.date) > thirtyDaysAgo &&
+      (e.impact_level === 'high' || e.type === 'release'),
+  ).length;
+
+  const feature_velocity = Math.min(100, recentHighImpact * 20);
+
+  // Hiring velocity: increase in hiring activity
+  const recent_hiring = hiring_signals.filter(
+    (s) => new Date(s.date) > thirtyDaysAgo,
+  ).length;
+  const hiring_velocity = Math.min(100, recent_hiring * 10);
+
+  // Market sentiment: inverse of negative complaints
+  const negative_complaints = user_feedback.filter(
+    (c) => c.sentiment === 'negative',
+  ).length;
+  const positive_complaints = user_feedback.filter(
+    (c) => c.sentiment === 'positive',
+  ).length;
+
+  let sentiment_score = 50; // neutral baseline
+  if (user_feedback.length > 0) {
+    sentiment_score = Math.round(
+      ((positive_complaints - negative_complaints) / user_feedback.length) *
+        50 +
+        50,
+    );
+  }
+  const market_sentiment = Math.max(0, Math.min(100, sentiment_score));
+
+  // Funding signal: estimated from hiring and GitHub activity
+  const hiring_signal = recent_hiring > 0 ? 40 : 20;
+  const github_signal = github_activity.length > 10 ? 40 : 20;
+  const funding_signal = hiring_signal + github_signal;
+
+  // Market traction: GitHub activity as proxy
+  const market_traction = Math.min(100, github_activity.length * 3);
+
+  return {
+    feature_velocity,
+    hiring_velocity,
+    market_sentiment,
+    funding_signal,
+    market_traction,
+  };
+}
+
+function getThreatLevel(score: number): 'critical' | 'high' | 'medium' | 'low' {
+  if (score >= 75) return 'critical';
+  if (score >= 50) return 'high';
+  if (score >= 25) return 'medium';
+  return 'low';
+}
+
+function mapSentimentToLabel(
+  score: number,
+): 'very_negative' | 'negative' | 'neutral' | 'positive' | 'very_positive' {
+  if (score >= 70) return 'very_positive';
+  if (score >= 55) return 'positive';
+  if (score >= 45) return 'neutral';
+  if (score >= 30) return 'negative';
+  return 'very_negative';
+}
+
+function identifyStrengths(
+  factors: ScoringFactors,
+  user_feedback: UserComplaint[],
+): string[] {
+  const strengths: string[] = [];
+
+  if (factors.feature_velocity > 60) {
+    strengths.push('Rapid feature development velocity');
+  }
+
+  if (factors.hiring_velocity > 50) {
+    strengths.push('Strong hiring momentum indicates investment');
+  }
+
+  const positive_feedback = user_feedback.filter(
+    (c) => c.sentiment === 'positive',
+  );
+  if (positive_feedback.length > 2) {
+    strengths.push('Positive user sentiment on key features');
+  }
+
+  if (factors.market_traction > 60) {
+    strengths.push('Strong community engagement');
+  }
+
+  return strengths.length > 0
+    ? strengths
+    : ['Stable market presence'];
+}
+
+function identifyWeaknesses(
+  factors: ScoringFactors,
+  user_feedback: UserComplaint[],
+): string[] {
+  const weaknesses: string[] = [];
+
+  if (factors.feature_velocity < 30) {
+    weaknesses.push('Slower feature release cycle');
+  }
+
+  if (factors.hiring_velocity < 20) {
+    weaknesses.push('Limited hiring investment');
+  }
+
+  const critical_issues = user_feedback.filter(
+    (c) => c.sentiment === 'negative' && c.frequency >= 8,
+  );
+
+  if (critical_issues.length > 0) {
+    weaknesses.push(
+      `${critical_issues.length} critical user pain points`,
+    );
+  }
+
+  // Cost-related complaints
+  const cost_complaints = user_feedback.filter(
+    (c) => c.category === 'cost' && c.sentiment === 'negative',
+  );
+  if (cost_complaints.length > 0) {
+    weaknesses.push('Pricing concerns from users');
+  }
+
+  return weaknesses.length > 0
+    ? weaknesses
+    : ['Limited data for assessment'];
+}
+
+function identifyOpportunities(
+  weaknesses: string[],
+  user_feedback: UserComplaint[],
+): string[] {
+  const opportunities: string[] = [];
+
+  // Gaps to exploit
+  if (
+    weaknesses.some((w) =>
+      w.includes('slower') || w.includes('Limited'),
+    )
+  ) {
+    opportunities.push('Out-pace with feature releases');
+  }
+
+  // Cost opportunities
+  const cost_complaints = user_feedback.filter(
+    (c) => c.category === 'cost' && c.sentiment === 'negative',
+  );
+  if (cost_complaints.length > 0) {
+    opportunities.push('Undercut on pricing');
+  }
+
+  // Performance opportunities
+  const perf_complaints = user_feedback.filter(
+    (c) => c.category === 'performance' && c.sentiment === 'negative',
+  );
+  if (perf_complaints.length > 0) {
+    opportunities.push('Optimize for performance');
+  }
+
+  return opportunities.length > 0
+    ? opportunities
+    : ['Monitor for strategic pivots'];
+}
+
+function identifyRisks(
+  factors: ScoringFactors,
+  hiring_signals: HiringSignal[],
+): string[] {
+  const risks: string[] = [];
+
+  if (factors.hiring_velocity > 60) {
+    risks.push('Aggressive team expansion may indicate major pivot');
+  }
+
+  if (factors.feature_velocity > 70) {
+    risks.push('Rapid innovation cycle could introduce new competitive advantage');
+  }
+
+  // Check for sales/market expansion hiring
+  const sales_hiring = hiring_signals.filter(
+    (s) => s.role_type === 'sales',
+  ).length;
+  if (sales_hiring > 2) {
+    risks.push('Enterprise market expansion underway');
+  }
+
+  return risks.length > 0 ? risks : ['Monitor quarterly'];
+}
+
+/**
+ * Compare multiple competitors and rank by threat
+ */
+export function rankCompetitorThreats(threats: CompetitorThreat[]): CompetitorThreat[] {
+  return [...threats].sort((a, b) => b.threat_score - a.threat_score);
+}
+
+/**
+ * Generate competitive positioning summary
+ */
+export function generatePositioningSummary(threat: CompetitorThreat): string {
+  const level = threat.threat_level.toUpperCase();
+  const score = threat.threat_score;
+
+  return `${threat.competitor_name}: ${level} threat (${score}/100) - ${threat.strengths[0] || 'Stable market presence'}`;
+}

package/src/intelligence/competitorTracker.ts

@@ -0,0 +1,362 @@
+/**
+ * Competitor Intelligence Orchestrator
+ * Coordinates parallel tracking across GitHub, hiring, and user feedback
+ * Generates weekly intelligence reports
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+import {
+  Competitor,
+  CompetitorIntelligence,
+  IntelligenceReport,
+  TrackingConfig,
+} from './competitorTypes.js';
+import { trackGitHub, analyzeGitHubTrend } from './gitHubTracker.js';
+import { detectHiringSignals, analyzeHiringStrategy, calculateHiringVelocity } from './hiringSignals.js';
+import { aggregateUserComplaints, analyzeComplaintPatterns } from './userComplaints.js';
+import {
+  scoreCompetitor,
+  rankCompetitorThreats,
+  generatePositioningSummary,
+} from './competitorScoring.js';
+
+export class CompetitorTracker {
+  private configPath: string;
+  private config: TrackingConfig = getDefaultTrackingConfig();
+  private competitors: Competitor[] = [];
+
+  constructor(configPath: string = 'src/intelligence/competitors.json') {
+    this.configPath = resolve(configPath);
+    this.loadConfig();
+  }
+
+  private loadConfig(): void {
+    try {
+      const raw = readFileSync(this.configPath, 'utf-8');
+      const data = JSON.parse(raw);
+      this.competitors = data.competitors || [];
+      // Merge tracking config with report_settings
+      const trackingConfig = data.tracking || getDefaultTrackingConfig();
+      const reportSettings = data.report_settings || {};
+      this.config = {
+        ...getDefaultTrackingConfig(),
+        ...trackingConfig,
+        auto_append_findings: reportSettings.auto_append_findings !== undefined
+          ? reportSettings.auto_append_findings
+          : trackingConfig.auto_append_findings !== undefined
+            ? trackingConfig.auto_append_findings
+            : true,
+        include_scoring: reportSettings.include_scoring !== undefined
+          ? reportSettings.include_scoring
+          : trackingConfig.include_scoring !== undefined
+            ? trackingConfig.include_scoring
+            : true,
+        weekly_summary: reportSettings.weekly_summary !== undefined
+          ? reportSettings.weekly_summary
+          : trackingConfig.weekly_summary !== undefined
+            ? trackingConfig.weekly_summary
+            : true,
+        slack_notifications: reportSettings.slack_notifications !== undefined
+          ? reportSettings.slack_notifications
+          : trackingConfig.slack_notifications !== undefined
+            ? trackingConfig.slack_notifications
+            : false,
+      };
+    } catch (error) {
+      console.error(`Failed to load competitors config: ${(error as Error).message}`);
+      this.competitors = [];
+      this.config = getDefaultTrackingConfig();
+    }
+  }
+
+  /**
+   * Track all competitors in parallel
+   */
+  async trackAllCompetitors(): Promise<CompetitorIntelligence[]> {
+    console.log(`[CompetitorTracker] Tracking ${this.competitors.length} competitors...`);
+
+    const promises = this.competitors.map((competitor) =>
+      this.trackCompetitor(competitor),
+    );
+
+    const results = await Promise.allSettled(promises);
+
+    const intelligence: CompetitorIntelligence[] = [];
+    for (let i = 0; i < results.length; i++) {
+      if (results[i].status === 'fulfilled') {
+        intelligence.push((results[i] as PromiseFulfilledResult<CompetitorIntelligence>).value);
+      } else {
+        console.error(
+          `Failed to track ${this.competitors[i].name}: ${(results[i] as PromiseRejectedResult).reason}`,
+        );
+      }
+    }
+
+    return intelligence;
+  }
+
+  /**
+   * Track individual competitor across all sources
+   */
+  private async trackCompetitor(
+    competitor: Competitor,
+  ): Promise<CompetitorIntelligence> {
+    console.log(`  Tracking: ${competitor.name}...`);
+
+    // Parallel data collection
+    const [github_activity, hiring_signals, user_feedback] = await Promise.all([
+      trackGitHub(competitor).catch((e) => {
+        console.error(`GitHub track failed for ${competitor.name}: ${e}`);
+        return [];
+      }),
+      detectHiringSignals(competitor).catch((e) => {
+        console.error(`Hiring detection failed for ${competitor.name}: ${e}`);
+        return [];
+      }),
+      aggregateUserComplaints(competitor).catch((e) => {
+        console.error(`Complaint aggregation failed for ${competitor.name}: ${e}`);
+        return [];
+      }),
+    ]);
+
+    // Assess threat level
+    const threat_assessment = scoreCompetitor(
+      competitor.id,
+      competitor.name,
+      github_activity,
+      hiring_signals,
+      user_feedback,
+    );
+
+    return {
+      competitor_id: competitor.id,
+      competitor_name: competitor.name,
+      github_activity,
+      hiring_signals,
+      user_feedback,
+      threat_assessment,
+      last_updated: new Date().toISOString(),
+      data_points: github_activity.length + hiring_signals.length + user_feedback.length,
+    };
+  }
+
+  /**
+   * Generate weekly intelligence report
+   */
+  generateIntelligenceReport(
+    intelligence_data: CompetitorIntelligence[],
+  ): IntelligenceReport {
+    const now = new Date();
+    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    // Calculate aggregated metrics
+    let total_feature_releases = 0;
+    let total_hiring_signals = 0;
+    let total_complaints = 0;
+
+    for (const intel of intelligence_data) {
+      total_feature_releases += intel.github_activity.filter(
+        (e) => e.type === 'release',
+      ).length;
+      total_hiring_signals += intel.hiring_signals.length;
+      total_complaints += intel.user_feedback.length;
+    }
+
+    // Rank threats
+    const threats = intelligence_data.map((i) => i.threat_assessment);
+    const ranked_threats = rankCompetitorThreats(threats);
+    const highest_threat = ranked_threats[0]?.competitor_name || 'None detected';
+
+    // Key findings
+    const key_findings: string[] = [];
+    for (const intel of intelligence_data) {
+      const summary = generatePositioningSummary(intel.threat_assessment);
+      key_findings.push(summary);
+
+      // Add specific findings
+      if (intel.threat_assessment.threat_level === 'critical') {
+        key_findings.push(
+          `  ⚠️  ${intel.competitor_name}: ${intel.threat_assessment.risks[0]}`,
+        );
+      }
+
+      if (intel.github_activity.length > 5) {
+        const trend = analyzeGitHubTrend(intel.github_activity);
+        if (trend.feature_velocity > 3) {
+          key_findings.push(
+            `  📈 ${intel.competitor_name}: High feature velocity (${trend.feature_velocity} releases)`,
+          );
+        }
+      }
+    }
+
+    const summary = `
+Competitive Intelligence Report
+Period: ${weekAgo.toISOString().split('T')[0]} to ${now.toISOString().split('T')[0]}
+
+High-Threat Competitors: ${ranked_threats.filter((t) => t.threat_level === 'critical' || t.threat_level === 'high').length}
+Top Threat: ${highest_threat}
+
+Aggregate Metrics:
+- Feature Releases Detected: ${total_feature_releases}
+- Hiring Signals: ${total_hiring_signals}
+- User Complaints Aggregated: ${total_complaints}
+    `.trim();
+
+    return {
+      period_start: weekAgo.toISOString().split('T')[0],
+      period_end: now.toISOString().split('T')[0],
+      total_competitors_tracked: intelligence_data.length,
+      highest_threat,
+      key_findings,
+      feature_releases_detected: total_feature_releases,
+      hiring_signals_detected: total_hiring_signals,
+      user_complaints_aggregated: total_complaints,
+      competitor_data: intelligence_data,
+      summary,
+    };
+  }
+
+  /**
+   * Save report to findings markdown file
+   */
+  async saveReport(report: IntelligenceReport, findings_path: string): Promise<void> {
+    const markdown = this.formatReportAsMarkdown(report);
+
+    try {
+      const fullPath = resolve(findings_path);
+      const dir = dirname(fullPath);
+
+      // Ensure directory exists
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      let existing = '';
+
+      if (existsSync(fullPath)) {
+        existing = readFileSync(fullPath, 'utf-8');
+      }
+
+      const updated = existing + '\n' + markdown;
+      writeFileSync(fullPath, updated, 'utf-8');
+
+      console.log(`✓ Report saved to ${fullPath}`);
+    } catch (error) {
+      console.error(`Failed to save report: ${(error as Error).message}`);
+    }
+  }
+
+  get trackingConfig(): TrackingConfig {
+    return this.config;
+  }
+
+  private formatReportAsMarkdown(report: IntelligenceReport): string {
+    const date = new Date().toISOString();
+
+    let md = `## Competitive Intelligence Report - ${report.period_end}\n\n`;
+    md += `**Generated**: ${date}\n\n`;
+    md += `**Period**: ${report.period_start} to ${report.period_end}\n\n`;
+
+    md += `### Summary\n\n${report.summary}\n\n`;
+
+    md += `### Key Findings\n\n`;
+    for (const finding of report.key_findings) {
+      md += `- ${finding}\n`;
+    }
+    md += '\n';
+
+    md += `### Threat Assessment\n\n`;
+    md += `| Competitor | Threat Level | Score | Strengths |\n`;
+    md += `|---|---|---|---|\n`;
+
+    for (const intel of report.competitor_data) {
+      const threat = intel.threat_assessment;
+      const strengths = threat.strengths.slice(0, 2).join(', ');
+      md += `| ${threat.competitor_name} | **${threat.threat_level.toUpperCase()}** | ${threat.threat_score}/100 | ${strengths} |\n`;
+    }
+    md += '\n';
+
+    md += `### Feature Releases\n\n`;
+    for (const intel of report.competitor_data) {
+      if (intel.github_activity.length > 0) {
+        const releases = intel.github_activity
+          .filter((e) => e.type === 'release')
+          .slice(0, 3);
+        if (releases.length > 0) {
+          md += `**${intel.competitor_name}**:\n`;
+          for (const release of releases) {
+            md += `- ${release.date}: ${release.feature}\n`;
+          }
+          md += '\n';
+        }
+      }
+    }
+
+    md += `### Hiring Signals\n\n`;
+    for (const intel of report.competitor_data) {
+      if (intel.hiring_signals.length > 0) {
+        md += `**${intel.competitor_name}**: ${intel.hiring_signals.length} open positions\n`;
+        const strategy = analyzeHiringStrategy(intel.hiring_signals);
+        md += `- Strategic Focus: ${strategy.strategic_focus}\n`;
+        md += `- Locations: ${strategy.geographic_expansion.join(', ')}\n`;
+        md += '\n';
+      }
+    }
+
+    md += `### User Sentiment\n\n`;
+    for (const intel of report.competitor_data) {
+      if (intel.user_feedback.length > 0) {
+        const analysis = analyzeComplaintPatterns(intel.user_feedback);
+        md += `**${intel.competitor_name}**:\n`;
+        if (analysis.critical_issues.length > 0) {
+          md += `- Critical Issues: ${analysis.critical_issues[0]}\n`;
+        }
+        md += `- Sentiment Distribution: ${JSON.stringify(analysis.sentiment_distribution)}\n`;
+        md += '\n';
+      }
+    }
+
+    md += `---\n\n`;
+
+    return md;
+  }
+}
+
+function getDefaultTrackingConfig(): TrackingConfig {
+  return {
+    enabled: true,
+    interval_hours: 24,
+    data_retention_days: 90,
+    sources: ['github', 'hiring', 'social'],
+    auto_append_findings: true,
+    include_scoring: true,
+    weekly_summary: true,
+    slack_notifications: false,
+  };
+}
+
+/**
+ * Main entry point for tracking competitors
+ */
+export async function trackCompetitors(
+  configPath: string = 'src/intelligence/competitors.json',
+  findingsPath: string = 'findings/competitor_intelligence.md',
+): Promise<IntelligenceReport> {
+  const tracker = new CompetitorTracker(configPath);
+
+  const intelligence = await tracker.trackAllCompetitors();
+  const report = tracker.generateIntelligenceReport(intelligence);
+
+  const config = tracker.trackingConfig;
+  const shouldSave = config && config.auto_append_findings;
+
+  if (shouldSave) {
+    await tracker.saveReport(report, findingsPath);
+  } else {
+    console.log(`[CompetitorTracker] Report generation skipped auto-append (config: ${JSON.stringify(config)})`);
+  }
+
+  return report;
+}