lean-claudient-core 0.1.0

package/src/metrics/trendMetrics.ts

@@ -0,0 +1,190 @@
+/**
+ * Market Intelligence & Trend Tracking
+ * Monitors market signals from Reddit, HN, Twitter, Polymarket
+ */
+
+export type TrendCategory = 'pain_point' | 'feature' | 'threat' | 'opportunity';
+export type SignalSource = 'reddit' | 'hackernews' | 'twitter' | 'polymarket' | 'internal';
+
+export interface Signal {
+  id: string;
+  source: SignalSource;
+  content: string;
+  detectedAt: number;
+  relevanceScore: number; // 0-100
+}
+
+export interface Trend {
+  id: string;
+  title: string;
+  category: TrendCategory;
+  strength: number; // 0-100
+  signals: Signal[];
+  firstDetected: number;
+  lastDetected: number;
+  mentions: number;
+  keywords: string[];
+}
+
+export interface TrendMetrics {
+  totalTrends: number;
+  trendsByCategory: Record<TrendCategory, number>;
+  signalsBySource: Record<SignalSource, number>;
+  avgTrendStrength: number;
+  emergingTrends: Trend[]; // Strength > 70
+  decayingTrends: Trend[]; // Strength < 30
+  trends: Trend[];
+  timeSeries: Array<{ date: string; trendCount: number; avgStrength: number }>;
+}
+
+export function createTrend(
+  id: string,
+  title: string,
+  category: TrendCategory,
+  keywords: string[]
+): Trend {
+  return {
+    id,
+    title,
+    category,
+    strength: 0,
+    signals: [],
+    firstDetected: Date.now(),
+    lastDetected: Date.now(),
+    mentions: 0,
+    keywords,
+  };
+}
+
+export function addSignalToTrend(
+  trend: Trend,
+  source: SignalSource,
+  content: string,
+  relevanceScore: number = 50
+): Signal {
+  const signal: Signal = {
+    id: `${trend.id}-${Date.now()}`,
+    source,
+    content,
+    detectedAt: Date.now(),
+    relevanceScore,
+  };
+
+  trend.signals.push(signal);
+  trend.mentions++;
+  trend.lastDetected = Date.now();
+
+  // Update trend strength based on signals
+  trend.strength = Math.min(100, trend.signals.reduce((sum, s) => sum + s.relevanceScore, 0) / Math.max(1, trend.signals.length));
+
+  return signal;
+}
+
+export function calculateTrendMetrics(trends: Trend[]): TrendMetrics {
+  const trendsByCategory: Record<TrendCategory, number> = {
+    pain_point: 0,
+    feature: 0,
+    threat: 0,
+    opportunity: 0,
+  };
+
+  trends.forEach(t => {
+    trendsByCategory[t.category]++;
+  });
+
+  const signalsBySource: Record<SignalSource, number> = {
+    reddit: 0,
+    hackernews: 0,
+    twitter: 0,
+    polymarket: 0,
+    internal: 0,
+  };
+
+  const allSignals = trends.flatMap(t => t.signals);
+  allSignals.forEach(s => {
+    signalsBySource[s.source]++;
+  });
+
+  const avgStrength = trends.length > 0 ? trends.reduce((sum, t) => sum + t.strength, 0) / trends.length : 0;
+
+  const emergingTrends = trends.filter(t => t.strength > 70).sort((a, b) => b.strength - a.strength);
+  const decayingTrends = trends.filter(t => t.strength < 30).sort((a, b) => a.strength - b.strength);
+
+  // Generate time series (daily aggregates)
+  const now = Date.now();
+  const timeSeries: Array<{ date: string; trendCount: number; avgStrength: number }> = [];
+
+  for (let i = 0; i < 30; i++) {
+    const dayStart = now - (i * 24 * 60 * 60 * 1000);
+    const dayEnd = dayStart + 24 * 60 * 60 * 1000;
+
+    const dayTrends = trends.filter(t => t.lastDetected >= dayStart && t.lastDetected <= dayEnd);
+    const date = new Date(dayStart).toISOString().split('T')[0];
+
+    timeSeries.push({
+      date,
+      trendCount: dayTrends.length,
+      avgStrength: dayTrends.length > 0 ? Math.round((dayTrends.reduce((sum, t) => sum + t.strength, 0) / dayTrends.length) * 10) / 10 : 0,
+    });
+  }
+
+  return {
+    totalTrends: trends.length,
+    trendsByCategory,
+    signalsBySource,
+    avgTrendStrength: Math.round(avgStrength * 10) / 10,
+    emergingTrends,
+    decayingTrends,
+    trends,
+    timeSeries: timeSeries.reverse(),
+  };
+}
+
+export function detectTrendMomentum(trend: Trend): {
+  momentum: 'accelerating' | 'stable' | 'decaying';
+  changeRate: number; // percentage change
+} {
+  if (trend.signals.length < 2) {
+    return { momentum: 'stable', changeRate: 0 };
+  }
+
+  const recentSignals = trend.signals.slice(-10);
+  const olderSignals = trend.signals.slice(Math.max(0, trend.signals.length - 20), -10);
+
+  const recentAvg = recentSignals.reduce((sum, s) => sum + s.relevanceScore, 0) / recentSignals.length;
+  const olderAvg = olderSignals.length > 0 ? olderSignals.reduce((sum, s) => sum + s.relevanceScore, 0) / olderSignals.length : recentAvg;
+
+  const changeRate = olderAvg > 0 ? ((recentAvg - olderAvg) / olderAvg) * 100 : 0;
+
+  let momentum: 'accelerating' | 'stable' | 'decaying';
+  if (changeRate > 15) momentum = 'accelerating';
+  else if (changeRate < -15) momentum = 'decaying';
+  else momentum = 'stable';
+
+  return {
+    momentum,
+    changeRate: Math.round(changeRate * 100) / 100,
+  };
+}
+
+export function correlateWithLeads(trends: Trend[], sourceFilter?: string[]): {
+  painPointTrends: Trend[];
+  opportunityTrends: Trend[];
+  correlationScore: number;
+} {
+  const sources = sourceFilter || ['reddit', 'hackernews', 'twitter'];
+
+  const relevantTrends = trends.filter(t => t.signals.some(s => sources.includes(s.source)));
+
+  const painPoints = relevantTrends.filter(t => t.category === 'pain_point');
+  const opportunities = relevantTrends.filter(t => t.category === 'opportunity');
+
+  // Correlation = how many strong trends exist relative to total
+  const correlationScore = Math.round(((painPoints.length + opportunities.length) / Math.max(1, trends.length)) * 100);
+
+  return {
+    painPointTrends: painPoints.sort((a, b) => b.strength - a.strength),
+    opportunityTrends: opportunities.sort((a, b) => b.strength - a.strength),
+    correlationScore,
+  };
+}

