@dependabit/action 0.1.1

package/src/utils/metrics.ts

@@ -0,0 +1,169 @@
+/**
+ * Metrics calculator for false positive rate tracking
+ * Implements 30-day rolling window analysis and trend detection
+ */
+
+export interface MetricsConfig {
+  windowDays?: number;
+  threshold?: number;
+}
+
+export interface FeedbackSummary {
+  truePositives: number;
+  falsePositives: number;
+  total: number;
+}
+
+export interface DataPoint {
+  date: string;
+  falsePositiveRate: number;
+}
+
+export interface Trend {
+  direction: 'improving' | 'worsening' | 'stable' | 'no-data';
+  slope: number;
+}
+
+export interface ThresholdCheck {
+  passed: boolean;
+  rate: number;
+  threshold: number;
+}
+
+export interface MetricsReport {
+  currentRate: number;
+  rollingAverage: number;
+  trend: Trend;
+  thresholdCheck: ThresholdCheck;
+  totalFeedback: number;
+}
+
+/**
+ * Calculator for false positive metrics with rolling window analysis
+ */
+export class MetricsCalculator {
+  private windowDays: number;
+  private threshold: number;
+
+  constructor(config: MetricsConfig = {}) {
+    this.windowDays = config.windowDays || 30;
+    this.threshold = config.threshold || 0.1; // 10% default threshold
+  }
+
+  /**
+   * Calculate false positive rate from feedback data
+   */
+  calculateFalsePositiveRate(feedback: FeedbackSummary): number {
+    if (feedback.total === 0) {
+      return 0;
+    }
+    return feedback.falsePositives / feedback.total;
+  }
+
+  /**
+   * Calculate rolling average over the time window
+   */
+  calculateRollingAverage(
+    dataPoints: DataPoint[],
+    windowDays?: number,
+    referenceDate?: Date
+  ): number {
+    const days = windowDays || this.windowDays;
+    const endDate = referenceDate || new Date();
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - days);
+
+    // Filter data points within the window
+    const windowData = dataPoints.filter((point) => {
+      const pointDate = new Date(point.date);
+      return pointDate >= startDate && pointDate <= endDate;
+    });
+
+    if (windowData.length === 0) {
+      return 0;
+    }
+
+    const sum = windowData.reduce((acc, point) => acc + point.falsePositiveRate, 0);
+    return sum / windowData.length;
+  }
+
+  /**
+   * Detect trend direction using linear regression
+   */
+  getTrend(dataPoints: DataPoint[]): Trend {
+    if (dataPoints.length < 2) {
+      return { direction: 'no-data', slope: 0 };
+    }
+
+    // Simple linear regression
+    const n = dataPoints.length;
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumX2 = 0;
+
+    dataPoints.forEach((point, index) => {
+      const x = index;
+      const y = point.falsePositiveRate;
+      sumX += x;
+      sumY += y;
+      sumXY += x * y;
+      sumX2 += x * x;
+    });
+
+    const denominator = n * sumX2 - sumX * sumX;
+    if (denominator === 0) {
+      return { direction: 'no-data', slope: 0 };
+    }
+
+    const slope = (n * sumXY - sumX * sumY) / denominator;
+    // Determine direction based on slope
+    let direction: Trend['direction'];
+    if (Math.abs(slope) < 0.001) {
+      direction = 'stable';
+    } else if (slope < 0) {
+      direction = 'improving';
+    } else {
+      direction = 'worsening';
+    }
+
+    return { direction, slope };
+  }
+
+  /**
+   * Check if rate is within acceptable threshold
+   */
+  checkThreshold(rate: number, threshold?: number): ThresholdCheck {
+    const targetThreshold = threshold !== undefined ? threshold : this.threshold;
+    return {
+      passed: rate <= targetThreshold,
+      rate,
+      threshold: targetThreshold
+    };
+  }
+
+  /**
+   * Generate comprehensive metrics report
+   */
+  generateReport(currentFeedback: FeedbackSummary, history: DataPoint[]): MetricsReport {
+    const currentRate = this.calculateFalsePositiveRate(currentFeedback);
+    const rollingAverage = this.calculateRollingAverage(history);
+    const trend = this.getTrend(history);
+    const thresholdCheck = this.checkThreshold(rollingAverage);
+
+    return {
+      currentRate,
+      rollingAverage,
+      trend,
+      thresholdCheck,
+      totalFeedback: currentFeedback.total
+    };
+  }
+
+  /**
+   * Format rate as percentage string
+   */
+  formatRate(rate: number): string {
+    return `${(rate * 100).toFixed(1)}%`;
+  }
+}

package/src/utils/outputs.ts

