start-command 0.24.7 → 0.24.8

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # start-command
 
+## 0.24.8
+
+### Patch Changes
+
+- 1195fc1: Add CI/CD coverage enforcement and Rust/JS test parity checks (issue #93)
+  - Add `scripts/check-test-parity.mjs` script to enforce Rust/JS test count within 10%
+  - Add coverage job to JavaScript CI/CD workflow (80% minimum threshold)
+  - Update `ARCHITECTURE.md` to document dual-language sync requirements
+  - Update `REQUIREMENTS.md` to document test coverage requirements and parity rules
+
 ## 0.24.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.24.7",
+  "version": "0.24.8",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/test/echo-integration.test.js

@@ -24,6 +24,7 @@ const path = require('path');
 const {
   isCommandAvailable,
   canRunLinuxDockerImages,
+  hasTTY,
 } = require('../src/lib/isolation');
 
 // Path to the CLI
@@ -537,6 +538,14 @@ describe('Echo Integration Tests - Issue #55', () => {
     }
 
     describe('Attached Mode', () => {
+      if (!hasTTY()) {
+        it('should skip attached docker tests when no TTY is available', () => {
+          console.log('  ⚠ no TTY available, skipping attached docker tests');
+          assert.ok(true);
+        });
+        return;
+      }
+
       it('should execute echo hi in attached docker mode with proper formatting', () => {
         const containerName = `test-docker-attached-${Date.now()}`;
         const result = runCli(

package/test/failure-handler.test.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for failure-handler module
+ * Tests pure functions: parseGitUrl and handleFailure early-exit behavior
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { parseGitUrl, handleFailure } = require('../src/lib/failure-handler');
+
+describe('failure-handler', () => {
+  describe('parseGitUrl', () => {
+    it('should parse HTTPS GitHub URL', () => {
+      const result = parseGitUrl('https://github.com/owner/my-repo');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+      assert.strictEqual(result.url, 'https://github.com/owner/my-repo');
+    });
+
+    it('should parse HTTPS URL with .git suffix', () => {
+      const result = parseGitUrl('https://github.com/owner/my-repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+      assert.strictEqual(result.url, 'https://github.com/owner/my-repo');
+    });
+
+    it('should parse SSH git@ URL', () => {
+      const result = parseGitUrl('git@github.com:owner/my-repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+    });
+
+    it('should parse git+https URL format', () => {
+      const result = parseGitUrl('git+https://github.com/owner/repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'repo');
+    });
+
+    it('should return null for empty string', () => {
+      const result = parseGitUrl('');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for null/undefined input', () => {
+      assert.strictEqual(parseGitUrl(null), null);
+      assert.strictEqual(parseGitUrl(undefined), null);
+    });
+
+    it('should return null for non-github URL', () => {
+      const result = parseGitUrl('https://gitlab.com/owner/repo');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for invalid/random string', () => {
+      const result = parseGitUrl('not-a-url-at-all');
+      assert.strictEqual(result, null);
+    });
+
+    it('should normalize URL to https://github.com format', () => {
+      const result = parseGitUrl('git@github.com:myorg/myrepo');
+      assert.ok(result !== null);
+      assert.ok(result.url.startsWith('https://github.com/'));
+    });
+
+    it('should handle URL with subdirectory (only owner/repo captured)', () => {
+      const result = parseGitUrl('https://github.com/myorg/myrepo/issues');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'myorg');
+      assert.strictEqual(result.repo, 'myrepo');
+    });
+
+    it('should return object with owner, repo, url keys', () => {
+      const result = parseGitUrl('https://github.com/test/project');
+      assert.ok(result !== null);
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'owner'));
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'repo'));
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'url'));
+    });
+  });
+
+  describe('handleFailure', () => {
+    it('should return early when disableAutoIssue is true', () => {
+      // This should not throw and should return without calling external processes
+      const config = { disableAutoIssue: true };
+      // If it tries to call external tools, it would either throw or hang;
+      // returning cleanly means the early-exit path was taken.
+      assert.doesNotThrow(() => {
+        handleFailure(config, 'someCmd', 'someCmd --flag', 1, '/tmp/fake.log');
+      });
+    });
+
+    it('should return early when disableAutoIssue is true (verbose mode)', () => {
+      const config = { disableAutoIssue: true, verbose: true };
+      assert.doesNotThrow(() => {
+        handleFailure(config, 'cmd', 'cmd arg', 2, '/tmp/fake.log');
+      });
+    });
+  });
+});

package/test/isolation-log-utils.test.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for isolation-log-utils module
+ * Tests pure utility functions for log file management
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const path = require('path');
+const {
+  getTimestamp,
+  generateLogFilename,
+  createLogHeader,
+  createLogFooter,
+  getLogDir,
+  createLogPath,
+} = require('../src/lib/isolation-log-utils');
+
+describe('isolation-log-utils', () => {
+  describe('getTimestamp', () => {
+    it('should return a non-empty string', () => {
+      const ts = getTimestamp();
+      assert.strictEqual(typeof ts, 'string');
+      assert.ok(ts.length > 0);
+    });
+
+    it('should return a timestamp without T or Z (ISO-like but space-separated)', () => {
+      const ts = getTimestamp();
+      assert.ok(!ts.includes('T'), 'Should not contain ISO T separator');
+      assert.ok(!ts.endsWith('Z'), 'Should not end with Z');
+    });
+
+    it('should contain date-like content (numbers and dashes)', () => {
+      const ts = getTimestamp();
+      // Expect format like "2024-01-15 10:30:45.123"
+      assert.match(ts, /\d{4}-\d{2}-\d{2}/);
+    });
+
+    it('should return different values on successive calls (or same within same ms)', () => {
+      const ts1 = getTimestamp();
+      assert.strictEqual(typeof ts1, 'string');
+      // Just verify it's callable multiple times without error
+      const ts2 = getTimestamp();
+      assert.strictEqual(typeof ts2, 'string');
+    });
+  });
+
+  describe('generateLogFilename', () => {
+    it('should return a string ending with .log', () => {
+      const filename = generateLogFilename('screen');
+      assert.ok(filename.endsWith('.log'));
+    });
+
+    it('should include the environment name in the filename', () => {
+      const filename = generateLogFilename('docker');
+      assert.ok(filename.includes('docker'));
+    });
+
+    it('should start with "start-command-"', () => {
+      const filename = generateLogFilename('tmux');
+      assert.ok(filename.startsWith('start-command-'));
+    });
+
+    it('should generate unique filenames on successive calls', () => {
+      const f1 = generateLogFilename('screen');
+      const f2 = generateLogFilename('screen');
+      // Due to random component, should be different
+      assert.notStrictEqual(f1, f2);
+    });
+
+    it('should handle different environment names', () => {
+      const environments = ['screen', 'tmux', 'docker', 'user', 'none'];
+      for (const env of environments) {
+        const filename = generateLogFilename(env);
+        assert.ok(
+          filename.includes(env),
+          `Filename should include environment "${env}"`
+        );
+        assert.ok(filename.endsWith('.log'));
+      }
+    });
+  });
+
+  describe('createLogHeader', () => {
+    const baseParams = {
+      command: 'npm test',
+      environment: 'screen',
+      mode: 'attached',
+      sessionName: 'test-session-123',
+      startTime: '2024-01-15 10:30:00.000',
+    };
+
+    it('should return a non-empty string', () => {
+      const header = createLogHeader(baseParams);
+      assert.strictEqual(typeof header, 'string');
+      assert.ok(header.length > 0);
+    });
+
+    it('should include the command in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('npm test'));
+    });
+
+    it('should include the environment in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('screen'));
+    });
+
+    it('should include the session name in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('test-session-123'));
+    });
+
+    it('should include the mode in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('attached'));
+    });
+
+    it('should include image field when provided', () => {
+      const params = { ...baseParams, image: 'node:20-alpine' };
+      const header = createLogHeader(params);
+      assert.ok(header.includes('node:20-alpine'));
+    });
+
+    it('should include user field when provided', () => {
+      const params = { ...baseParams, user: 'isolateduser' };
+      const header = createLogHeader(params);
+      assert.ok(header.includes('isolateduser'));
+    });
+
+    it('should NOT include Image line when image is not provided', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(!header.includes('Image:'));
+    });
+
+    it('should contain separator line', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('==='));
+    });
+  });
+
+  describe('createLogFooter', () => {
+    it('should return a non-empty string', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.strictEqual(typeof footer, 'string');
+      assert.ok(footer.length > 0);
+    });
+
+    it('should include the exit code', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 42);
+      assert.ok(footer.includes('42'));
+    });
+
+    it('should include exit code 0', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.ok(footer.includes('0'));
+    });
+
+    it('should include the end time', () => {
+      const endTime = '2024-01-15 10:35:00.000';
+      const footer = createLogFooter(endTime, 1);
+      assert.ok(footer.includes(endTime));
+    });
+
+    it('should contain separator line', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.ok(footer.includes('='));
+    });
+  });
+
+  describe('getLogDir', () => {
+    it('should return a string', () => {
+      const dir = getLogDir();
+      assert.strictEqual(typeof dir, 'string');
+    });
+
+    it('should return a non-empty path', () => {
+      const dir = getLogDir();
+      assert.ok(dir.length > 0);
+    });
+
+    it('should use START_LOG_DIR env var when set', () => {
+      const original = process.env.START_LOG_DIR;
+      process.env.START_LOG_DIR = '/tmp/custom-log-dir';
+      try {
+        const dir = getLogDir();
+        assert.strictEqual(dir, '/tmp/custom-log-dir');
+      } finally {
+        if (original === undefined) {
+          delete process.env.START_LOG_DIR;
+        } else {
+          process.env.START_LOG_DIR = original;
+        }
+      }
+    });
+
+    it('should fall back to os.tmpdir() when START_LOG_DIR is not set', () => {
+      const os = require('os');
+      const original = process.env.START_LOG_DIR;
+      delete process.env.START_LOG_DIR;
+      try {
+        const dir = getLogDir();
+        assert.strictEqual(dir, os.tmpdir());
+      } finally {
+        if (original !== undefined) {
+          process.env.START_LOG_DIR = original;
+        }
+      }
+    });
+  });
+
+  describe('createLogPath', () => {
+    it('should return a string ending with .log', () => {
+      const logPath = createLogPath('screen');
+      assert.ok(logPath.endsWith('.log'));
+    });
+
+    it('should return an absolute path', () => {
+      const logPath = createLogPath('tmux');
+      assert.ok(path.isAbsolute(logPath));
+    });
+
+    it('should include the environment name', () => {
+      const logPath = createLogPath('docker');
+      assert.ok(logPath.includes('docker'));
+    });
+
+    it('should be under the log directory', () => {
+      const logDir = getLogDir();
+      const logPath = createLogPath('screen');
+      assert.ok(logPath.startsWith(logDir));
+    });
+  });
+});