package/src/modes/conservativeCTOMode.ts

@@ -0,0 +1,124 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { createHash } from 'crypto';
+import { resolve } from 'path';
+
+export interface Warning {
+  type: 'redundant_read';
+  filePath: string;
+  savedTokens: number;
+}
+
+export interface Alert {
+  type: 'context_avalanche';
+  fileCount: number;
+  estimatedTokens: number;
+  message: string;
+}
+
+export interface TokenStatus {
+  used: number;
+  remaining: number;
+  percentUsed: number;
+}
+
+export class ConservativeCTOMode {
+  private budgetPerSession: number;
+  private tokensUsed: number = 0;
+  private readHashes: Map<string, string> = new Map();
+  private progressPath: string;
+  private startTime: number = Date.now();
+
+  constructor(budgetPerSession: number, progressPath?: string) {
+    this.budgetPerSession = budgetPerSession;
+    this.progressPath = progressPath || resolve(process.cwd(), 'progress.md');
+  }
+
+  enforceTokenBudget(currentTokens: number): void {
+    this.tokensUsed = currentTokens;
+    if (this.tokensUsed >= this.budgetPerSession) {
+      const msg = `Token budget exceeded: ${this.tokensUsed}/${this.budgetPerSession}`;
+      this.log(`[BUDGET_EXCEEDED] ${msg}`);
+      throw new Error(msg);
+    }
+  }
+
+  flagRedundantReads(filePath: string, previousReads: Set<string>): Warning | null {
+    if (!previousReads.has(filePath)) return null;
+
+    const hash = this.computeFileHash(filePath);
+    if (this.readHashes.has(filePath) && this.readHashes.get(filePath) === hash) {
+      const tokens = this.estimateTokens(filePath);
+      this.log(`[REDUNDANT] ${filePath} (${tokens} tokens)`);
+      return { type: 'redundant_read', filePath, savedTokens: tokens };
+    }
+
+    this.readHashes.set(filePath, hash);
+    return null;
+  }
+
+  alertMultiFileContext(fileCount: number, estimatedTokens: number): Alert | null {
+    const FILE_LIMIT = 10;
+    const TOKEN_LIMIT = 15000;
+
+    if (fileCount <= FILE_LIMIT && estimatedTokens <= TOKEN_LIMIT) return null;
+
+    const reasons: string[] = [];
+    if (fileCount > FILE_LIMIT) reasons.push(`${fileCount} files (limit: ${FILE_LIMIT})`);
+    if (estimatedTokens > TOKEN_LIMIT) reasons.push(`${estimatedTokens} tokens (limit: ${TOKEN_LIMIT})`);
+
+    const msg = `Context avalanche: ${reasons.join(' + ')}`;
+    this.log(`[ALERT] ${msg}`);
+
+    return {
+      type: 'context_avalanche',
+      fileCount,
+      estimatedTokens,
+      message: msg,
+    };
+  }
+
+  getTokenStatus(): TokenStatus {
+    const remaining = Math.max(0, this.budgetPerSession - this.tokensUsed);
+    const percentUsed = this.budgetPerSession > 0
+      ? Math.round((this.tokensUsed / this.budgetPerSession) * 100)
+      : 0;
+
+    return { used: this.tokensUsed, remaining, percentUsed };
+  }
+
+  private computeFileHash(filePath: string): string {
+    try {
+      if (!existsSync(filePath)) return '';
+      const content = readFileSync(filePath, 'utf-8');
+      return createHash('md5').update(content).digest('hex');
+    } catch {
+      return '';
+    }
+  }
+
+  private estimateTokens(filePath: string): number {
+    try {
+      if (!existsSync(filePath)) return 0;
+      const content = readFileSync(filePath, 'utf-8');
+      return Math.ceil(content.length / 4);
+    } catch {
+      return 0;
+    }
+  }
+
+  private log(message: string): void {
+    try {
+      const ts = new Date().toISOString();
+      const elapsed = Math.round((Date.now() - this.startTime) / 1000);
+      const entry = `[${ts}] (+${elapsed}s) ${message}`;
+      const exists = existsSync(this.progressPath);
+      if (!exists) {
+        writeFileSync(this.progressPath, `# Progress\n\n${entry}\n`, 'utf-8');
+      } else {
+        appendFileSync(this.progressPath, `${entry}\n`, 'utf-8');
+      }
+    } catch (e) {
+      console.error(`Log failed: ${(e as Error).message}`);
+    }
+  }
+}

