@dependabit/manifest 0.1.13 → 0.1.15

package/src/schema.ts

@@ -1,266 +0,0 @@
-import { z } from 'zod';
-
-// Version tracking
-export const ManifestVersionSchema = z.literal('1.0.0');
-
-// Access methods (HOW to retrieve/check dependency)
-export const AccessMethodSchema = z.enum(['context7', 'arxiv', 'openapi', 'github-api', 'http']);
-
-// Dependency types (WHAT the dependency represents)
-export const DependencyTypeSchema = z.enum([
-  'reference-implementation',
-  'schema',
-  'documentation',
-  'research-paper',
-  'api-example',
-  'other'
-]);
-
-// Detection methods
-export const DetectionMethodSchema = z.enum([
-  'llm-analysis',
-  'manual',
-  'package-json',
-  'requirements-txt',
-  'code-comment'
-]);
-
-// Severity levels
-export const SeveritySchema = z.enum(['breaking', 'major', 'minor']);
-
-// Authentication configuration
-export const AuthConfigSchema = z
-  .object({
-    type: z.enum(['token', 'basic', 'oauth', 'none']),
-    // Reference to an environment variable or secret identifier.
-    // Do NOT store raw secret values directly in the manifest.
-    secretEnvVar: z.string().optional()
-  })
-  .optional();
-
-// Monitoring rules
-export const MonitoringRulesSchema = z.object({
-  enabled: z.boolean().default(true),
-  checkFrequency: z.enum(['hourly', 'daily', 'weekly', 'monthly']).default('daily'),
-  ignoreChanges: z.boolean().default(false),
-  severityOverride: SeveritySchema.optional()
-});
-
-// Individual dependency entry
-export const DependencyEntrySchema = z.object({
-  id: z.string().uuid(),
-  url: z.string().url(),
-  type: DependencyTypeSchema,
-  accessMethod: AccessMethodSchema,
-  name: z.string(),
-  description: z.string().optional(),
-
-  // Version/state tracking
-  currentVersion: z.string().optional(),
-  currentStateHash: z.string(),
-
-  // Metadata
-  detectionMethod: DetectionMethodSchema,
-  detectionConfidence: z.number().min(0).max(1),
-  detectedAt: z.string().datetime(),
-  lastChecked: z.string().datetime(),
-  lastChanged: z.string().datetime().optional(),
-
-  // Configuration
-  auth: AuthConfigSchema,
-  monitoring: MonitoringRulesSchema.optional(),
-
-  // Relationships
-  referencedIn: z.array(
-    z.object({
-      file: z.string(),
-      line: z.number().optional(),
-      context: z.string().optional()
-    })
-  ),
-
-  // Change history
-  changeHistory: z
-    .array(
-      z.object({
-        detectedAt: z.string().datetime(),
-        oldVersion: z.string().optional(),
-        newVersion: z.string().optional(),
-        severity: SeveritySchema,
-        issueNumber: z.number().optional(),
-        falsePositive: z.boolean().default(false)
-      })
-    )
-    .default([])
-});
-
-// Complete manifest
-export const DependencyManifestSchema = z.object({
-  version: ManifestVersionSchema,
-  generatedAt: z.string().datetime(),
-  generatedBy: z.object({
-    action: z.string(),
-    version: z.string(),
-    llmProvider: z.string(),
-    llmModel: z.string().optional()
-  }),
-
-  repository: z.object({
-    owner: z.string(),
-    name: z.string(),
-    branch: z.string(),
-    commit: z.string()
-  }),
-
-  dependencies: z.array(DependencyEntrySchema),
-
-  statistics: z.object({
-    totalDependencies: z.number(),
-    byType: z.record(z.string(), z.number()),
-    byAccessMethod: z.record(z.string(), z.number()),
-    byDetectionMethod: z.record(z.string(), z.number()),
-    averageConfidence: z.number(),
-    falsePositiveRate: z.number().min(0).max(1).optional()
-  })
-});
-
-// Schedule configuration (dependabot-compatible)
-export const ScheduleSchema = z.object({
-  interval: z.enum(['hourly', 'daily', 'weekly', 'monthly']),
-  day: z
-    .enum(['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'])
-    .optional(),
-  time: z
-    .string()
-    .regex(/^([01]\d|2[0-3]):([0-5]\d)$/)
-    .optional(),
-  timezone: z.string().default('UTC')
-});
-
-// LLM provider configuration
-export const LLMConfigSchema = z.object({
-  provider: z
-    .enum(['github-copilot', 'claude', 'openai', 'azure-openai'])
-    .default('github-copilot'),
-  model: z.string().optional(),
-  maxTokens: z.number().int().positive().default(4000),
-  temperature: z.number().min(0).max(2).default(0.3)
-});
-
-// Issue configuration
-export const IssueConfigSchema = z.object({
-  labels: z.array(z.string()).default(['dependabit', 'dependency-update']),
-  assignees: z.array(z.string()).default([]),
-  aiAgentAssignment: z
-    .object({
-      enabled: z.boolean().default(false),
-      breaking: z.string().optional(),
-      major: z.string().optional(),
-      minor: z.string().optional()
-    })
-    .optional(),
-  titleTemplate: z.string().default('[dependabit] {name}: {change}'),
-  bodyTemplate: z.string().optional()
-});
-
-// Per-dependency override
-export const DependencyOverrideSchema = z.object({
-  url: z.string().url(),
-  schedule: ScheduleSchema.optional(),
-  monitoring: MonitoringRulesSchema.optional(),
-  issues: IssueConfigSchema.optional()
-});
-
-// Complete configuration
-export const DependabitConfigSchema = z.object({
-  version: z.literal('1'),
-
-  // Global settings
-  llm: LLMConfigSchema.optional(),
-  schedule: ScheduleSchema.default({ interval: 'daily', timezone: 'UTC' }),
-  issues: IssueConfigSchema.optional(),
-
-  // Monitoring behavior
-  monitoring: z
-    .object({
-      enabled: z.boolean().default(true),
-      autoUpdate: z.boolean().default(true),
-      falsePositiveThreshold: z.number().min(0).max(1).default(0.1)
-    })
-    .optional(),
-
-  // Dependency-specific overrides
-  dependencies: z.array(DependencyOverrideSchema).optional(),
-
-  // Exclusions
-  ignore: z
-    .object({
-      urls: z.array(z.string()).optional(),
-      types: z.array(DependencyTypeSchema).optional(),
-      patterns: z.array(z.string()).optional(),
-      useGitExcludes: z.boolean().default(true)
-    })
-    .optional()
-});
-
-// Change detection schemas
-export const ChangeTypeSchema = z.enum([
-  'version-bump',
-  'content-changed',
-  'released',
-  'deprecated',
-  'unavailable',
-  'unknown'
-]);
-
-export const ChangeDetectionRecordSchema = z.object({
-  id: z.string().uuid(),
-  timestamp: z.string().datetime(),
-
-  // Dependency reference
-  dependencyId: z.string().uuid(),
-  dependencyUrl: z.string().url(),
-  dependencyName: z.string(),
-
-  // Change details
-  changeType: ChangeTypeSchema,
-  severity: SeveritySchema,
-
-  // State comparison
-  oldState: z.object({
-    version: z.string().optional(),
-    hash: z.string(),
-    checkedAt: z.string().datetime()
-  }),
-  newState: z.object({
-    version: z.string().optional(),
-    hash: z.string(),
-    checkedAt: z.string().datetime()
-  }),
-
-  // Change description
-  summary: z.string(),
-  details: z.string().optional(),
-  breakingChanges: z.array(z.string()).optional(),
-
-  // Action taken
-  issueCreated: z.boolean().default(false),
-  issueNumber: z.number().optional(),
-  issueUrl: z.string().url().optional()
-});
-
-// TypeScript types
-export type DependencyManifest = z.infer<typeof DependencyManifestSchema>;
-export type DependencyEntry = z.infer<typeof DependencyEntrySchema>;
-export type DependencyType = z.infer<typeof DependencyTypeSchema>;
-export type AccessMethod = z.infer<typeof AccessMethodSchema>;
-export type DetectionMethod = z.infer<typeof DetectionMethodSchema>;
-export type Severity = z.infer<typeof SeveritySchema>;
-export type MonitoringRules = z.infer<typeof MonitoringRulesSchema>;
-export type DependabitConfig = z.infer<typeof DependabitConfigSchema>;
-export type Schedule = z.infer<typeof ScheduleSchema>;
-export type LLMConfig = z.infer<typeof LLMConfigSchema>;
-export type IssueConfig = z.infer<typeof IssueConfigSchema>;
-export type DependencyOverride = z.infer<typeof DependencyOverrideSchema>;
-export type ChangeType = z.infer<typeof ChangeTypeSchema>;
-export type ChangeDetectionRecord = z.infer<typeof ChangeDetectionRecordSchema>;

