@boshu2/vibe-check 1.0.0 → 1.0.2

package/src/metrics/index.ts

@@ -1,169 +0,0 @@
-import { Commit, VibeCheckResult, OverallRating, Rating } from '../types';
-import { calculateIterationVelocity, calculateActiveHours } from './velocity';
-import { calculateReworkRatio } from './rework';
-import { calculateTrustPassRate } from './trust';
-import {
-  detectFixChains,
-  calculateDebugSpiralDuration,
-  calculatePatternSummary,
-} from './spirals';
-import { calculateFlowEfficiency } from './flow';
-
-export function analyzeCommits(commits: Commit[]): VibeCheckResult {
-  if (commits.length === 0) {
-    return emptyResult();
-  }
-
-  // Sort commits by date
-  const sorted = [...commits].sort((a, b) => a.date.getTime() - b.date.getTime());
-  const from = sorted[0].date;
-  const to = sorted[sorted.length - 1].date;
-  const activeHours = calculateActiveHours(sorted);
-
-  // Count commit types
-  const commitCounts = countCommitTypes(sorted);
-
-  // Detect fix chains
-  const fixChains = detectFixChains(sorted);
-
-  // Calculate all metrics
-  const iterationVelocity = calculateIterationVelocity(sorted);
-  const reworkRatio = calculateReworkRatio(sorted);
-  const trustPassRate = calculateTrustPassRate(sorted);
-  const debugSpiralDuration = calculateDebugSpiralDuration(fixChains);
-  const flowEfficiency = calculateFlowEfficiency(activeHours * 60, fixChains);
-
-  // Calculate pattern summary
-  const patterns = calculatePatternSummary(fixChains);
-
-  // Determine overall rating
-  const overall = calculateOverallRating([
-    iterationVelocity.rating,
-    reworkRatio.rating,
-    trustPassRate.rating,
-    debugSpiralDuration.rating,
-    flowEfficiency.rating,
-  ]);
-
-  return {
-    period: {
-      from,
-      to,
-      activeHours: Math.round(activeHours * 10) / 10,
-    },
-    commits: commitCounts,
-    metrics: {
-      iterationVelocity,
-      reworkRatio,
-      trustPassRate,
-      debugSpiralDuration,
-      flowEfficiency,
-    },
-    fixChains,
-    patterns,
-    overall,
-  };
-}
-
-function countCommitTypes(commits: Commit[]): VibeCheckResult['commits'] {
-  const counts = {
-    total: commits.length,
-    feat: 0,
-    fix: 0,
-    docs: 0,
-    other: 0,
-  };
-
-  for (const commit of commits) {
-    switch (commit.type) {
-      case 'feat':
-        counts.feat++;
-        break;
-      case 'fix':
-        counts.fix++;
-        break;
-      case 'docs':
-        counts.docs++;
-        break;
-      default:
-        counts.other++;
-    }
-  }
-
-  return counts;
-}
-
-function calculateOverallRating(ratings: Rating[]): OverallRating {
-  const scores: Record<Rating, number> = {
-    elite: 4,
-    high: 3,
-    medium: 2,
-    low: 1,
-  };
-
-  const avgScore =
-    ratings.reduce((sum, r) => sum + scores[r], 0) / ratings.length;
-
-  if (avgScore >= 3.5) return 'ELITE';
-  if (avgScore >= 2.5) return 'HIGH';
-  if (avgScore >= 1.5) return 'MEDIUM';
-  return 'LOW';
-}
-
-function emptyResult(): VibeCheckResult {
-  return {
-    period: {
-      from: new Date(),
-      to: new Date(),
-      activeHours: 0,
-    },
-    commits: {
-      total: 0,
-      feat: 0,
-      fix: 0,
-      docs: 0,
-      other: 0,
-    },
-    metrics: {
-      iterationVelocity: {
-        value: 0,
-        unit: 'commits/hour',
-        rating: 'low',
-        description: 'No commits found',
-      },
-      reworkRatio: {
-        value: 0,
-        unit: '%',
-        rating: 'elite',
-        description: 'No commits found',
-      },
-      trustPassRate: {
-        value: 100,
-        unit: '%',
-        rating: 'elite',
-        description: 'No commits found',
-      },
-      debugSpiralDuration: {
-        value: 0,
-        unit: 'min',
-        rating: 'elite',
-        description: 'No debug spirals detected',
-      },
-      flowEfficiency: {
-        value: 100,
-        unit: '%',
-        rating: 'elite',
-        description: 'No active time recorded',
-      },
-    },
-    fixChains: [],
-    patterns: {
-      categories: {},
-      total: 0,
-      tracerAvailable: 0,
-    },
-    overall: 'HIGH',
-  };
-}
-
-export { calculateActiveHours } from './velocity';

