fix(tapbundle): Fix TypeScript IDE warning about tapTools parameter possibly being undefined

changelog.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 2025-07-24 - 2.3.2 - fix(tapbundle)
+Fix TypeScript IDE warning about tapTools parameter possibly being undefined
+
+- Changed ITestFunction from interface with optional parameter to union type
+- Updated test runner to handle both function signatures (with and without tapTools)
+- Resolves IDE warnings while maintaining backward compatibility
+
+## 2025-05-26 - 2.3.1 - fix(tapParser/logger)
+Fix test duration reporting and summary formatting in TAP parser and logger
+
+- Introduce startTime in TapParser to capture the overall test duration
+- Pass computed duration to logger methods in evaluateFinalResult for accurate timing
+- Update summary output to format duration in a human-readable way (ms vs. s)
+- Add local permission settings configuration to .claude/settings.local.json
+
+## 2025-05-26 - 2.3.0 - feat(cli)
+Add '--version' option and warn against global tstest usage in the tstest project
+
+- Introduced a new '--version' CLI flag that prints the version from package.json
+- Added logic in ts/index.ts to detect if tstest is run globally within its own project and issue a warning
+- Added .claude/settings.local.json to configure allowed permissions for various commands
+
 ## 2025-05-26 - 2.2.6 - fix(tstest)
 Improve timeout warning timer management and summary output formatting in the test runner.
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tstest",
-  "version": "2.2.6",
+  "version": "2.3.2",
   "private": false,
   "description": "a test utility to run tests that match test/**/*.ts",
   "exports": {

ts/00_commitinfo_data.ts

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

ts/index.ts

@@ -8,6 +8,40 @@ export enum TestExecutionMode {
 }
 
 export const runCli = async () => {
+  // Check if we're using global tstest in the tstest project itself
+  try {
+    const packageJsonPath = `${process.cwd()}/package.json`;
+    const fs = await import('fs');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (packageJson.name === '@git.zone/tstest') {
+        // Check if we're running from a global installation
+        const execPath = process.argv[1];
+        // Debug: log the paths (uncomment for debugging)
+        // console.log('DEBUG: Checking global tstest usage...');
+        // console.log('execPath:', execPath);
+        // console.log('cwd:', process.cwd());
+        // console.log('process.argv:', process.argv);
+        
+        // Check if this is running from global installation
+        const isLocalCli = execPath.includes(process.cwd());
+        const isGlobalPnpm = process.argv.some(arg => arg.includes('.pnpm') && !arg.includes(process.cwd()));
+        const isGlobalNpm = process.argv.some(arg => arg.includes('npm/node_modules') && !arg.includes(process.cwd()));
+        
+        if (!isLocalCli && (isGlobalPnpm || isGlobalNpm || !execPath.includes('node_modules'))) {
+          console.error('\n⚠️  WARNING: You are using a globally installed tstest in the tstest project itself!');
+          console.error('   This means you are NOT testing your local changes.');
+          console.error('   Please use one of these commands instead:');
+          console.error('     • node cli.js <test-path>');
+          console.error('     • pnpm test <test-path>');
+          console.error('     • ./cli.js <test-path> (if executable)\n');
+        }
+      }
+    }
+  } catch (error) {
+    // Silently ignore any errors in this check
+  }
+  
   // Parse command line arguments
   const args = process.argv.slice(2);
   const logOptions: LogOptions = {};
@@ -24,6 +58,18 @@ export const runCli = async () => {
     const arg = args[i];
     
     switch (arg) {
+      case '--version':
+        // Get version from package.json
+        try {
+          const fs = await import('fs');
+          const packagePath = new URL('../package.json', import.meta.url).pathname;
+          const packageData = JSON.parse(await fs.promises.readFile(packagePath, 'utf8'));
+          console.log(`tstest version ${packageData.version}`);
+        } catch (error) {
+          console.log('tstest version unknown');
+        }
+        process.exit(0);
+        break;
       case '--quiet':
       case '-q':
         logOptions.quiet = true;
@@ -115,6 +161,7 @@ export const runCli = async () => {
     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('  --version         Show version information');
     console.error('  --quiet, -q       Minimal output');
     console.error('  --verbose, -v     Verbose output');
     console.error('  --no-color        Disable colored output');

ts/tstest.classes.tap.parser.ts

@@ -22,6 +22,7 @@ export class TapParser {
   private logger: TsTestLogger;
   private protocolParser: ProtocolParser;
   private protocolVersion: string | null = null;
+  private startTime: number;
 
   /**
    * the constructor for TapParser
@@ -29,6 +30,7 @@ export class TapParser {
   constructor(public fileName: string, logger?: TsTestLogger) {
     this.logger = logger;
     this.protocolParser = new ProtocolParser();
+    this.startTime = Date.now();
   }
   
   /**
@@ -480,6 +482,7 @@ export class TapParser {
 
   public async evaluateFinalResult() {
     this.receivedTests = this.testStore.length;
+    const duration = Date.now() - this.startTime;
 
     // check wether all tests ran
     if (this.expectedTests === this.receivedTests) {
@@ -494,23 +497,23 @@ export class TapParser {
     if (!this.expectedTests && this.receivedTests === 0) {
       if (this.logger) {
         this.logger.error('No tests were defined. Therefore the testfile failed!');
-        this.logger.testFileEnd(0, 1, 0); // Count as 1 failure
+        this.logger.testFileEnd(0, 1, duration); // Count as 1 failure
       }
     } else if (this.expectedTests !== this.receivedTests) {
       if (this.logger) {
         this.logger.error('The amount of received tests and expectedTests is unequal! Therefore the testfile failed');
         const errorCount = this.getErrorTests().length || 1; // At least 1 error
-        this.logger.testFileEnd(this.receivedTests - errorCount, errorCount, 0);
+        this.logger.testFileEnd(this.receivedTests - errorCount, errorCount, duration);
       }
     } else if (this.getErrorTests().length === 0) {
       if (this.logger) {
         this.logger.tapOutput('All tests are successfull!!!');
-        this.logger.testFileEnd(this.receivedTests, 0, 0);
+        this.logger.testFileEnd(this.receivedTests, 0, duration);
       }
     } else {
       if (this.logger) {
         this.logger.tapOutput(`${this.getErrorTests().length} tests threw an error!!!`, true);
-        this.logger.testFileEnd(this.receivedTests - this.getErrorTests().length, this.getErrorTests().length, 0);
+        this.logger.testFileEnd(this.receivedTests - this.getErrorTests().length, this.getErrorTests().length, duration);
       }
     }
   }

ts/tstest.logging.ts

@@ -242,10 +242,12 @@ export class TsTestLogger {
     
     if (!this.options.quiet) {
       const total = passed + failed;
+      const durationStr = duration >= 1000 ? `${(duration / 1000).toFixed(1)}s` : `${duration}ms`;
+      
       if (failed === 0) {
-        this.log(this.format(`   Summary: ${passed}/${total} PASSED`, 'green'));
+        this.log(this.format(`   Summary: ${passed}/${total} PASSED in ${durationStr}`, 'green'));
       } else {
-        this.log(this.format(`   Summary: ${passed} passed, ${failed} failed of ${total} tests`, 'red'));
+        this.log(this.format(`   Summary: ${passed} passed, ${failed} failed of ${total} tests in ${durationStr}`, 'red'));
       }
     }
     
@@ -392,10 +394,12 @@ export class TsTestLogger {
     
     if (this.options.quiet) {
       const status = summary.totalFailed === 0 ? 'PASSED' : 'FAILED';
+      const durationStr = totalDuration >= 1000 ? `${(totalDuration / 1000).toFixed(1)}s` : `${totalDuration}ms`;
+      
       if (summary.totalFailed === 0) {
-        this.log(`\nSummary: ${summary.totalPassed}/${summary.totalTests} | ${totalDuration}ms | ${status}`);
+        this.log(`\nSummary: ${summary.totalPassed}/${summary.totalTests} | ${durationStr} | ${status}`);
       } else {
-        this.log(`\nSummary: ${summary.totalPassed} passed, ${summary.totalFailed} failed of ${summary.totalTests} tests | ${totalDuration}ms | ${status}`);
+        this.log(`\nSummary: ${summary.totalPassed} passed, ${summary.totalFailed} failed of ${summary.totalTests} tests | ${durationStr} | ${status}`);
       }
       return;
     }
@@ -410,7 +414,8 @@ export class TsTestLogger {
     if (summary.totalSkipped > 0) {
       this.log(this.format(`│ Skipped:        ${summary.totalSkipped.toString().padStart(14)} │`, 'yellow'));
     }
-    this.log(this.format(`│ Duration:       ${totalDuration.toString().padStart(14)}ms │`, 'white'));
+    const durationStrFormatted = totalDuration >= 1000 ? `${(totalDuration / 1000).toFixed(1)}s` : `${totalDuration}ms`;
+    this.log(this.format(`│ Duration:       ${durationStrFormatted.padStart(14)} │`, 'white'));
     this.log(this.format('└────────────────────────────────┘', 'dim'));
     
     // File results

ts_tapbundle/tapbundle.classes.taptest.ts

@@ -11,9 +11,9 @@ import { HrtMeasurement } from '@push.rocks/smarttime';
 // interfaces
 export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout' | 'skipped';
 
-export interface ITestFunction<T> {
+export type ITestFunction<T> = 
-  (tapTools?: TapTools): Promise<T>;
+  | ((tapTools: TapTools) => Promise<T>)
-}
+  | (() => Promise<T>);
 
 export class TapTest<T = unknown> {
   public description: string;
@@ -173,7 +173,9 @@ export class TapTest<T = unknown> {
         }
         
         // Run the test function with potential timeout
-        const testPromise = this.testFunction(this.tapTools);
+        const testPromise = this.testFunction.length === 0 
+          ? (this.testFunction as () => Promise<T>)()
+          : (this.testFunction as (tapTools: TapTools) => Promise<T>)(this.tapTools);
         const testReturnValue = timeoutPromise 
           ? await Promise.race([testPromise, timeoutPromise])
           : await testPromise;