lean-claudient-core 0.1.0

package/src/intelligence/userComplaints.ts

@@ -0,0 +1,236 @@
+/**
+ * User Complaints Aggregator
+ * Scans: Reddit r/devops, product review sites, Twitter, GitHub issues
+ * Extracts and classifies user pain points
+ */
+
+import { UserComplaint, Competitor } from './competitorTypes.js';
+
+interface MockComplaintData {
+  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[];
+}
+
+// Mock complaint data: Real implementation would scrape Reddit, Twitter, Trustpilot, etc.
+const MOCK_COMPLAINTS: Record<string, MockComplaintData[]> = {
+  'cursor': [
+    {
+      complaint: 'High latency on large codebases with context window issues',
+      frequency: 12,
+      sentiment: 'negative',
+      category: 'performance',
+      source: 'reddit',
+      keywords: ['latency', 'slow', 'lag', 'context', 'window'],
+    },
+    {
+      complaint: 'Limited free tier - many features locked behind $20/month subscription',
+      frequency: 8,
+      sentiment: 'negative',
+      category: 'cost',
+      source: 'twitter',
+      keywords: ['expensive', 'pricing', 'subscription', 'cost'],
+    },
+    {
+      complaint: 'UI crashes occasionally when working with multiple files',
+      frequency: 5,
+      sentiment: 'negative',
+      category: 'ux',
+      source: 'github',
+      keywords: ['crash', 'bug', 'unstable', 'freeze'],
+    },
+  ],
+  'codeium': [
+    {
+      complaint: 'Less accurate than Copilot for complex code generation',
+      frequency: 15,
+      sentiment: 'negative',
+      category: 'features',
+      source: 'reddit',
+      keywords: ['accuracy', 'quality', 'suggestions', 'bad'],
+    },
+    {
+      complaint: 'Enterprise licensing unclear and expensive',
+      frequency: 6,
+      sentiment: 'negative',
+      category: 'cost',
+      source: 'review_site',
+      keywords: ['pricing', 'enterprise', 'license', 'negotiation'],
+    },
+    {
+      complaint: 'Privacy claims are good but hard to verify',
+      frequency: 4,
+      sentiment: 'neutral',
+      category: 'privacy',
+      source: 'twitter',
+      keywords: ['privacy', 'data', 'local', 'transparent'],
+    },
+  ],
+  'github_copilot': [
+    {
+      complaint: 'High subscription cost relative to value for individual developers',
+      frequency: 20,
+      sentiment: 'negative',
+      category: 'cost',
+      source: 'reddit',
+      keywords: ['expensive', 'price', 'cost', 'monthly'],
+    },
+    {
+      complaint: 'Occasional code suggestions that violate license agreements',
+      frequency: 7,
+      sentiment: 'negative',
+      category: 'privacy',
+      source: 'github',
+      keywords: ['license', 'copyright', 'training', 'data'],
+    },
+    {
+      complaint: 'Poor performance on legacy code and uncommon languages',
+      frequency: 9,
+      sentiment: 'negative',
+      category: 'features',
+      source: 'reddit',
+      keywords: ['legacy', 'cobol', 'rare', 'languages'],
+    },
+  ],
+  'tabnine': [
+    {
+      complaint: 'Weaker AI models compared to newer competitors',
+      frequency: 11,
+      sentiment: 'negative',
+      category: 'features',
+      source: 'reddit',
+      keywords: ['weak', 'outdated', 'model', 'ai'],
+    },
+    {
+      complaint: 'Community features outdated and rarely updated',
+      frequency: 5,
+      sentiment: 'negative',
+      category: 'ux',
+      source: 'twitter',
+      keywords: ['abandoned', 'inactive', 'development'],
+    },
+  ],
+};
+
+const COMPLAINT_KEYWORDS_NEGATIVE = [
+  'crash', 'bug', 'slow', 'expensive', 'bad', 'weak', 'poor',
+  'lag', 'latency', 'unstable', 'freeze', 'hang', 'fail',
+];
+
+const COMPLAINT_KEYWORDS_POSITIVE = [
+  'great', 'excellent', 'fast', 'cheap', 'easy', 'simple',
+  'smooth', 'reliable', 'responsive', 'good', 'solid',
+];
+
+function classifySentiment(text: string): 'negative' | 'neutral' | 'positive' {
+  const lower = text.toLowerCase();
+
+  let negCount = COMPLAINT_KEYWORDS_NEGATIVE.filter((k) =>
+    lower.includes(k),
+  ).length;
+  let posCount = COMPLAINT_KEYWORDS_POSITIVE.filter((k) =>
+    lower.includes(k),
+  ).length;
+
+  if (negCount > posCount) return 'negative';
+  if (posCount > negCount) return 'positive';
+  return 'neutral';
+}
+
+function classifyCategory(
+  text: string,
+): 'performance' | 'cost' | 'ux' | 'features' | 'support' | 'privacy' | 'other' {
+  const lower = text.toLowerCase();
+
+  const categories = {
+    performance: ['fast', 'slow', 'latency', 'lag', 'speed', 'performance'],
+    cost: ['price', 'expensive', 'cost', 'subscription', 'free'],
+    ux: ['ui', 'ux', 'interface', 'crash', 'freeze', 'hang'],
+    features: ['feature', 'functionality', 'capability', 'support'],
+    support: ['support', 'help', 'customer', 'service', 'response'],
+    privacy: ['privacy', 'data', 'training', 'license', 'copyright'],
+  };
+
+  for (const [cat, keywords] of Object.entries(categories)) {
+    if (keywords.some((k) => lower.includes(k))) {
+      return cat as keyof typeof categories;
+    }
+  }
+
+  return 'other';
+}
+
+export async function aggregateUserComplaints(
+  competitor: Competitor,
+): Promise<UserComplaint[]> {
+  const complaints: UserComplaint[] = [];
+  const competitorId = competitor.id.toLowerCase();
+
+  // Get mock complaint data
+  const mockData = MOCK_COMPLAINTS[competitorId] || [];
+
+  for (const mock of mockData) {
+    complaints.push({
+      date: new Date().toISOString().split('T')[0],
+      competitor_id: competitor.id,
+      complaint: mock.complaint,
+      frequency: mock.frequency,
+      sentiment: mock.sentiment,
+      category: mock.category,
+      source: mock.source,
+      keywords: mock.keywords,
+    });
+  }
+
+  return complaints;
+}
+
+export function analyzeComplaintPatterns(complaints: UserComplaint[]): {
+  top_complaints: string[];
+  sentiment_distribution: Record<string, number>;
+  category_breakdown: Record<string, number>;
+  avg_frequency: number;
+  critical_issues: string[];
+} {
+  // Top 3 complaints by frequency
+  const top_complaints = complaints
+    .sort((a, b) => b.frequency - a.frequency)
+    .slice(0, 3)
+    .map((c) => c.complaint);
+
+  // Sentiment distribution
+  const sentiment_distribution = {
+    negative: complaints.filter((c) => c.sentiment === 'negative').length,
+    neutral: complaints.filter((c) => c.sentiment === 'neutral').length,
+    positive: complaints.filter((c) => c.sentiment === 'positive').length,
+  };
+
+  // Category breakdown
+  const category_breakdown: Record<string, number> = {};
+  complaints.forEach((c) => {
+    category_breakdown[c.category] = (category_breakdown[c.category] || 0) + 1;
+  });
+
+  // Average frequency
+  const avg_frequency =
+    complaints.length > 0
+      ? complaints.reduce((sum, c) => sum + c.frequency, 0) /
+        complaints.length
+      : 0;
+
+  // Critical issues (high frequency negative)
+  const critical_issues = complaints
+    .filter((c) => c.sentiment === 'negative' && c.frequency >= 8)
+    .map((c) => c.complaint);
+
+  return {
+    top_complaints,
+    sentiment_distribution,
+    category_breakdown,
+    avg_frequency,
+    critical_issues,
+  };
+}