package/src/modes/index.ts

@@ -0,0 +1,6 @@
+export { SeniorDeveloperMode, type Finding } from './seniorDeveloperMode';
+export {
+  ConservativeCTOMode,
+  type Warning,
+  type Alert,
+} from './conservativeCTOMode';

package/src/modes/seniorDeveloperMode.ts

@@ -0,0 +1,94 @@
+export interface Finding {
+  module: string;
+  title: string;
+  severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+  description?: string;
+}
+
+export class SeniorDeveloperMode {
+  private readonly edgeCaseKeywords = [
+    'race condition',
+    'concurrent',
+    'async ordering',
+    'boundary',
+    'undefined',
+    'invariant',
+    'workaround',
+    'regression',
+  ];
+
+  private readonly fillerPatterns = [
+    /\blet me\b/i,
+    /\bi will\b/i,
+    /\bgreat question\b/i,
+    /\binteresting\b/i,
+    /\bhappy to\b/i,
+    /\bbasically\b/i,
+    /\bessentially\b/i,
+    /\bactually\b/i,
+  ];
+
+  formatOutput(text: string): string {
+    return text
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && !this.isFillerLine(line))
+      .join('\n');
+  }
+
+  shouldAddCommentary(context: string): boolean {
+    const lower = context.toLowerCase();
+    return this.edgeCaseKeywords.some((kw) => lower.includes(kw));
+  }
+
+  createModularSummary(findings: Finding[]): string {
+    const grouped = this.groupByModule(findings);
+    const sorted = this.sortByImpact(grouped);
+
+    return sorted
+      .map(({ module, items }) => {
+        const header = `📦 ${module}`;
+        const body = items.map((item) => `  • [${item.severity.toUpperCase()}] ${item.title}`).join('\n');
+        return `${header}\n${body}`;
+      })
+      .join('\n\n');
+  }
+
+  private isFillerLine(line: string): boolean {
+    return this.fillerPatterns.some((pattern) => pattern.test(line));
+  }
+
+  private groupByModule(findings: Finding[]): Array<{ module: string; items: Finding[] }> {
+    const map = new Map<string, Finding[]>();
+
+    for (const finding of findings) {
+      const mod = finding.module || 'general';
+      if (!map.has(mod)) map.set(mod, []);
+      map.get(mod)!.push(finding);
+    }
+
+    return Array.from(map.entries()).map(([module, items]) => ({ module, items }));
+  }
+
+  private sortByImpact(
+    grouped: Array<{ module: string; items: Finding[] }>
+  ): Array<{ module: string; items: Finding[] }> {
+    const severityScore: Record<string, number> = {
+      critical: 5,
+      high: 4,
+      medium: 3,
+      low: 2,
+      info: 1,
+    };
+
+    const withMaxScore = grouped.map(({ module, items }) => ({
+      module,
+      items: items.sort((a, b) => severityScore[b.severity] - severityScore[a.severity]),
+      maxScore: Math.max(...items.map((i) => severityScore[i.severity])),
+    }));
+
+    return withMaxScore
+      .sort((a, b) => b.maxScore - a.maxScore)
+      .map(({ module, items }) => ({ module, items }));
+  }
+}

