lean-claudient-core 0.1.0

package/src/intelligence/gitHubTracker.ts

@@ -0,0 +1,204 @@
+/**
+ * GitHub Competitor Tracker
+ * Monitors: Commits, releases, PRs, open issues
+ * Detects: Feature additions, architecture changes
+ */
+
+import { GithubEvent, Competitor } from './competitorTypes.js';
+
+interface GitHubRepoInfo {
+  repo: string;
+  org: string;
+  data: {
+    commits_last_week: number;
+    recent_releases: string[];
+    open_prs: number;
+    open_issues: number;
+    last_updated: string;
+  };
+}
+
+interface MockCommitData {
+  date: string;
+  message: string;
+  hash: string;
+  impact: 'low' | 'medium' | 'high';
+}
+
+interface MockReleaseData {
+  tag: string;
+  name: string;
+  date: string;
+  body: string;
+  draft: boolean;
+  prerelease: boolean;
+}
+
+// Mock data: Real implementation would use GitHub API or web scraping
+const MOCK_COMMIT_HISTORY: Record<string, MockCommitData[]> = {
+  'anysphere/cursor': [
+    {
+      date: '2026-06-18',
+      message: 'feat: Add Claude 3.5 model support',
+      hash: 'abc1234',
+      impact: 'high',
+    },
+    {
+      date: '2026-06-15',
+      message: 'refactor: Optimize context window management',
+      hash: 'def5678',
+      impact: 'medium',
+    },
+    {
+      date: '2026-06-10',
+      message: 'fix: Improve multi-file editing stability',
+      hash: 'ghi9012',
+      impact: 'low',
+    },
+  ],
+  'Exafunction/codeium': [
+    {
+      date: '2026-06-17',
+      message: 'feat: Add enterprise SSO integration',
+      hash: 'jkl3456',
+      impact: 'high',
+    },
+    {
+      date: '2026-06-14',
+      message: 'perf: Improve latency for real-time suggestions',
+      hash: 'mno7890',
+      impact: 'medium',
+    },
+  ],
+};
+
+const MOCK_RELEASES: Record<string, MockReleaseData[]> = {
+  'anysphere/cursor': [
+    {
+      tag: 'v0.24.0',
+      name: 'Cursor 0.24.0: Claude Opus Integration',
+      date: '2026-06-15',
+      body: 'Adds support for Claude 3 Opus model for complex tasks',
+      draft: false,
+      prerelease: false,
+    },
+  ],
+  'Exafunction/codeium': [
+    {
+      tag: 'v1.15.0',
+      name: 'Codeium 1.15.0: Enterprise Features',
+      date: '2026-06-10',
+      body: 'Enterprise SSO, audit logs, admin dashboard',
+      draft: false,
+      prerelease: false,
+    },
+  ],
+};
+
+const FEATURE_KEYWORDS = [
+  'feat',
+  'feature',
+  'add',
+  'implement',
+  'support',
+  'enable',
+  'integrate',
+  'release',
+];
+const OPTIMIZATION_KEYWORDS = [
+  'perf',
+  'optimize',
+  'improve',
+  'refactor',
+  'efficiency',
+  'speed',
+  'latency',
+];
+const BREAKING_KEYWORDS = [
+  'breaking',
+  'breaking change',
+  'major',
+  'migration',
+  'deprecate',
+];
+
+function detectImpactLevel(message: string): 'low' | 'medium' | 'high' {
+  const lowerMsg = message.toLowerCase();
+
+  if (BREAKING_KEYWORDS.some((k) => lowerMsg.includes(k))) return 'high';
+  if (FEATURE_KEYWORDS.some((k) => lowerMsg.includes(k))) return 'high';
+  if (OPTIMIZATION_KEYWORDS.some((k) => lowerMsg.includes(k))) return 'medium';
+
+  return 'low';
+}
+
+export async function trackGitHub(competitor: Competitor): Promise<GithubEvent[]> {
+  const events: GithubEvent[] = [];
+
+  if (!competitor.github_repo || !competitor.github_org) {
+    return events;
+  }
+
+  const fullRepo = `${competitor.github_org}/${competitor.github_repo}`;
+
+  // Get commit history
+  const commits = MOCK_COMMIT_HISTORY[fullRepo] || [];
+  for (const commit of commits) {
+    events.push({
+      date: commit.date,
+      type: 'commit',
+      feature: extractFeatureFromMessage(commit.message),
+      impact_level: commit.impact,
+      details: commit.message,
+      url: `https://github.com/${fullRepo}/commit/${commit.hash}`,
+    });
+  }
+
+  // Get releases
+  const releases = MOCK_RELEASES[fullRepo] || [];
+  for (const release of releases) {
+    events.push({
+      date: release.date,
+      type: 'release',
+      feature: release.name.replace(/^.*:\s*/, ''),
+      impact_level: 'high',
+      details: release.body,
+      url: `https://github.com/${fullRepo}/releases/tag/${release.tag}`,
+    });
+  }
+
+  return events.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+}
+
+function extractFeatureFromMessage(message: string): string {
+  // Extract feature description from commit message
+  const match = message.match(/:\s*(.+?)(?:\s*\(|$)/);
+  return match ? match[1].trim() : message.substring(0, 50);
+}
+
+export function analyzeGitHubTrend(events: GithubEvent[]): {
+  monthly_commits: number;
+  feature_velocity: number;
+  optimization_focus: boolean;
+  recent_major_changes: string[];
+} {
+  const thirtyDaysAgo = new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+  const recent = events.filter((e) => new Date(e.date) > thirtyDaysAgo);
+  const high_impact = recent.filter((e) => e.impact_level === 'high');
+  const has_optimization = recent.some((e) =>
+    OPTIMIZATION_KEYWORDS.some((k) =>
+      e.details.toLowerCase().includes(k),
+    ),
+  );
+
+  return {
+    monthly_commits: recent.length,
+    feature_velocity: high_impact.length,
+    optimization_focus: has_optimization,
+    recent_major_changes: high_impact
+      .slice(0, 3)
+      .map((e) => e.feature),
+  };
+}

package/src/intelligence/hackerNewsScanner.ts

@@ -0,0 +1,121 @@
+import axios from 'axios';
+import { z } from 'zod';
+import { HNStory } from './types.js';
+
+const HN_API_URL = 'https://hacker-news.firebaseio.com/v0';
+
+const HNItemSchema = z.object({
+  id: z.number(),
+  title: z.string().optional(),
+  url: z.string().optional(),
+  score: z.number().min(0),
+  descendants: z.number().min(0),
+  by: z.string(),
+  time: z.number(),
+  type: z.string(),
+});
+
+interface HNScannerOptions {
+  minPoints?: number;
+  days?: number;
+  timeout?: number;
+  maxStories?: number;
+}
+
+export class HackerNewsScanner {
+  private minPoints: number;
+  private days: number;
+  private timeout: number;
+  private maxStories: number;
+
+  constructor(options: HNScannerOptions = {}) {
+    this.minPoints = options.minPoints || 20;
+    this.days = options.days || 30;
+    this.timeout = options.timeout || 15000;
+    this.maxStories = options.maxStories || 500;
+  }
+
+  async scan(keywords: string[]): Promise<HNStory[]> {
+    try {
+      const topStories = await this.getTopStories();
+      const newStories = await this.getNewStories();
+      const deduped = new Set([...topStories, ...newStories]);
+      const allStoryIds = Array.from(deduped).slice(0, this.maxStories);
+
+      const stories: HNStory[] = [];
+      const cutoffTime = Date.now() - this.days * 24 * 60 * 60 * 1000;
+
+      for (const id of allStoryIds) {
+        try {
+          const story = await this.getStoryDetails(id);
+          if (!story) continue;
+
+          const matchesKeywords = keywords.some((kw) =>
+            (story.title || '').toLowerCase().includes(kw.toLowerCase())
+          );
+
+          if (
+            matchesKeywords &&
+            story.points >= this.minPoints &&
+            story.timestamp.getTime() > cutoffTime
+          ) {
+            stories.push(story);
+          }
+        } catch {
+          // Skip failed stories
+        }
+      }
+
+      return stories;
+    } catch (error) {
+      console.warn(`HN scan failed: ${(error as Error).message}`);
+      return [];
+    }
+  }
+
+  private async getTopStories(): Promise<number[]> {
+    const response = await axios.get(`${HN_API_URL}/topstories.json`, {
+      timeout: this.timeout,
+    });
+    return Array.isArray(response.data) ? response.data.slice(0, 100) : [];
+  }
+
+  private async getNewStories(): Promise<number[]> {
+    const response = await axios.get(`${HN_API_URL}/newstories.json`, {
+      timeout: this.timeout,
+    });
+    return Array.isArray(response.data) ? response.data.slice(0, 100) : [];
+  }
+
+  private async getStoryDetails(id: number): Promise<HNStory | null> {
+    const response = await axios.get(`${HN_API_URL}/item/${id}.json`, {
+      timeout: this.timeout,
+    });
+
+    const parsed = HNItemSchema.parse(response.data);
+
+    if (!parsed.title || parsed.type !== 'story') {
+      return null;
+    }
+
+    const url = parsed.url || `https://news.ycombinator.com/item?id=${id}`;
+
+    return {
+      title: parsed.title,
+      url,
+      points: parsed.score,
+      comments: parsed.descendants,
+      rank: 0, // Will be set during ranking
+      author: parsed.by,
+      timestamp: new Date(parsed.time * 1000),
+    };
+  }
+}
+
+export async function scanHackerNews(
+  keywords: string[],
+  options: HNScannerOptions = {}
+): Promise<HNStory[]> {
+  const scanner = new HackerNewsScanner(options);
+  return scanner.scan(keywords);
+}

package/src/intelligence/hiringSignals.ts

@@ -0,0 +1,162 @@
+/**
+ * Hiring Signals Detector
+ * Monitors: LinkedIn hiring pages, job boards (Indeed, Glassdoor)
+ * Detects: Strategic pivots via hiring patterns
+ */
+
+import { HiringSignal, Competitor } from './competitorTypes.js';
+
+interface MockJobPosting {
+  date: string;
+  title: string;
+  role_type: 'engineering' | 'sales' | 'operations' | 'product' | 'leadership';
+  location: string[];
+  count: number;
+  seniority: string;
+  description: string;
+}
+
+// Mock hiring data: Real implementation would scrape LinkedIn & job boards
+const MOCK_HIRING_DATA: Record<string, MockJobPosting[]> = {
+  'cursor': [
+    {
+      date: '2026-06-18',
+      title: 'Senior ML Engineer',
+      role_type: 'engineering',
+      location: ['San Francisco, CA', 'Remote'],
+      count: 3,
+      seniority: 'senior',
+      description: 'Build next-generation code generation models',
+    },
+    {
+      date: '2026-06-15',
+      title: 'Sales Engineer',
+      role_type: 'sales',
+      location: ['New York, NY', 'San Francisco, CA'],
+      count: 2,
+      seniority: 'mid',
+      description: 'Enterprise sales for AI code editor',
+    },
+  ],
+  'codeium': [
+    {
+      date: '2026-06-17',
+      title: 'Enterprise Account Executive',
+      role_type: 'sales',
+      location: ['Remote', 'US'],
+      count: 5,
+      seniority: 'mid-senior',
+      description: 'Expand enterprise customer base',
+    },
+    {
+      date: '2026-06-10',
+      title: 'ML Research Scientist',
+      role_type: 'engineering',
+      location: ['Mountain View, CA'],
+      count: 2,
+      seniority: 'senior',
+      description: 'Research better code completion models',
+    },
+  ],
+  'github': [
+    {
+      date: '2026-06-16',
+      title: 'AI/ML Product Manager',
+      role_type: 'product',
+      location: ['San Francisco, CA'],
+      count: 1,
+      seniority: 'senior',
+      description: 'Lead AI-powered developer tools strategy',
+    },
+  ],
+};
+
+// Mock historical data to detect trends
+const HISTORICAL_HIRING: Record<string, number[]> = {
+  'cursor': [8, 9, 10, 10, 12], // Last 5 weeks
+  'codeium': [15, 16, 18, 20, 22],
+  'github': [25, 26, 26, 28, 30],
+};
+
+function detectTrend(historical: number[]): 'increasing' | 'stable' | 'decreasing' {
+  if (historical.length < 2) return 'stable';
+
+  const recent = historical.slice(-2);
+  const change = recent[1] - recent[0];
+
+  if (change > 2) return 'increasing';
+  if (change < -2) return 'decreasing';
+  return 'stable';
+}
+
+export async function detectHiringSignals(competitor: Competitor): Promise<HiringSignal[]> {
+  const signals: HiringSignal[] = [];
+  const competitorId = competitor.id.toLowerCase();
+
+  // Get mock hiring data
+  const jobPostings = MOCK_HIRING_DATA[competitorId] || [];
+
+  const hiring_history = HISTORICAL_HIRING[competitorId] || [10, 10, 10, 10, 10];
+  const trend = detectTrend(hiring_history);
+
+  for (const posting of jobPostings) {
+    signals.push({
+      date: posting.date,
+      competitor_id: competitor.id,
+      role: posting.title,
+      role_type: posting.role_type,
+      count: posting.count,
+      location: posting.location,
+      trend: trend,
+      source: 'linkedin',
+      details: posting.description,
+    });
+  }
+
+  return signals.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+}
+
+export function analyzeHiringStrategy(signals: HiringSignal[]): {
+  total_open_positions: number;
+  engineering_ratio: number;
+  sales_ratio: number;
+  strategic_focus: string;
+  geographic_expansion: string[];
+} {
+  const total = signals.reduce((sum, s) => sum + s.count, 0);
+  const engineering = signals
+    .filter((s) => s.role_type === 'engineering')
+    .reduce((sum, s) => sum + s.count, 0);
+  const sales = signals
+    .filter((s) => s.role_type === 'sales')
+    .reduce((sum, s) => sum + s.count, 0);
+
+  // Determine strategic focus based on role distribution
+  let focus = 'balanced';
+  if (engineering > total * 0.6) focus = 'engineering_heavy';
+  if (sales > total * 0.4) focus = 'enterprise_expansion';
+
+  // Extract unique locations
+  const locations = Array.from(
+    new Set(signals.flatMap((s) => s.location)),
+  );
+
+  return {
+    total_open_positions: total,
+    engineering_ratio: engineering / total,
+    sales_ratio: sales / total,
+    strategic_focus: focus,
+    geographic_expansion: locations,
+  };
+}
+
+export function calculateHiringVelocity(signals: HiringSignal[]): number {
+  // Returns hiring increase rate per month (0-100%)
+  if (signals.length === 0) return 0;
+
+  const thirtyDaysAgo = new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+  const recent = signals.filter((s) => new Date(s.date) > thirtyDaysAgo);
+  return Math.min(recent.length * 5, 100); // Scale to 0-100
+}

package/src/intelligence/index.ts

@@ -0,0 +1,9 @@
+export { MarketScanner, scanMarkets } from './marketScanner.js';
+export { RedditScanner, scanReddit } from './redditScanner.js';
+export { HackerNewsScanner, scanHackerNews } from './hackerNewsScanner.js';
+export { TwitterScanner, scanTwitter } from './twitterScanner.js';
+export { PolymarketScanner, scanPolymarket } from './polymarketScanner.js';
+export { TrendAnalyzer, analyzeTrends } from './trendAnalysis.js';
+export { SignalAggregator, aggregateSignals } from './signalAggregator.js';
+
+export * from './types.js';