@dependabit/manifest 0.1.1

package/src/size-check.test.ts

@@ -0,0 +1,246 @@
+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

@@ -0,0 +1,124 @@
+/**
+ * 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)`
+    }
+  };
+}

package/src/validator.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateManifest,
+  validateDependencyEntry,
+  validateConfig,
+  safeValidateManifest,
+  ValidationError
+} from '../src/validator.js';
+
+describe('Validator Tests', () => {
+  describe('validateManifest', () => {
+    it('should validate a valid manifest', () => {
+      const manifest = {
+        version: '1.0.0',
+        generatedAt: '2026-01-29T10:30:00Z',
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot'
+        },
+        repository: {
+          owner: 'pradeepmouli',
+          name: 'dependabit',
+          branch: 'main',
+          commit: 'abc123'
+        },
+        dependencies: [],
+        statistics: {
+          totalDependencies: 0,
+          byType: {},
+          byAccessMethod: {},
+          byDetectionMethod: {},
+          averageConfidence: 0
+        }
+      };
+
+      const result = validateManifest(manifest);
+      expect(result.version).toBe('1.0.0');
+    });
+
+    it('should throw ValidationError for invalid manifest', () => {
+      const invalid = {
+        version: '2.0.0'
+      };
+
+      expect(() => validateManifest(invalid)).toThrow(ValidationError);
+    });
+
+    it('should provide formatted error messages', () => {
+      const invalid = {
+        version: '1.0.0'
+      };
+
+      try {
+        validateManifest(invalid);
+        expect.fail('Should have thrown');
+      } catch (error) {
+        expect(error).toBeInstanceOf(ValidationError);
+        const validationError = error as ValidationError;
+        const formatted = validationError.getFormattedErrors();
+        expect(formatted.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('validateDependencyEntry', () => {
+    it('should validate a valid dependency entry', () => {
+      const entry = {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        url: 'https://github.com/microsoft/TypeScript',
+        type: 'reference-implementation',
+        accessMethod: 'github-api',
+        name: 'TypeScript',
+        currentStateHash: 'sha256:abc123',
+        detectionMethod: 'manual',
+        detectionConfidence: 1.0,
+        detectedAt: '2026-01-29T10:30:00Z',
+        lastChecked: '2026-01-29T10:30:00Z',
+        referencedIn: []
+      };
+
+      const result = validateDependencyEntry(entry);
+      expect(result.name).toBe('TypeScript');
+    });
+
+    it('should throw ValidationError for invalid entry', () => {
+      const invalid = {
+        url: 'https://example.com'
+      };
+
+      expect(() => validateDependencyEntry(invalid)).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('should validate a valid config', () => {
+      const config = {
+        version: '1',
+        schedule: {
+          interval: 'daily',
+          timezone: 'UTC'
+        }
+      };
+
+      const result = validateConfig(config);
+      expect(result.version).toBe('1');
+    });
+
+    it('should throw ValidationError for invalid config', () => {
+      const invalid = {
+        version: '2'
+      };
+
+      expect(() => validateConfig(invalid)).toThrow(ValidationError);
+    });
+  });
+
+  describe('safeValidateManifest', () => {
+    it('should return success for valid manifest', () => {
+      const manifest = {
+        version: '1.0.0',
+        generatedAt: '2026-01-29T10:30:00Z',
+        generatedBy: {
+          action: 'dependabit',
+          version: '1.0.0',
+          llmProvider: 'github-copilot'
+        },
+        repository: {
+          owner: 'pradeepmouli',
+          name: 'dependabit',
+          branch: 'main',
+          commit: 'abc123'
+        },
+        dependencies: [],
+        statistics: {
+          totalDependencies: 0,
+          byType: {},
+          byAccessMethod: {},
+          byDetectionMethod: {},
+          averageConfidence: 0
+        }
+      };
+
+      const result = safeValidateManifest(manifest);
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should return error for invalid manifest', () => {
+      const invalid = {
+        version: '2.0.0'
+      };
+
+      const result = safeValidateManifest(invalid);
+      expect(result.success).toBe(false);
+      expect(result.data).toBeUndefined();
+      expect(result.error).toBeInstanceOf(ValidationError);
+    });
+  });
+});

package/src/validator.ts

@@ -0,0 +1,131 @@
+import {
+  DependencyManifestSchema,
+  DependencyEntrySchema,
+  DependabitConfigSchema,
+  type DependencyManifest,
+  type DependencyEntry,
+  type DependabitConfig
+} from './schema.js';
+import { ZodError } from 'zod';
+
+/**
+ * Validation error class with detailed error information
+ */
+export class ValidationError extends Error {
+  constructor(
+    message: string,
+    public readonly errors: ZodError
+  ) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+
+  /**
+   * Get formatted error messages
+   */
+  getFormattedErrors(): string[] {
+    return this.errors.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+  }
+}
+
+/**
+ * Validate a dependency manifest
+ * @throws {ValidationError} if validation fails
+ */
+export function validateManifest(data: unknown): DependencyManifest {
+  try {
+    return DependencyManifestSchema.parse(data);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new ValidationError('Manifest validation failed', error);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Validate a dependency entry
+ * @throws {ValidationError} if validation fails
+ */
+export function validateDependencyEntry(data: unknown): DependencyEntry {
+  try {
+    return DependencyEntrySchema.parse(data);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new ValidationError('Dependency entry validation failed', error);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Validate a dependabit configuration
+ * @throws {ValidationError} if validation fails
+ */
+export function validateConfig(data: unknown): DependabitConfig {
+  try {
+    return DependabitConfigSchema.parse(data);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new ValidationError('Config validation failed', error);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Safe validation that returns success/error result
+ */
+export function safeValidateManifest(data: unknown): {
+  success: boolean;
+  data?: DependencyManifest;
+  error?: ValidationError;
+} {
+  try {
+    const validated = validateManifest(data);
+    return { success: true, data: validated };
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      return { success: false, error };
+    }
+    throw error;
+  }
+}
+
+/**
+ * Safe validation for dependency entry
+ */
+export function safeValidateDependencyEntry(data: unknown): {
+  success: boolean;
+  data?: DependencyEntry;
+  error?: ValidationError;
+} {
+  try {
+    const validated = validateDependencyEntry(data);
+    return { success: true, data: validated };
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      return { success: false, error };
+    }
+    throw error;
+  }
+}
+
+/**
+ * Safe validation for config
+ */
+export function safeValidateConfig(data: unknown): {
+  success: boolean;
+  data?: DependabitConfig;
+  error?: ValidationError;
+} {
+  try {
+    const validated = validateConfig(data);
+    return { success: true, data: validated };
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      return { success: false, error };
+    }
+    throw error;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"],
+  "references": []
+}