package/src/metrics/businessMetrics.ts

@@ -0,0 +1,186 @@
+/**
+ * Business Metrics Aggregator
+ * Centralizes KPI tracking: leads, competitors, market trends
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+export interface TimeSeriesPoint {
+  timestamp: number;
+  value: number;
+  label?: string;
+}
+
+export interface BusinessMetrics {
+  leadsIdentified: number;
+  competitorVulnerabilitiesFound: number;
+  marketTrendsDetected: number;
+
+  // Time windows
+  period: {
+    today: Partial<BusinessMetrics>;
+    week: Partial<BusinessMetrics>;
+    month: Partial<BusinessMetrics>;
+    year: Partial<BusinessMetrics>;
+  };
+
+  // Time series for trending
+  timeSeries: {
+    leads: TimeSeriesPoint[];
+    vulnerabilities: TimeSeriesPoint[];
+    trends: TimeSeriesPoint[];
+  };
+
+  // Financial impact
+  financial: {
+    estimatedRevenuePotential: number;
+    estimatedROI: number;
+    paybackPeriod: string;
+  };
+
+  timestamp: number;
+  sessionId: string;
+}
+
+const METRICS_STORE_PATH = '.lean-claudient/business-metrics.json';
+
+export function getMetricsStorePath(cwd: string): string {
+  return resolve(cwd, METRICS_STORE_PATH);
+}
+
+function loadMetricsFromDisk(storePath: string): BusinessMetrics | null {
+  try {
+    if (!existsSync(storePath)) return null;
+    const data = readFileSync(storePath, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+function saveMetricsToDisk(storePath: string, metrics: BusinessMetrics): void {
+  try {
+    const dir = resolve(storePath, '..');
+    if (!existsSync(dir)) {
+      throw new Error(`Directory ${dir} not found`);
+    }
+    writeFileSync(storePath, JSON.stringify(metrics, null, 2), 'utf-8');
+  } catch (error) {
+    console.warn(`Failed to save metrics: ${(error as Error).message}`);
+  }
+}
+
+function computePeriodMetrics(metrics: BusinessMetrics, period: 'today' | 'week' | 'month' | 'year'): Partial<BusinessMetrics> {
+  const now = Date.now();
+  const windows = {
+    today: 24 * 60 * 60 * 1000,
+    week: 7 * 24 * 60 * 60 * 1000,
+    month: 30 * 24 * 60 * 60 * 1000,
+    year: 365 * 24 * 60 * 60 * 1000,
+  };
+
+  const cutoff = now - windows[period];
+
+  const leads = metrics.timeSeries.leads.filter(p => p.timestamp >= cutoff).reduce((sum, p) => sum + p.value, 0);
+  const vulns = metrics.timeSeries.vulnerabilities.filter(p => p.timestamp >= cutoff).reduce((sum, p) => sum + p.value, 0);
+  const trends = metrics.timeSeries.trends.filter(p => p.timestamp >= cutoff).reduce((sum, p) => sum + p.value, 0);
+
+  return {
+    leadsIdentified: leads,
+    competitorVulnerabilitiesFound: vulns,
+    marketTrendsDetected: trends,
+  };
+}
+
+export function aggregateMetrics(
+  leadsData: any,
+  competitorData: any,
+  trendsData: any,
+  options: {
+    cwd: string;
+    sessionId: string;
+    persist?: boolean;
+  }
+): BusinessMetrics {
+  const storePath = getMetricsStorePath(options.cwd);
+  const existing = loadMetricsFromDisk(storePath) || getDefaultMetrics(options.sessionId);
+
+  const now = Date.now();
+
+  // Merge time series data
+  const leads = leadsData?.total || existing.leadsIdentified;
+  const vulns = competitorData?.total || existing.competitorVulnerabilitiesFound;
+  const trends = trendsData?.total || existing.marketTrendsDetected;
+
+  const metrics: BusinessMetrics = {
+    leadsIdentified: leads,
+    competitorVulnerabilitiesFound: vulns,
+    marketTrendsDetected: trends,
+
+    period: {
+      today: computePeriodMetrics(existing, 'today'),
+      week: computePeriodMetrics(existing, 'week'),
+      month: computePeriodMetrics(existing, 'month'),
+      year: computePeriodMetrics(existing, 'year'),
+    },
+
+    timeSeries: {
+      leads: [...existing.timeSeries.leads, { timestamp: now, value: leads }].slice(-365),
+      vulnerabilities: [...existing.timeSeries.vulnerabilities, { timestamp: now, value: vulns }].slice(-365),
+      trends: [...existing.timeSeries.trends, { timestamp: now, value: trends }].slice(-365),
+    },
+
+    financial: {
+      estimatedRevenuePotential: 0, // Calculated by ROI calculator
+      estimatedROI: 0,
+      paybackPeriod: '0 weeks',
+    },
+
+    timestamp: now,
+    sessionId: options.sessionId,
+  };
+
+  if (options.persist !== false) {
+    saveMetricsToDisk(storePath, metrics);
+  }
+
+  return metrics;
+}
+
+export function getDefaultMetrics(sessionId: string): BusinessMetrics {
+  return {
+    leadsIdentified: 0,
+    competitorVulnerabilitiesFound: 0,
+    marketTrendsDetected: 0,
+
+    period: {
+      today: { leadsIdentified: 0, competitorVulnerabilitiesFound: 0, marketTrendsDetected: 0 },
+      week: { leadsIdentified: 0, competitorVulnerabilitiesFound: 0, marketTrendsDetected: 0 },
+      month: { leadsIdentified: 0, competitorVulnerabilitiesFound: 0, marketTrendsDetected: 0 },
+      year: { leadsIdentified: 0, competitorVulnerabilitiesFound: 0, marketTrendsDetected: 0 },
+    },
+
+    timeSeries: {
+      leads: [],
+      vulnerabilities: [],
+      trends: [],
+    },
+
+    financial: {
+      estimatedRevenuePotential: 0,
+      estimatedROI: 0,
+      paybackPeriod: '0 weeks',
+    },
+
+    timestamp: Date.now(),
+    sessionId,
+  };
+}
+
+export function loadMetrics(cwd: string): BusinessMetrics {
+  const storePath = getMetricsStorePath(cwd);
+  const metrics = loadMetricsFromDisk(storePath);
+  if (metrics) return metrics;
+  return getDefaultMetrics('bootstrap');
+}