package/src/metrics/rework.ts

@@ -1,45 +0,0 @@
-import { Commit, MetricResult, Rating } from '../types';
-
-export function calculateReworkRatio(commits: Commit[]): MetricResult {
-  if (commits.length === 0) {
-    return {
-      value: 0,
-      unit: '%',
-      rating: 'elite',
-      description: 'No commits found',
-    };
-  }
-
-  const fixCommits = commits.filter((c) => c.type === 'fix').length;
-  const ratio = (fixCommits / commits.length) * 100;
-  const rating = getRating(ratio);
-
-  return {
-    value: Math.round(ratio),
-    unit: '%',
-    rating,
-    description: getDescription(rating, fixCommits, commits.length),
-  };
-}
-
-function getRating(ratio: number): Rating {
-  if (ratio < 30) return 'elite';
-  if (ratio < 50) return 'high';
-  if (ratio < 70) return 'medium';
-  return 'low';
-}
-
-function getDescription(rating: Rating, fixes: number, total: number): string {
-  const fixText = `${fixes}/${total} commits are fixes`;
-
-  switch (rating) {
-    case 'elite':
-      return `${fixText}. Mostly forward progress`;
-    case 'high':
-      return `${fixText}. Normal for complex work`;
-    case 'medium':
-      return `${fixText}. Consider validating assumptions before coding`;
-    case 'low':
-      return `${fixText}. High rework, stop and reassess approach`;
-  }
-}

package/src/metrics/spirals.ts

