@dependabit/action 0.1.1

package/test/actions/validate.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { validateAction } from '../../src/actions/validate.js';
+import type { DependencyManifest, DependabitConfig } from '@dependabit/manifest';
+
+// Mock the manifest module
+vi.mock('@dependabit/manifest', async () => {
+  const actual = await vi.importActual('@dependabit/manifest');
+  return {
+    ...actual,
+    readManifest: vi.fn(),
+    validateManifest: vi.fn(),
+    readConfig: vi.fn()
+  };
+});
+
+describe('Validate Action', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('validateAction', () => {
+    it('should validate a valid manifest successfully', async () => {
+      const { readManifest, validateManifest } = await import('@dependabit/manifest');
+
+      const validManifest: DependencyManifest = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot',
+          llmModel: 'gpt-4'
+        },
+        repository: {
+          owner: 'test-owner',
+          name: 'test-repo',
+          branch: 'main',
+          commit: 'abc123'
+        },
+        dependencies: [
+          {
+            id: '550e8400-e29b-41d4-a716-446655440000',
+            url: 'https://github.com/microsoft/TypeScript',
+            type: 'reference-implementation',
+            accessMethod: 'github-api',
+            name: 'TypeScript',
+            currentStateHash: 'hash1',
+            detectionMethod: 'package-json',
+            detectionConfidence: 1.0,
+            detectedAt: new Date().toISOString(),
+            lastChecked: new Date().toISOString(),
+            referencedIn: [{ file: 'package.json', line: 15 }],
+            changeHistory: []
+          }
+        ],
+        statistics: {
+          totalDependencies: 1,
+          byType: { 'reference-implementation': 1 },
+          byAccessMethod: { 'github-api': 1 },
+          byDetectionMethod: { 'package-json': 1 },
+          averageConfidence: 1.0
+        }
+      };
+
+      vi.mocked(readManifest).mockResolvedValue(validManifest);
+      vi.mocked(validateManifest).mockReturnValue(validManifest);
+
+      const result = await validateAction('.dependabit/manifest.json');
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      expect(readManifest).toHaveBeenCalledWith('.dependabit/manifest.json');
+    });
+
+    it('should detect schema validation errors', async () => {
+      const { readManifest, validateManifest } = await import('@dependabit/manifest');
+
+      const invalidManifest = {
+        version: '2.0.0', // Invalid version
+        dependencies: []
+      };
+
+      vi.mocked(readManifest).mockResolvedValue(invalidManifest as any);
+      vi.mocked(validateManifest).mockImplementation(() => {
+        throw new Error('Invalid manifest version');
+      });
+
+      const result = await validateAction('.dependabit/manifest.json');
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0]).toContain('Invalid manifest version');
+    });
+
+    it('should detect duplicate dependency IDs', async () => {
+      const { readManifest, validateManifest } = await import('@dependabit/manifest');
+
+      const duplicateManifest: DependencyManifest = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot'
+        },
+        repository: {
+          owner: 'test',
+          name: 'test',
+          branch: 'main',
+          commit: 'abc'
+        },
+        dependencies: [
+          {
+            id: '550e8400-e29b-41d4-a716-446655440000',
+            url: 'https://github.com/owner/repo1',
+            type: 'reference-implementation',
+            accessMethod: 'github-api',
+            name: 'Repo1',
+            currentStateHash: 'hash1',
+            detectionMethod: 'manual',
+            detectionConfidence: 1.0,
+            detectedAt: new Date().toISOString(),
+            lastChecked: new Date().toISOString(),
+            referencedIn: [],
+            changeHistory: []
+          },
+          {
+            id: '550e8400-e29b-41d4-a716-446655440000', // Duplicate ID
+            url: 'https://github.com/owner/repo2',
+            type: 'reference-implementation',
+            accessMethod: 'github-api',
+            name: 'Repo2',
+            currentStateHash: 'hash2',
+            detectionMethod: 'manual',
+            detectionConfidence: 1.0,
+            detectedAt: new Date().toISOString(),
+            lastChecked: new Date().toISOString(),
+            referencedIn: [],
+            changeHistory: []
+          }
+        ],
+        statistics: {
+          totalDependencies: 2,
+          byType: { 'reference-implementation': 2 },
+          byAccessMethod: { 'github-api': 2 },
+          byDetectionMethod: { manual: 2 },
+          averageConfidence: 1.0
+        }
+      };
+
+      vi.mocked(readManifest).mockResolvedValue(duplicateManifest);
+      vi.mocked(validateManifest).mockReturnValue(duplicateManifest);
+
+      const result = await validateAction('.dependabit/manifest.json');
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('duplicate') || e.includes('Duplicate'))).toBe(
+        true
+      );
+    });
+
+    it('should detect invalid URLs', async () => {
+      const { readManifest, validateManifest } = await import('@dependabit/manifest');
+
+      const invalidUrlManifest: any = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot'
+        },
+        repository: {
+          owner: 'test',
+          name: 'test',
+          branch: 'main',
+          commit: 'abc'
+        },
+        dependencies: [
+          {
+            id: '550e8400-e29b-41d4-a716-446655440000',
+            url: 'not-a-valid-url',
+            type: 'reference-implementation',
+            accessMethod: 'github-api',
+            name: 'Invalid',
+            currentStateHash: 'hash1',
+            detectionMethod: 'manual',
+            detectionConfidence: 1.0,
+            detectedAt: new Date().toISOString(),
+            lastChecked: new Date().toISOString(),
+            referencedIn: [],
+            changeHistory: []
+          }
+        ],
+        statistics: {
+          totalDependencies: 1,
+          byType: { 'reference-implementation': 1 },
+          byAccessMethod: { 'github-api': 1 },
+          byDetectionMethod: { manual: 1 },
+          averageConfidence: 1.0
+        }
+      };
+
+      vi.mocked(readManifest).mockResolvedValue(invalidUrlManifest);
+      vi.mocked(validateManifest).mockImplementation(() => {
+        throw new Error('Invalid URL format');
+      });
+
+      const result = await validateAction('.dependabit/manifest.json');
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('URL') || e.includes('url'))).toBe(true);
+    });
+
+    it('should validate with config file when provided', async () => {
+      const { readManifest, readConfig, validateManifest } = await import('@dependabit/manifest');
+
+      const manifest: DependencyManifest = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot'
+        },
+        repository: {
+          owner: 'test',
+          name: 'test',
+          branch: 'main',
+          commit: 'abc'
+        },
+        dependencies: [],
+        statistics: {
+          totalDependencies: 0,
+          byType: {},
+          byAccessMethod: {},
+          byDetectionMethod: {},
+          averageConfidence: 0
+        }
+      };
+
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' }
+      };
+
+      vi.mocked(readManifest).mockResolvedValue(manifest);
+      vi.mocked(readConfig).mockResolvedValue(config);
+      vi.mocked(validateManifest).mockReturnValue(manifest);
+
+      const result = await validateAction('.dependabit/manifest.json', '.dependabit/config.yml');
+
+      expect(result.valid).toBe(true);
+      expect(readConfig).toHaveBeenCalledWith('.dependabit/config.yml');
+    });
+  });
+});

