@git.zone/tstest 1.1.0 → 1.3.0

package/ts/tstest.classes.tstest.ts

@@ -8,10 +8,13 @@ import { TestDirectory } from './tstest.classes.testdirectory.js';
 import { TapCombinator } from './tstest.classes.tap.combinator.js';
 import { TapParser } from './tstest.classes.tap.parser.js';
 import { TestExecutionMode } from './index.js';
+import { TsTestLogger } from './tstest.logging.js';
+import type { LogOptions } from './tstest.logging.js';
 
 export class TsTest {
   public testDir: TestDirectory;
   public executionMode: TestExecutionMode;
+  public logger: TsTestLogger;
 
   public smartshellInstance = new plugins.smartshell.Smartshell({
     executor: 'bash',
@@ -22,62 +25,57 @@ export class TsTest {
 
   public tsbundleInstance = new plugins.tsbundle.TsBundle();
 
-  constructor(cwdArg: string, testPathArg: string, executionModeArg: TestExecutionMode) {
+  constructor(cwdArg: string, testPathArg: string, executionModeArg: TestExecutionMode, logOptions: LogOptions = {}) {
     this.executionMode = executionModeArg;
     this.testDir = new TestDirectory(cwdArg, testPathArg, executionModeArg);
+    this.logger = new TsTestLogger(logOptions);
   }
 
   async run() {
     const fileNamesToRun: string[] = await this.testDir.getTestFilePathArray();
-    console.log(cs(plugins.figures.hamburger.repeat(80), 'cyan'));
-    console.log('');
-    console.log(`${logPrefixes.TsTestPrefix} FOUND ${fileNamesToRun.length} TESTFILE(S):`);
-    for (const fileName of fileNamesToRun) {
-      console.log(`${logPrefixes.TsTestPrefix} ${cs(fileName, 'orange')}`);
-    }
-    console.log('-'.repeat(48));
-    console.log(''); // force new line
+    
+    // Log test discovery
+    this.logger.testDiscovery(
+      fileNamesToRun.length, 
+      this.testDir.testPath,
+      this.executionMode
+    );
 
-    const tapCombinator = new TapCombinator(); // lets create the TapCombinator
+    const tapCombinator = new TapCombinator(this.logger); // lets create the TapCombinator
+    let fileIndex = 0;
     for (const fileNameArg of fileNamesToRun) {
+      fileIndex++;
       switch (true) {
         case process.env.CI && fileNameArg.includes('.nonci.'):
-          console.log('!!!!!!!!!!!');
-          console.log(
-            `not running testfile ${fileNameArg}, since we are CI and file name includes '.nonci.' tag`
-          );
-          console.log('!!!!!!!!!!!');
+          this.logger.tapOutput(`Skipping ${fileNameArg} - marked as non-CI`);
           break;
         case fileNameArg.endsWith('.browser.ts') || fileNameArg.endsWith('.browser.nonci.ts'):
-          const tapParserBrowser = await this.runInChrome(fileNameArg);
+          const tapParserBrowser = await this.runInChrome(fileNameArg, fileIndex, fileNamesToRun.length);
           tapCombinator.addTapParser(tapParserBrowser);
           break;
         case fileNameArg.endsWith('.both.ts') || fileNameArg.endsWith('.both.nonci.ts'):
-          console.log('>>>>>>> TEST PART 1: chrome');
-          const tapParserBothBrowser = await this.runInChrome(fileNameArg);
+          this.logger.sectionStart('Part 1: Chrome');
+          const tapParserBothBrowser = await this.runInChrome(fileNameArg, fileIndex, fileNamesToRun.length);
           tapCombinator.addTapParser(tapParserBothBrowser);
-          console.log(cs(`|`.repeat(16), 'cyan'));
-          console.log(''); // force new line
-          console.log('>>>>>>> TEST PART 2: node');
-          const tapParserBothNode = await this.runInNode(fileNameArg);
+          this.logger.sectionEnd();
+          
+          this.logger.sectionStart('Part 2: Node');
+          const tapParserBothNode = await this.runInNode(fileNameArg, fileIndex, fileNamesToRun.length);
           tapCombinator.addTapParser(tapParserBothNode);
+          this.logger.sectionEnd();
           break;
         default:
-          const tapParserNode = await this.runInNode(fileNameArg);
+          const tapParserNode = await this.runInNode(fileNameArg, fileIndex, fileNamesToRun.length);
           tapCombinator.addTapParser(tapParserNode);
           break;
       }
-
-      console.log(cs(`^`.repeat(16), 'cyan'));
-      console.log(''); // force new line
     }
     tapCombinator.evaluate();
   }
 
-  public async runInNode(fileNameArg: string): Promise<TapParser> {
-    console.log(`${cs('=> ', 'blue')} Running ${cs(fileNameArg, 'orange')} in node.js runtime.`);
-    console.log(`${cs(`= `.repeat(32), 'cyan')}`);
-    const tapParser = new TapParser(fileNameArg + ':node');
+  public async runInNode(fileNameArg: string, index: number, total: number): Promise<TapParser> {
+    this.logger.testFileStart(fileNameArg, 'node.js', index, total);
+    const tapParser = new TapParser(fileNameArg + ':node', this.logger);
 
     // tsrun options
     let tsrunOptions = '';
@@ -92,9 +90,8 @@ export class TsTest {
     return tapParser;
   }
 
-  public async runInChrome(fileNameArg: string): Promise<TapParser> {
-    console.log(`${cs('=> ', 'blue')} Running ${cs(fileNameArg, 'orange')} in chromium runtime.`);
-    console.log(`${cs(`= `.repeat(32), 'cyan')}`);
+  public async runInChrome(fileNameArg: string, index: number, total: number): Promise<TapParser> {
+    this.logger.testFileStart(fileNameArg, 'chromium', index, total);
 
     // lets get all our paths sorted
     const tsbundleCacheDirPath = plugins.path.join(paths.cwd, './.nogit/tstest_cache');
@@ -133,11 +130,17 @@ export class TsTest {
     await server.start();
 
     // lets handle realtime comms
-    const tapParser = new TapParser(fileNameArg + ':chrome');
+    const tapParser = new TapParser(fileNameArg + ':chrome', this.logger);
     const wss = new plugins.ws.WebSocketServer({ port: 8080 });
     wss.on('connection', (ws) => {
       ws.on('message', (message) => {
-        tapParser.handleTapLog(message.toString());
+        const messageStr = message.toString();
+        if (messageStr.startsWith('console:')) {
+          const [, level, ...messageParts] = messageStr.split(':');
+          this.logger.browserConsole(messageParts.join(':'), level);
+        } else {
+          tapParser.handleTapLog(messageStr);
+        }
       });
     });
 

package/ts/tstest.logging.ts

@@ -0,0 +1,358 @@
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import * as plugins from './tstest.plugins.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface LogOptions {
+  quiet?: boolean;
+  verbose?: boolean;
+  noColor?: boolean;
+  json?: boolean;
+  logFile?: boolean;
+}
+
+export interface TestFileResult {
+  file: string;
+  passed: number;
+  failed: number;
+  total: number;
+  duration: number;
+  tests: Array<{
+    name: string;
+    passed: boolean;
+    duration: number;
+    error?: string;
+  }>;
+}
+
+export interface TestSummary {
+  totalFiles: number;
+  totalTests: number;
+  totalPassed: number;
+  totalFailed: number;
+  totalDuration: number;
+  fileResults: TestFileResult[];
+}
+
+export class TsTestLogger {
+  private options: LogOptions;
+  private startTime: number;
+  private fileResults: TestFileResult[] = [];
+  private currentFileResult: TestFileResult | null = null;
+  private currentTestLogFile: string | null = null;
+  
+  constructor(options: LogOptions = {}) {
+    this.options = options;
+    this.startTime = Date.now();
+  }
+  
+  private format(text: string, color?: string): string {
+    if (this.options.noColor || !color) {
+      return text;
+    }
+    return cs(text, color as any);
+  }
+  
+  private log(message: string) {
+    if (this.options.json) {
+      // For JSON mode, skip console output
+      // JSON output is handled by logJson method
+      return;
+    }
+    
+    console.log(message);
+    
+    // Log to the current test file log if we're in a test and --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(message);
+    }
+  }
+  
+  private logToFile(message: string) {
+    // This method is no longer used since we use logToTestFile for individual test logs
+    // Keeping it for potential future use with a global log file
+  }
+  
+  private logToTestFile(message: string) {
+    try {
+      // Remove ANSI color codes for file logging
+      const cleanMessage = message.replace(/\u001b\[[0-9;]*m/g, '');
+      
+      // Append to test log file
+      fs.appendFileSync(this.currentTestLogFile, cleanMessage + '\n');
+    } catch (error) {
+      // Silently fail to avoid disrupting the test run
+    }
+  }
+  
+  private logJson(data: any) {
+    const jsonString = JSON.stringify(data);
+    console.log(jsonString);
+    
+    // Also log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(jsonString);
+    }
+  }
+  
+  // Section separators
+  sectionStart(title: string) {
+    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: number, total: number, message: string) {
+    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: number, pattern: string, executionMode: string) {
+    if (this.options.json) {
+      this.logJson({ 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: string, runtime: string, index: number, total: number) {
+    this.currentFileResult = {
+      file: filename,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      duration: 0,
+      tests: []
+    };
+    
+    // Only set up test log file if --logfile option is specified
+    if (this.options.logFile) {
+      const baseFilename = path.basename(filename, '.ts');
+      this.currentTestLogFile = path.join('.nogit', 'testlogs', `${baseFilename}.log`);
+      
+      // Ensure the directory exists
+      const logDir = path.dirname(this.currentTestLogFile);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+      
+      // Clear the log file for this test
+      fs.writeFileSync(this.currentTestLogFile, '');
+    }
+    
+    if (this.options.json) {
+      this.logJson({ 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: string, passed: boolean, duration: number, error?: string) {
+    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) {
+      this.logJson({ 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: number, failed: number, duration: number) {
+    if (this.currentFileResult) {
+      this.fileResults.push(this.currentFileResult);
+      this.currentFileResult = null;
+    }
+    
+    if (this.options.json) {
+      this.logJson({ 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));
+    }
+    
+    // Clear the current test log file reference only if using --logfile
+    if (this.options.logFile) {
+      this.currentTestLogFile = null;
+    }
+  }
+  
+  // TAP output forwarding (for TAP protocol messages)
+  tapOutput(message: string, isError: boolean = false) {
+    if (this.options.json) return;
+    
+    // Never show raw TAP protocol messages in console
+    // They are already processed by TapParser and shown in our format
+    
+    // Always log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(`   ${message}`);
+    }
+  }
+  
+  // Console output from test files (non-TAP output)
+  testConsoleOutput(message: string) {
+    if (this.options.json) return;
+    
+    // Show console output from test files only in verbose mode
+    if (this.options.verbose) {
+      this.log(this.format(`   ${message}`, 'dim'));
+    }
+    
+    // Always log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(`   ${message}`);
+    }
+  }
+  
+  // Browser console
+  browserConsole(message: string, level: string = 'log') {
+    if (this.options.json) {
+      this.logJson({ 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: TestSummary = {
+      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) {
+      this.logJson({ 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: string, file?: string, stack?: string) {
+    if (this.options.json) {
+      this.logJson({ 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'));
+      }
+    }
+  }
+}

package/readme.plan.md

@@ -1,51 +0,0 @@
-# Plan for adding single file and glob pattern execution support to 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