@@ -1,173 +0,0 @@
-import { differenceInMinutes } from 'date-fns';
-import { Commit, FixChain, MetricResult, Rating } from '../types';
-
-const SPIRAL_THRESHOLD = 3; // 3+ consecutive fixes = spiral
-
-// Pattern detection regexes
-const PATTERNS: Record<string, RegExp> = {
-  VOLUME_CONFIG: /volume|mount|path|permission|readonly|pvc|storage/i,
-  SECRETS_AUTH: /secret|auth|oauth|token|credential|password|key/i,
-  API_MISMATCH: /api|version|field|spec|schema|crd|resource/i,
-  SSL_TLS: /ssl|tls|cert|fips|handshake|https/i,
-  IMAGE_REGISTRY: /image|pull|registry|docker|tag/i,
-  GITOPS_DRIFT: /drift|sync|argocd|reconcil|outof/i,
-};
-
-export function detectFixChains(commits: Commit[]): FixChain[] {
-  if (commits.length === 0) return [];
-
-  // Sort by date ascending
-  const sorted = [...commits].sort((a, b) => a.date.getTime() - b.date.getTime());
-
-  const chains: FixChain[] = [];
-  let currentChain: Commit[] = [];
-  let currentComponent: string | null = null;
-
-  for (const commit of sorted) {
-    if (commit.type === 'fix') {
-      const component = getComponent(commit);
-
-      if (component === currentComponent || currentComponent === null) {
-        currentChain.push(commit);
-        currentComponent = component;
-      } else {
-        // Different component, save current chain if valid
-        if (currentChain.length >= SPIRAL_THRESHOLD) {
-          chains.push(createFixChain(currentChain, currentComponent));
-        }
-        currentChain = [commit];
-        currentComponent = component;
-      }
-    } else {
-      // Non-fix commit breaks the chain
-      if (currentChain.length >= SPIRAL_THRESHOLD && currentComponent) {
-        chains.push(createFixChain(currentChain, currentComponent));
-      }
-      currentChain = [];
-      currentComponent = null;
-    }
-  }
-
-  // Handle final chain
-  if (currentChain.length >= SPIRAL_THRESHOLD && currentComponent) {
-    chains.push(createFixChain(currentChain, currentComponent));
-  }
-
-  return chains;
-}
-
-function getComponent(commit: Commit): string {
-  // Use scope if available
-  if (commit.scope) {
-    return commit.scope.toLowerCase();
-  }
-
-  // Extract first meaningful word from message
-  const words = commit.message
-    .replace(/^fix\s*:?\s*/i, '')
-    .split(/\s+/)
-    .filter((w) => w.length > 2);
-
-  return words[0]?.toLowerCase() || 'unknown';
-}
-
-function createFixChain(commits: Commit[], component: string): FixChain {
-  const firstCommit = commits[0].date;
-  const lastCommit = commits[commits.length - 1].date;
-  const duration = differenceInMinutes(lastCommit, firstCommit);
-
-  // Detect pattern from commit messages
-  const allMessages = commits.map((c) => c.message).join(' ');
-  const pattern = detectPattern(allMessages);
-
-  return {
-    component,
-    commits: commits.length,
-    duration,
-    isSpiral: commits.length >= SPIRAL_THRESHOLD,
-    pattern,
-    firstCommit,
-    lastCommit,
-  };
-}
-
-function detectPattern(text: string): string | null {
-  for (const [pattern, regex] of Object.entries(PATTERNS)) {
-    if (regex.test(text)) {
-      return pattern;
-    }
-  }
-  return null;
-}
-
-export function calculateDebugSpiralDuration(chains: FixChain[]): MetricResult {
-  const spirals = chains.filter((c) => c.isSpiral);
-
-  if (spirals.length === 0) {
-    return {
-      value: 0,
-      unit: 'min',
-      rating: 'elite',
-      description: 'No debug spirals detected',
-    };
-  }
-
-  const totalDuration = spirals.reduce((sum, s) => sum + s.duration, 0);
-  const avgDuration = totalDuration / spirals.length;
-  const rating = getRating(avgDuration);
-
-  return {
-    value: Math.round(avgDuration),
-    unit: 'min',
-    rating,
-    description: getDescription(rating, spirals.length),
-  };
-}
-
-function getRating(duration: number): Rating {
-  if (duration < 15) return 'elite';
-  if (duration < 30) return 'high';
-  if (duration < 60) return 'medium';
-  return 'low';
-}
-
-function getDescription(rating: Rating, spiralCount: number): string {
-  const spiralText = spiralCount === 1 ? '1 spiral' : `${spiralCount} spirals`;
-
-  switch (rating) {
-    case 'elite':
-      return `${spiralText} resolved quickly`;
-    case 'high':
-      return `${spiralText}, normal debugging time`;
-    case 'medium':
-      return `${spiralText}, consider using tracer tests`;
-    case 'low':
-      return `${spiralText}, extended debugging. Use tracer tests before implementation`;
-  }
-}
-
-export function calculatePatternSummary(chains: FixChain[]): {
-  categories: Record<string, number>;
-  total: number;
-  tracerAvailable: number;
-} {
-  const categories: Record<string, number> = {};
-  let total = 0;
-  let withTracer = 0;
-
-  for (const chain of chains) {
-    const pattern = chain.pattern || 'OTHER';
-    categories[pattern] = (categories[pattern] || 0) + chain.commits;
-    total += chain.commits;
-
-    if (chain.pattern) {
-      withTracer += chain.commits;
-    }
-  }
-
-  return {
-    categories,
-    total,
-    tracerAvailable: total > 0 ? Math.round((withTracer / total) * 100) : 0,
-  };
-}

