@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/principles/AGENTS.md

@@ -0,0 +1,111 @@
+# PRINCIPLES CHECKER MODULE
+
+**Generated:** 2026-06-14
+**Commit:** e215a50
+**Branch:** main
+**Version:** 0.8.10.0
+
+## OVERVIEW
+Clean Code & SOLID principles checker — **Gate 4** of pre-commit. 14 rules × 9 language adapters, SARIF 2.1.0 output. Houses the **Boy Scout Rule** enforcement engine (Gate 6) and warning-baseline storage.
+
+## STRUCTURE
+```
+src/principles/
+├── adapters/           # 9 language adapters
+│   ├── base.ts         # Shared base class
+│   ├── typescript.ts
+│   ├── python.ts
+│   ├── go.ts
+│   ├── java.ts
+│   ├── kotlin.ts
+│   ├── dart.ts
+│   ├── swift.ts
+│   ├── cpp.ts          # Regex-based C++ extraction (handles .cpp AND .c files)
+│   └── objectivec.ts   # Regex-based ObjC extraction
+├── rules/
+│   ├── clean-code/     # 9 Clean Code rules
+│   │   ├── long-function.ts          (≤50 lines)
+│   │   ├── large-file.ts
+│   │   ├── god-class.ts
+│   │   ├── deep-nesting.ts           (≤4 levels)
+│   │   ├── magic-numbers.ts
+│   │   ├── missing-error-handling.ts
+│   │   ├── too-many-params.ts        (≤4 params)
+│   │   ├── unused-imports.ts
+│   │   └── code-duplication.ts
+│   └── solid/          # 5 SOLID rules: srp, ocp, lsp, isp, dip
+├── analyzer.ts         # Rule orchestration engine
+├── boy-scout.ts        # Differential warning enforcement (Gate 6)
+├── baseline.ts         # Warning history (.warnings-baseline.json)
+├── reporter.ts         # Console / JSON / SARIF 2.1.0 output
+├── config.ts           # .principlesrc loader
+├── index.ts            # CLI entry — `getAllRules()` aggregates all 14
+├── types.ts            # Type definitions
+└── __tests__/          # Unit tests across adapters, rules, core
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Rule engine | analyzer.ts | Orchestrates 14 rules × 9 adapters |
+| CLI entry | index.ts | `getAllRules()` returns the full rule set |
+| Output | reporter.ts | Emits Console, JSON, or SARIF 2.1.0 |
+| Thresholds | config.ts + .principlesrc | Defaults + project overrides |
+| Boy Scout enforcement | boy-scout.ts | classifyFiles → calculateDelta → enforceBoyScoutRule |
+| Baseline lifecycle | baseline.ts | loadBaseline, saveBaseline, initBaseline |
+| Adapter for new language | adapters/base.ts + add `<lang>.ts` | Subclass base; export via index |
+| C / C++ extraction | adapters/cpp.ts | Regex-based; handles both `.cpp` and `.c` |
+| Tests | __tests__/ | Adapter, rule, and core tests |
+
+## CODE MAP
+| Symbol | Type | Location | Role |
+|--------|------|----------|------|
+| getAllRules | Function | index.ts | Aggregates 9 clean-code + 5 SOLID rules |
+| analyze | Function | analyzer.ts | Walks files × rules × adapters; collects violations |
+| report | Function | reporter.ts | Picks Console / JSON / SARIF emitter |
+| loadConfig | Function | config.ts | Reads `.principlesrc`; merges with built-in defaults |
+| classifyFiles | Function | boy-scout.ts | new / modified / untouched bucket assignment |
+| calculateDelta | Function | boy-scout.ts | Diff vs `.warnings-baseline.json` |
+| enforceBoyScoutRule | Function | boy-scout.ts | Block when modified-file warnings increase |
+| loadBaseline | Function | baseline.ts | Read `.warnings-baseline.json` |
+| saveBaseline | Function | baseline.ts | Write updated baseline after successful commit |
+| initBaseline | Function | baseline.ts | First-time auto-snapshot (≤5 warnings ⇒ must clear to zero) |
+
+## CONVENTIONS
+- **Rule ID format**: `clean-code.long-function`, `solid.srp`. Stable, dot-namespaced.
+- **Severity**: `error` (block), `warning` (block under Boy Scout if increased), `info` (log only).
+- **SARIF 2.1.0** output includes rule descriptions + default level mapping for GitHub Code Scanning.
+- **Boy Scout Rule**: auto-baseline on first touch. Modified files cannot increase warning count vs `.warnings-baseline.json`. New files: zero warnings required. Initial baseline ≤5 warnings must clear to zero on next modification.
+- **Test annotations mandatory**: every test file declares `@test REQ-XXX`, `@intent ...`, `@covers AC-XXX` in JSDoc. Missing tags ⇒ test rejected.
+- **Mock-first**: inline mocks only, no separate fixture files.
+- **ast-grep preferred** for AST work; regex fallback only where ast-grep doesn't reach (cpp / objc).
+
+## ANTI-PATTERNS
+- Do NOT use `as any`, `@ts-ignore`, or `@ts-expect-error` in rule implementations.
+- Do NOT suppress violations via config for production code paths.
+- Do NOT skip `ast-grep` installation — regex fallback is intentionally limited.
+- Do NOT introduce a new rule without: (a) ID under `rules/<category>/`, (b) unit tests, (c) listing in `index.ts`, (d) SARIF rule description in `reporter.ts`.
+
+## UNIQUE STYLES
+- **9 language adapters** here vs **13 shell adapters** in `githooks/adapters/` — divergence is intentional. Principles engine covers what can be parsed; shell adapters cover what can be linted/tested. Languages in shell-only set (shell, powershell, flutter, iac) don't have TS-side rule support.
+- **C++ adapter handles C** via regex — no standalone `c.ts`.
+- **SARIF 2.1.0** chosen for GitHub Code Scanning compatibility.
+
+## COMMANDS
+```bash
+# Console output
+npx tsx src/principles/index.ts --files "src/**/*.ts" --format console
+
+# SARIF for GitHub Actions
+npx tsx src/principles/index.ts --files "src/**/*.ts" --format sarif > results.sarif
+
+# Custom config
+npx tsx src/principles/index.ts --files "src/**/*.ts" --config .principlesrc
+```
+
+## NOTES
+- Gate 4 of pre-commit (one of 10 numbered gates; see root `AGENTS.md` GATES section).
+- Boy Scout enforcement runs separately as Gate 6 in `githooks/pre-commit`.
+- Performance: ~95ms for 28 files; ~340ms estimated for 100 files. Memory: ~102 MB (Node.js baseline).
+- `getAllRules()` is the stable extension point — register new rules there.
+

package/principles/__tests__/analyzer.test.ts

@@ -0,0 +1,343 @@
+/**
+ * @test analyzer.ts - Rule orchestration engine
+ * @intent Verify analyzer runs rules and aggregates violations correctly
+ * @covers clean-code-solid-checker-design Section 3 (CORE ENGINE)
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { analyze } from '../analyzer';
+import { Rule, Adapter, Severity } from '../types';
+
+describe('analyzer.ts - Rule Orchestration Engine', () => {
+  let mockAdapter: Adapter;
+  let mockRule: Rule;
+  
+  beforeEach(() => {
+    // Mock adapter
+    mockAdapter = {
+      detectLanguage: vi.fn().mockReturnValue('typescript'),
+      parseAST: vi.fn().mockReturnValue({}),
+      extractFunctions: vi.fn().mockReturnValue([
+        { name: 'testFunc', startLine: 1, length: 60 }
+      ]),
+      extractClasses: vi.fn().mockReturnValue([]),
+      extractExports: vi.fn().mockReturnValue([]),
+      countLines: vi.fn().mockReturnValue(100)
+    };
+    
+    // Mock rule that detects violations
+    mockRule = {
+      id: 'clean-code.long-function',
+      name: 'Long Function Rule',
+      threshold: 50,
+      severity: 'warning' as Severity,
+      check: vi.fn().mockReturnValue([
+        {
+          file: 'test.ts',
+          line: 1,
+          ruleId: 'clean-code.long-function',
+          message: 'Function "testFunc" is too long: 60 lines (maximum: 50)',
+          severity: 'warning' as Severity
+        }
+      ])
+    };
+  });
+
+  describe('analyze function', () => {
+    it('should return AnalysisResult with violations array', async () => {
+      const files = ['test.ts'];
+      const rules = [mockRule];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result).toBeDefined();
+      expect(result.violations).toBeInstanceOf(Array);
+      expect(result.summary).toBeDefined();
+    });
+
+    it('should run each rule against each file', async () => {
+      const files = ['test.ts', 'test2.ts'];
+      const rules = [mockRule];
+      
+      await analyze(files, rules, mockAdapter);
+      
+      // Each file should be checked
+      expect(mockRule.check).toHaveBeenCalledTimes(2);
+    });
+
+    it('should aggregate violations from all rules', async () => {
+      const files = ['test.ts'];
+      const rules = [
+        mockRule,
+        {
+          id: 'clean-code.large-file',
+          name: 'Large File Rule',
+          threshold: 500,
+          severity: 'warning' as Severity,
+          check: vi.fn().mockReturnValue([
+            {
+              file: 'test.ts',
+              line: 1,
+              ruleId: 'clean-code.large-file',
+              message: 'File is too large: 600 lines',
+              severity: 'warning' as Severity
+            }
+          ])
+        } as Rule
+      ];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.violations.length).toBe(2);
+      expect(result.violations[0].ruleId).toBe('clean-code.long-function');
+      expect(result.violations[1].ruleId).toBe('clean-code.large-file');
+    });
+
+    it('should filter rules by enabled config', async () => {
+      const files = ['test.ts'];
+      
+      // Mock a disabled rule
+      const disabledRule = {
+        id: 'clean-code.disabled-rule',
+        name: 'Disabled Rule',
+        threshold: 10,
+        severity: 'info' as Severity,
+        check: vi.fn().mockReturnValue([])
+      };
+      
+      await analyze(files, [mockRule, disabledRule], mockAdapter, {
+        enabledRules: ['clean-code.long-function']
+      });
+      
+      // Only enabled rule should run
+      expect(mockRule.check).toHaveBeenCalled();
+      expect(disabledRule.check).not.toHaveBeenCalled();
+    });
+
+    it('should return empty violations if all rules pass', async () => {
+      const passingRule: Rule = {
+        id: 'clean-code.passing',
+        name: 'Passing Rule',
+        threshold: 50,
+        severity: 'warning' as Severity,
+        check: vi.fn().mockReturnValue([])
+      };
+      
+      const files = ['clean.ts'];
+      const result = await analyze(files, [passingRule], mockAdapter);
+      
+      expect(result.violations.length).toBe(0);
+      expect(result.summary.totalViolations).toBe(0);
+    });
+
+    it('should calculate summary statistics correctly', async () => {
+      const files = ['test.ts'];
+      const rules = [mockRule];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.summary.totalViolations).toBe(1);
+      expect(result.summary.warningCount).toBe(1);
+      expect(result.summary.errorCount).toBe(0);
+      expect(result.summary.infoCount).toBe(0);
+    });
+
+    it('should handle multiple severity levels in summary', async () => {
+      const files = ['test.ts'];
+      const rules = [
+        mockRule,
+        {
+          id: 'test.error',
+          name: 'Error Rule',
+          threshold: 10,
+          severity: 'error' as Severity,
+          check: vi.fn().mockReturnValue([
+            {
+              file: 'test.ts',
+              line: 1,
+              ruleId: 'test.error',
+              message: 'Error violation',
+              severity: 'error' as Severity
+            }
+          ])
+        } as Rule,
+        {
+          id: 'test.info',
+          name: 'Info Rule',
+          threshold: 10,
+          severity: 'info' as Severity,
+          check: vi.fn().mockReturnValue([
+            {
+              file: 'test.ts',
+              line: 2,
+              ruleId: 'test.info',
+              message: 'Info violation',
+              severity: 'info' as Severity
+            }
+          ])
+        } as Rule
+      ];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.summary.errorCount).toBe(1);
+      expect(result.summary.warningCount).toBe(1);
+      expect(result.summary.infoCount).toBe(1);
+      expect(result.summary.totalViolations).toBe(3);
+    });
+
+it('should skip files that do not match adapter language', async () => {
+      const files = ['test.py', 'test.ts'];
+      
+      const adapterFactory = (filePath: string): Adapter => {
+        const ext = filePath.split('.').pop()?.toLowerCase();
+        if (ext === 'ts' || ext === 'tsx') {
+          return mockAdapter;
+        }
+        return {
+          ...mockAdapter,
+          detectLanguage: () => 'unknown'
+        };
+      };
+      
+      await analyze(files, [mockRule], adapterFactory);
+      
+      expect(mockRule.check).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle rule check errors gracefully', async () => {
+      const errorRule: Rule = {
+        id: 'error.rule',
+        name: 'Error Rule',
+        threshold: 10,
+        severity: 'warning' as Severity,
+        check: vi.fn().mockImplementation(() => {
+          throw new Error('Rule check failed');
+        })
+      };
+      
+      const files = ['test.ts'];
+      
+      // Should not throw, should handle gracefully
+      const result = await analyze(files, [errorRule], mockAdapter);
+      
+      expect(result.violations.length).toBe(0);
+      expect(result.errors).toBeDefined();
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('runRuleOnFile (via analyze) — verifies context-object parameter bundling', () => {
+    it('should correctly aggregate violations per file and per rule', async () => {
+      const files = ['a.ts', 'b.ts'];
+      const ruleA = {
+        id: 'test.rule-a',
+        name: 'Rule A',
+        threshold: 10,
+        severity: 'warning' as Severity,
+        check: vi.fn().mockImplementation((file: string) => {
+          if (file === 'a.ts') {
+            return [{ file: 'a.ts', line: 1, ruleId: 'test.rule-a', message: 'violation in a', severity: 'warning' as Severity }];
+          }
+          return [];
+        })
+      } as Rule;
+      const ruleB = {
+        id: 'test.rule-b',
+        name: 'Rule B',
+        threshold: 10,
+        severity: 'error' as Severity,
+        check: vi.fn().mockReturnValue([
+          { file: 'a.ts', line: 2, ruleId: 'test.rule-b', message: 'error in a', severity: 'error' as Severity },
+          { file: 'b.ts', line: 1, ruleId: 'test.rule-b', message: 'error in b', severity: 'error' as Severity },
+        ])
+      } as Rule;
+
+      const result = await analyze(files, [ruleA, ruleB], mockAdapter);
+
+      // fileResults — each file has the correct violations
+      // ruleA: 1 violation for a.ts via file-match, 0 for b.ts; ruleB: mockReturnValue returns both for any file
+      expect(result.fileResults['a.ts'].violations).toHaveLength(3);
+      expect(result.fileResults['a.ts'].ruleIds).toEqual(['test.rule-a', 'test.rule-b']);
+      // ruleB returns both violations on every call (mockReturnValue — no per-file filter)
+      expect(result.fileResults['b.ts'].violations).toHaveLength(2);
+      expect(result.fileResults['b.ts'].ruleIds).toEqual(['test.rule-b']);
+
+      // ruleResults — each rule tracked correctly
+      expect(result.ruleResults['test.rule-a'].violationCount).toBe(1);
+      expect(result.ruleResults['test.rule-a'].filesChecked).toBe(2);
+      // ruleB's violationCount accumulates across all files (2 per file × 2 files = 4)
+      expect(result.ruleResults['test.rule-b'].violationCount).toBe(4);
+      expect(result.ruleResults['test.rule-b'].filesChecked).toBe(2);
+
+      // total violations = 1 (ruleA) + 4 (ruleB) = 5
+      expect(result.summary.totalViolations).toBe(5);
+    });
+
+    it('should collect per-rule errors from runRuleOnFile into top-level errors array', async () => {
+      const files = ['a.ts', 'b.ts'];
+      const goodRule = {
+        id: 'test.good',
+        name: 'Good Rule',
+        threshold: 10,
+        severity: 'info' as Severity,
+        check: vi.fn().mockReturnValue([])
+      } as Rule;
+      const badRule = {
+        id: 'test.bad',
+        name: 'Bad Rule',
+        threshold: 10,
+        severity: 'error' as Severity,
+        check: vi.fn().mockImplementation((file: string) => {
+          if (file === 'b.ts') throw new Error('crash on b');
+          return [];
+        })
+      } as Rule;
+
+      const result = await analyze(files, [goodRule, badRule], mockAdapter);
+
+      // goodRule ran on both files
+      expect(goodRule.check).toHaveBeenCalledTimes(2);
+      // badRule crashed on b.ts — error captured, a.ts succeeded
+      expect(result.errors).toContain('Rule test.bad failed on b.ts: crash on b');
+      // goodRule results still intact
+      expect(result.ruleResults['test.good'].filesChecked).toBe(2);
+      // filesChecked counts attempted files (incremented before try/catch)
+      expect(result.ruleResults['test.bad'].filesChecked).toBe(2);
+    });
+  });
+
+  describe('AnalysisResult structure', () => {
+    it('should include file-by-file breakdown', async () => {
+      const files = ['test.ts'];
+      const rules = [mockRule];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.fileResults).toBeDefined();
+      expect(result.fileResults['test.ts']).toBeDefined();
+      expect(result.fileResults['test.ts'].violations.length).toBe(1);
+    });
+
+    it('should include execution time', async () => {
+      const files = ['test.ts'];
+      const rules = [mockRule];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.executionTimeMs).toBeDefined();
+      expect(result.executionTimeMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should include rule-by-rule breakdown', async () => {
+      const files = ['test.ts'];
+      const rules = [mockRule];
+      
+      const result = await analyze(files, rules, mockAdapter);
+      
+      expect(result.ruleResults).toBeDefined();
+      expect(result.ruleResults['clean-code.long-function']).toBeDefined();
+      expect(result.ruleResults['clean-code.long-function'].violationCount).toBe(1);
+    });
+  });
+});

package/principles/__tests__/baseline-storage.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import { BaselineStorage, BaselineEntry, filterBaselineWarnings } from '../baseline';
+
+describe('Baseline Storage', () => {
+  const mockBaselinePath = '.warnings-baseline.json';
+  let baselineStorage: BaselineStorage;
+
+  beforeEach(() => {
+    baselineStorage = new BaselineStorage();
+  });
+
+  afterEach(() => {
+    (fs.access as unknown as {mockRestore?: () => void}).mockRestore?.();
+    (fs.readFile as unknown as {mockRestore?: () => void}).mockRestore?.();
+    (fs.writeFile as unknown as {mockRestore?: () => void}).mockRestore?.();
+    vi.resetAllMocks();
+  });
+
+  it('loads baseline from json file when exists', async () => {
+    const mockBaseline = {
+      'src/example.ts': {
+        eslint: { warnings: 5, errors: 0 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    vi.spyOn(fs, 'access').mockResolvedValue();
+    vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify(mockBaseline));
+
+    const result = await baselineStorage.load(mockBaselinePath);
+    expect(result).toEqual(mockBaseline);
+  });
+
+  it('returns empty baseline when file missing', async () => {
+    vi.spyOn(fs, 'access').mockRejectedValue(new Error('File does not exist'));
+
+    const result = await baselineStorage.load(mockBaselinePath);
+    expect(result).toEqual({});
+  });
+
+  it('saves updated baseline on pass', async () => {
+    const mockBaseline = {
+      'src/example.ts': {
+        eslint: { warnings: 5, errors: 0 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    const writeFileSpy = vi.spyOn(fs, 'writeFile').mockResolvedValue();
+
+    await baselineStorage.save(mockBaselinePath, mockBaseline);
+    
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      mockBaselinePath,
+      JSON.stringify(mockBaseline, null, 2)
+    );
+  });
+
+  it('handles large baselines efficiently', async () => {
+    const largeBaseline: Record<string, BaselineEntry> = {};
+    for (let i = 0; i < 100; i++) {
+      largeBaseline[`src/component-${i}.ts`] = {
+        eslint: { warnings: 2, errors: 0 },
+        totalWarnings: 2,
+        lastAnalyzed: new Date().toISOString()
+      };
+    }
+
+    const spyOnWrite = vi.spyOn(fs, 'writeFile').mockResolvedValue();
+
+    await baselineStorage.save(mockBaselinePath, largeBaseline);
+    expect(spyOnWrite).toHaveBeenCalledWith(
+      mockBaselinePath,
+      expect.any(String)
+    );
+    
+    const [calledWithPath, content] = spyOnWrite.mock.calls[0];
+    expect(calledWithPath).toBe(mockBaselinePath);
+    expect(JSON.parse(content as string)).toEqual(largeBaseline);
+  });
+
+  it('validates baseline with proper structure', () => {
+    const validBaseline = {
+      'src/file1.ts': {
+        eslint: { warnings: 2, errors: 1 },
+        principles: { warnings: 0, errors: 1 },
+        ccn: { warnings: 0, max: 3 },
+        totalWarnings: 2,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    expect(() => baselineStorage.validate(validBaseline)).not.toThrow();
+  });
+
+  it('throws error for invalid baseline', () => {
+    const invalidBaseline = {
+      'src/file1.ts': {
+        totalWarnings: -5,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    expect(() => baselineStorage.validate(invalidBaseline)).toThrow();
+  });
+
+  it('filters baseline to include only files with warnings', () => {
+    const baseline = {
+      'src/clean1.ts': {
+        eslint: { warnings: 0, errors: 0 },
+        totalWarnings: 0,
+        lastAnalyzed: new Date().toISOString()
+      },
+      'src/warning1.ts': {
+        eslint: { warnings: 5, errors: 0 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString()
+      },
+      'src/clean2.ts': {
+        eslint: { warnings: 0, errors: 0 },
+        totalWarnings: 0,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    const filtered = filterBaselineWarnings(baseline, 1);
+    expect(Object.keys(filtered)).toHaveLength(1);
+    expect(filtered['src/warning1.ts']).toBeDefined();
+    expect(filtered['src/clean1.ts']).toBeUndefined();
+    expect(filtered['src/clean2.ts']).toBeUndefined();
+  });
+
+  it('gets summary statistics', () => {
+    const baseline = {
+      'src/file1.ts': {
+        eslint: { warnings: 2, errors: 1 },
+        principles: { warnings: 1, errors: 0 },
+        totalWarnings: 3,
+        lastAnalyzed: new Date().toISOString()
+      },
+      'src/file2.ts': {
+        eslint: { warnings: 4, errors: 0 },
+        principles: { warnings: 0, errors: 2 },
+        totalWarnings: 4,
+        lastAnalyzed: new Date().toISOString()
+      }
+    };
+
+    const stats = baselineStorage.getSummaryStatistics(baseline);
+    
+    expect(stats.totalFiles).toBe(2);
+    expect(stats.totalWarnings).toBe(7);
+    expect(stats.averageWarningsPerFile).toBe(3.5);
+    expect(stats.eslint?.totalWarnings).toBe(6);
+    expect(stats.eslint?.totalErrors).toBe(1);
+  });
+
+  it('creates baseline from files with warning data', async () => {
+    const warningData = [
+      {
+        file: 'src/example1.ts',
+        counts: {
+          eslint: { warnings: 2, errors: 1 },
+          totalWarnings: 2
+        }
+      },
+      {
+        file: 'src/example2.ts',
+        counts: {
+          eslint: { warnings: 5, errors: 0 },
+          principles: { warnings: 1, errors: 0 },
+          totalWarnings: 6
+        }
+      }
+    ];
+
+    const result = await baselineStorage.createFromFiles(warningData);
+    
+    expect(Object.keys(result)).toEqual(['src/example1.ts', 'src/example2.ts']);
+    expect(result['src/example1.ts'].totalWarnings).toBe(2);
+    expect(result['src/example2.ts'].totalWarnings).toBe(6);
+    expect(result['src/example1.ts'].eslint!.warnings).toBe(2);
+  });
+});