lean-claudient-core 0.1.0

package/src/intelligence/competitorTypes.ts

@@ -0,0 +1,100 @@
+/**
+ * Competitive Intelligence Data Types
+ * Lean Claudient Phase 7B: Autonomous Market Analysis
+ */
+
+export interface Competitor {
+  id: string;
+  name: string;
+  website?: string;
+  github_repo?: string;
+  github_org?: string;
+  linkedin_page?: string;
+  twitter_handle?: string;
+  description?: string;
+}
+
+export interface GithubEvent {
+  date: string;
+  type: 'commit' | 'release' | 'pr' | 'issue';
+  feature: string;
+  impact_level: 'low' | 'medium' | 'high';
+  details: string;
+  url?: string;
+  commit_count?: number;
+}
+
+export interface HiringSignal {
+  date: string;
+  competitor_id: string;
+  role: string;
+  role_type: 'engineering' | 'sales' | 'operations' | 'product' | 'leadership';
+  count: number;
+  location: string[];
+  trend: 'increasing' | 'stable' | 'decreasing';
+  source: 'linkedin' | 'indeed' | 'glassdoor' | 'other';
+  details: string;
+}
+
+export interface UserComplaint {
+  date: string;
+  competitor_id: string;
+  complaint: string;
+  frequency: number;
+  sentiment: 'negative' | 'neutral' | 'positive';
+  category: 'performance' | 'cost' | 'ux' | 'features' | 'support' | 'privacy' | 'other';
+  source: 'reddit' | 'twitter' | 'review_site' | 'github' | 'other';
+  keywords: string[];
+  url?: string;
+}
+
+export interface CompetitorThreat {
+  competitor_id: string;
+  competitor_name: string;
+  threat_score: number; // 0-100
+  threat_level: 'critical' | 'high' | 'medium' | 'low';
+  feature_velocity: number; // releases per month
+  hiring_velocity: number; // hiring increase rate per month
+  market_sentiment: 'very_negative' | 'negative' | 'neutral' | 'positive' | 'very_positive';
+  strengths: string[];
+  weaknesses: string[];
+  opportunities: string[];
+  risks: string[];
+  confidence: number; // 0-100
+  updated: string;
+}
+
+export interface CompetitorIntelligence {
+  competitor_id: string;
+  competitor_name: string;
+  github_activity: GithubEvent[];
+  hiring_signals: HiringSignal[];
+  user_feedback: UserComplaint[];
+  threat_assessment: CompetitorThreat;
+  last_updated: string;
+  data_points: number; // Total data points collected
+}
+
+export interface IntelligenceReport {
+  period_start: string;
+  period_end: string;
+  total_competitors_tracked: number;
+  highest_threat: string;
+  key_findings: string[];
+  feature_releases_detected: number;
+  hiring_signals_detected: number;
+  user_complaints_aggregated: number;
+  competitor_data: CompetitorIntelligence[];
+  summary: string;
+}
+
+export interface TrackingConfig {
+  enabled: boolean;
+  interval_hours: number;
+  data_retention_days: number;
+  sources: string[];
+  auto_append_findings: boolean;
+  include_scoring: boolean;
+  weekly_summary: boolean;
+  slack_notifications: boolean;
+}

package/src/intelligence/competitors.json

@@ -0,0 +1,76 @@
+{
+  "competitors": [
+    {
+      "id": "cursor",
+      "name": "Cursor",
+      "website": "https://cursor.sh",
+      "github_repo": "anysphere/cursor",
+      "github_org": "anysphere",
+      "linkedin_page": "cursor-ai",
+      "twitter_handle": "@cursoriscode",
+      "description": "AI code editor with Claude integration"
+    },
+    {
+      "id": "codeium",
+      "name": "Codeium",
+      "website": "https://codeium.com",
+      "github_repo": "Exafunction/codeium",
+      "github_org": "Exafunction",
+      "linkedin_page": "codeium",
+      "twitter_handle": "@codeiumdev",
+      "description": "Free code completion with multi-language support"
+    },
+    {
+      "id": "github_copilot",
+      "name": "GitHub Copilot",
+      "website": "https://github.com/features/copilot",
+      "github_org": "github",
+      "linkedin_page": "github",
+      "twitter_handle": "@github",
+      "description": "OpenAI-powered code completion integrated with GitHub"
+    },
+    {
+      "id": "tabnine",
+      "name": "Tabnine",
+      "website": "https://www.tabnine.com",
+      "github_repo": "codota/TabNine",
+      "github_org": "codota",
+      "linkedin_page": "tabnine",
+      "twitter_handle": "@tabnine",
+      "description": "AI code completion with privacy-first approach"
+    },
+    {
+      "id": "aws_codewhisperer",
+      "name": "AWS CodeWhisperer",
+      "website": "https://aws.amazon.com/codewhisperer",
+      "linkedin_page": "aws",
+      "twitter_handle": "@awscloud",
+      "description": "AWS-native code generation for enterprise"
+    },
+    {
+      "id": "jetbrains_ai",
+      "name": "JetBrains AI Assistant",
+      "website": "https://www.jetbrains.com/help/idea/ai-assistant.html",
+      "linkedin_page": "jetbrains",
+      "twitter_handle": "@jetbrains",
+      "description": "Built-in AI for JetBrains IDEs"
+    }
+  ],
+  "tracking": {
+    "enabled": true,
+    "interval_hours": 24,
+    "data_retention_days": 90,
+    "sources": [
+      "github",
+      "hiring",
+      "social",
+      "funding"
+    ]
+  },
+  "report_settings": {
+    "auto_append_findings": true,
+    "include_scoring": true,
+    "weekly_summary": true,
+    "slack_notifications": false
+  }
+}

