@dependabit/manifest 0.1.1

package/src/config.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import {
+  readConfig,
+  parseConfig,
+  stringifyConfig,
+  getEffectiveMonitoringRules,
+  shouldIgnoreUrl
+} from '../src/config.js';
+import type { DependabitConfig } from '../src/schema.js';
+
+const TEST_DIR = '/tmp/dependabit-config-tests';
+
+describe('Config Operations Tests', () => {
+  beforeEach(async () => {
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe('readConfig and parseConfig', () => {
+    it('should parse valid YAML config', async () => {
+      const yaml = `
+version: "1"
+llm:
+  provider: github-copilot
+  model: gpt-4
+  maxTokens: 4000
+  temperature: 0.3
+schedule:
+  interval: daily
+  time: "02:00"
+  timezone: UTC
+`;
+
+      const config = parseConfig(yaml);
+      expect(config.version).toBe('1');
+      expect(config.llm?.provider).toBe('github-copilot');
+      expect(config.schedule.interval).toBe('daily');
+    });
+
+    it('should read config from file', async () => {
+      const yaml = `
+version: "1"
+schedule:
+  interval: weekly
+  day: monday
+`;
+
+      const path = join(TEST_DIR, 'config.yml');
+      await writeFile(path, yaml, 'utf-8');
+
+      const config = await readConfig(path);
+      expect(config.version).toBe('1');
+      expect(config.schedule.interval).toBe('weekly');
+    });
+
+    it('should apply defaults for missing fields', () => {
+      const yaml = `
+version: "1"
+`;
+
+      const config = parseConfig(yaml);
+      expect(config.schedule.interval).toBe('daily');
+      expect(config.schedule.timezone).toBe('UTC');
+    });
+
+    it('should validate config structure', () => {
+      const invalidYaml = `
+version: "2"
+`;
+
+      expect(() => parseConfig(invalidYaml)).toThrow();
+    });
+  });
+
+  describe('stringifyConfig', () => {
+    it('should convert config to YAML', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        }
+      };
+
+      const yaml = stringifyConfig(config);
+      expect(yaml).toContain('version:');
+      expect(yaml).toContain('daily');
+    });
+
+    it('should validate before stringifying', () => {
+      const invalid = {
+        version: '2'
+      } as any;
+
+      expect(() => stringifyConfig(invalid)).toThrow();
+    });
+  });
+
+  describe('getEffectiveMonitoringRules', () => {
+    it('should return global defaults when no override', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        monitoring: {
+          enabled: true,
+          autoUpdate: true,
+          falsePositiveThreshold: 0.1
+        }
+      };
+
+      const rules = getEffectiveMonitoringRules(config, 'https://github.com/microsoft/TypeScript');
+
+      expect(rules.enabled).toBe(true);
+      expect(rules.checkFrequency).toBe('daily');
+      expect(rules.ignoreChanges).toBe(false);
+    });
+
+    it('should apply dependency-specific overrides', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        dependencies: [
+          {
+            url: 'https://github.com/microsoft/TypeScript',
+            schedule: {
+              interval: 'hourly',
+              timezone: 'UTC'
+            },
+            monitoring: {
+              enabled: true,
+              checkFrequency: 'hourly',
+              ignoreChanges: false
+            }
+          }
+        ]
+      };
+
+      const rules = getEffectiveMonitoringRules(config, 'https://github.com/microsoft/TypeScript');
+
+      expect(rules.checkFrequency).toBe('hourly');
+    });
+
+    it('should merge global and override settings', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        monitoring: {
+          enabled: true,
+          autoUpdate: true,
+          falsePositiveThreshold: 0.1
+        },
+        dependencies: [
+          {
+            url: 'https://github.com/microsoft/TypeScript',
+            monitoring: {
+              enabled: true,
+              checkFrequency: 'hourly',
+              ignoreChanges: true
+            }
+          }
+        ]
+      };
+
+      const rules = getEffectiveMonitoringRules(config, 'https://github.com/microsoft/TypeScript');
+
+      expect(rules.enabled).toBe(true);
+      expect(rules.checkFrequency).toBe('hourly');
+      expect(rules.ignoreChanges).toBe(true);
+    });
+  });
+
+  describe('shouldIgnoreUrl', () => {
+    it('should return false when no ignore rules', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        }
+      };
+
+      expect(shouldIgnoreUrl(config, 'https://github.com/test/repo')).toBe(false);
+    });
+
+    it('should match exact URLs', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        ignore: {
+          urls: ['https://example.com/deprecated']
+        }
+      };
+
+      expect(shouldIgnoreUrl(config, 'https://example.com/deprecated')).toBe(true);
+      expect(shouldIgnoreUrl(config, 'https://example.com/current')).toBe(false);
+    });
+
+    it('should match regex patterns', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        ignore: {
+          patterns: ['.*\\.example\\.com.*', '.*deprecated.*']
+        }
+      };
+
+      expect(shouldIgnoreUrl(config, 'https://subdomain.example.com/path')).toBe(true);
+      expect(shouldIgnoreUrl(config, 'https://github.com/deprecated-repo')).toBe(true);
+      expect(shouldIgnoreUrl(config, 'https://github.com/active-repo')).toBe(false);
+    });
+
+    it('should match either URLs or patterns', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        ignore: {
+          urls: ['https://exact-match.com'],
+          patterns: ['.*pattern.*']
+        }
+      };
+
+      expect(shouldIgnoreUrl(config, 'https://exact-match.com')).toBe(true);
+      expect(shouldIgnoreUrl(config, 'https://some-pattern-match.com')).toBe(true);
+    });
+
+    it('should handle invalid regex patterns gracefully', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        },
+        ignore: {
+          patterns: ['[invalid', '.*valid.*']
+        }
+      };
+
+      // Invalid pattern should be skipped, valid pattern should work
+      expect(shouldIgnoreUrl(config, 'https://validurl.com')).toBe(true);
+      expect(shouldIgnoreUrl(config, 'https://other.com')).toBe(false);
+    });
+  });
+});