package/src/recovery/contextRecovery.ts

@@ -0,0 +1,141 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+export interface CheckpointData {
+  gitHash: string;
+  timestamp: string;
+  taskPlanPath: string;
+  findingsPath: string;
+  progressPath: string;
+  claudeMdPath: string;
+}
+
+export class ContextRecovery {
+  private workingDir: string;
+
+  constructor(workingDir: string) {
+    this.workingDir = resolve(workingDir);
+  }
+
+  findLastCheckpoint(): { gitHash: string; timestamp: string } {
+    try {
+      const gitHash = execSync('git rev-parse HEAD', {
+        cwd: this.workingDir,
+        encoding: 'utf-8',
+      }).trim();
+
+      const timestamp = this.getProgressTimestamp();
+
+      return { gitHash, timestamp };
+    } catch (error) {
+      throw new Error(`Failed to find last checkpoint: ${(error as Error).message}`);
+    }
+  }
+
+  async restoreFromCheckpoint(gitHash: string): Promise<{
+    restored: boolean;
+    checkpoint: CheckpointData | null;
+  }> {
+    try {
+      const commitType = execSync(`git cat-file -t ${gitHash}`, {
+        cwd: this.workingDir,
+        encoding: 'utf-8',
+      }).trim();
+
+      if (commitType !== 'commit') {
+        return { restored: false, checkpoint: null };
+      }
+
+      const taskPlanPath = resolve(this.workingDir, 'task_plan.md');
+      const findingsPath = resolve(this.workingDir, 'findings.md');
+      const progressPath = resolve(this.workingDir, 'progress.md');
+      const claudeMdPath = resolve(this.workingDir, 'CLAUDE.md');
+
+      const checkpoint: CheckpointData = {
+        gitHash,
+        timestamp: this.getProgressTimestamp(),
+        taskPlanPath,
+        findingsPath,
+        progressPath,
+        claudeMdPath,
+      };
+
+      return { restored: true, checkpoint };
+    } catch (error) {
+      return { restored: false, checkpoint: null };
+    }
+  }
+
+  getCurrentCheckpoint(): { gitHash: string; timestamp: string } {
+    return this.findLastCheckpoint();
+  }
+
+  listCheckpoints(limit: number): CheckpointData[] {
+    try {
+      const log = execSync(`git log --oneline -n ${limit}`, {
+        cwd: this.workingDir,
+        encoding: 'utf-8',
+      }).trim();
+
+      const lines = log.split('\n').filter((line) => line.length > 0);
+      const checkpoints: CheckpointData[] = [];
+
+      for (const line of lines) {
+        const [hash] = line.split(' ');
+        const taskPlanPath = resolve(this.workingDir, 'task_plan.md');
+        const findingsPath = resolve(this.workingDir, 'findings.md');
+        const progressPath = resolve(this.workingDir, 'progress.md');
+        const claudeMdPath = resolve(this.workingDir, 'CLAUDE.md');
+
+        checkpoints.push({
+          gitHash: hash,
+          timestamp: this.getCommitTimestamp(hash),
+          taskPlanPath,
+          findingsPath,
+          progressPath,
+          claudeMdPath,
+        });
+      }
+
+      return checkpoints;
+    } catch (error) {
+      throw new Error(`Failed to list checkpoints: ${(error as Error).message}`);
+    }
+  }
+
+  private getProgressTimestamp(): string {
+    try {
+      const progressPath = resolve(this.workingDir, 'progress.md');
+      if (!existsSync(progressPath)) {
+        return new Date().toISOString();
+      }
+
+      const content = readFileSync(progressPath, 'utf-8');
+      const lines = content.split('\n').reverse();
+
+      for (const line of lines) {
+        const match = line.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)/);
+        if (match) {
+          return match[1];
+        }
+      }
+
+      return new Date().toISOString();
+    } catch (error) {
+      return new Date().toISOString();
+    }
+  }
+
+  private getCommitTimestamp(gitHash: string): string {
+    try {
+      const timestamp = execSync(`git log -1 --format=%aI ${gitHash}`, {
+        cwd: this.workingDir,
+        encoding: 'utf-8',
+      }).trim();
+      return timestamp;
+    } catch (error) {
+      return new Date().toISOString();
+    }
+  }
+}