package/src/size-check.test.ts

@@ -1,246 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  checkManifestSize,
-  formatSize,
-  validateManifestObject,
-  estimateEntrySize,
-  canAddEntry
-} from './size-check.js';
-
-describe('checkManifestSize', () => {
-  it('should return ok status for small content', () => {
-    const content = 'small content';
-    const result = checkManifestSize(content);
-
-    expect(result.status).toBe('ok');
-    expect(result.message).toBeUndefined();
-  });
-
-  it('should return warning status when exceeding warn threshold', () => {
-    const content = Buffer.alloc(1.5 * 1024 * 1024); // 1.5 MB
-    const result = checkManifestSize(content);
-
-    expect(result.status).toBe('warning');
-    expect(result.message).toContain('approaching limit');
-  });
-
-  it('should return error status when exceeding error threshold', () => {
-    const content = Buffer.alloc(11 * 1024 * 1024); // 11 MB
-    const result = checkManifestSize(content);
-
-    expect(result.status).toBe('error');
-    expect(result.message).toContain('exceeds maximum limit');
-  });
-
-  it('should handle exact threshold values', () => {
-    const exactWarnSize = 1 * 1024 * 1024; // Exactly 1 MB
-    const result = checkManifestSize(Buffer.alloc(exactWarnSize));
-
-    expect(result.status).toBe('warning');
-  });
-
-  it('should support custom thresholds', () => {
-    const content = Buffer.alloc(2.5 * 1024 * 1024); // 2.5 MB
-    const result = checkManifestSize(content, {
-      warnThreshold: 2,
-      errorThreshold: 5
-    });
-
-    expect(result.status).toBe('warning');
-  });
-
-  it('should handle empty content', () => {
-    const result = checkManifestSize('');
-
-    expect(result.status).toBe('ok');
-    expect(result.sizeBytes).toBe(0);
-    expect(result.sizeMB).toBe(0);
-  });
-
-  it('should handle Buffer input', () => {
-    const buffer = Buffer.from('test content');
-    const result = checkManifestSize(buffer);
-
-    expect(result.sizeBytes).toBe(buffer.length);
-    expect(result.status).toBe('ok');
-  });
-
-  it('should handle string input with multi-byte characters', () => {
-    const content = '你好世界🌍'; // Multi-byte UTF-8 characters
-    const result = checkManifestSize(content);
-
-    expect(result.sizeBytes).toBe(Buffer.byteLength(content, 'utf8'));
-  });
-});
-
-describe('formatSize', () => {
-  it('should format bytes correctly', () => {
-    expect(formatSize(512)).toBe('512 B');
-  });
-
-  it('should format kilobytes correctly', () => {
-    expect(formatSize(1024)).toBe('1.00 KB');
-    expect(formatSize(5 * 1024)).toBe('5.00 KB');
-  });
-
-  it('should format megabytes correctly', () => {
-    expect(formatSize(1024 * 1024)).toBe('1.00 MB');
-    expect(formatSize(2.5 * 1024 * 1024)).toBe('2.50 MB');
-  });
-
-  it('should handle zero', () => {
-    expect(formatSize(0)).toBe('0 B');
-  });
-
-  it('should handle large values', () => {
-    expect(formatSize(100 * 1024 * 1024)).toBe('100.00 MB');
-  });
-});
-
-describe('validateManifestObject', () => {
-  it('should validate small manifest objects', () => {
-    const manifest = { dependencies: [{ id: '1', name: 'test' }] };
-    const result = validateManifestObject(manifest);
-
-    expect(result.status).toBe('ok');
-  });
-
-  it('should detect large manifest objects', () => {
-    const largeDeps = Array.from({ length: 10000 }, (_, i) => ({
-      id: `dep-${i}`,
-      name: `dependency-${i}`,
-      url: `https://github.com/org/repo-${i}`,
-      description: 'A'.repeat(100)
-    }));
-
-    const manifest = { dependencies: largeDeps };
-    const result = validateManifestObject(manifest);
-
-    expect(result.status).not.toBe('ok');
-  });
-
-  it('should handle empty objects', () => {
-    const result = validateManifestObject({});
-
-    expect(result.status).toBe('ok');
-  });
-
-  it('should support custom thresholds', () => {
-    const manifest = { data: 'x'.repeat(500 * 1024) }; // ~500 KB
-    const result = validateManifestObject(manifest, {
-      warnThreshold: 0.4,
-      errorThreshold: 1
-    });
-
-    expect(result.status).toBe('warning');
-  });
-});
-
-describe('estimateEntrySize', () => {
-  it('should estimate size of simple entries', () => {
-    const entry = { id: '1', name: 'test' };
-    const size = estimateEntrySize(entry);
-
-    expect(size).toBeGreaterThan(0);
-    expect(size).toBe(JSON.stringify(entry).length);
-  });
-
-  it('should estimate size of complex entries', () => {
-    const entry = {
-      id: '1',
-      name: 'complex-dependency',
-      metadata: {
-        version: '1.0.0',
-        tags: ['tag1', 'tag2', 'tag3'],
-        description: 'A long description with multiple words'
-      }
-    };
-
-    const size = estimateEntrySize(entry);
-    expect(size).toBeGreaterThan(50);
-  });
-
-  it('should handle null', () => {
-    expect(estimateEntrySize(null)).toBe(4); // "null"
-  });
-
-  it('should handle arrays', () => {
-    const entry = [1, 2, 3];
-    const size = estimateEntrySize(entry);
-    expect(size).toBe(JSON.stringify(entry).length);
-  });
-});
-
-describe('canAddEntry', () => {
-  it('should allow adding small entries to small manifests', () => {
-    const manifest = { dependencies: [] };
-    const entry = { id: '1', name: 'test' };
-
-    const result = canAddEntry(manifest, entry);
-
-    expect(result.canAdd).toBe(true);
-    expect(result.currentSize.status).toBe('ok');
-  });
-
-  it('should prevent adding entries when it would exceed limit', () => {
-    // Create a manifest that's already close to the limit
-    const largeDeps = Array.from({ length: 10000 }, (_, i) => ({
-      id: `dep-${i}`,
-      url: `https://example.com/${i}`,
-      description: 'A'.repeat(800) // ~800 bytes each, total ~8MB
-    }));
-
-    const manifest = { dependencies: largeDeps };
-    const newEntry = {
-      id: 'new-dep',
-      url: 'https://example.com/new',
-      description: 'B'.repeat(3000000) // Very large entry ~3MB
-    };
-
-    const result = canAddEntry(manifest, newEntry, {
-      errorThreshold: 10
-    });
-
-    expect(result.canAdd).toBe(false);
-    expect(result.estimatedSize.message).toContain('exceed size limit');
-  });
-
-  it('should show warning status when approaching limit', () => {
-    const deps = Array.from({ length: 1000 }, (_, i) => ({
-      id: `dep-${i}`,
-      data: 'x'.repeat(900) // Each ~900 bytes
-    }));
-
-    const manifest = { dependencies: deps };
-    const entry = { id: 'new', data: 'y'.repeat(100) };
-
-    const result = canAddEntry(manifest, entry, {
-      warnThreshold: 0.8,
-      errorThreshold: 10
-    });
-
-    expect(result.canAdd).toBe(true);
-    expect(result.estimatedSize.status).toBe('warning');
-  });
-
-  it('should handle adding entry to empty manifest', () => {
-    const manifest = {};
-    const entry = { id: '1', name: 'first' };
-
-    const result = canAddEntry(manifest, entry);
-
-    expect(result.canAdd).toBe(true);
-  });
-
-  it('should account for JSON formatting overhead', () => {
-    const manifest = { dependencies: [{ id: '1' }] };
-    const entry = { id: '2' };
-
-    const result = canAddEntry(manifest, entry);
-
-    // Estimated size should be larger than current + entry due to formatting buffer
-    expect(result.estimatedSize.sizeBytes).toBeGreaterThan(
-      result.currentSize.sizeBytes + estimateEntrySize(entry)
-    );
-  });
-});