package/src/metrics/trust.ts

@@ -1,80 +0,0 @@
-import { differenceInMinutes } from 'date-fns';
-import { Commit, MetricResult, Rating } from '../types';
-
-const FOLLOWUP_WINDOW_MINUTES = 30;
-
-export function calculateTrustPassRate(commits: Commit[]): MetricResult {
-  if (commits.length === 0) {
-    return {
-      value: 100,
-      unit: '%',
-      rating: 'elite',
-      description: 'No commits found',
-    };
-  }
-
-  // Sort by date ascending
-  const sorted = [...commits].sort((a, b) => a.date.getTime() - b.date.getTime());
-
-  let trustedCommits = 0;
-
-  for (let i = 0; i < sorted.length; i++) {
-    const commit = sorted[i];
-    const nextCommit = sorted[i + 1];
-
-    // Check if next commit is a fix to same component within 30 min
-    const needsFollowup =
-      nextCommit &&
-      nextCommit.type === 'fix' &&
-      sameComponent(commit, nextCommit) &&
-      differenceInMinutes(nextCommit.date, commit.date) < FOLLOWUP_WINDOW_MINUTES;
-
-    if (!needsFollowup) {
-      trustedCommits++;
-    }
-  }
-
-  const rate = (trustedCommits / commits.length) * 100;
-  const rating = getRating(rate);
-
-  return {
-    value: Math.round(rate),
-    unit: '%',
-    rating,
-    description: getDescription(rating),
-  };
-}
-
-function sameComponent(a: Commit, b: Commit): boolean {
-  // If both have scopes, compare them
-  if (a.scope && b.scope) {
-    return a.scope.toLowerCase() === b.scope.toLowerCase();
-  }
-
-  // If neither has scope, check if messages reference same area
-  // This is a simple heuristic - first word after type
-  const aWords = a.message.split(/\s+/).slice(0, 3);
-  const bWords = b.message.split(/\s+/).slice(0, 3);
-
-  return aWords.some((word) => bWords.includes(word) && word.length > 3);
-}
-
-function getRating(rate: number): Rating {
-  if (rate > 95) return 'elite';
-  if (rate >= 80) return 'high';
-  if (rate >= 60) return 'medium';
-  return 'low';
-}
-
-function getDescription(rating: Rating): string {
-  switch (rating) {
-    case 'elite':
-      return 'Code sticks on first try, high AI trust';
-    case 'high':
-      return 'Occasional fixes needed, mostly autonomous';
-    case 'medium':
-      return 'Regular intervention required';
-    case 'low':
-      return 'Heavy oversight needed, run tracer tests before implementation';
-  }
-}

package/src/metrics/velocity.ts

