@rcrsr/rill-cli 0.6.0

package/tests/cli-explain.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Tests for CLI error explanation functionality
+ */
+
+import { describe, it, expect } from 'vitest';
+import { explainError } from '../src/cli-explain.js';
+
+describe('explainError', () => {
+  describe('valid error IDs', () => {
+    it('returns formatted documentation for error with all fields', () => {
+      // Create a mock error with all optional fields populated
+      // We need to find an error ID that has cause, resolution, and examples
+      // For this test, we'll use RILL-R009 if it has these fields, otherwise we need to check
+
+      const result = explainError('RILL-R009');
+
+      // Since RILL-R009 exists in ERROR_REGISTRY, this should not be null
+      expect(result).not.toBeNull();
+
+      if (result !== null) {
+        // Should contain the error ID and description
+        expect(result).toContain('RILL-R009');
+        expect(result).toContain('Property not found');
+      }
+    });
+
+    it('returns formatted documentation for lexer error', () => {
+      const result = explainError('RILL-L001');
+
+      expect(result).not.toBeNull();
+      if (result !== null) {
+        expect(result).toContain('RILL-L001');
+        expect(result).toContain('Unterminated string literal');
+      }
+    });
+
+    it('returns formatted documentation for parse error', () => {
+      const result = explainError('RILL-P001');
+
+      expect(result).not.toBeNull();
+      if (result !== null) {
+        expect(result).toContain('RILL-P001');
+        expect(result).toContain('Unexpected token');
+      }
+    });
+
+    it('returns formatted documentation for runtime error', () => {
+      const result = explainError('RILL-R001');
+
+      expect(result).not.toBeNull();
+      if (result !== null) {
+        expect(result).toContain('RILL-R001');
+        expect(result).toContain('Parameter type mismatch');
+      }
+    });
+
+    it('returns formatted documentation for check error', () => {
+      const result = explainError('RILL-C001');
+
+      expect(result).not.toBeNull();
+      if (result !== null) {
+        expect(result).toContain('RILL-C001');
+        expect(result).toContain('File not found');
+      }
+    });
+
+    it('includes cause section when present', () => {
+      // We need to check which error has cause field populated
+      // For now, we'll test the structure by creating a scenario
+      const result = explainError('RILL-R001');
+
+      if (result !== null && result.includes('Cause:')) {
+        expect(result).toMatch(/Cause:\n {2}.+/);
+      }
+    });
+
+    it('includes resolution section when present', () => {
+      const result = explainError('RILL-R001');
+
+      if (result !== null && result.includes('Resolution:')) {
+        expect(result).toMatch(/Resolution:\n {2}.+/);
+      }
+    });
+
+    it('includes examples section when present', () => {
+      const result = explainError('RILL-R001');
+
+      if (result !== null && result.includes('Examples:')) {
+        expect(result).toContain('Examples:');
+        // Should have indented code
+        expect(result).toMatch(/ {4}.+/);
+      }
+    });
+
+    it('formats output with proper structure', () => {
+      const result = explainError('RILL-R001');
+
+      expect(result).not.toBeNull();
+      if (result !== null) {
+        // Should start with errorId: description
+        expect(result).toMatch(/^RILL-R\d{3}: .+/);
+
+        // Should not have trailing whitespace
+        expect(result).not.toMatch(/\s$/);
+      }
+    });
+  });
+
+  describe('invalid error IDs', () => {
+    it('returns null for invalid errorId format - missing prefix', () => {
+      const result = explainError('R001');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - wrong prefix', () => {
+      const result = explainError('RILL001');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - invalid category', () => {
+      const result = explainError('RILL-X001');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - too few digits', () => {
+      const result = explainError('RILL-R01');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - too many digits', () => {
+      const result = explainError('RILL-R0001');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - lowercase', () => {
+      const result = explainError('rill-r001');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - empty string', () => {
+      const result = explainError('');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid errorId format - random string', () => {
+      const result = explainError('invalid');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('unknown error IDs', () => {
+    it('returns null for unknown lexer error ID', () => {
+      const result = explainError('RILL-L999');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for unknown parse error ID', () => {
+      const result = explainError('RILL-P999');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for unknown runtime error ID', () => {
+      const result = explainError('RILL-R999');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for unknown check error ID', () => {
+      const result = explainError('RILL-C999');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('output formatting', () => {
+    it('indents code examples with 4 spaces', () => {
+      // Find an error with examples and test indentation
+      const result = explainError('RILL-R001');
+
+      if (result !== null && result.includes('Examples:')) {
+        const lines = result.split('\n');
+        const codeLines = lines.filter((line) => line.match(/^ {4}[^ ]/));
+        // If examples exist, should have at least one code line
+        if (lines.some((line) => line.includes('Examples:'))) {
+          // Code lines should be indented with exactly 4 spaces
+          for (const line of codeLines) {
+            expect(line).toMatch(/^ {4}/);
+          }
+        }
+      }
+    });
+
+    it('indents example descriptions with 2 spaces', () => {
+      const result = explainError('RILL-R001');
+
+      if (result !== null && result.includes('Examples:')) {
+        const lines = result.split('\n');
+        // Find lines after "Examples:" that are descriptions (before code)
+        let inExamples = false;
+        for (const line of lines) {
+          if (line === 'Examples:') {
+            inExamples = true;
+            continue;
+          }
+          if (
+            inExamples &&
+            line.trim() !== '' &&
+            !line.startsWith('    ') &&
+            line.startsWith('  ')
+          ) {
+            // This is a description line
+            expect(line).toMatch(/^ {2}[^ ]/);
+          }
+        }
+      }
+    });
+
+    it('separates sections with blank lines', () => {
+      const result = explainError('RILL-R001');
+
+      if (result !== null) {
+        // Should have blank lines between sections
+        const lines = result.split('\n');
+
+        // Find section headers and check they're followed by content then blank line
+        const sectionHeaders = ['Cause:', 'Resolution:', 'Examples:'];
+        for (const header of sectionHeaders) {
+          const headerIndex = lines.indexOf(header);
+          if (headerIndex !== -1 && headerIndex < lines.length - 2) {
+            // After the header content, should have a blank line
+            // (unless it's the last section)
+            let nextNonContentIndex = headerIndex + 1;
+            while (
+              nextNonContentIndex < lines.length &&
+              lines[nextNonContentIndex]?.trim() !== '' &&
+              !sectionHeaders.includes(lines[nextNonContentIndex] ?? '')
+            ) {
+              nextNonContentIndex++;
+            }
+            if (
+              nextNonContentIndex < lines.length &&
+              !sectionHeaders.includes(lines[nextNonContentIndex] ?? '')
+            ) {
+              expect(lines[nextNonContentIndex]).toBe('');
+            }
+          }
+        }
+      }
+    });
+  });
+});

package/tests/cli-lsp-diagnostic.test.ts

@@ -0,0 +1,202 @@
+/**
+ * CLI LSP Diagnostic Tests
+ * Test LSP diagnostic conversion from RillError
+ */
+
+import { describe, it, expect } from 'vitest';
+import { toLspDiagnostic } from '../src/cli-lsp-diagnostic.js';
+import { RillError, RuntimeError } from '@rcrsr/rill';
+
+describe('CLI LSP Diagnostic', () => {
+  describe('toLspDiagnostic', () => {
+    // IR-9: Convert RillError with span to LspDiagnostic with zero-based positions
+    it('converts RillError with location to LspDiagnostic', () => {
+      const error = new RuntimeError(
+        'RILL-R005',
+        'Variable foo is not defined',
+        { line: 5, column: 10, offset: 42 },
+        { name: 'foo' }
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic).toEqual({
+        range: {
+          start: { line: 4, character: 9 }, // 1-based line 5, column 10 -> 0-based line 4, character 9
+          end: { line: 4, character: 9 },
+        },
+        severity: 1, // Error
+        code: 'RILL-R005',
+        source: 'rill',
+        message: 'Variable foo is not defined',
+      });
+    });
+
+    // EC-11: Missing span returns diagnostic with null range
+    it('converts RillError without location to diagnostic with null range', () => {
+      const error = new RuntimeError(
+        'RILL-R010',
+        'Iteration limit of 1000 exceeded',
+        undefined,
+        { limit: 1000 }
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic).toEqual({
+        range: null,
+        severity: 1, // Error
+        code: 'RILL-R010',
+        source: 'rill',
+        message: 'Iteration limit of 1000 exceeded',
+      });
+    });
+
+    it('converts zero-based positions correctly', () => {
+      const error = new RuntimeError(
+        'RILL-R005',
+        'Variable x is not defined',
+        { line: 1, column: 1, offset: 0 }, // First line, first column
+        { name: 'x' }
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.range).toEqual({
+        start: { line: 0, character: 0 }, // 1-based line 1, column 1 -> 0-based line 0, character 0
+        end: { line: 0, character: 0 },
+      });
+    });
+
+    it('strips location suffix from message', () => {
+      const error = new RuntimeError(
+        'RILL-R005',
+        'Variable foo is not defined',
+        { line: 10, column: 5, offset: 100 }
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      // Message should not include " at 10:5" suffix
+      expect(diagnostic.message).toBe('Variable foo is not defined');
+      expect(diagnostic.message).not.toContain(' at 10:5');
+    });
+
+    it('always sets source to rill', () => {
+      const error = new RuntimeError('RILL-R001', 'Type error', {
+        line: 1,
+        column: 1,
+        offset: 0,
+      });
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.source).toBe('rill');
+    });
+
+    it('maps error severity to LSP severity 1', () => {
+      const error = new RuntimeError(
+        'RILL-R005',
+        'Variable foo is not defined',
+        { line: 1, column: 1, offset: 0 }
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.severity).toBe(1); // Error
+    });
+
+    it('includes suggestions when present in context', () => {
+      const error = new RillError({
+        errorId: 'RILL-R005',
+        message: 'Variable foo is not defined',
+        location: { line: 1, column: 1, offset: 0 },
+        context: {
+          name: 'foo',
+          suggestions: ['foobar', 'food', 'foot'],
+        },
+      });
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.suggestions).toEqual(['foobar', 'food', 'foot']);
+    });
+
+    it('limits suggestions to max 3 entries', () => {
+      const error = new RillError({
+        errorId: 'RILL-R005',
+        message: 'Variable foo is not defined',
+        location: { line: 1, column: 1, offset: 0 },
+        context: {
+          name: 'foo',
+          suggestions: ['a', 'b', 'c', 'd', 'e'],
+        },
+      });
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.suggestions).toEqual(['a', 'b', 'c']);
+      expect(diagnostic.suggestions?.length).toBe(3);
+    });
+
+    it('omits suggestions field when not present', () => {
+      const error = new RuntimeError(
+        'RILL-R005',
+        'Variable foo is not defined',
+        { line: 1, column: 1, offset: 0 },
+        { name: 'foo' } // No suggestions in context
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic).not.toHaveProperty('suggestions');
+    });
+
+    it('omits suggestions field when empty array', () => {
+      const error = new RillError({
+        errorId: 'RILL-R005',
+        message: 'Variable foo is not defined',
+        location: { line: 1, column: 1, offset: 0 },
+        context: {
+          name: 'foo',
+          suggestions: [],
+        },
+      });
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic).not.toHaveProperty('suggestions');
+    });
+
+    it('filters out empty suggestion strings', () => {
+      const error = new RillError({
+        errorId: 'RILL-R005',
+        message: 'Variable foo is not defined',
+        location: { line: 1, column: 1, offset: 0 },
+        context: {
+          name: 'foo',
+          suggestions: ['valid', '', 'also-valid'],
+        },
+      });
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.suggestions).toEqual(['valid', 'also-valid']);
+    });
+
+    it('handles multi-line spans by using start location', () => {
+      const error = new RuntimeError(
+        'RILL-R002',
+        'Operator type mismatch',
+        { line: 5, column: 10, offset: 42 } // Only start location available
+      );
+
+      const diagnostic = toLspDiagnostic(error);
+
+      expect(diagnostic.range).toEqual({
+        start: { line: 4, character: 9 },
+        end: { line: 4, character: 9 },
+      });
+    });
+  });
+});