package/src/intelligence/feedbackLoop.ts

@@ -0,0 +1,538 @@
+/**
+ * Lead Feedback Loop
+ * Tracks conversion outcomes and reweights scoring model based on accuracy
+ * Phase 8C Task 10
+ */
+
+import { z } from 'zod';
+
+/**
+ * Feedback record for a converted lead
+ */
+export interface LeadFeedback {
+  id: string;
+  leadId: string;
+  projectedRevenue: number;
+  actualRevenue: number;
+  errorPercent: number;
+  closedDate: string;
+  stage: 'cold' | 'warm' | 'hot' | 'sales-ready' | 'won' | 'lost';
+  createdAt: string;
+  metadata?: {
+    signalCount?: number;
+    threatLevel?: string;
+    source?: string;
+    conversionRateFactored?: number;
+    acvFactored?: number;
+  };
+}
+
+/**
+ * Accuracy analysis result
+ */
+export interface AccuracyAnalysis {
+  mape: number; // Mean Absolute Percentage Error
+  mae: number; // Mean Absolute Error
+  rmse: number; // Root Mean Squared Error
+  totalSamples: number;
+  overestimateCount: number;
+  underestimateCount: number;
+  avgOverestimate: number;
+  avgUnderestimate: number;
+  errorDistribution: {
+    veryAccurate: number; // 0-5% error
+    accurate: number; // 5-15% error
+    acceptable: number; // 15-30% error
+    poor: number; // >30% error
+  };
+}
+
+/**
+ * Factor accuracy analysis
+ */
+export interface FactorAccuracy {
+  factor: string;
+  contribution: number; // 0-100%
+  accuracy: number; // 0-100%
+  trend: 'improving' | 'stable' | 'degrading';
+  samples: number;
+  recommendation?: string;
+}
+
+/**
+ * Model weight update recommendation
+ */
+export interface WeightUpdate {
+  factor: string;
+  currentWeight: number;
+  recommendedWeight: number;
+  change: number; // percentage point
+  rationale: string;
+  confidence: number; // 0-100%
+}
+
+/**
+ * Validation schemas
+ */
+const LeadFeedbackSchema = z.object({
+  id: z.string().min(1),
+  leadId: z.string().min(1),
+  projectedRevenue: z.number().nonnegative(),
+  actualRevenue: z.number().nonnegative(),
+  errorPercent: z.number().min(-100).max(500),
+  closedDate: z.string().datetime(),
+  stage: z.enum(['cold', 'warm', 'hot', 'sales-ready', 'won', 'lost']),
+  createdAt: z.string().datetime(),
+  metadata: z
+    .object({
+      signalCount: z.number().nonnegative().optional(),
+      threatLevel: z.string().optional(),
+      source: z.string().optional(),
+      conversionRateFactored: z.number().min(0).max(1).optional(),
+      acvFactored: z.number().nonnegative().optional(),
+    })
+    .optional(),
+});
+
+/**
+ * FeedbackLoop class
+ * Manages conversion feedback and model reweighting
+ */
+export class FeedbackLoop {
+  private feedbackHistory: LeadFeedback[] = [];
+  private scoringWeights: Map<string, number> = new Map();
+  private lastMonthlyUpdate: Date;
+
+  constructor(initialWeights?: Record<string, number>, lastUpdateDate?: Date) {
+    this.lastMonthlyUpdate = lastUpdateDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // Default: 30 days ago
+    // Initialize with default weights
+    this.scoringWeights.set('signalCount', 0.3);
+    this.scoringWeights.set('threatMultiplier', 0.2);
+    this.scoringWeights.set('conversionRate', 0.25);
+    this.scoringWeights.set('acvEstimation', 0.15);
+    this.scoringWeights.set('sourceQuality', 0.1);
+
+    // Override with initial weights if provided
+    if (initialWeights) {
+      Object.entries(initialWeights).forEach(([key, value]) => {
+        this.scoringWeights.set(key, value);
+      });
+    }
+  }
+
+  /**
+   * Log a conversion event
+   */
+  logConversion(
+    leadId: string,
+    projectedRevenue: number,
+    actualRevenue: number,
+    closedDate: string,
+    stage: 'cold' | 'warm' | 'hot' | 'sales-ready' | 'won' | 'lost' = 'won',
+    metadata?: LeadFeedback['metadata']
+  ): LeadFeedback {
+    const errorPercent =
+      projectedRevenue > 0
+        ? ((projectedRevenue - actualRevenue) / projectedRevenue) * 100
+        : 0;
+
+    const feedback: LeadFeedback = {
+      id: `feedback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      leadId,
+      projectedRevenue,
+      actualRevenue,
+      errorPercent,
+      closedDate,
+      stage,
+      createdAt: new Date().toISOString(),
+      metadata,
+    };
+
+    // Validate feedback
+    LeadFeedbackSchema.parse(feedback);
+
+    this.feedbackHistory.push(feedback);
+    return feedback;
+  }
+
+  /**
+   * Calculate MAPE (Mean Absolute Percentage Error)
+   */
+  calculateAccuracy(
+    samples?: LeadFeedback[]
+  ): AccuracyAnalysis {
+    const data = samples || this.feedbackHistory;
+
+    if (data.length === 0) {
+      return {
+        mape: 0,
+        mae: 0,
+        rmse: 0,
+        totalSamples: 0,
+        overestimateCount: 0,
+        underestimateCount: 0,
+        avgOverestimate: 0,
+        avgUnderestimate: 0,
+        errorDistribution: {
+          veryAccurate: 0,
+          accurate: 0,
+          acceptable: 0,
+          poor: 0,
+        },
+      };
+    }
+
+    // Calculate error metrics
+    let sumAbsPercentError = 0;
+    let sumAbsError = 0;
+    let sumSquaredError = 0;
+    let overestimateCount = 0;
+    let underestimateCount = 0;
+    let sumOverestimate = 0;
+    let sumUnderestimate = 0;
+
+    const errorDistribution = {
+      veryAccurate: 0,
+      accurate: 0,
+      acceptable: 0,
+      poor: 0,
+    };
+
+    data.forEach((feedback) => {
+      const error = feedback.projectedRevenue - feedback.actualRevenue;
+      const absError = Math.abs(error);
+      const percentError = feedback.actualRevenue
+        ? Math.abs(error / feedback.actualRevenue) * 100
+        : 0;
+
+      sumAbsPercentError += percentError;
+      sumAbsError += absError;
+      sumSquaredError += error * error;
+
+      if (feedback.projectedRevenue > feedback.actualRevenue) {
+        overestimateCount++;
+        sumOverestimate += absError;
+      } else {
+        underestimateCount++;
+        sumUnderestimate += absError;
+      }
+
+      // Categorize error
+      if (percentError <= 5) errorDistribution.veryAccurate++;
+      else if (percentError <= 15) errorDistribution.accurate++;
+      else if (percentError <= 30) errorDistribution.acceptable++;
+      else errorDistribution.poor++;
+    });
+
+    const mape = sumAbsPercentError / data.length;
+    const mae = sumAbsError / data.length;
+    const rmse = Math.sqrt(sumSquaredError / data.length);
+
+    return {
+      mape,
+      mae,
+      rmse,
+      totalSamples: data.length,
+      overestimateCount,
+      underestimateCount,
+      avgOverestimate:
+        overestimateCount > 0 ? sumOverestimate / overestimateCount : 0,
+      avgUnderestimate:
+        underestimateCount > 0 ? sumUnderestimate / underestimateCount : 0,
+      errorDistribution: {
+        veryAccurate: Math.round(
+          (errorDistribution.veryAccurate / data.length) * 100
+        ),
+        accurate: Math.round(
+          (errorDistribution.accurate / data.length) * 100
+        ),
+        acceptable: Math.round(
+          (errorDistribution.acceptable / data.length) * 100
+        ),
+        poor: Math.round((errorDistribution.poor / data.length) * 100),
+      },
+    };
+  }
+
+  /**
+   * Analyze which factors were accurate vs inaccurate
+   */
+  analyzeFactorAccuracy(
+    samples?: LeadFeedback[]
+  ): FactorAccuracy[] {
+    const data = samples || this.feedbackHistory;
+
+    if (data.length === 0) {
+      return [];
+    }
+
+    // Group feedback by metadata characteristics
+    const bySignalCount = this.groupByKey(data, (f) =>
+      f.metadata?.signalCount ? 'signal-based' : 'no-signal'
+    );
+    const byThreatLevel = this.groupByKey(
+      data,
+      (f) => f.metadata?.threatLevel || 'unknown'
+    );
+    const bySource = this.groupByKey(data, (f) => f.metadata?.source || 'unknown');
+
+    const factors: FactorAccuracy[] = [];
+
+    // Analyze signal count factor
+    const signalAccuracy = this.calculateGroupAccuracy(bySignalCount);
+    factors.push({
+      factor: 'signalCount',
+      contribution: 30,
+      accuracy: signalAccuracy.avgAccuracy,
+      trend: this.determineTrend(signalAccuracy, bySignalCount),
+      samples: signalAccuracy.totalSamples,
+      recommendation:
+        signalAccuracy.avgAccuracy < 70
+          ? 'Recalibrate signal weighting in scoring'
+          : undefined,
+    });
+
+    // Analyze threat multiplier factor
+    const threatAccuracy = this.calculateGroupAccuracy(byThreatLevel);
+    factors.push({
+      factor: 'threatMultiplier',
+      contribution: 20,
+      accuracy: threatAccuracy.avgAccuracy,
+      trend: this.determineTrend(threatAccuracy, byThreatLevel),
+      samples: threatAccuracy.totalSamples,
+      recommendation:
+        threatAccuracy.avgAccuracy < 70
+          ? 'Adjust threat level multipliers'
+          : undefined,
+    });
+
+    // Analyze conversion rate factor
+    const conversionAccuracy = this.calculateGroupAccuracy(bySource);
+    factors.push({
+      factor: 'conversionRate',
+      contribution: 25,
+      accuracy: conversionAccuracy.avgAccuracy,
+      trend: this.determineTrend(conversionAccuracy, bySource),
+      samples: conversionAccuracy.totalSamples,
+      recommendation:
+        conversionAccuracy.avgAccuracy < 70
+          ? 'Retrain conversion rate model by source'
+          : undefined,
+    });
+
+    // ACV estimation
+    const acvAccuracy = data
+      .filter((f) => f.metadata?.acvFactored)
+      .reduce((acc, f) => {
+        const error = Math.abs(
+          f.projectedRevenue - f.actualRevenue
+        ) / Math.max(f.actualRevenue, 1);
+        return acc + error;
+      }, 0) / Math.max(data.filter((f) => f.metadata?.acvFactored).length, 1);
+
+    factors.push({
+      factor: 'acvEstimation',
+      contribution: 15,
+      accuracy: Math.max(0, 100 - acvAccuracy * 100),
+      trend:
+        acvAccuracy < 0.2
+          ? 'improving'
+          : acvAccuracy < 0.35
+            ? 'stable'
+            : 'degrading',
+      samples: data.filter((f) => f.metadata?.acvFactored).length,
+      recommendation:
+        acvAccuracy > 0.3
+          ? 'Review ACV estimation assumptions'
+          : undefined,
+    });
+
+    return factors;
+  }
+
+  /**
+   * Get recommended model weight updates (conservative: max 5% change)
+   */
+  getModelUpdateRecommendations(
+    samples?: LeadFeedback[]
+  ): WeightUpdate[] {
+    const factorAccuracy = this.analyzeFactorAccuracy(samples);
+    const maxChangePercent = 5; // Conservative: max 5% per month
+
+    return factorAccuracy
+      .map((factor) => {
+        const currentWeight = this.scoringWeights.get(factor.factor) || 0;
+
+        // Only recommend change if accuracy is significantly off
+        if (factor.accuracy < 65) {
+          // Needs improvement
+          const recommendedChange = Math.min(
+            maxChangePercent,
+            (100 - factor.accuracy) / 10
+          );
+          return {
+            factor: factor.factor,
+            currentWeight,
+            recommendedWeight: Math.max(
+              0.05,
+              Math.min(0.95, currentWeight + recommendedChange / 100)
+            ),
+            change: Math.min(maxChangePercent, recommendedChange),
+            rationale: `Factor accuracy ${factor.accuracy.toFixed(1)}% suggests weight adjustment`,
+            confidence: Math.min(100, factor.samples * 5),
+          };
+        } else if (factor.accuracy > 85) {
+          // Already performing well
+          const recommendedChange = Math.max(
+            -maxChangePercent,
+            -(factor.accuracy - 85) / 10
+          );
+          return {
+            factor: factor.factor,
+            currentWeight,
+            recommendedWeight: Math.max(
+              0.05,
+              Math.min(0.95, currentWeight + recommendedChange / 100)
+            ),
+            change: Math.max(-maxChangePercent, recommendedChange),
+            rationale: `Factor performing well at ${factor.accuracy.toFixed(1)}% accuracy`,
+            confidence: Math.min(100, factor.samples * 5),
+          };
+        }
+
+        return null;
+      })
+      .filter((u) => u !== null && Math.abs(u.change) > 0.1) as WeightUpdate[];
+  }
+
+  /**
+   * Apply monthly update to scoring model weights
+   */
+  applyMonthlyUpdate(recommendations?: WeightUpdate[]): Map<string, number> {
+    const now = new Date();
+    const lastUpdate = this.lastMonthlyUpdate;
+    const daysSinceUpdate = Math.floor(
+      (now.getTime() - lastUpdate.getTime()) / (1000 * 60 * 60 * 24)
+    );
+
+    if (daysSinceUpdate < 25) {
+      throw new Error('Monthly update can only be applied once per 25 days');
+    }
+
+    const updates = recommendations || this.getModelUpdateRecommendations();
+
+    // Apply high-confidence updates
+    let updateCount = 0;
+    updates.forEach((update) => {
+      if (update.confidence > 50) {
+        // Only apply high-confidence updates
+        this.scoringWeights.set(update.factor, update.recommendedWeight);
+        updateCount++;
+      }
+    });
+
+    // Normalize weights to sum to 1.0
+    const sum = Array.from(this.scoringWeights.values()).reduce(
+      (a, b) => a + b,
+      0
+    );
+    if (sum > 0) {
+      this.scoringWeights.forEach((value, key) => {
+        this.scoringWeights.set(key, value / sum);
+      });
+    }
+
+    this.lastMonthlyUpdate = now;
+    return this.scoringWeights;
+  }
+
+  /**
+   * Get complete feedback history
+   */
+  getFeedbackHistory(leadId?: string, limit?: number): LeadFeedback[] {
+    let results = this.feedbackHistory;
+
+    if (leadId) {
+      results = results.filter((f) => f.leadId === leadId);
+    }
+
+    if (limit) {
+      results = results.slice(-limit);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get current scoring weights
+   */
+  getScoringWeights(): Record<string, number> {
+    const result: Record<string, number> = {};
+    this.scoringWeights.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+
+  /**
+   * Private helper: Group feedback by key function
+   */
+  private groupByKey(
+    data: LeadFeedback[],
+    keyFn: (f: LeadFeedback) => string
+  ): Map<string, LeadFeedback[]> {
+    const groups = new Map<string, LeadFeedback[]>();
+    data.forEach((item) => {
+      const key = keyFn(item);
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)!.push(item);
+    });
+    return groups;
+  }
+
+  /**
+   * Private helper: Calculate accuracy for grouped feedback
+   */
+  private calculateGroupAccuracy(
+    groups: Map<string, LeadFeedback[]>
+  ): { avgAccuracy: number; totalSamples: number } {
+    let totalAccuracy = 0;
+    let totalSamples = 0;
+
+    groups.forEach((group) => {
+      const accuracy = this.calculateAccuracy(group);
+      totalAccuracy += 100 - accuracy.mape; // Accuracy is inverse of error
+      totalSamples += group.length;
+    });
+
+    return {
+      avgAccuracy:
+        groups.size > 0 ? totalAccuracy / groups.size : 0,
+      totalSamples,
+    };
+  }
+
+  /**
+   * Private helper: Determine trend for a factor
+   */
+  private determineTrend(
+    accuracy: { avgAccuracy: number },
+    groups: Map<string, LeadFeedback[]>
+  ): 'improving' | 'stable' | 'degrading' {
+    // Simple heuristic: if accuracy is improving month-over-month
+    // For now, use static determination based on current state
+    if (accuracy.avgAccuracy > 80) return 'improving';
+    if (accuracy.avgAccuracy > 60) return 'stable';
+    return 'degrading';
+  }
+}
+
+// Export factory function
+export function createFeedbackLoop(
+  initialWeights?: Record<string, number>,
+  lastUpdateDate?: Date
+): FeedbackLoop {
+  return new FeedbackLoop(initialWeights, lastUpdateDate);
+}