spec-up-t 1.4.1 → 1.6.0-beta.1

package/test/logger.test.js

@@ -0,0 +1,290 @@
+/**
+ * @file Unit tests for enhanced Logger.error and Logger.warn functionality
+ * 
+ * Tests the new context, hint, and details options for error and warning messages.
+ * Ensures backward compatibility with existing simple message calls.
+ */
+
+const Logger = require('../src/utils/logger');
+const messageCollector = require('../src/utils/message-collector');
+
+// Mock console.log to capture output
+let consoleLogs = [];
+const originalConsoleLog = console.log;
+
+beforeAll(() => {
+    console.log = (...args) => {
+        consoleLogs.push(args);
+    };
+});
+
+afterAll(() => {
+    console.log = originalConsoleLog;
+});
+
+beforeEach(() => {
+    consoleLogs = [];
+    messageCollector.clearMessages();
+});
+
+afterEach(() => {
+    messageCollector.stopCollecting();
+});
+
+describe('Enhanced Logger.error', () => {
+    test('should work with simple message (backward compatibility)', () => {
+        Logger.error('Simple error message');
+
+        expect(consoleLogs.length).toBeGreaterThan(0);
+        expect(consoleLogs[0].join(' ')).toContain('Simple error message');
+    });
+
+    test('should work with message and regular arguments', () => {
+        Logger.error('Error with args', 'arg1', 123);
+
+        expect(consoleLogs.length).toBeGreaterThan(0);
+        const output = consoleLogs[0].join(' ');
+        expect(output).toContain('Error with args');
+        expect(output).toContain('arg1');
+        expect(output).toContain('123');
+    });
+
+    test('should display context when provided', () => {
+        consoleLogs = [];
+        Logger.error('Test error', { context: 'specs.json' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Context:');
+        expect(allOutput).toContain('specs.json');
+    });
+
+    test('should display hint when provided', () => {
+        consoleLogs = [];
+        Logger.error('Test error', { hint: 'Run npm install' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('How to fix:');
+        expect(allOutput).toContain('Run npm install');
+    });
+
+    test('should display details when provided', () => {
+        consoleLogs = [];
+        Logger.error('Test error', { details: 'Error code: 404' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Details:');
+        expect(allOutput).toContain('Error code: 404');
+    });
+
+    test('should handle all options together', () => {
+        consoleLogs = [];
+        Logger.error('Test error', {
+            context: 'Test context',
+            hint: 'Test hint',
+            details: 'Test details'
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Test error');
+        expect(allOutput).toContain('Context:');
+        expect(allOutput).toContain('Test context');
+        expect(allOutput).toContain('How to fix:');
+        expect(allOutput).toContain('Test hint');
+        expect(allOutput).toContain('Details:');
+        expect(allOutput).toContain('Test details');
+    });
+
+    test('should handle regular args mixed with options', () => {
+        consoleLogs = [];
+        Logger.error('Error', 'arg1', 'arg2', { hint: 'Fix it' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Error');
+        expect(allOutput).toContain('arg1');
+        expect(allOutput).toContain('arg2');
+        expect(allOutput).toContain('Fix it');
+    });
+
+    test('should handle object details', () => {
+        consoleLogs = [];
+        Logger.error('Test error', {
+            details: { code: 404, message: 'Not found' }
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('404');
+        expect(allOutput).toContain('Not found');
+    });
+
+    test('should not treat regular object as options', () => {
+        consoleLogs = [];
+        Logger.error('Test error', { someData: 'value' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Test error');
+        // Should treat it as regular argument, not as options
+        // The object will be stringified as [object Object]
+        expect(allOutput).toContain('[object Object]');
+    });
+
+    test('should collect enhanced messages', () => {
+        messageCollector.startCollecting('test');
+
+        Logger.error('Test error', {
+            context: 'test context',
+            hint: 'test hint',
+            details: 'test details'
+        });
+
+        const messages = messageCollector.getMessages();
+        expect(messages).toHaveLength(1);
+        expect(messages[0].type).toBe('error');
+        expect(messages[0].message).toBe('Test error');
+
+        // Should have collected the options
+        const additionalData = messages[0].additionalData;
+        expect(additionalData).toBeDefined();
+        expect(additionalData.length).toBeGreaterThan(0);
+
+        messageCollector.stopCollecting();
+    });
+});
+
+describe('Enhanced Logger.warn', () => {
+    test('should work with simple message (backward compatibility)', () => {
+        Logger.warn('Simple warning message');
+
+        expect(consoleLogs.length).toBeGreaterThan(0);
+        expect(consoleLogs[0].join(' ')).toContain('Simple warning message');
+    });
+
+    test('should work with message and regular arguments', () => {
+        Logger.warn('Warning with args', 'arg1', 123);
+
+        expect(consoleLogs.length).toBeGreaterThan(0);
+        const output = consoleLogs[0].join(' ');
+        expect(output).toContain('Warning with args');
+        expect(output).toContain('arg1');
+        expect(output).toContain('123');
+    });
+
+    test('should display context when provided', () => {
+        consoleLogs = [];
+        Logger.warn('Test warning', { context: 'Configuration file' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Context:');
+        expect(allOutput).toContain('Configuration file');
+    });
+
+    test('should display hint when provided', () => {
+        consoleLogs = [];
+        Logger.warn('Test warning', { hint: 'Consider updating to latest version' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Suggestion:');
+        expect(allOutput).toContain('Consider updating to latest version');
+    });
+
+    test('should display details when provided', () => {
+        consoleLogs = [];
+        Logger.warn('Test warning', { details: 'Using fallback: default' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Details:');
+        expect(allOutput).toContain('Using fallback: default');
+    });
+
+    test('should handle all options together', () => {
+        consoleLogs = [];
+        Logger.warn('Test warning', {
+            context: 'Test context',
+            hint: 'Test suggestion',
+            details: 'Test details'
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Test warning');
+        expect(allOutput).toContain('Context:');
+        expect(allOutput).toContain('Test context');
+        expect(allOutput).toContain('Suggestion:');
+        expect(allOutput).toContain('Test suggestion');
+        expect(allOutput).toContain('Details:');
+        expect(allOutput).toContain('Test details');
+    });
+
+    test('should handle regular args mixed with options', () => {
+        consoleLogs = [];
+        Logger.warn('Warning', 'arg1', 'arg2', { hint: 'Update config' });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Warning');
+        expect(allOutput).toContain('arg1');
+        expect(allOutput).toContain('arg2');
+        expect(allOutput).toContain('Update config');
+    });
+
+    test('should collect enhanced messages', () => {
+        messageCollector.startCollecting('test');
+
+        Logger.warn('Test warning', {
+            context: 'test context',
+            hint: 'test hint',
+            details: 'test details'
+        });
+
+        const messages = messageCollector.getMessages();
+        expect(messages).toHaveLength(1);
+        expect(messages[0].type).toBe('warn');
+        expect(messages[0].message).toBe('Test warning');
+
+        messageCollector.stopCollecting();
+    });
+});
+
+describe('Edge Cases', () => {
+    test('should handle empty options object', () => {
+        consoleLogs = [];
+        Logger.error('Test', {});
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Test');
+        // Should just show the message without extra lines
+    });
+
+    test('should handle null and undefined in options', () => {
+        consoleLogs = [];
+        Logger.error('Test', {
+            context: null,
+            hint: undefined,
+            details: 'valid'
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Test');
+        expect(allOutput).toContain('Details:');
+        expect(allOutput).toContain('valid');
+    });
+
+    test('should handle special characters in options', () => {
+        consoleLogs = [];
+        Logger.error('Test', {
+            hint: 'Fix with: npm run build && npm test'
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('npm run build && npm test');
+    });
+
+    test('should handle multiline strings in options', () => {
+        consoleLogs = [];
+        Logger.error('Test', {
+            details: 'Line 1\nLine 2\nLine 3'
+        });
+
+        const allOutput = consoleLogs.map(log => log.join(' ')).join('\n');
+        expect(allOutput).toContain('Line 1');
+        expect(allOutput).toContain('Line 2');
+        expect(allOutput).toContain('Line 3');
+    });
+});

package/test/message-collector.test.js

@@ -0,0 +1,286 @@
+/**
+ * @file Unit tests for message-collector utility
+ * 
+ * Tests the message collection functionality that captures console output
+ * from Logger calls and stores them in JSON format.
+ */
+
+const messageCollector = require('../src/utils/message-collector');
+const Logger = require('../src/utils/logger');
+const fs = require('fs-extra');
+const path = require('path');
+
+describe('Message Collector', () => {
+    // Clean up before and after each test
+    beforeEach(() => {
+        messageCollector.clearMessages();
+    });
+
+    afterEach(() => {
+        messageCollector.stopCollecting();
+        messageCollector.clearMessages();
+    });
+
+    describe('Basic Collection', () => {
+        test('should start and stop collecting', () => {
+            expect(messageCollector.getStatistics().isCollecting).toBe(false);
+            
+            messageCollector.startCollecting('test');
+            expect(messageCollector.getStatistics().isCollecting).toBe(true);
+            expect(messageCollector.getStatistics().currentOperation).toBe('test');
+            
+            messageCollector.stopCollecting();
+            expect(messageCollector.getStatistics().isCollecting).toBe(false);
+            expect(messageCollector.getStatistics().currentOperation).toBe(null);
+        });
+
+        test('should collect messages when active', () => {
+            messageCollector.startCollecting('test');
+            
+            Logger.info('Test message');
+            Logger.success('Success message');
+            Logger.warn('Warning message');
+            
+            const messages = messageCollector.getMessages();
+            expect(messages).toHaveLength(3);
+            expect(messages[0].message).toBe('Test message');
+            expect(messages[0].type).toBe('info');
+            expect(messages[0].operation).toBe('test');
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should not collect messages when inactive', () => {
+            Logger.info('This should not be collected');
+            
+            const messages = messageCollector.getMessages();
+            expect(messages).toHaveLength(0);
+        });
+
+        test('should clear messages', () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Message 1');
+            Logger.info('Message 2');
+            
+            expect(messageCollector.getMessages()).toHaveLength(2);
+            
+            messageCollector.clearMessages();
+            expect(messageCollector.getMessages()).toHaveLength(0);
+            
+            messageCollector.stopCollecting();
+        });
+    });
+
+    describe('Message Structure', () => {
+        test('should include all required fields', () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Test message', 'extra', 'data');
+            
+            const messages = messageCollector.getMessages();
+            expect(messages[0]).toHaveProperty('timestamp');
+            expect(messages[0]).toHaveProperty('type');
+            expect(messages[0]).toHaveProperty('message');
+            expect(messages[0]).toHaveProperty('operation');
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should capture additional arguments', () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Test', 'arg1', 'arg2', 123);
+            
+            const messages = messageCollector.getMessages();
+            expect(messages[0].additionalData).toEqual(['arg1', 'arg2', '123']);
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should handle different message types', () => {
+            messageCollector.startCollecting('test');
+            
+            Logger.success('Success');
+            Logger.error('Error');
+            Logger.warn('Warning');
+            Logger.info('Info');
+            Logger.process('Process');
+            Logger.highlight('Highlight');
+            Logger.debug('Debug');
+            Logger.separator();
+            
+            const messages = messageCollector.getMessages();
+            expect(messages).toHaveLength(8);
+            
+            const types = messages.map(m => m.type);
+            expect(types).toContain('success');
+            expect(types).toContain('error');
+            expect(types).toContain('warn');
+            expect(types).toContain('info');
+            expect(types).toContain('process');
+            expect(types).toContain('highlight');
+            expect(types).toContain('debug');
+            expect(types).toContain('separator');
+            
+            messageCollector.stopCollecting();
+        });
+    });
+
+    describe('Statistics', () => {
+        test('should calculate message counts by type', () => {
+            messageCollector.startCollecting('test');
+            
+            Logger.info('Info 1');
+            Logger.info('Info 2');
+            Logger.success('Success 1');
+            Logger.error('Error 1');
+            
+            const stats = messageCollector.getStatistics();
+            expect(stats.total).toBe(4);
+            expect(stats.byType.info).toBe(2);
+            expect(stats.byType.success).toBe(1);
+            expect(stats.byType.error).toBe(1);
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should track messages by operation', () => {
+            messageCollector.startCollecting('render');
+            Logger.info('Render 1');
+            Logger.info('Render 2');
+            messageCollector.stopCollecting();
+            
+            messageCollector.startCollecting('collect');
+            Logger.info('Collect 1');
+            messageCollector.stopCollecting();
+            
+            const stats = messageCollector.getStatistics();
+            expect(stats.byOperation.render).toBe(2);
+            expect(stats.byOperation.collect).toBe(1);
+        });
+    });
+
+    describe('File Operations', () => {
+        const testOutputPath = path.join(__dirname, '.test-cache', 'test-messages.json');
+
+        beforeEach(async () => {
+            // Clean up test output
+            await fs.remove(path.dirname(testOutputPath));
+        });
+
+        afterEach(async () => {
+            // Clean up test output
+            await fs.remove(path.dirname(testOutputPath));
+        });
+
+        test('should save messages to file', async () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Test message');
+            Logger.success('Success');
+            messageCollector.stopCollecting();
+            
+            const savedPath = await messageCollector.saveMessages(testOutputPath);
+            expect(savedPath).toBe(testOutputPath);
+            
+            const exists = await fs.pathExists(testOutputPath);
+            expect(exists).toBe(true);
+        });
+
+        test('should create directory if it does not exist', async () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Test');
+            messageCollector.stopCollecting();
+            
+            await messageCollector.saveMessages(testOutputPath);
+            
+            const dirExists = await fs.pathExists(path.dirname(testOutputPath));
+            expect(dirExists).toBe(true);
+        });
+
+        test('should include metadata in saved file', async () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Info message');
+            Logger.success('Success message');
+            Logger.warn('Warning message');
+            messageCollector.stopCollecting();
+            
+            await messageCollector.saveMessages(testOutputPath);
+            
+            const output = await fs.readJson(testOutputPath);
+            
+            expect(output).toHaveProperty('metadata');
+            expect(output).toHaveProperty('messages');
+            
+            expect(output.metadata).toHaveProperty('generatedAt');
+            expect(output.metadata).toHaveProperty('totalMessages');
+            expect(output.metadata).toHaveProperty('operations');
+            expect(output.metadata).toHaveProperty('messagesByType');
+            
+            expect(output.metadata.totalMessages).toBe(3);
+            expect(output.metadata.operations).toContain('test');
+            expect(output.metadata.messagesByType.info).toBe(1);
+            expect(output.metadata.messagesByType.success).toBe(1);
+            expect(output.metadata.messagesByType.warn).toBe(1);
+        });
+
+        test('should save valid JSON', async () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Message 1');
+            Logger.success('Message 2');
+            messageCollector.stopCollecting();
+            
+            await messageCollector.saveMessages(testOutputPath);
+            
+            // Should not throw when reading
+            const output = await fs.readJson(testOutputPath);
+            expect(output.messages).toHaveLength(2);
+        });
+    });
+
+    describe('Edge Cases', () => {
+        test('should handle empty message collection', () => {
+            messageCollector.startCollecting('test');
+            messageCollector.stopCollecting();
+            
+            const messages = messageCollector.getMessages();
+            expect(messages).toHaveLength(0);
+            
+            const stats = messageCollector.getStatistics();
+            expect(stats.total).toBe(0);
+        });
+
+        test('should handle multiple start calls', () => {
+            messageCollector.startCollecting('operation1');
+            messageCollector.startCollecting('operation2');
+            
+            Logger.info('Test');
+            
+            const messages = messageCollector.getMessages();
+            expect(messages[0].operation).toBe('operation2'); // Last operation
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should handle special characters in messages', () => {
+            messageCollector.startCollecting('test');
+            Logger.info('Special chars: 😀 🔥 \n\t \\');
+            
+            const messages = messageCollector.getMessages();
+            expect(messages[0].message).toContain('😀');
+            
+            messageCollector.stopCollecting();
+        });
+
+        test('should convert non-string messages to strings', () => {
+            messageCollector.startCollecting('test');
+            Logger.info({ nested: 'object' });
+            Logger.info(123);
+            Logger.info(null);
+            
+            const messages = messageCollector.getMessages();
+            expect(typeof messages[0].message).toBe('string');
+            expect(typeof messages[1].message).toBe('string');
+            expect(typeof messages[2].message).toBe('string');
+            
+            messageCollector.stopCollecting();
+        });
+    });
+});

package/assets/css/insert-trefs.css

@@ -1 +0,0 @@
-/* Currently empty */

package/src/markdown-it/link-enhancement.js

@@ -1,98 +0,0 @@
-'use strict';
-
-/**
- * Markdown-it Link Enhancement Module
- * 
- * This module enhances link rendering by adding path-based attributes to anchor tags.
- * These attributes can be used for CSS styling or JavaScript behavior based on the
- * link's destination (domain, path segments, etc.).
- * 
- * For example, a link to "https://example.com/docs/api" would get attributes like:
- * - path-0="example.com"
- * - path-1="docs"
- * - path-2="api"
- * 
- * This allows for targeted styling of links based on their destination.
- */
-
-/**
- * Regular expression to extract domains and path segments from URLs
- * 
- * This regex has two capture groups:
- * - Group 1: Domain from http(s):// URLs (e.g., "example.com" from "https://example.com/path")
- * - Group 2: Path segments from relative URLs (e.g., "docs" from "/docs/page")
- * 
- * The 'g' flag enables global matching to find all segments in a URL.
- */
-const pathSegmentRegex = /(?:http[s]*:\/\/([^\/]*)|(?:\/([^\/?]*)))/g;
-
-/**
- * Applies link enhancements to a markdown-it instance
- * 
- * @param {Object} md - The markdown-it instance to enhance
- * 
- * This function overrides the default link_open and link_close renderers
- * to add path-based attributes and special handling for auto-detected links.
- */
-function applyLinkEnhancements(md) {
-  
-  /**
-   * Custom link_open renderer that adds path attributes
-   * 
-   * @param {Array} tokens - Array of all tokens being processed
-   * @param {Number} idx - Index of the current link_open token
-   * @param {Object} options - Markdown-it options
-   * @param {Object} env - Environment/context object
-   * @param {Object} renderer - The renderer instance
-   * @returns {String} HTML string for the opening anchor tag with path attributes
-   */
-  md.renderer.rules.link_open = function (tokens, idx, options, env, renderer) {
-    let token = tokens[idx];
-    
-    // Process all attributes of the link token
-    let attrs = token.attrs.reduce((str, attr) => {
-      let name = attr[0];   // Attribute name (e.g., 'href', 'title')
-      let value = attr[1];  // Attribute value (e.g., 'https://example.com')
-      
-      // Special processing for href attributes to add path information
-      if (name === 'href') {
-        let index = 0;
-        
-        // Extract domain and path segments using the regex
-        value.replace(pathSegmentRegex, (match, domain, pathSegment) => {
-          // Add path-N attributes for each segment found
-          // domain OR pathSegment will be defined (not both, due to regex groups)
-          str += `path-${index++}="${domain || pathSegment}" `;
-        });
-      }
-      
-      // Add the original attribute to the string
-      str += `${name}="${value}" `;
-      return str;
-    }, '');
-
-    // Create the opening anchor tag with all attributes
-    let anchor = `<a ${attrs}>`;
-    
-    // Special handling for auto-detected links (linkify plugin)
-    // These get an extra <span> wrapper for styling purposes
-    return token.markup === 'linkify' ? anchor + '<span>' : anchor;
-  };
-
-  /**
-   * Custom link_close renderer
-   * 
-   * @param {Array} tokens - Array of all tokens being processed
-   * @param {Number} idx - Index of the current link_close token
-   * @param {Object} options - Markdown-it options
-   * @param {Object} env - Environment/context object
-   * @param {Object} renderer - The renderer instance
-   * @returns {String} HTML string for the closing anchor tag
-   */
-  md.renderer.rules.link_close = function (tokens, idx, options, env, renderer) {
-    // Close the extra span for linkify links, or just close the anchor
-    return tokens[idx].markup === 'linkify' ? '</span></a>' : '</a>';
-  };
-}
-
-module.exports = applyLinkEnhancements;