package/test/utils/agent-config.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'vitest';
+import { parseAgentConfig, type AgentAssignmentConfig } from '../../src/utils/agent-config.js';
+import type { DependabitConfig } from '@dependabit/manifest';
+
+describe('Agent Config Parser', () => {
+  describe('parseAgentConfig', () => {
+    it('should parse agent assignment configuration', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' },
+        issues: {
+          labels: ['dependabit'],
+          assignees: [],
+          aiAgentAssignment: {
+            enabled: true,
+            breaking: 'copilot',
+            major: 'claude',
+            minor: 'copilot'
+          }
+        }
+      };
+
+      const result = parseAgentConfig(config);
+
+      expect(result.enabled).toBe(true);
+      expect(result.severityMapping).toEqual({
+        breaking: 'copilot',
+        major: 'claude',
+        minor: 'copilot'
+      });
+    });
+
+    it('should return disabled config when aiAgentAssignment is not set', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' }
+      };
+
+      const result = parseAgentConfig(config);
+
+      expect(result.enabled).toBe(false);
+      expect(result.severityMapping).toEqual({});
+    });
+
+    it('should return disabled config when aiAgentAssignment is explicitly disabled', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' },
+        issues: {
+          labels: ['dependabit'],
+          assignees: [],
+          aiAgentAssignment: {
+            enabled: false,
+            breaking: 'copilot'
+          }
+        }
+      };
+
+      const result = parseAgentConfig(config);
+
+      expect(result.enabled).toBe(false);
+    });
+
+    it('should handle partial severity mappings', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' },
+        issues: {
+          labels: ['dependabit'],
+          assignees: [],
+          aiAgentAssignment: {
+            enabled: true,
+            breaking: 'copilot'
+            // major and minor not specified
+          }
+        }
+      };
+
+      const result = parseAgentConfig(config);
+
+      expect(result.enabled).toBe(true);
+      expect(result.severityMapping.breaking).toBe('copilot');
+      expect(result.severityMapping.major).toBeUndefined();
+      expect(result.severityMapping.minor).toBeUndefined();
+    });
+
+    it('should normalize agent names to lowercase', () => {
+      const config: DependabitConfig = {
+        version: '1',
+        schedule: { interval: 'daily', timezone: 'UTC' },
+        issues: {
+          labels: ['dependabit'],
+          assignees: [],
+          aiAgentAssignment: {
+            enabled: true,
+            breaking: 'COPILOT',
+            major: 'Claude',
+            minor: 'CoPiLoT'
+          }
+        }
+      };
+
+      const result = parseAgentConfig(config);
+
+      expect(result.severityMapping).toEqual({
+        breaking: 'copilot',
+        major: 'claude',
+        minor: 'copilot'
+      });
+    });
+  });
+});

