command-stream 0.7.1 → 0.8.2

package/src/commands/$.pwd.mjs

@@ -1,8 +1,11 @@
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function pwd({ args, stdin, cwd }) {
+export default async function pwd({ args: _args, stdin: _stdin, cwd }) {
   // If cwd option is provided, return that instead of process.cwd()
   const dir = cwd || process.cwd();
-  trace('VirtualCommand', () => `pwd: getting directory | ${JSON.stringify({ dir }, null, 2)}`);
-  return VirtualUtils.success(dir + '\n');
-}
+  trace(
+    'VirtualCommand',
+    () => `pwd: getting directory | ${JSON.stringify({ dir }, null, 2)}`
+  );
+  return VirtualUtils.success(`${dir}\n`);
+}

package/src/commands/$.rm.mjs

@@ -1,14 +1,16 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function rm({ args, stdin, cwd }) {
+export default async function rm({ args, stdin: _stdin, cwd }) {
   const argError = VirtualUtils.validateArgs(args, 1, 'rm');
-  if (argError) return argError;
+  if (argError) {
+    return argError;
+  }
 
   // Parse flags and paths
   const flags = new Set();
   const paths = [];
-  
+
   for (const arg of args) {
     if (arg.startsWith('-')) {
       for (const flag of arg.slice(1)) {
@@ -25,18 +27,24 @@ export default async function rm({ args, stdin, cwd }) {
 
   const recursive = flags.has('r') || flags.has('R');
   const force = flags.has('f');
-  
+
   try {
     for (const file of paths) {
       const resolvedPath = VirtualUtils.resolvePath(file, cwd);
-      trace('VirtualCommand', () => `rm: removing | ${JSON.stringify({ file: resolvedPath, recursive, force }, null, 2)}`);
-      
+      trace(
+        'VirtualCommand',
+        () =>
+          `rm: removing | ${JSON.stringify({ file: resolvedPath, recursive, force }, null, 2)}`
+      );
+
       try {
         const stats = fs.statSync(resolvedPath);
         if (stats.isDirectory() && !recursive) {
-          return VirtualUtils.error(`rm: cannot remove '${file}': Is a directory`);
+          return VirtualUtils.error(
+            `rm: cannot remove '${file}': Is a directory`
+          );
         }
-        
+
         if (stats.isDirectory()) {
           fs.rmSync(resolvedPath, { recursive: true, force });
         } else {
@@ -44,17 +52,26 @@ export default async function rm({ args, stdin, cwd }) {
         }
       } catch (error) {
         if (error.code === 'ENOENT' && !force) {
-          return VirtualUtils.error(`rm: cannot remove '${file}': No such file or directory`);
+          return VirtualUtils.error(
+            `rm: cannot remove '${file}': No such file or directory`
+          );
         } else if (error.code !== 'ENOENT') {
           throw error;
         }
       }
     }
-    
-    trace('VirtualCommand', () => `rm: success | ${JSON.stringify({ filesRemoved: paths.length }, null, 2)}`);
+
+    trace(
+      'VirtualCommand',
+      () =>
+        `rm: success | ${JSON.stringify({ filesRemoved: paths.length }, null, 2)}`
+    );
     return VirtualUtils.success();
   } catch (error) {
-    trace('VirtualCommand', () => `rm: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    trace(
+      'VirtualCommand',
+      () => `rm: error | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return VirtualUtils.error(`rm: ${error.message}`);
   }
-}
+}

package/src/commands/$.seq.mjs

@@ -2,10 +2,12 @@ import { VirtualUtils } from '../$.utils.mjs';
 
 export default async function seq({ args }) {
   const argError = VirtualUtils.validateArgs(args, 1, 'seq');
-  if (argError) return argError;
+  if (argError) {
+    return argError;
+  }
 
   let start, step, end;
-  
+
   if (args.length === 1) {
     // seq END
     start = 1;
@@ -22,18 +24,18 @@ export default async function seq({ args }) {
     step = parseFloat(args[1]);
     end = parseFloat(args[2]);
   }
-  
+
   // Validate numbers
   if (isNaN(start) || isNaN(step) || isNaN(end)) {
     return VirtualUtils.error('seq: invalid number');
   }
-  
+
   if (step === 0) {
     return VirtualUtils.error('seq: step cannot be zero');
   }
-  
+
   const output = [];
-  
+
   if (step > 0) {
     for (let i = start; i <= end; i += step) {
       output.push(i.toString());
@@ -43,6 +45,8 @@ export default async function seq({ args }) {
       output.push(i.toString());
     }
   }
-  
-  return VirtualUtils.success(output.join('\n') + (output.length > 0 ? '\n' : ''));
-}
+
+  return VirtualUtils.success(
+    output.join('\n') + (output.length > 0 ? '\n' : '')
+  );
+}

package/src/commands/$.sleep.mjs

@@ -2,54 +2,94 @@ import { trace } from '../$.utils.mjs';
 
 export default async function sleep({ args, abortSignal, isCancelled }) {
   const seconds = parseFloat(args[0] || 0);
-  trace('VirtualCommand', () => `sleep: starting | ${JSON.stringify({ 
-    seconds,
-    hasSignal: !!abortSignal,
-    signalAborted: abortSignal?.aborted,
-    hasIsCancelled: !!isCancelled
-  }, null, 2)}`);
-  
+  trace(
+    'VirtualCommand',
+    () =>
+      `sleep: starting | ${JSON.stringify(
+        {
+          seconds,
+          hasSignal: !!abortSignal,
+          signalAborted: abortSignal?.aborted,
+          hasIsCancelled: !!isCancelled,
+        },
+        null,
+        2
+      )}`
+  );
+
   if (isNaN(seconds) || seconds < 0) {
     return { stderr: `sleep: invalid time interval '${args[0]}'`, code: 1 };
   }
-  
+
   // Use abort signal if available, otherwise use setTimeout
   try {
     await new Promise((resolve, reject) => {
       const timeoutId = setTimeout(resolve, seconds * 1000);
-      
+
       // Handle cancellation via abort signal
       if (abortSignal) {
-        trace('VirtualCommand', () => `sleep: setting up abort signal listener | ${JSON.stringify({
-          signalAborted: abortSignal.aborted
-        }, null, 2)}`);
-        
+        trace(
+          'VirtualCommand',
+          () =>
+            `sleep: setting up abort signal listener | ${JSON.stringify(
+              {
+                signalAborted: abortSignal.aborted,
+              },
+              null,
+              2
+            )}`
+        );
+
         abortSignal.addEventListener('abort', () => {
-          trace('VirtualCommand', () => `sleep: abort signal received | ${JSON.stringify({
-            seconds,
-            signalAborted: abortSignal.aborted
-          }, null, 2)}`);
+          trace(
+            'VirtualCommand',
+            () =>
+              `sleep: abort signal received | ${JSON.stringify(
+                {
+                  seconds,
+                  signalAborted: abortSignal.aborted,
+                },
+                null,
+                2
+              )}`
+          );
           clearTimeout(timeoutId);
           reject(new Error('Sleep cancelled'));
         });
-        
+
         // Check if already aborted
         if (abortSignal.aborted) {
-          trace('VirtualCommand', () => `sleep: signal already aborted | ${JSON.stringify({ seconds }, null, 2)}`);
+          trace(
+            'VirtualCommand',
+            () =>
+              `sleep: signal already aborted | ${JSON.stringify({ seconds }, null, 2)}`
+          );
           clearTimeout(timeoutId);
           reject(new Error('Sleep cancelled'));
           return;
         }
       } else {
-        trace('VirtualCommand', () => `sleep: no abort signal provided | ${JSON.stringify({ seconds }, null, 2)}`);
+        trace(
+          'VirtualCommand',
+          () =>
+            `sleep: no abort signal provided | ${JSON.stringify({ seconds }, null, 2)}`
+        );
       }
-      
+
       // Also check isCancelled periodically for quicker response
       if (isCancelled) {
-        trace('VirtualCommand', () => `sleep: setting up isCancelled polling | ${JSON.stringify({ seconds }, null, 2)}`);
+        trace(
+          'VirtualCommand',
+          () =>
+            `sleep: setting up isCancelled polling | ${JSON.stringify({ seconds }, null, 2)}`
+        );
         const checkInterval = setInterval(() => {
           if (isCancelled()) {
-            trace('VirtualCommand', () => `sleep: isCancelled returned true | ${JSON.stringify({ seconds }, null, 2)}`);
+            trace(
+              'VirtualCommand',
+              () =>
+                `sleep: isCancelled returned true | ${JSON.stringify({ seconds }, null, 2)}`
+            );
             clearTimeout(timeoutId);
             clearInterval(checkInterval);
             reject(new Error('Sleep cancelled'));
@@ -57,16 +97,28 @@ export default async function sleep({ args, abortSignal, isCancelled }) {
         }, 100);
       }
     });
-    
-    trace('VirtualCommand', () => `sleep: completed naturally | ${JSON.stringify({ seconds }, null, 2)}`);
+
+    trace(
+      'VirtualCommand',
+      () =>
+        `sleep: completed naturally | ${JSON.stringify({ seconds }, null, 2)}`
+    );
     return { stdout: '', code: 0 };
   } catch (err) {
-    trace('VirtualCommand', () => `sleep: interrupted | ${JSON.stringify({ 
-      seconds, 
-      error: err.message,
-      errorName: err.name
-    }, null, 2)}`);
+    trace(
+      'VirtualCommand',
+      () =>
+        `sleep: interrupted | ${JSON.stringify(
+          {
+            seconds,
+            error: err.message,
+            errorName: err.name,
+          },
+          null,
+          2
+        )}`
+    );
     // Let the ProcessRunner determine the appropriate exit code based on the cancellation signal
     throw err;
   }
-}
+}

package/src/commands/$.test.mjs

@@ -44,16 +44,16 @@ export default async function test({ args }) {
         }
 
       case '-z': // String is empty
-        return { stdout: '', code: (!operand || operand.length === 0) ? 0 : 1 };
+        return { stdout: '', code: !operand || operand.length === 0 ? 0 : 1 };
 
       case '-n': // String is not empty
-        return { stdout: '', code: (operand && operand.length > 0) ? 0 : 1 };
+        return { stdout: '', code: operand && operand.length > 0 ? 0 : 1 };
 
       default:
         // Simple string test (non-empty)
-        return { stdout: '', code: (operator && operator.length > 0) ? 0 : 1 };
+        return { stdout: '', code: operator && operator.length > 0 ? 0 : 1 };
     }
   } catch (error) {
     return VirtualUtils.error(`test: ${error.message}`);
   }
-}
+}

package/src/commands/$.touch.mjs

@@ -1,36 +1,61 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function touch({ args, stdin, cwd }) {
+export default async function touch({ args, stdin: _stdin, cwd }) {
   const argError = VirtualUtils.validateArgs(args, 1, 'touch');
-  if (argError) return VirtualUtils.missingOperandError('touch', 'touch: missing file operand');
+  if (argError) {
+    return VirtualUtils.missingOperandError(
+      'touch',
+      'touch: missing file operand'
+    );
+  }
 
   try {
     for (const file of args) {
       const resolvedPath = VirtualUtils.resolvePath(file, cwd);
-      trace('VirtualCommand', () => `touch: processing | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
-      
+      trace(
+        'VirtualCommand',
+        () =>
+          `touch: processing | ${JSON.stringify({ file: resolvedPath }, null, 2)}`
+      );
+
       const now = new Date();
-      
+
       try {
         // Try to update existing file's timestamp
         fs.utimesSync(resolvedPath, now, now);
-        trace('VirtualCommand', () => `touch: updated timestamp | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+        trace(
+          'VirtualCommand',
+          () =>
+            `touch: updated timestamp | ${JSON.stringify({ file: resolvedPath }, null, 2)}`
+        );
       } catch (error) {
         if (error.code === 'ENOENT') {
           // File doesn't exist, create it
           fs.writeFileSync(resolvedPath, '');
-          trace('VirtualCommand', () => `touch: created file | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+          trace(
+            'VirtualCommand',
+            () =>
+              `touch: created file | ${JSON.stringify({ file: resolvedPath }, null, 2)}`
+          );
         } else {
           throw error;
         }
       }
     }
-    
-    trace('VirtualCommand', () => `touch: success | ${JSON.stringify({ filesTouched: args.length }, null, 2)}`);
+
+    trace(
+      'VirtualCommand',
+      () =>
+        `touch: success | ${JSON.stringify({ filesTouched: args.length }, null, 2)}`
+    );
     return VirtualUtils.success();
   } catch (error) {
-    trace('VirtualCommand', () => `touch: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    trace(
+      'VirtualCommand',
+      () =>
+        `touch: error | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return VirtualUtils.error(`touch: ${error.message}`);
   }
-}
+}

package/src/commands/$.true.mjs

@@ -2,4 +2,4 @@ import { VirtualUtils } from '../$.utils.mjs';
 
 export default async function trueCommand() {
   return VirtualUtils.success();
-}
+}

package/src/commands/$.which.mjs

@@ -5,7 +5,9 @@ import { VirtualUtils } from '../$.utils.mjs';
 export default function createWhichCommand(virtualCommands) {
   return async function which({ args }) {
     const argError = VirtualUtils.validateArgs(args, 1, 'which');
-    if (argError) return argError;
+    if (argError) {
+      return argError;
+    }
 
     const cmd = args[0];
 
@@ -13,20 +15,23 @@ export default function createWhichCommand(virtualCommands) {
       return VirtualUtils.success(`${cmd}: shell builtin\n`);
     }
 
-    const paths = (process.env.PATH || '').split(process.platform === 'win32' ? ';' : ':');
-    const extensions = process.platform === 'win32' ? ['', '.exe', '.cmd', '.bat'] : [''];
+    const paths = (process.env.PATH || '').split(
+      process.platform === 'win32' ? ';' : ':'
+    );
+    const extensions =
+      process.platform === 'win32' ? ['', '.exe', '.cmd', '.bat'] : [''];
 
     for (const pathDir of paths) {
       for (const ext of extensions) {
         const fullPath = path.join(pathDir, cmd + ext);
         try {
           if (fs.statSync(fullPath).isFile()) {
-            return VirtualUtils.success(fullPath + '\n');
+            return VirtualUtils.success(`${fullPath}\n`);
           }
-        } catch { }
+        } catch {}
       }
     }
 
     return VirtualUtils.error(`which: no ${cmd} in PATH`);
   };
-}
+}

package/src/commands/$.yes.mjs

@@ -1,48 +1,92 @@
 import { trace } from '../$.utils.mjs';
 
-export default async function* yes({ args, stdin, isCancelled, abortSignal, ...rest }) {
+export default async function* yes({
+  args,
+  stdin: _stdin,
+  isCancelled,
+  abortSignal,
+  ...rest
+}) {
   const output = args.length > 0 ? args.join(' ') : 'y';
-  trace('VirtualCommand', () => `yes: starting infinite generator | ${JSON.stringify({ 
-    output,
-    hasIsCancelled: !!isCancelled,
-    hasAbortSignal: !!abortSignal
-  }, null, 2)}`);
+  trace(
+    'VirtualCommand',
+    () =>
+      `yes: starting infinite generator | ${JSON.stringify(
+        {
+          output,
+          hasIsCancelled: !!isCancelled,
+          hasAbortSignal: !!abortSignal,
+        },
+        null,
+        2
+      )}`
+  );
 
   let iteration = 0;
   const MAX_ITERATIONS = 1000000; // Safety limit
 
   while (!isCancelled?.() && iteration < MAX_ITERATIONS) {
-    trace('VirtualCommand', () => `yes: iteration ${iteration} starting | ${JSON.stringify({
-      isCancelled: isCancelled?.(),
-      abortSignalAborted: abortSignal?.aborted
-    }, null, 2)}`);
-    
+    trace(
+      'VirtualCommand',
+      () =>
+        `yes: iteration ${iteration} starting | ${JSON.stringify(
+          {
+            isCancelled: isCancelled?.(),
+            abortSignalAborted: abortSignal?.aborted,
+          },
+          null,
+          2
+        )}`
+    );
+
     // Check for abort signal
     if (abortSignal?.aborted) {
-      trace('VirtualCommand', () => `yes: aborted via abort signal | ${JSON.stringify({ iteration }, null, 2)}`);
+      trace(
+        'VirtualCommand',
+        () =>
+          `yes: aborted via abort signal | ${JSON.stringify({ iteration }, null, 2)}`
+      );
       break;
     }
 
     // Also check rest properties for various cancellation methods
     if (rest.aborted || rest.cancelled || rest.stop) {
-      trace('VirtualCommand', () => `yes: stopped via property | ${JSON.stringify({ iteration }, null, 2)}`);
+      trace(
+        'VirtualCommand',
+        () =>
+          `yes: stopped via property | ${JSON.stringify({ iteration }, null, 2)}`
+      );
       break;
     }
 
-    trace('VirtualCommand', () => `yes: yielding output for iteration ${iteration}`);
-    yield output + '\n';
+    trace(
+      'VirtualCommand',
+      () => `yes: yielding output for iteration ${iteration}`
+    );
+    yield `${output}\n`;
 
     iteration++;
 
     // Yield control after every iteration to allow cancellation
     // This ensures the consumer can break cleanly
-    trace('VirtualCommand', () => `yes: yielding control after iteration ${iteration - 1}`);
-    await new Promise(resolve => setImmediate(resolve));
+    trace(
+      'VirtualCommand',
+      () => `yes: yielding control after iteration ${iteration - 1}`
+    );
+    await new Promise((resolve) => setImmediate(resolve));
   }
 
-  trace('VirtualCommand', () => `yes: generator completed | ${JSON.stringify({ 
-    iteration,
-    wasCancelled: isCancelled?.(),
-    wasAborted: abortSignal?.aborted
-  }, null, 2)}`);
-}
+  trace(
+    'VirtualCommand',
+    () =>
+      `yes: generator completed | ${JSON.stringify(
+        {
+          iteration,
+          wasCancelled: isCancelled?.(),
+          wasAborted: abortSignal?.aborted,
+        },
+        null,
+        2
+      )}`
+  );
+}