@@ -0,0 +1,202 @@
+/**
+ * Action Output Formatting
+ * Handles setting GitHub Action outputs and creating summaries
+ */
+
+import * as core from '@actions/core';
+import type { DependencyManifest } from '@dependabit/manifest';
+
+/**
+ * Set outputs for the generate action
+ */
+export function setGenerateOutputs(
+  manifest: DependencyManifest,
+  manifestPath: string,
+  statistics: {
+    filesScanned: number;
+    llmCalls: number;
+    totalTokens: number;
+    totalLatencyMs: number;
+  }
+): void {
+  core.setOutput('manifest_path', manifestPath);
+  core.setOutput('dependency_count', manifest.dependencies.length);
+  core.setOutput('files_scanned', statistics.filesScanned);
+  core.setOutput('llm_calls', statistics.llmCalls);
+  core.setOutput('total_tokens', statistics.totalTokens);
+  core.setOutput('average_confidence', manifest.statistics.averageConfidence);
+}
+
+/**
+ * Create a summary report for the generate action
+ */
+export async function createGenerateSummary(
+  manifest: DependencyManifest,
+  statistics: {
+    filesScanned: number;
+    llmCalls: number;
+    totalTokens: number;
+    totalLatencyMs: number;
+  }
+): Promise<void> {
+  await core.summary
+    .addHeading('🔍 Dependency Detection Complete')
+    .addRaw('\n')
+    .addTable([
+      [
+        { data: 'Metric', header: true },
+        { data: 'Value', header: true }
+      ],
+      ['Dependencies Found', manifest.dependencies.length.toString()],
+      ['Files Scanned', statistics.filesScanned.toString()],
+      ['LLM Calls', statistics.llmCalls.toString()],
+      ['Total Tokens Used', statistics.totalTokens.toString()],
+      ['Average Confidence', `${(manifest.statistics.averageConfidence * 100).toFixed(1)}%`],
+      ['Analysis Time', `${(statistics.totalLatencyMs / 1000).toFixed(2)}s`]
+    ])
+    .addRaw('\n')
+    .addHeading('📊 Dependencies by Type', 3)
+    .addList(Object.entries(manifest.statistics.byType).map(([type, count]) => `${type}: ${count}`))
+    .addRaw('\n')
+    .addHeading('🔧 Dependencies by Access Method', 3)
+    .addList(
+      Object.entries(manifest.statistics.byAccessMethod).map(
+        ([method, count]) => `${method}: ${count}`
+      )
+    )
+    .write();
+}
+
+/**
+ * Create a summary for detected dependencies
+ */
+export async function createDependencyListSummary(
+  dependencies: Array<{ name: string; url: string; type: string; confidence: number }>
+): Promise<void> {
+  if (dependencies.length === 0) {
+    await core.summary
+      .addHeading('No Dependencies Found')
+      .addRaw('No external informational dependencies were detected in this repository.')
+      .write();
+    return;
+  }
+
+  await core.summary
+    .addHeading('🔗 Detected Dependencies', 3)
+    .addTable([
+      [
+        { data: 'Name', header: true },
+        { data: 'Type', header: true },
+        { data: 'Confidence', header: true },
+        { data: 'URL', header: true }
+      ],
+      ...dependencies
+        .slice(0, 20)
+        .map((dep) => [
+          dep.name,
+          dep.type,
+          `${(dep.confidence * 100).toFixed(0)}%`,
+          `[Link](${dep.url})`
+        ])
+    ])
+    .write();
+
+  if (dependencies.length > 20) {
+    await core.summary.addRaw(`\n_...and ${dependencies.length - 20} more dependencies_\n`).write();
+  }
+}
+
+/**
+ * Set outputs for the update action
+ */
+function countDependencyDiffs(
+  existingManifest: DependencyManifest,
+  updatedManifest: DependencyManifest
+): { added: number; removed: number } {
+  const existingSet = new Set(existingManifest.dependencies.map((dep) => JSON.stringify(dep)));
+  const updatedSet = new Set(updatedManifest.dependencies.map((dep) => JSON.stringify(dep)));
+
+  let added = 0;
+  for (const dep of updatedSet) {
+    if (!existingSet.has(dep)) {
+      added++;
+    }
+  }
+
+  let removed = 0;
+  for (const dep of existingSet) {
+    if (!updatedSet.has(dep)) {
+      removed++;
+    }
+  }
+
+  return { added, removed };
+}
+
+export function setUpdateOutputs(
+  updatedManifest: DependencyManifest,
+  existingManifest: DependencyManifest,
+  filesChanged: number
+): void {
+  const { added, removed } = countDependencyDiffs(existingManifest, updatedManifest);
+  const changesDetected = added > 0 || removed > 0;
+
+  core.setOutput('changes_detected', changesDetected);
+  core.setOutput('dependencies_added', added);
+  core.setOutput('dependencies_removed', removed);
+  core.setOutput('total_dependencies', updatedManifest.dependencies.length);
+  core.setOutput('files_analyzed', filesChanged);
+}
+
+/**
+ * Create a summary report for the update action
+ */
+export async function createUpdateSummary(
+  existingManifest: DependencyManifest,
+  updatedManifest: DependencyManifest,
+  stats: {
+    commitsAnalyzed: number;
+    filesChanged: number;
+    urlsAdded: number;
+    urlsRemoved: number;
+  }
+): Promise<void> {
+  const dependenciesAdded =
+    updatedManifest.dependencies.length - existingManifest.dependencies.length;
+  const changesDetected = dependenciesAdded !== 0;
+
+  await core.summary
+    .addHeading('🔄 Manifest Update Complete')
+    .addRaw('\n')
+    .addTable([
+      [
+        { data: 'Metric', header: true },
+        { data: 'Value', header: true }
+      ],
+      ['Commits Analyzed', stats.commitsAnalyzed.toString()],
+      ['Files Changed', stats.filesChanged.toString()],
+      ['URLs Added', stats.urlsAdded.toString()],
+      ['URLs Removed', stats.urlsRemoved.toString()],
+      ['Dependencies Before', existingManifest.dependencies.length.toString()],
+      ['Dependencies After', updatedManifest.dependencies.length.toString()],
+      [
+        'Net Change',
+        dependenciesAdded >= 0 ? `+${dependenciesAdded}` : dependenciesAdded.toString()
+      ],
+      ['Changes Detected', changesDetected ? '✅ Yes' : '❌ No']
+    ])
+    .write();
+
+  if (dependenciesAdded > 0) {
+    const newDeps = updatedManifest.dependencies
+      .filter((dep) => !existingManifest.dependencies.some((existing) => existing.url === dep.url))
+      .slice(0, 10);
+
+    if (newDeps.length > 0) {
+      await core.summary
+        .addHeading('🆕 New Dependencies', 3)
+        .addList(newDeps.map((dep) => `**${dep.name}**: ${dep.url} (${dep.type})`))
+        .write();
+    }
+  }
+}

