feat(cli): verbose flag outputs stack traces and error codes (#96)

Author: mackenziemcclaskey

cli/src/lib/command.ts

@@ -15,17 +15,42 @@ export default abstract class EverywhereBaseCommand extends Command {
     }),
     verbose: Flags.boolean({
       char: 'v',
-      description: 'Show detailed output.',
+      description: 'Show detailed output including stack traces and error codes.',
     }),
   };
 
+  protected get isVerbose(): boolean {
+    return this._verbose;
+  }
+
   protected get pluginDir(): string {
-    // Resolved during run() after flags are parsed
     return this._pluginDir;
   }
 
+  private _verbose = false;
   private _pluginDir = process.cwd();
 
+  override async init(): Promise<void> {
+    await super.init();
+    const { flags } = await this.parse(this.constructor as typeof EverywhereBaseCommand);
+    this._verbose = flags.verbose ?? false;
+  }
+
+  override async catch(error: Error & { code?: string; exitCode?: number }): Promise<void> {
+    if (this._verbose) {
+      const timestamp = new Date().toISOString();
+      const stack = error.stack ?? `Error: ${error.message}`;
+      this.warn(`[${timestamp}]\n${stack}`);
+      if (error.code) {
+        this.warn(`  code: ${error.code}`);
+      }
+      if (error.exitCode !== undefined) {
+        this.warn(`  exit: ${error.exitCode}`);
+      }
+    }
+    return super.catch(error);
+  }
+
   protected async parsePluginDir(): Promise<string> {
     const { flags } = await this.parse(this.constructor as typeof EverywhereBaseCommand);
     const dir = flags['plugin-dir'];

cli/tests/lib/command.test.ts

@@ -1,6 +1,14 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import EverywhereBaseCommand from '../../src/lib/command.js';
 
+class TestCommand extends EverywhereBaseCommand {
+  async run(): Promise<void> {}
+
+  setVerbose(value: boolean): void {
+    (this as any)._verbose = value;
+  }
+}
+
 describe('EverywhereBaseCommand', () => {
   describe('baseFlags', () => {
     it('defines a plugin-dir flag', () => {
@@ -19,4 +27,103 @@ describe('EverywhereBaseCommand', () => {
       expect(EverywhereBaseCommand.baseFlags['verbose'].char).toBe('v');
     });
   });
+
+  describe('isVerbose', () => {
+    describe('when verbose has not been set', () => {
+      it('returns false', () => {
+        const cmd = new TestCommand([], {} as any);
+        expect((cmd as any).isVerbose).toBe(false);
+      });
+    });
+
+    describe('when verbose has been set', () => {
+      it('returns true', () => {
+        const cmd = new TestCommand([], {} as any);
+        cmd.setVerbose(true);
+        expect((cmd as any).isVerbose).toBe(true);
+      });
+    });
+  });
+
+  describe('catch()', () => {
+    let cmd: TestCommand;
+    let warnSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+      cmd = new TestCommand([], {} as any);
+      warnSpy = vi.spyOn(cmd, 'warn').mockImplementation(() => {});
+    });
+
+    describe('when verbose is not set', () => {
+      it('does not output the stack trace', async () => {
+        const error = new Error('oops');
+        error.stack = 'Error: oops\n    at src/build.ts:42:5';
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('at src/build.ts'));
+      });
+
+      it('does not output a timestamp', async () => {
+        const error = new Error('oops');
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        expect(warnSpy).not.toHaveBeenCalledWith(expect.stringMatching(/\d{4}-\d{2}-\d{2}T/));
+      });
+    });
+
+    describe('when verbose is set', () => {
+      beforeEach(() => {
+        cmd.setVerbose(true);
+      });
+
+      it('outputs the stack trace', async () => {
+        const error = new Error('oops');
+        error.stack = 'Error: oops\n    at src/build.ts:42:5';
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('at src/build.ts'));
+      });
+
+      it('outputs a timestamp', async () => {
+        const error = new Error('oops');
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringMatching(/\d{4}-\d{2}-\d{2}T/));
+      });
+
+      it('outputs the error code when present', async () => {
+        const error = Object.assign(new Error('oops'), { code: 'ENOENT' });
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('ENOENT'));
+      });
+
+      it('does not output the error cause', async () => {
+        const cause = { token: 'eyJ0b2tlbg.secret.sig' };
+        const error = Object.assign(new Error('Request failed'), { cause });
+        try {
+          await cmd.catch(error);
+        } catch {
+          /* oclif re-throws */
+        }
+        const allWarnArgs = warnSpy.mock.calls.flat().join('');
+        expect(allWarnArgs).not.toContain('eyJ0b2tlbg');
+      });
+    });
+  });
 });