package/src/config.ts

@@ -0,0 +1,96 @@
+import { readFile } from 'node:fs/promises';
+import YAML from 'yaml';
+import { type DependabitConfig } from './schema.js';
+import { validateConfig } from './validator.js';
+
+/**
+ * Parse and validate a YAML configuration file
+ */
+export async function readConfig(path: string): Promise<DependabitConfig> {
+  const content = await readFile(path, 'utf-8');
+  const data = YAML.parse(content);
+  return validateConfig(data);
+}
+
+/**
+ * Parse YAML string to config
+ */
+export function parseConfig(yaml: string): DependabitConfig {
+  const data = YAML.parse(yaml);
+  return validateConfig(data);
+}
+
+/**
+ * Convert config to YAML string
+ */
+export function stringifyConfig(config: DependabitConfig): string {
+  // Validate before stringifying
+  validateConfig(config);
+  return YAML.stringify(config);
+}
+
+/**
+ * Get effective monitoring rules for a dependency
+ * Merges global config with dependency-specific overrides
+ */
+export function getEffectiveMonitoringRules(
+  config: DependabitConfig,
+  dependencyUrl: string
+): {
+  enabled: boolean;
+  checkFrequency: 'hourly' | 'daily' | 'weekly' | 'monthly';
+  ignoreChanges: boolean;
+} {
+  // Start with global defaults
+  const globalEnabled = config.monitoring?.enabled ?? true;
+  const globalCheckFrequency = config.schedule?.interval ?? 'daily';
+
+  // Find dependency-specific override
+  const override = config.dependencies?.find((dep) => dep.url === dependencyUrl);
+
+  if (override?.monitoring) {
+    return {
+      enabled: override.monitoring.enabled ?? globalEnabled,
+      checkFrequency:
+        override.monitoring.checkFrequency ?? override.schedule?.interval ?? globalCheckFrequency,
+      ignoreChanges: override.monitoring.ignoreChanges ?? false
+    };
+  }
+
+  return {
+    enabled: globalEnabled,
+    checkFrequency: globalCheckFrequency,
+    ignoreChanges: false
+  };
+}
+
+/**
+ * Check if a URL should be ignored based on config
+ */
+export function shouldIgnoreUrl(config: DependabitConfig, url: string): boolean {
+  if (!config.ignore) {
+    return false;
+  }
+
+  // Check exact URL matches
+  if (config.ignore.urls?.includes(url)) {
+    return true;
+  }
+
+  // Check regex patterns with error handling
+  if (config.ignore.patterns) {
+    for (const pattern of config.ignore.patterns) {
+      try {
+        const regex = new RegExp(pattern);
+        if (regex.test(url)) {
+          return true;
+        }
+      } catch {
+        // Invalid regex pattern - log warning but continue
+        console.warn(`Invalid regex pattern in config.ignore.patterns: ${pattern}`);
+      }
+    }
+  }
+
+  return false;
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+// Entry point for @dependabit/manifest
+
+// Export schemas and types
+export * from './schema.js';
+
+// Export validators
+export * from './validator.js';
+
+// Export manifest operations
+export * from './manifest.js';
+
+// Export config operations
+export * from './config.js';
+
+// Export size checking
+export * from './size-check.js';