package/src/utils/performance.ts

@@ -0,0 +1,248 @@
+/**
+ * Performance metrics tracking for operations
+ * Tracks operation durations, API quotas, and resource usage
+ */
+
+export interface OperationMetrics {
+  operationId?: string | undefined;
+  name: string;
+  startTime: number;
+  endTime?: number | undefined;
+  duration?: number | undefined;
+  status: 'running' | 'completed' | 'failed';
+  metadata?: Record<string, unknown> | undefined;
+}
+
+export interface APIQuotaMetrics {
+  limit: number;
+  remaining: number;
+  used: number;
+  resetAt: Date;
+  percentUsed: number;
+}
+
+export interface PerformanceReport {
+  totalOperations: number;
+  completedOperations: number;
+  failedOperations: number;
+  averageDuration: number;
+  totalDuration: number;
+  apiQuota?: APIQuotaMetrics | undefined;
+  operations: OperationMetrics[];
+}
+
+/**
+ * Performance metrics tracker
+ */
+export class PerformanceTracker {
+  private operations: Map<string, OperationMetrics>;
+  private completedOperations: OperationMetrics[];
+  private apiQuota?: APIQuotaMetrics | undefined;
+
+  constructor() {
+    this.operations = new Map();
+    this.completedOperations = [];
+    this.apiQuota = undefined;
+  }
+
+  /**
+   * Start tracking an operation
+   */
+  startOperation(name: string, metadata?: Record<string, unknown>): string {
+    const operationId = `${name}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+
+    const metrics: OperationMetrics = {
+      operationId,
+      name,
+      startTime: Date.now(),
+      status: 'running',
+      metadata
+    };
+
+    this.operations.set(operationId, metrics);
+    return operationId;
+  }
+
+  /**
+   * End tracking an operation
+   */
+  endOperation(operationId: string, status: 'completed' | 'failed' = 'completed'): void {
+    const metrics = this.operations.get(operationId);
+    if (!metrics) {
+      return;
+    }
+
+    metrics.endTime = Date.now();
+    metrics.duration = metrics.endTime - metrics.startTime;
+    metrics.status = status;
+
+    this.completedOperations.push(metrics);
+    this.operations.delete(operationId);
+  }
+
+  /**
+   * Update API quota metrics
+   */
+  updateAPIQuota(quota: { limit: number; remaining: number; used: number; reset: number }): void {
+    this.apiQuota = {
+      limit: quota.limit,
+      remaining: quota.remaining,
+      used: quota.used,
+      resetAt: new Date(quota.reset * 1000),
+      percentUsed: (quota.used / quota.limit) * 100
+    };
+  }
+
+  /**
+   * Get current API quota status
+   */
+  getAPIQuota(): APIQuotaMetrics | undefined {
+    return this.apiQuota;
+  }
+
+  /**
+   * Get metrics for a specific operation
+   */
+  getOperation(operationId: string): OperationMetrics | undefined {
+    return (
+      this.operations.get(operationId) ||
+      this.completedOperations.find((op) => op.operationId === operationId)
+    );
+  }
+
+  /**
+   * Get all running operations
+   */
+  getRunningOperations(): OperationMetrics[] {
+    return Array.from(this.operations.values());
+  }
+
+  /**
+   * Get all completed operations
+   */
+  getCompletedOperations(): OperationMetrics[] {
+    return this.completedOperations;
+  }
+
+  /**
+   * Generate performance report
+   */
+  generateReport(): PerformanceReport {
+    const allOperations = this.completedOperations;
+    const completed = allOperations.filter((op) => op.status === 'completed');
+    const failed = allOperations.filter((op) => op.status === 'failed');
+
+    const durations = completed.filter((op) => op.duration !== undefined).map((op) => op.duration!);
+
+    const totalDuration = durations.reduce((sum, d) => sum + d, 0);
+    const averageDuration = durations.length > 0 ? totalDuration / durations.length : 0;
+
+    return {
+      totalOperations: allOperations.length,
+      completedOperations: completed.length,
+      failedOperations: failed.length,
+      averageDuration,
+      totalDuration,
+      apiQuota: this.apiQuota,
+      operations: allOperations
+    };
+  }
+
+  /**
+   * Get operations by name
+   */
+  getOperationsByName(name: string): OperationMetrics[] {
+    return this.completedOperations.filter((op) => op.name === name);
+  }
+
+  /**
+   * Calculate percentile duration for an operation
+   */
+  getOperationPercentile(name: string, percentile: number): number {
+    const operations = this.getOperationsByName(name);
+    const durations = operations
+      .filter((op) => op.duration !== undefined)
+      .map((op) => op.duration!)
+      .sort((a, b) => a - b);
+
+    if (durations.length === 0) {
+      return 0;
+    }
+
+    const index = Math.ceil((percentile / 100) * durations.length) - 1;
+    const value = durations[Math.max(0, index)];
+    return value !== undefined ? value : 0;
+  }
+
+  /**
+   * Clear all metrics
+   */
+  clear(): void {
+    this.operations.clear();
+    this.completedOperations = [];
+    this.apiQuota = undefined;
+  }
+
+  /**
+   * Format metrics as human-readable string
+   */
+  formatReport(report?: PerformanceReport): string {
+    const r = report || this.generateReport();
+    const lines = [
+      'Performance Report',
+      '==================',
+      `Total Operations: ${r.totalOperations}`,
+      `Completed: ${r.completedOperations} | Failed: ${r.failedOperations}`,
+      `Average Duration: ${r.averageDuration.toFixed(2)}ms`,
+      `Total Duration: ${r.totalDuration.toFixed(2)}ms`
+    ];
+
+    if (r.apiQuota) {
+      lines.push('');
+      lines.push('API Quota:');
+      lines.push(
+        `  Used: ${r.apiQuota.used}/${r.apiQuota.limit} (${r.apiQuota.percentUsed.toFixed(1)}%)`
+      );
+      lines.push(`  Remaining: ${r.apiQuota.remaining}`);
+      lines.push(`  Resets at: ${r.apiQuota.resetAt.toISOString()}`);
+    }
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * Global performance tracker instance
+ */
+let globalTracker: PerformanceTracker | undefined;
+
+/**
+ * Get or create global performance tracker
+ */
+export function getPerformanceTracker(): PerformanceTracker {
+  if (!globalTracker) {
+    globalTracker = new PerformanceTracker();
+  }
+  return globalTracker;
+}
+
+/**
+ * Track an async operation
+ */
+export async function trackOperation<T>(
+  name: string,
+  fn: () => Promise<T>,
+  metadata?: Record<string, unknown>
+): Promise<T> {
+  const tracker = getPerformanceTracker();
+  const operationId = tracker.startOperation(name, metadata);
+
+  try {
+    const result = await fn();
+    tracker.endOperation(operationId, 'completed');
+    return result;
+  } catch (error) {
+    tracker.endOperation(operationId, 'failed');
+    throw error;
+  }
+}