@@ -1,86 +0,0 @@
-import { differenceInMinutes } from 'date-fns';
-import { Commit, MetricResult, Rating } from '../types';
-
-const SESSION_GAP_MINUTES = 120; // 2 hours = new session
-
-export function calculateIterationVelocity(commits: Commit[]): MetricResult {
-  if (commits.length === 0) {
-    return {
-      value: 0,
-      unit: 'commits/hour',
-      rating: 'low',
-      description: 'No commits found',
-    };
-  }
-
-  const activeHours = calculateActiveHours(commits);
-
-  if (activeHours === 0) {
-    return {
-      value: commits.length,
-      unit: 'commits/hour',
-      rating: 'high',
-      description: 'All commits in rapid succession',
-    };
-  }
-
-  const velocity = commits.length / activeHours;
-  const rating = getRating(velocity);
-
-  return {
-    value: Math.round(velocity * 10) / 10,
-    unit: 'commits/hour',
-    rating,
-    description: getDescription(rating),
-  };
-}
-
-export function calculateActiveHours(commits: Commit[]): number {
-  if (commits.length < 2) {
-    return 0.1; // Minimum to avoid division by zero
-  }
-
-  // Sort by date ascending
-  const sorted = [...commits].sort((a, b) => a.date.getTime() - b.date.getTime());
-
-  let totalMinutes = 0;
-  let sessionStart = sorted[0].date;
-
-  for (let i = 1; i < sorted.length; i++) {
-    const gap = differenceInMinutes(sorted[i].date, sorted[i - 1].date);
-
-    if (gap > SESSION_GAP_MINUTES) {
-      // End current session, start new one
-      totalMinutes += differenceInMinutes(sorted[i - 1].date, sessionStart);
-      sessionStart = sorted[i].date;
-    }
-  }
-
-  // Add final session
-  totalMinutes += differenceInMinutes(sorted[sorted.length - 1].date, sessionStart);
-
-  // Minimum of 10 minutes per session to account for work between commits
-  const minMinutes = Math.max(totalMinutes, commits.length * 10);
-
-  return minMinutes / 60;
-}
-
-function getRating(velocity: number): Rating {
-  if (velocity > 5) return 'elite';
-  if (velocity >= 3) return 'high';
-  if (velocity >= 1) return 'medium';
-  return 'low';
-}
-
-function getDescription(rating: Rating): string {
-  switch (rating) {
-    case 'elite':
-      return 'Excellent iteration speed, tight feedback loops';
-    case 'high':
-      return 'Good iteration speed';
-    case 'medium':
-      return 'Normal pace';
-    case 'low':
-      return 'Slow iteration, consider smaller commits';
-  }
-}

package/src/output/index.ts

@@ -1,20 +0,0 @@
-import { VibeCheckResult, OutputFormat } from '../types';
-import { formatTerminal } from './terminal';
-import { formatJson } from './json';
-import { formatMarkdown } from './markdown';
-
-export function formatOutput(result: VibeCheckResult, format: OutputFormat): string {
-  switch (format) {
-    case 'json':
-      return formatJson(result);
-    case 'markdown':
-      return formatMarkdown(result);
-    case 'terminal':
-    default:
-      return formatTerminal(result);
-  }
-}
-
-export { formatTerminal } from './terminal';
-export { formatJson } from './json';
-export { formatMarkdown } from './markdown';

package/src/output/json.ts

@@ -1,51 +0,0 @@
-import { VibeCheckResult } from '../types';
-
-export function formatJson(result: VibeCheckResult): string {
-  // Create a JSON-friendly version with ISO date strings
-  const output = {
-    period: {
-      from: result.period.from.toISOString(),
-      to: result.period.to.toISOString(),
-      activeHours: result.period.activeHours,
-    },
-    commits: result.commits,
-    metrics: {
-      iterationVelocity: {
-        value: result.metrics.iterationVelocity.value,
-        unit: result.metrics.iterationVelocity.unit,
-        rating: result.metrics.iterationVelocity.rating,
-      },
-      reworkRatio: {
-        value: result.metrics.reworkRatio.value,
-        unit: result.metrics.reworkRatio.unit,
-        rating: result.metrics.reworkRatio.rating,
-      },
-      trustPassRate: {
-        value: result.metrics.trustPassRate.value,
-        unit: result.metrics.trustPassRate.unit,
-        rating: result.metrics.trustPassRate.rating,
-      },
-      debugSpiralDuration: {
-        value: result.metrics.debugSpiralDuration.value,
-        unit: result.metrics.debugSpiralDuration.unit,
-        rating: result.metrics.debugSpiralDuration.rating,
-      },
-      flowEfficiency: {
-        value: result.metrics.flowEfficiency.value,
-        unit: result.metrics.flowEfficiency.unit,
-        rating: result.metrics.flowEfficiency.rating,
-      },
-    },
-    fixChains: result.fixChains.map((chain) => ({
-      component: chain.component,
-      commits: chain.commits,
-      duration: chain.duration,
-      isSpiral: chain.isSpiral,
-      pattern: chain.pattern,
-    })),
-    patterns: result.patterns,
-    overall: result.overall,
-  };
-
-  return JSON.stringify(output, null, 2);
-}