@dependabit/monitor 0.1.14 → 0.1.15

package/src/checkers/github-repo.ts

@@ -1,150 +0,0 @@
-/**
- * GitHub Repository Checker
- * Monitors GitHub repositories for new releases and changes
- */
-
-import type { Checker, DependencySnapshot, ChangeDetection, AccessConfig } from '../types.js';
-import crypto from 'node:crypto';
-
-export class GitHubRepoChecker implements Checker {
-  /**
-   * Fetches latest release information from a GitHub repository
-   */
-  async fetch(config: AccessConfig): Promise<DependencySnapshot> {
-    const { url } = config;
-
-    // Extract owner and repo from GitHub URL
-    const match = url.match(/github\.com\/([^/]+)\/([^/]+)/);
-    if (!match || !match[1] || !match[2]) {
-      throw new Error(`Invalid GitHub URL: ${url}`);
-    }
-
-    const owner = match[1];
-    const repo = match[2];
-    const cleanRepo = repo.replace(/\.git$/, '');
-
-    try {
-      // Fetch latest release from GitHub API
-      const apiUrl = `https://api.github.com/repos/${owner}/${cleanRepo}/releases/latest`;
-      const response = await fetch(apiUrl, {
-        headers: {
-          Accept: 'application/vnd.github+json',
-          'User-Agent': 'dependabit',
-          ...(config.auth?.secret && { Authorization: `Bearer ${config.auth.secret}` })
-        }
-      });
-
-      if (response.status === 404) {
-        // No releases found, fall back to latest commit
-        return this.fetchLatestCommit(owner, cleanRepo, config.auth?.secret);
-      }
-
-      if (!response.ok) {
-        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-      }
-
-      const release = (await response.json()) as {
-        tag_name: string;
-        name: string;
-        published_at: string;
-        body: string;
-        html_url: string;
-      };
-
-      // Create state hash from release info
-      const stateContent = JSON.stringify({
-        tagName: release.tag_name,
-        name: release.name,
-        publishedAt: release.published_at
-      });
-      const stateHash = crypto.createHash('sha256').update(stateContent).digest('hex');
-
-      return {
-        version: release.tag_name,
-        stateHash,
-        fetchedAt: new Date(),
-        metadata: {
-          name: release.name,
-          publishedAt: release.published_at,
-          body: release.body,
-          htmlUrl: release.html_url
-        }
-      };
-    } catch (error) {
-      throw new Error(`Failed to fetch GitHub release: ${(error as Error).message}`);
-    }
-  }
-
-  /**
-   * Fallback: Fetch latest commit when no releases exist
-   */
-  private async fetchLatestCommit(
-    owner: string,
-    repo: string,
-    token?: string
-  ): Promise<DependencySnapshot> {
-    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/commits?per_page=1`;
-    const response = await fetch(apiUrl, {
-      headers: {
-        Accept: 'application/vnd.github+json',
-        'User-Agent': 'dependabit',
-        ...(token && { Authorization: `Bearer ${token}` })
-      }
-    });
-
-    if (!response.ok) {
-      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-    }
-
-    const commits = (await response.json()) as Array<{
-      sha: string;
-      commit: {
-        message: string;
-        author: { date: string };
-      };
-    }>;
-
-    if (commits.length === 0 || !commits[0]) {
-      throw new Error('No commits found in repository');
-    }
-
-    const latestCommit = commits[0];
-    const stateHash = latestCommit.sha;
-
-    return {
-      stateHash,
-      fetchedAt: new Date(),
-      metadata: {
-        sha: latestCommit.sha,
-        message: latestCommit.commit.message,
-        date: latestCommit.commit.author.date
-      }
-    };
-  }
-
-  /**
-   * Compares two snapshots to detect version/state changes
-   */
-  async compare(prev: DependencySnapshot, curr: DependencySnapshot): Promise<ChangeDetection> {
-    const changes: string[] = [];
-
-    // Check version change
-    if (prev.version !== curr.version) {
-      if (prev.version && curr.version) {
-        changes.push('version');
-      }
-    }
-
-    // Check state hash change
-    if (prev.stateHash !== curr.stateHash) {
-      changes.push('stateHash');
-    }
-
-    return {
-      hasChanged: changes.length > 0,
-      changes,
-      oldVersion: prev.version,
-      newVersion: curr.version
-    };
-  }
-}

package/src/checkers/index.ts

@@ -1,7 +0,0 @@
-/**
- * Dependency checkers for different access methods
- */
-
-export { GitHubRepoChecker } from './github-repo.js';
-export { URLContentChecker } from './url-content.js';
-export { OpenAPIChecker } from './openapi.js';

package/src/checkers/openapi.ts

@@ -1,310 +0,0 @@
-/**
- * OpenAPI Spec Checker
- * Monitors OpenAPI/Swagger specifications for changes with semantic diffing
- */
-
-import type { Checker, DependencySnapshot, ChangeDetection, AccessConfig } from '../types.js';
-import crypto from 'node:crypto';
-import { parse as parseYAML } from 'yaml';
-
-/**
- * OpenAPI document structure (partial, for what we need)
- */
-interface OpenAPIDocument {
-  openapi?: string;
-  swagger?: string;
-  info?: {
-    title?: string;
-    version?: string;
-    description?: string;
-  };
-  paths?: Record<string, PathItem>;
-  components?: {
-    schemas?: Record<string, unknown>;
-    securitySchemes?: Record<string, unknown>;
-  };
-}
-
-interface PathItem {
-  get?: Operation;
-  post?: Operation;
-  put?: Operation;
-  patch?: Operation;
-  delete?: Operation;
-  options?: Operation;
-  head?: Operation;
-  trace?: Operation;
-  parameters?: unknown[];
-}
-
-interface Operation {
-  operationId?: string;
-  summary?: string;
-  description?: string;
-  parameters?: unknown[];
-  requestBody?: unknown;
-  responses?: Record<string, unknown>;
-  deprecated?: boolean;
-}
-
-/**
- * Semantic diff result for OpenAPI specs
- */
-interface OpenAPIDiff {
-  addedEndpoints: string[];
-  removedEndpoints: string[];
-  modifiedEndpoints: string[];
-  addedSchemas: string[];
-  removedSchemas: string[];
-  modifiedSchemas: string[];
-  versionChanged: boolean;
-  oldVersion?: string;
-  newVersion?: string;
-}
-
-export class OpenAPIChecker implements Checker {
-  /**
-   * Fetches and parses OpenAPI specification
-   */
-  async fetch(config: AccessConfig): Promise<DependencySnapshot> {
-    const { url } = config;
-
-    try {
-      const headers: Record<string, string> = {
-        Accept: 'application/json, application/yaml, text/yaml, */*',
-        'User-Agent': 'dependabit-monitor/1.0'
-      };
-
-      if (config.auth?.secret) {
-        if (config.auth.type === 'token' || config.auth.type === 'oauth') {
-          headers['Authorization'] = `Bearer ${config.auth.secret}`;
-        } else if (config.auth.type === 'basic') {
-          headers['Authorization'] = `Basic ${config.auth.secret}`;
-        }
-      }
-
-      const response = await fetch(url, {
-        headers
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-      }
-
-      const contentType = response.headers.get('content-type') || '';
-      const content = await response.text();
-
-      // Parse the OpenAPI spec
-      let spec: OpenAPIDocument;
-      if (contentType.includes('yaml') || url.endsWith('.yaml') || url.endsWith('.yml')) {
-        // Parse YAML using standard yaml library
-        spec = parseYAML(content) as OpenAPIDocument;
-      } else {
-        spec = JSON.parse(content) as OpenAPIDocument;
-      }
-
-      // Extract key information for semantic comparison
-      const endpoints = this.extractEndpoints(spec);
-      const schemas = this.extractSchemas(spec);
-      const version = spec.info?.version;
-
-      // Create a deterministic hash from the semantic content
-      const semanticContent = JSON.stringify({
-        version,
-        endpoints: Object.keys(endpoints).sort(),
-        schemas: Object.keys(schemas).sort(),
-        endpointDetails: endpoints,
-        schemaDetails: schemas
-      });
-      const stateHash = crypto.createHash('sha256').update(semanticContent).digest('hex');
-
-      return {
-        version,
-        stateHash,
-        fetchedAt: new Date(),
-        metadata: {
-          title: spec.info?.title,
-          description: spec.info?.description,
-          specVersion: spec.openapi || spec.swagger,
-          endpointCount: Object.keys(endpoints).length,
-          schemaCount: Object.keys(schemas).length,
-          endpoints,
-          schemas
-        }
-      };
-    } catch (error) {
-      throw new Error(`Failed to fetch OpenAPI spec: ${(error as Error).message}`);
-    }
-  }
-
-  /**
-   * Extract endpoints from OpenAPI spec
-   */
-  private extractEndpoints(spec: OpenAPIDocument): Record<string, string[]> {
-    const endpoints: Record<string, string[]> = {};
-
-    if (!spec.paths) return endpoints;
-
-    for (const [path, pathItem] of Object.entries(spec.paths)) {
-      const methods: string[] = [];
-      const httpMethods = [
-        'get',
-        'post',
-        'put',
-        'patch',
-        'delete',
-        'options',
-        'head',
-        'trace'
-      ] as const;
-
-      for (const method of httpMethods) {
-        if (pathItem[method]) {
-          methods.push(method.toUpperCase());
-        }
-      }
-
-      if (methods.length > 0) {
-        endpoints[path] = methods;
-      }
-    }
-
-    return endpoints;
-  }
-
-  /**
-   * Extract schemas from OpenAPI spec
-   */
-  private extractSchemas(spec: OpenAPIDocument): Record<string, unknown> {
-    return spec.components?.schemas || {};
-  }
-
-  /**
-   * Compares two OpenAPI snapshots with semantic diffing
-   */
-  async compare(prev: DependencySnapshot, curr: DependencySnapshot): Promise<ChangeDetection> {
-    const changes: string[] = [];
-    let severity: 'breaking' | 'major' | 'minor' = 'minor';
-
-    // Extract endpoints and schemas from metadata
-    let prevEndpoints = (prev.metadata?.['endpoints'] as Record<string, string[]>) || {};
-    let currEndpoints = (curr.metadata?.['endpoints'] as Record<string, string[]>) || {};
-    let prevSchemas = (prev.metadata?.['schemas'] as Record<string, unknown>) || {};
-    let currSchemas = (curr.metadata?.['schemas'] as Record<string, unknown>) || {};
-
-    // If the state hashes match but previous metadata is missing, avoid spurious diffs
-    if (
-      prev.stateHash !== undefined &&
-      curr.stateHash !== undefined &&
-      prev.stateHash === curr.stateHash
-    ) {
-      prevEndpoints = currEndpoints;
-      prevSchemas = currSchemas;
-    }
-    const diff: OpenAPIDiff = {
-      addedEndpoints: [],
-      removedEndpoints: [],
-      modifiedEndpoints: [],
-      addedSchemas: [],
-      removedSchemas: [],
-      modifiedSchemas: [],
-      versionChanged: prev.version !== curr.version
-    };
-
-    if (prev.version !== undefined) {
-      diff.oldVersion = prev.version;
-    }
-
-    if (curr.version !== undefined) {
-      diff.newVersion = curr.version;
-    }
-
-    // Compare endpoints
-    const prevEndpointKeys = Object.keys(prevEndpoints);
-    const currEndpointKeys = Object.keys(currEndpoints);
-
-    for (const path of currEndpointKeys) {
-      if (!prevEndpointKeys.includes(path)) {
-        diff.addedEndpoints.push(path);
-      } else if (JSON.stringify(prevEndpoints[path]) !== JSON.stringify(currEndpoints[path])) {
-        diff.modifiedEndpoints.push(path);
-      }
-    }
-
-    for (const path of prevEndpointKeys) {
-      if (!currEndpointKeys.includes(path)) {
-        diff.removedEndpoints.push(path);
-      }
-    }
-
-    // Compare schemas
-    const prevSchemaKeys = Object.keys(prevSchemas);
-    const currSchemaKeys = Object.keys(currSchemas);
-
-    for (const schema of currSchemaKeys) {
-      if (!prevSchemaKeys.includes(schema)) {
-        diff.addedSchemas.push(schema);
-      } else if (JSON.stringify(prevSchemas[schema]) !== JSON.stringify(currSchemas[schema])) {
-        diff.modifiedSchemas.push(schema);
-      }
-    }
-
-    for (const schema of prevSchemaKeys) {
-      if (!currSchemaKeys.includes(schema)) {
-        diff.removedSchemas.push(schema);
-      }
-    }
-
-    // Determine changes and severity
-    if (diff.removedEndpoints.length > 0) {
-      changes.push('endpoints_removed');
-      severity = 'breaking';
-    }
-
-    if (diff.removedSchemas.length > 0) {
-      changes.push('schemas_removed');
-      severity = 'breaking';
-    }
-
-    if (diff.modifiedEndpoints.length > 0) {
-      changes.push('endpoints_modified');
-      if (severity !== 'breaking') severity = 'major';
-    }
-
-    if (diff.modifiedSchemas.length > 0) {
-      changes.push('schemas_modified');
-      if (severity !== 'breaking') severity = 'major';
-    }
-
-    if (diff.addedEndpoints.length > 0) {
-      changes.push('endpoints_added');
-    }
-
-    if (diff.addedSchemas.length > 0) {
-      changes.push('schemas_added');
-    }
-
-    if (diff.versionChanged) {
-      changes.push('version');
-    }
-
-    // Check overall hash change
-    if (prev.stateHash !== curr.stateHash && changes.length === 0) {
-      changes.push('content');
-    }
-
-    const result: ChangeDetection = {
-      hasChanged: changes.length > 0,
-      changes,
-      oldVersion: prev.version,
-      newVersion: curr.version,
-      diff
-    };
-
-    if (changes.length > 0) {
-      result.severity = severity;
-    }
-
-    return result;
-  }
-}

package/src/checkers/url-content.ts

@@ -1,78 +0,0 @@
-/**
- * URL Content Checker
- * Monitors documentation URLs for content changes using SHA256 hashing
- */
-
-import type { Checker, DependencySnapshot, ChangeDetection, AccessConfig } from '../types.js';
-import { normalizeHTML } from '../normalizer.js';
-import crypto from 'node:crypto';
-
-export class URLContentChecker implements Checker {
-  /**
-   * Fetches and hashes URL content
-   */
-  async fetch(config: AccessConfig): Promise<DependencySnapshot> {
-    const { url } = config;
-
-    try {
-      const response = await fetch(url, {
-        headers: {
-          'User-Agent': 'dependabit-monitor/1.0'
-        }
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-      }
-
-      const contentType = response.headers.get('content-type') || '';
-      const content = await response.text();
-
-      let normalizedContent: string;
-
-      // Apply HTML normalization if content is HTML
-      if (
-        contentType.includes('text/html') ||
-        content.trim().startsWith('<!DOCTYPE') ||
-        content.trim().startsWith('<html')
-      ) {
-        normalizedContent = normalizeHTML(content);
-      } else {
-        // For non-HTML content (markdown, plain text, etc.), just normalize whitespace
-        normalizedContent = content.replace(/\s+/g, ' ').trim();
-      }
-
-      // Generate SHA256 hash of normalized content
-      const stateHash = crypto.createHash('sha256').update(normalizedContent).digest('hex');
-
-      return {
-        stateHash,
-        fetchedAt: new Date(),
-        metadata: {
-          contentType,
-          contentLength: content.length,
-          normalizedLength: normalizedContent.length
-        }
-      };
-    } catch (error) {
-      throw new Error(`Failed to fetch URL content: ${(error as Error).message}`);
-    }
-  }
-
-  /**
-   * Compares two snapshots to detect content changes
-   */
-  async compare(prev: DependencySnapshot, curr: DependencySnapshot): Promise<ChangeDetection> {
-    const changes: string[] = [];
-
-    // Content changed if hashes differ
-    if (prev.stateHash !== curr.stateHash) {
-      changes.push('content');
-    }
-
-    return {
-      hasChanged: changes.length > 0,
-      changes
-    };
-  }
-}

package/src/comparator.ts

@@ -1,68 +0,0 @@
-/**
- * State Comparator
- * Generic comparison logic for dependency state snapshots
- */
-
-import type { DependencySnapshot, ChangeDetection } from './types.js';
-
-export class StateComparator {
-  /**
-   * Compares two dependency snapshots to detect changes
-   */
-  compare(oldState: DependencySnapshot, newState: DependencySnapshot): ChangeDetection {
-    const changes: string[] = [];
-
-    // Check state hash
-    if (oldState.stateHash !== newState.stateHash) {
-      changes.push('stateHash');
-    }
-
-    // Check version
-    if (oldState.version !== newState.version) {
-      changes.push('version');
-    }
-
-    // Check metadata changes (shallow comparison)
-    if (this.hasMetadataChanges(oldState.metadata, newState.metadata)) {
-      changes.push('metadata');
-    }
-
-    return {
-      hasChanged: changes.length > 0,
-      changes,
-      oldVersion: oldState.version,
-      newVersion: newState.version
-    };
-  }
-
-  /**
-   * Checks if metadata has changed (shallow comparison)
-   */
-  private hasMetadataChanges(
-    oldMeta?: Record<string, unknown>,
-    newMeta?: Record<string, unknown>
-  ): boolean {
-    if (!oldMeta && !newMeta) {
-      return false;
-    }
-
-    if (!oldMeta || !newMeta) {
-      return true;
-    }
-
-    const oldKeys = Object.keys(oldMeta);
-    const newKeys = Object.keys(newMeta);
-
-    if (oldKeys.length !== newKeys.length) {
-      return true;
-    }
-
-    for (const key of oldKeys) {
-      if (oldMeta[key] !== newMeta[key]) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-/**
- * @dependabit/monitor - Dependency change detection and monitoring
- */
-
-export { Monitor } from './monitor.js';
-export type { DependencyConfig, CheckResult } from './monitor.js';
-
-export { GitHubRepoChecker } from './checkers/github-repo.js';
-export { URLContentChecker } from './checkers/url-content.js';
-export { OpenAPIChecker } from './checkers/openapi.js';
-
-export { StateComparator } from './comparator.js';
-export { SeverityClassifier } from './severity.js';
-export type { Severity } from './severity.js';
-
-export { normalizeHTML, normalizeURL } from './normalizer.js';
-
-export { Scheduler } from './scheduler.js';
-
-export type { Checker, DependencySnapshot, ChangeDetection, AccessConfig } from './types.js';