package/src/size-check.ts

@@ -1,124 +0,0 @@
-/**
- * Manifest size validation and warnings
- * Checks manifest size and warns when approaching limits
- */
-
-export interface SizeCheckResult {
-  sizeBytes: number;
-  sizeMB: number;
-  status: 'ok' | 'warning' | 'error';
-  message?: string | undefined;
-}
-
-export interface SizeCheckOptions {
-  warnThreshold?: number; // MB (default: 1)
-  errorThreshold?: number; // MB (default: 10)
-}
-
-/**
- * Check manifest size and return status
- */
-export function checkManifestSize(
-  content: string | Buffer,
-  options?: SizeCheckOptions
-): SizeCheckResult {
-  const warnThreshold = (options?.warnThreshold ?? 1) * 1024 * 1024; // Convert MB to bytes
-  const errorThreshold = (options?.errorThreshold ?? 10) * 1024 * 1024;
-
-  const sizeBytes =
-    typeof content === 'string' ? Buffer.byteLength(content, 'utf8') : content.length;
-
-  const sizeMB = sizeBytes / (1024 * 1024);
-
-  if (sizeBytes >= errorThreshold) {
-    return {
-      sizeBytes,
-      sizeMB,
-      status: 'error',
-      message: `Manifest size (${sizeMB.toFixed(2)}MB) exceeds maximum limit of ${(errorThreshold / 1024 / 1024).toFixed(0)}MB. Consider splitting or pruning data.`
-    };
-  }
-
-  if (sizeBytes >= warnThreshold) {
-    return {
-      sizeBytes,
-      sizeMB,
-      status: 'warning',
-      message: `Manifest size (${sizeMB.toFixed(2)}MB) is approaching limit. Warning threshold: ${(warnThreshold / 1024 / 1024).toFixed(0)}MB, Max: ${(errorThreshold / 1024 / 1024).toFixed(0)}MB.`
-    };
-  }
-
-  return {
-    sizeBytes,
-    sizeMB,
-    status: 'ok'
-  };
-}
-
-/**
- * Get formatted size string
- */
-export function formatSize(bytes: number): string {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(2)} KB`;
-  }
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-
-/**
- * Validate manifest object size before serialization
- */
-export function validateManifestObject(
-  manifest: unknown,
-  options?: SizeCheckOptions
-): SizeCheckResult {
-  const serialized = JSON.stringify(manifest, null, 2);
-  return checkManifestSize(serialized, options);
-}
-
-/**
- * Estimate manifest size impact of adding an entry
- */
-export function estimateEntrySize(entry: unknown): number {
-  const serialized = JSON.stringify(entry);
-  return Buffer.byteLength(serialized, 'utf8');
-}
-
-/**
- * Check if adding an entry would exceed limits
- */
-export function canAddEntry(
-  currentManifest: unknown,
-  newEntry: unknown,
-  options?: SizeCheckOptions
-): {
-  canAdd: boolean;
-  currentSize: SizeCheckResult;
-  estimatedSize: SizeCheckResult;
-} {
-  const currentSize = validateManifestObject(currentManifest, options);
-  const entrySize = estimateEntrySize(newEntry);
-
-  // Estimate new size (accounting for JSON formatting)
-  const estimatedBytes = currentSize.sizeBytes + entrySize + 100; // Add buffer for formatting
-  const estimatedSizeMB = estimatedBytes / (1024 * 1024);
-
-  const errorThreshold = (options?.errorThreshold ?? 10) * 1024 * 1024;
-  const canAdd = estimatedBytes < errorThreshold;
-
-  const estimatedResult = checkManifestSize(Buffer.alloc(estimatedBytes), options);
-
-  return {
-    canAdd,
-    currentSize,
-    estimatedSize: {
-      ...estimatedResult,
-      message: canAdd
-        ? estimatedResult.message
-        : `Adding entry would exceed size limit (estimated: ${estimatedSizeMB.toFixed(2)}MB)`
-    }
-  };
-}