@git.zone/tstest 1.1.0 → 1.2.0

package/dist_ts/tstest.logging.js

@@ -0,0 +1,228 @@
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import * as plugins from './tstest.plugins.js';
+export class TsTestLogger {
+    constructor(options = {}) {
+        this.fileResults = [];
+        this.currentFileResult = null;
+        this.options = options;
+        this.startTime = Date.now();
+    }
+    format(text, color) {
+        if (this.options.noColor || !color) {
+            return text;
+        }
+        return cs(text, color);
+    }
+    log(message) {
+        if (this.options.json)
+            return;
+        console.log(message);
+        if (this.options.logFile) {
+            // TODO: Implement file logging
+        }
+    }
+    // Section separators
+    sectionStart(title) {
+        if (this.options.quiet || this.options.json)
+            return;
+        this.log(this.format(`\n━━━ ${title} ━━━`, 'cyan'));
+    }
+    sectionEnd() {
+        if (this.options.quiet || this.options.json)
+            return;
+        this.log(this.format('─'.repeat(50), 'dim'));
+    }
+    // Progress indication
+    progress(current, total, message) {
+        if (this.options.quiet || this.options.json)
+            return;
+        const percentage = Math.round((current / total) * 100);
+        const filled = Math.round((current / total) * 20);
+        const empty = 20 - filled;
+        this.log(this.format(`\n📊 Progress: ${current}/${total} (${percentage}%)`, 'cyan'));
+        this.log(this.format(`[${'█'.repeat(filled)}${'░'.repeat(empty)}] ${message}`, 'dim'));
+    }
+    // Test discovery
+    testDiscovery(count, pattern, executionMode) {
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'discovery', count, pattern, executionMode }));
+            return;
+        }
+        if (this.options.quiet) {
+            this.log(`Found ${count} tests`);
+        }
+        else {
+            this.log(this.format(`\n🔍 Test Discovery`, 'bold'));
+            this.log(this.format(`   Mode: ${executionMode}`, 'dim'));
+            this.log(this.format(`   Pattern: ${pattern}`, 'dim'));
+            this.log(this.format(`   Found: ${count} test file(s)`, 'green'));
+        }
+    }
+    // Test execution
+    testFileStart(filename, runtime, index, total) {
+        this.currentFileResult = {
+            file: filename,
+            passed: 0,
+            failed: 0,
+            total: 0,
+            duration: 0,
+            tests: []
+        };
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'fileStart', filename, runtime, index, total }));
+            return;
+        }
+        if (this.options.quiet)
+            return;
+        this.log(this.format(`\n▶️  ${filename} (${index}/${total})`, 'blue'));
+        this.log(this.format(`   Runtime: ${runtime}`, 'dim'));
+    }
+    testResult(testName, passed, duration, error) {
+        if (this.currentFileResult) {
+            this.currentFileResult.tests.push({ name: testName, passed, duration, error });
+            this.currentFileResult.total++;
+            if (passed) {
+                this.currentFileResult.passed++;
+            }
+            else {
+                this.currentFileResult.failed++;
+            }
+            this.currentFileResult.duration += duration;
+        }
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'testResult', testName, passed, duration, error }));
+            return;
+        }
+        const icon = passed ? '✅' : '❌';
+        const color = passed ? 'green' : 'red';
+        if (this.options.quiet) {
+            this.log(`${icon} ${testName}`);
+        }
+        else {
+            this.log(this.format(`   ${icon} ${testName} (${duration}ms)`, color));
+            if (error && !passed) {
+                this.log(this.format(`      ${error}`, 'red'));
+            }
+        }
+    }
+    testFileEnd(passed, failed, duration) {
+        if (this.currentFileResult) {
+            this.fileResults.push(this.currentFileResult);
+            this.currentFileResult = null;
+        }
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'fileEnd', passed, failed, duration }));
+            return;
+        }
+        if (!this.options.quiet) {
+            const total = passed + failed;
+            const status = failed === 0 ? 'PASSED' : 'FAILED';
+            const color = failed === 0 ? 'green' : 'red';
+            this.log(this.format(`   Summary: ${passed}/${total} ${status}`, color));
+        }
+    }
+    // TAP output forwarding
+    tapOutput(message, isError = false) {
+        if (this.options.json)
+            return;
+        if (this.options.verbose || isError) {
+            const prefix = isError ? '   ⚠️ ' : '   ';
+            const color = isError ? 'red' : 'dim';
+            this.log(this.format(`${prefix}${message}`, color));
+        }
+    }
+    // Browser console
+    browserConsole(message, level = 'log') {
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'browserConsole', message, level }));
+            return;
+        }
+        if (!this.options.quiet) {
+            const prefix = level === 'error' ? '🌐❌' : '🌐';
+            const color = level === 'error' ? 'red' : 'magenta';
+            this.log(this.format(`   ${prefix} ${message}`, color));
+        }
+    }
+    // Final summary
+    summary() {
+        const totalDuration = Date.now() - this.startTime;
+        const summary = {
+            totalFiles: this.fileResults.length,
+            totalTests: this.fileResults.reduce((sum, r) => sum + r.total, 0),
+            totalPassed: this.fileResults.reduce((sum, r) => sum + r.passed, 0),
+            totalFailed: this.fileResults.reduce((sum, r) => sum + r.failed, 0),
+            totalDuration,
+            fileResults: this.fileResults
+        };
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'summary', summary }));
+            return;
+        }
+        if (this.options.quiet) {
+            const status = summary.totalFailed === 0 ? 'PASSED' : 'FAILED';
+            this.log(`\nSummary: ${summary.totalPassed}/${summary.totalTests} | ${totalDuration}ms | ${status}`);
+            return;
+        }
+        // Detailed summary
+        this.log(this.format('\n📊 Test Summary', 'bold'));
+        this.log(this.format('┌────────────────────────────────┐', 'dim'));
+        this.log(this.format(`│ Total Files:    ${summary.totalFiles.toString().padStart(14)} │`, 'white'));
+        this.log(this.format(`│ Total Tests:    ${summary.totalTests.toString().padStart(14)} │`, 'white'));
+        this.log(this.format(`│ Passed:         ${summary.totalPassed.toString().padStart(14)} │`, 'green'));
+        this.log(this.format(`│ Failed:         ${summary.totalFailed.toString().padStart(14)} │`, summary.totalFailed > 0 ? 'red' : 'green'));
+        this.log(this.format(`│ Duration:       ${totalDuration.toString().padStart(14)}ms │`, 'white'));
+        this.log(this.format('└────────────────────────────────┘', 'dim'));
+        // File results
+        if (summary.totalFailed > 0) {
+            this.log(this.format('\n❌ Failed Tests:', 'red'));
+            this.fileResults.forEach(fileResult => {
+                if (fileResult.failed > 0) {
+                    this.log(this.format(`\n   ${fileResult.file}`, 'yellow'));
+                    fileResult.tests.filter(t => !t.passed).forEach(test => {
+                        this.log(this.format(`      ❌ ${test.name}`, 'red'));
+                        if (test.error) {
+                            this.log(this.format(`         ${test.error}`, 'dim'));
+                        }
+                    });
+                }
+            });
+        }
+        // Performance metrics
+        if (this.options.verbose) {
+            const avgDuration = Math.round(totalDuration / summary.totalTests);
+            const slowestTest = this.fileResults
+                .flatMap(r => r.tests)
+                .sort((a, b) => b.duration - a.duration)[0];
+            this.log(this.format('\n⏱️  Performance Metrics:', 'cyan'));
+            this.log(this.format(`   Average per test: ${avgDuration}ms`, 'white'));
+            if (slowestTest) {
+                this.log(this.format(`   Slowest test: ${slowestTest.name} (${slowestTest.duration}ms)`, 'yellow'));
+            }
+        }
+        // Final status
+        const status = summary.totalFailed === 0 ? 'ALL TESTS PASSED! 🎉' : 'SOME TESTS FAILED! ❌';
+        const statusColor = summary.totalFailed === 0 ? 'green' : 'red';
+        this.log(this.format(`\n${status}`, statusColor));
+    }
+    // Error display
+    error(message, file, stack) {
+        if (this.options.json) {
+            console.log(JSON.stringify({ event: 'error', message, file, stack }));
+            return;
+        }
+        if (this.options.quiet) {
+            console.error(`ERROR: ${message}`);
+        }
+        else {
+            this.log(this.format('\n⚠️  Error', 'red'));
+            if (file)
+                this.log(this.format(`   File: ${file}`, 'yellow'));
+            this.log(this.format(`   ${message}`, 'red'));
+            if (stack && this.options.verbose) {
+                this.log(this.format(`   Stack:`, 'dim'));
+                this.log(this.format(stack.split('\n').map(line => `     ${line}`).join('\n'), 'dim'));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tstest.logging.js","sourceRoot":"","sources":["../ts/tstest.logging.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tstest",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "private": false,
   "description": "a test utility to run tests that match test/**/*.ts",
   "main": "dist_ts/index.js",

package/readme.plan.md

@@ -1,51 +1,199 @@
-# Plan for adding single file and glob pattern execution support to tstest
+# Plan for improving logging and output in tstest
 
 !! FIRST: Reread /home/philkunz/.claude/CLAUDE.md to ensure following all guidelines !!
 
-## Goal - ✅ COMPLETED
-- ✅ Make `tstest test/test.abc.ts` run the specified file directly
-- ✅ Support glob patterns like `tstest test/*.spec.ts` or `tstest test/**/*.test.ts`
-- ✅ Maintain backward compatibility with directory argument
-
-## Current behavior - UPDATED
-- ✅ tstest now supports three modes: directory, single file, and glob patterns
-- ✅ Directory mode now searches recursively using `**/test*.ts` pattern
-- ✅ Single file mode runs a specific test file
-- ✅ Glob mode runs files matching the pattern
-
-## Completed changes
-
-### 1. ✅ Update cli argument handling in index.ts
-- ✅ Detect argument type: file path, glob pattern, or directory
-- ✅ Check if argument contains glob characters (*, **, ?, [], etc.)
-- ✅ Pass appropriate mode to TsTest constructor
-- ✅ Added TestExecutionMode enum
-
-### 2. ✅ Modify TsTest constructor and class
-- ✅ Add support for three modes: directory, file, glob
-- ✅ Update constructor to accept pattern/path and mode
-- ✅ Added executionMode property to track the mode
-
-### 3. ✅ Update TestDirectory class
-- ✅ Used `listFileTree` for glob pattern support
-- ✅ Used `SmartFile.fromFilePath` for single file loading
-- ✅ Refactored to support all three modes in `_init` method
-- ✅ Return appropriate file array based on mode
-- ✅ Changed default directory behavior to recursive search
-  - ✅ When directory argument: use `**/test*.ts` pattern for recursive search
-  - ✅ This ensures subdirectories are included in test discovery
-
-### 4. ✅ Test the implementation
-- ✅ Created test file `test/test.single.ts` for single file functionality
-- ✅ Created test file `test/test.glob.ts` for glob pattern functionality
-- ✅ Created test in subdirectory `test/subdir/test.sub.ts` for recursive search
-- ✅ Tested with existing test files for backward compatibility
-- ✅ Tested glob patterns: `test/test.*.ts` works correctly
-- ✅ Verified that default behavior now includes subdirectories
-
-## Implementation completed
-1. ✅ CLI argument type detection implemented
-2. ✅ TsTest class supports all three modes
-3. ✅ TestDirectory handles files, globs, and directories
-4. ✅ Default pattern changed from `test*.ts` to `**/test*.ts` for recursive search
-5. ✅ Comprehensive tests added and all modes verified
+## Goal - ✅ MOSTLY COMPLETED
+- ✅ Make test output cleaner and more visually appealing
+- ✅ Add structured logging capabilities
+- ✅ Support different verbosity levels
+- ✅ Improve CI/CD compatibility
+- ✅ Add progress indicators and timing summaries
+
+## Current State - UPDATED
+- ✅ Clean, modern visual design with Unicode characters
+- ✅ Structured output format (JSON support)
+- ✅ Multiple verbosity levels (quiet, normal, verbose)
+- ✅ Real-time output with cleaner formatting
+- ✅ Better error aggregation and display
+- ✅ TAP protocol support integrated with new logger
+
+## Completed Improvements
+
+### 1. ✅ Created new TsTestLogger class
+- ✅ Centralized logging with consistent formatting
+- ✅ Support for different output modes (normal, quiet, verbose)
+- ✅ Better visual hierarchy with modern Unicode characters
+- ✅ Progress indicators for multiple test files
+- ✅ Structured error collection and display
+
+### 2. ✅ Updated visual design
+- ✅ Replaced heavy separators with cleaner alternatives
+- ✅ Used better emoji and Unicode characters
+- ✅ Added indentation for hierarchical display
+- ✅ Grouped related information visually
+- ✅ Added color coding consistently
+
+### 3. ✅ Added command-line options
+- ✅ `--quiet` for minimal CI-friendly output
+- ✅ `--verbose` for detailed debugging information
+- ✅ `--no-color` for environments without color support
+- ✅ `--json` for structured JSON output
+- ⏳ `--log-file <path>` for persistent logging (TODO)
+
+### 4. ✅ Improved progress feedback
+- ⏳ Show progress bar for multiple files (TODO)
+- ✅ Display current file being executed
+- ✅ Show real-time test counts
+- ⏳ Add ETA for long test suites (TODO)
+
+### 5. ✅ Better error and summary display
+- ✅ Collect all errors and display at end
+- ✅ Show timing metrics and performance summary (in verbose mode)
+- ✅ Highlight slowest tests (in verbose mode)
+- ✅ Add test failure context
+
+### 6. ✅ Browser console integration
+- ✅ Clearly separate browser logs from test output
+- ⏳ Add browser log filtering options (TODO)
+- ✅ Format browser errors specially
+
+## Implementation Steps - COMPLETED
+
+### Phase 1: ✅ Core Logger Implementation
+1. ✅ Created `tstest.logging.ts` with TsTestLogger class
+2. ✅ Added LogOptions interface for configuration
+3. ✅ Implemented basic formatting methods
+4. ✅ Added progress and summary methods
+
+### Phase 2: ✅ Integration
+1. ✅ Updated CLI to accept new command-line options
+2. ✅ Modified TsTest class to use new logger
+3. ✅ Updated TapParser to use structured logging
+4. ✅ Updated TapCombinator for better summaries
+
+### Phase 3: ✅ Visual Improvements
+1. ✅ Replaced all existing separators
+2. ✅ Updated color scheme
+3. ✅ Added emoji and Unicode characters
+4. ✅ Implemented hierarchical output
+
+### Phase 4: ✅ Advanced Features
+1. ✅ Add JSON output format
+2. ⏳ Implement file-based logging (TODO)
+3. ✅ Add performance metrics collection
+4. ✅ Create error aggregation system
+
+### Phase 5: ✅ Browser Integration
+1. ✅ Update browser console forwarding
+2. ✅ Add browser log formatting
+3. ✅ Implement browser-specific indicators
+
+## Files modified
+- ✅ `ts/tstest.logging.ts` - New logger implementation (created)
+- ✅ `ts/index.ts` - Added CLI options parsing
+- ✅ `ts/tstest.classes.tstest.ts` - Integrated new logger
+- ✅ `ts/tstest.classes.tap.parser.ts` - Updated output formatting
+- ✅ `ts/tstest.classes.tap.combinator.ts` - Improved summary display
+- ❌ `ts/tstest.logprefixes.ts` - Still in use, can be deprecated later
+- ❌ `package.json` - No new dependencies needed
+
+## Success Criteria - ACHIEVED
+- ✅ Cleaner, more readable test output
+- ✅ Configurable verbosity levels
+- ✅ Better CI/CD integration
+- ✅ Improved error visibility
+- ✅ Performance metrics available
+- ✅ Consistent visual design
+- ✅ Maintained backward compatibility
+
+## Example Output Comparison
+
+### Current Output
+```
+☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰
+**TSTEST** FOUND 4 TESTFILE(S):
+**TSTEST** test/test.ts
+------------------------------------------------
+=> Running test/test.ts in node.js runtime.
+= = = = = = = = = = = = = = = = = = = = = = = =
+```
+
+### Actual Output (IMPLEMENTED)
+```
+🔍 Test Discovery
+   Mode: directory
+   Pattern: test
+   Found: 4 test file(s)
+
+▶️  test/test.ts (1/4)
+   Runtime: node.js
+   ✅ prepare test (0ms)
+   Summary: 1/1 PASSED
+
+▶️  test/test.single.ts (2/4)
+   Runtime: node.js
+   ✅ single file test execution (1ms)
+   Summary: 1/1 PASSED
+
+📊 Test Summary
+┌────────────────────────────────┐
+│ Total Files:                 4 │
+│ Total Tests:                 4 │
+│ Passed:                      4 │
+│ Failed:                      0 │
+│ Duration:                 5739ms │
+└────────────────────────────────┘
+
+ALL TESTS PASSED! 🎉
+```
+
+### Additional Features Implemented
+
+1. **Quiet Mode**:
+```
+Found 1 tests
+✅ single file test execution
+
+Summary: 1/1 | 1210ms | PASSED
+```
+
+2. **JSON Mode**:
+```json
+{"event":"discovery","count":1,"pattern":"test/test.single.ts","executionMode":"file"}
+{"event":"fileStart","filename":"test/test.single.ts","runtime":"node.js","index":1,"total":1}
+{"event":"testResult","testName":"single file test execution","passed":true,"duration":0}
+{"event":"summary","summary":{"totalFiles":1,"totalTests":1,"totalPassed":1,"totalFailed":0,"totalDuration":1223,"fileResults":[...]}}
+```
+
+3. **Error Display**:
+```
+❌ Failed Tests:
+
+   test/test.fail.ts
+      ❌ This test should fail
+
+SOME TESTS FAILED! ❌
+```
+
+## Summary of Implementation
+
+The logging improvement plan has been successfully implemented with the following achievements:
+
+1. **Created a new centralized TsTestLogger class** that handles all output formatting
+2. **Added multiple output modes**: quiet, normal, verbose, and JSON
+3. **Improved visual design** with modern Unicode characters and emojis
+4. **Added CLI argument parsing** for all new options
+5. **Integrated the logger throughout the codebase** (TsTest, TapParser, TapCombinator)
+6. **Better error aggregation and display** with failed tests shown at the end
+7. **Performance metrics** available in verbose mode
+8. **Clean, hierarchical output** that's much more readable
+
+### Remaining TODOs
+
+Only a few minor features remain unimplemented:
+- File-based logging (--log-file option)
+- Progress bar visualization
+- ETA for long test suites
+- Browser log filtering options
+
+The core logging improvements are complete and provide a much better user experience!

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tstest',
-  version: '1.1.0',
+  version: '1.2.0',
   description: 'a test utility to run tests that match test/**/*.ts'
 }

package/ts/index.ts

@@ -1,4 +1,5 @@
 import { TsTest } from './tstest.classes.tstest.js';
+import type { LogOptions } from './tstest.logging.js';
 
 export enum TestExecutionMode {
   DIRECTORY = 'directory',
@@ -7,12 +8,54 @@ export enum TestExecutionMode {
 }
 
 export const runCli = async () => {
-  if (!process.argv[2]) {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const logOptions: LogOptions = {};
+  let testPath: string | null = null;
+  
+  // Parse options
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    switch (arg) {
+      case '--quiet':
+      case '-q':
+        logOptions.quiet = true;
+        break;
+      case '--verbose':
+      case '-v':
+        logOptions.verbose = true;
+        break;
+      case '--no-color':
+        logOptions.noColor = true;
+        break;
+      case '--json':
+        logOptions.json = true;
+        break;
+      case '--log-file':
+        if (i + 1 < args.length) {
+          logOptions.logFile = args[++i];
+        }
+        break;
+      default:
+        if (!arg.startsWith('-')) {
+          testPath = arg;
+        }
+    }
+  }
+  
+  if (!testPath) {
     console.error('You must specify a test directory/file/pattern as argument. Please try again.');
+    console.error('\nUsage: tstest <path> [options]');
+    console.error('\nOptions:');
+    console.error('  --quiet, -q     Minimal output');
+    console.error('  --verbose, -v   Verbose output');
+    console.error('  --no-color      Disable colored output');
+    console.error('  --json          Output results as JSON');
+    console.error('  --log-file      Write logs to file');
     process.exit(1);
   }
   
-  const testPath = process.argv[2];
   let executionMode: TestExecutionMode;
   
   // Detect execution mode based on the argument
@@ -24,6 +67,6 @@ export const runCli = async () => {
     executionMode = TestExecutionMode.DIRECTORY;
   }
   
-  const tsTestInstance = new TsTest(process.cwd(), testPath, executionMode);
+  const tsTestInstance = new TsTest(process.cwd(), testPath, executionMode, logOptions);
   await tsTestInstance.run();
 };