package/test/utils/agent-router.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import {
+  routeToAgent,
+  getAssigneeLabel,
+  type AgentAssignmentConfig
+} from '../../src/utils/agent-router.js';
+import type { Severity } from '@dependabit/manifest';
+
+describe('Agent Router', () => {
+  describe('routeToAgent', () => {
+    it('should route breaking changes to configured agent', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {
+          breaking: 'copilot',
+          major: 'claude',
+          minor: 'copilot'
+        }
+      };
+
+      const result = routeToAgent('breaking', config);
+
+      expect(result).toBe('copilot');
+    });
+
+    it('should route major changes to configured agent', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {
+          breaking: 'copilot',
+          major: 'claude',
+          minor: 'copilot'
+        }
+      };
+
+      const result = routeToAgent('major', config);
+
+      expect(result).toBe('claude');
+    });
+
+    it('should route minor changes to configured agent', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {
+          breaking: 'copilot',
+          major: 'claude',
+          minor: 'copilot'
+        }
+      };
+
+      const result = routeToAgent('minor', config);
+
+      expect(result).toBe('copilot');
+    });
+
+    it('should return null when routing is disabled', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: false,
+        severityMapping: {
+          breaking: 'copilot'
+        }
+      };
+
+      const result = routeToAgent('breaking', config);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when no mapping exists for severity', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {
+          breaking: 'copilot'
+          // major and minor not specified
+        }
+      };
+
+      const result = routeToAgent('major', config);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for unknown severity levels', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {
+          breaking: 'copilot',
+          major: 'claude',
+          minor: 'copilot'
+        }
+      };
+
+      const result = routeToAgent('unknown' as Severity, config);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle empty severity mapping', () => {
+      const config: AgentAssignmentConfig = {
+        enabled: true,
+        severityMapping: {}
+      };
+
+      const result = routeToAgent('breaking', config);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getAssigneeLabel', () => {
+    it('should generate assignee label for copilot', () => {
+      const result = getAssigneeLabel('copilot');
+
+      expect(result).toBe('assigned:copilot');
+    });
+
+    it('should generate assignee label for claude', () => {
+      const result = getAssigneeLabel('claude');
+
+      expect(result).toBe('assigned:claude');
+    });
+
+    it('should handle null agent gracefully', () => {
+      const result = getAssigneeLabel(null);
+
+      expect(result).toBeNull();
+    });
+  });
+});