feature-296-bugbot-autofix: Refactor CLI and GitHub Action execution logic to prevent auto-running during tests by checking for JEST_WORKER_ID. Export program instance in CLI modules for better accessibility. Enhance test coverage by adding scenarios for error handling and command execution, ensuring robust logging and proper management of exit codes. Update type definitions for clarity in CLI and GitHub Action modules.

efraespada · efraespada · commit 2bd54721cc7e · 2026-02-12T17:10:19.000+01:00
diff --git a/build/cli/index.js b/build/cli/index.js
@@ -47245,6 +47245,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.program = void 0;
 const child_process_1 = __nccwpck_require__(2081);
 const commander_1 = __nccwpck_require__(4379);
 const dotenv = __importStar(__nccwpck_require__(2437));
@@ -47258,6 +47259,7 @@ const ai_repository_1 = __nccwpck_require__(8307);
 // Load environment variables from .env file
 dotenv.config();
 const program = new commander_1.Command();
+exports.program = program;
 // Function to get git repository info
 function getGitInfo() {
     try {
@@ -47665,7 +47667,9 @@ program
     ];
     await (0, local_action_1.runLocalAction)(params);
 });
-program.parse(process.argv);
+if (typeof process.env.JEST_WORKER_ID === 'undefined') {
+    program.parse(process.argv);
+}
 
 
 /***/ }),
diff --git a/build/cli/src/__tests__/cli.test.d.ts b/build/cli/src/__tests__/cli.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for CLI commands.
+ * Mocks execSync (getGitInfo), runLocalAction, IssueRepository, AiRepository.
+ */
+export {};
diff --git a/build/cli/src/actions/__tests__/github_action.test.d.ts b/build/cli/src/actions/__tests__/github_action.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for runGitHubAction.
+ * Mocks @actions/core, ProjectRepository, mainRun, and finish flow.
+ */
+export {};
diff --git a/build/cli/src/actions/__tests__/local_action.test.d.ts b/build/cli/src/actions/__tests__/local_action.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for runLocalAction.
+ * Mocks getActionInputsWithDefaults, ProjectRepository, mainRun, chalk, boxen.
+ */
+export {};
diff --git a/build/cli/src/cli.d.ts b/build/cli/src/cli.d.ts
@@ -1 +1,3 @@
-export {};
+import { Command } from 'commander';
+declare const program: Command;
+export { program };
diff --git a/build/github_action/index.js b/build/github_action/index.js
@@ -42766,13 +42766,16 @@ function setFirstErrorIfExists(results) {
         }
     }
 }
-runGitHubAction()
-    .then(() => process.exit(0))
-    .catch((err) => {
-    (0, logger_1.logError)(err);
-    core.setFailed(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});
+// Only auto-run when executed as the action entry (not when imported by tests)
+if (typeof process.env.JEST_WORKER_ID === 'undefined') {
+    runGitHubAction()
+        .then(() => process.exit(0))
+        .catch((err) => {
+        (0, logger_1.logError)(err);
+        core.setFailed(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}
 
 
 /***/ }),
diff --git a/build/github_action/src/__tests__/cli.test.d.ts b/build/github_action/src/__tests__/cli.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for CLI commands.
+ * Mocks execSync (getGitInfo), runLocalAction, IssueRepository, AiRepository.
+ */
+export {};
diff --git a/build/github_action/src/actions/__tests__/github_action.test.d.ts b/build/github_action/src/actions/__tests__/github_action.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for runGitHubAction.
+ * Mocks @actions/core, ProjectRepository, mainRun, and finish flow.
+ */
+export {};
diff --git a/build/github_action/src/actions/__tests__/local_action.test.d.ts b/build/github_action/src/actions/__tests__/local_action.test.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Unit tests for runLocalAction.
+ * Mocks getActionInputsWithDefaults, ProjectRepository, mainRun, chalk, boxen.
+ */
+export {};
diff --git a/build/github_action/src/cli.d.ts b/build/github_action/src/cli.d.ts
@@ -1,2 +1,4 @@
 #!/usr/bin/env node
-export {};
+import { Command } from 'commander';
+declare const program: Command;
+export { program };
diff --git a/src/__tests__/cli.test.ts b/src/__tests__/cli.test.ts
@@ -35,13 +35,20 @@ jest.mock('../data/repository/ai_repository', () => ({
 }));
 
 describe('CLI', () => {
+  let exitSpy: jest.SpyInstance;
+
   beforeEach(() => {
     jest.clearAllMocks();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {}) as () => never);
     (execSync as jest.Mock).mockReturnValue(Buffer.from('https://github.com/test-owner/test-repo.git'));
     (runLocalAction as jest.Mock).mockResolvedValue(undefined);
     mockIsIssue.mockResolvedValue(true);
   });
 
+  afterEach(() => {
+    exitSpy?.mockRestore();
+  });
+
   describe('think', () => {
     it('calls runLocalAction with think action and question from -q', async () => {
       await program.parseAsync(['node', 'cli', 'think', '-q', 'how does X work?']);
@@ -58,14 +65,12 @@ describe('CLI', () => {
       (execSync as jest.Mock).mockImplementation(() => {
         throw new Error('git not found');
       });
-      const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {}) as () => never);
       const { logError } = require('../utils/logger');
 
       await program.parseAsync(['node', 'cli', 'think', '-q', 'hello']);
 
       expect(logError).toHaveBeenCalled();
       expect(exitSpy).toHaveBeenCalledWith(1);
-      exitSpy.mockRestore();
     });
 
   });
@@ -84,5 +89,64 @@ describe('CLI', () => {
       logSpy.mockRestore();
     });
 
+    it('calls process.exit(1) when do fails', async () => {
+      const { AiRepository } = require('../data/repository/ai_repository');
+      AiRepository.mockImplementation(() => ({
+        copilotMessage: jest.fn().mockRejectedValue(new Error('OpenCode down')),
+      }));
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      await program.parseAsync(['node', 'cli', 'do', '-p', 'hello']);
+
+      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(consoleSpy).toHaveBeenCalled();
+      const errMsg = consoleSpy.mock.calls.flat().join(' ');
+      expect(errMsg).toMatch(/error|Error/i);
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('check-progress', () => {
+    it('calls runLocalAction with CHECK_PROGRESS and issue number', async () => {
+      await program.parseAsync(['node', 'cli', 'check-progress', '-i', '99']);
+
+      expect(runLocalAction).toHaveBeenCalledTimes(1);
+      const params = (runLocalAction as jest.Mock).mock.calls[0][0];
+      expect(params[INPUT_KEYS.SINGLE_ACTION]).toBe(ACTIONS.CHECK_PROGRESS);
+      expect(params[INPUT_KEYS.SINGLE_ACTION_ISSUE]).toBe(99);
+      expect(params.issue?.number).toBe(99);
+      expect(params[INPUT_KEYS.WELCOME_TITLE]).toContain('Progress');
+    });
+
+    it('shows message when issue number is invalid', async () => {
+      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await program.parseAsync(['node', 'cli', 'check-progress', '-i', '0']);
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid issue number'));
+      logSpy.mockRestore();
+    });
+  });
+
+  describe('recommend-steps', () => {
+    it('calls runLocalAction with RECOMMEND_STEPS', async () => {
+      await program.parseAsync(['node', 'cli', 'recommend-steps', '-i', '5']);
+
+      expect(runLocalAction).toHaveBeenCalledTimes(1);
+      const params = (runLocalAction as jest.Mock).mock.calls[0][0];
+      expect(params[INPUT_KEYS.SINGLE_ACTION]).toBe(ACTIONS.RECOMMEND_STEPS);
+      expect(params.issue?.number).toBe(5);
+    });
+  });
+
+  describe('setup', () => {
+    it('calls runLocalAction with INITIAL_SETUP', async () => {
+      await program.parseAsync(['node', 'cli', 'setup']);
+
+      expect(runLocalAction).toHaveBeenCalledTimes(1);
+      const params = (runLocalAction as jest.Mock).mock.calls[0][0];
+      expect(params[INPUT_KEYS.SINGLE_ACTION]).toBe(ACTIONS.INITIAL_SETUP);
+      expect(params[INPUT_KEYS.WELCOME_TITLE]).toContain('Initial Setup');
+    });
   });
 });
diff --git a/src/actions/__tests__/common_action.test.ts b/src/actions/__tests__/common_action.test.ts
@@ -126,6 +126,24 @@ describe('mainRun', () => {
     expect(mockCommitInvoke).toHaveBeenCalled();
   });
 
+  it('logs welcome boxen and runs SingleActionUseCase when welcome and isSingleAction', async () => {
+    const logInfo = require('../../utils/logger').logInfo;
+    const execution = mockExecution({
+      welcome: { title: 'Welcome', messages: ['Step 1', 'Step 2'] },
+      issueNumber: 42,
+      runnedByToken: false,
+      isSingleAction: true,
+      singleAction: { validSingleAction: true, isSingleActionWithoutIssue: false, enabledSingleAction: true },
+    });
+    mockSingleActionInvoke.mockResolvedValue([new Result({ id: 's', success: true })]);
+
+    const results = await mainRun(execution);
+
+    expect(logInfo).toHaveBeenCalledWith(expect.any(String));
+    expect(mockSingleActionInvoke).toHaveBeenCalledWith(execution);
+    expect(results.length).toBeGreaterThan(0);
+  });
+
   it('runs SingleActionUseCase when runnedByToken and valid single action', async () => {
     const execution = mockExecution({
       runnedByToken: true,
diff --git a/src/actions/__tests__/github_action.test.ts b/src/actions/__tests__/github_action.test.ts
@@ -5,7 +5,7 @@
 
 import * as core from '@actions/core';
 import { runGitHubAction } from '../github_action';
-import { INPUT_KEYS } from '../../utils/constants';
+import { ACTIONS, INPUT_KEYS } from '../../utils/constants';
 
 jest.mock('@actions/core', () => ({
   getInput: jest.fn(),
@@ -95,4 +95,68 @@ describe('runGitHubAction', () => {
     expect(execution).toBeDefined();
     process.env.INPUT_VARS_JSON = orig;
   });
+
+  it('starts OpenCode server and stops it in finally when opencode-start-server is true', async () => {
+    const mockStop = jest.fn().mockResolvedValue(undefined);
+    const { startOpencodeServer } = require('../../utils/opencode_server');
+    (startOpencodeServer as jest.Mock).mockResolvedValue({ url: 'http://started:4096', stop: mockStop });
+    (core.getInput as jest.Mock).mockImplementation((key: string, opts?: { required?: boolean }) => {
+      if (key === INPUT_KEYS.OPENCODE_START_SERVER) return 'true';
+      if (opts?.required && key === INPUT_KEYS.TOKEN) return 'fake-token';
+      return '';
+    });
+
+    await runGitHubAction();
+
+    expect(startOpencodeServer).toHaveBeenCalledWith({ cwd: process.cwd() });
+    expect(mockStop).toHaveBeenCalledTimes(1);
+    const execution = mockMainRun.mock.calls[0][0];
+    expect(execution.ai.getOpencodeServerUrl()).toBe('http://started:4096');
+  });
+
+  it('calls setFailed and stops server when mainRun throws', async () => {
+    const mockStop = jest.fn().mockResolvedValue(undefined);
+    const { startOpencodeServer } = require('../../utils/opencode_server');
+    (startOpencodeServer as jest.Mock).mockResolvedValue({ url: 'http://x', stop: mockStop });
+    (core.getInput as jest.Mock).mockImplementation((key: string, opts?: { required?: boolean }) => {
+      if (key === INPUT_KEYS.OPENCODE_START_SERVER) return 'true';
+      if (opts?.required && key === INPUT_KEYS.TOKEN) return 'fake-token';
+      return '';
+    });
+    mockMainRun.mockRejectedValue(new Error('mainRun failed'));
+
+    await expect(runGitHubAction()).rejects.toThrow('mainRun failed');
+
+    expect(core.setFailed).not.toHaveBeenCalled();
+    expect(mockStop).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls setFailed when finishWithResults runs with single action throwError and results have errors', async () => {
+    const { Result } = require('../../data/model/result');
+    (core.getInput as jest.Mock).mockImplementation((key: string, opts?: { required?: boolean }) => {
+      if (key === INPUT_KEYS.SINGLE_ACTION) return ACTIONS.CREATE_RELEASE;
+      if (key === INPUT_KEYS.SINGLE_ACTION_ISSUE) return '42';
+      if (opts?.required && key === INPUT_KEYS.TOKEN) return 'fake-token';
+      return '';
+    });
+    mockMainRun.mockResolvedValue([
+      new Result({ id: 'a', success: false, executed: true, errors: ['First error'] }),
+    ]);
+
+    await runGitHubAction();
+
+    expect(mockPublishInvoke).toHaveBeenCalled();
+    expect(core.setFailed).toHaveBeenCalledWith('First error');
+  });
+
+  it('calls logError when INPUT_VARS_JSON is invalid JSON', async () => {
+    const orig = process.env.INPUT_VARS_JSON;
+    process.env.INPUT_VARS_JSON = 'not valid json';
+    const { logError } = require('../../utils/logger');
+
+    await runGitHubAction();
+
+    expect(logError).toHaveBeenCalledWith(expect.stringContaining('INPUT_VARS_JSON'));
+    process.env.INPUT_VARS_JSON = orig;
+  });
 });
diff --git a/src/actions/__tests__/local_action.test.ts b/src/actions/__tests__/local_action.test.ts
@@ -107,4 +107,43 @@ describe('runLocalAction', () => {
     expect(boxen.mock.calls[0][0]).toContain('Step 1');
     expect(boxen.mock.calls[0][0]).toContain('Reminder 1');
   });
+
+  it('calls getProjectDetail for each project id when PROJECT_IDS is set', async () => {
+    mockGetProjectDetail
+      .mockResolvedValueOnce({ id: 'proj-1', title: 'P1', url: 'https://x.com/1' })
+      .mockResolvedValueOnce({ id: 'proj-2', title: 'P2', url: 'https://x.com/2' });
+    const params: Record<string, unknown> = {
+      [INPUT_KEYS.TOKEN]: 't',
+      [INPUT_KEYS.PROJECT_IDS]: 'proj-1, proj-2',
+      repo: { owner: 'o', repo: 'r' },
+      eventName: 'push',
+      commits: { ref: 'refs/heads/main' },
+    };
+
+    await runLocalAction(params);
+
+    expect(mockGetProjectDetail).toHaveBeenCalledTimes(2);
+    expect(mockGetProjectDetail).toHaveBeenCalledWith('proj-1', 't');
+    expect(mockGetProjectDetail).toHaveBeenCalledWith('proj-2', 't');
+  });
+
+  it('includes errors and reminders in boxen content when results have errors and reminders', async () => {
+    const boxen = require('boxen');
+    mockMainRun.mockResolvedValue([
+      { executed: false, steps: [], errors: ['Error one'], reminders: [] },
+      { executed: true, steps: [], errors: [], reminders: ['Reminder text'] },
+    ]);
+    const params: Record<string, unknown> = {
+      [INPUT_KEYS.TOKEN]: 't',
+      repo: { owner: 'o', repo: 'r' },
+      eventName: 'push',
+      commits: { ref: 'refs/heads/main' },
+    };
+
+    await runLocalAction(params);
+
+    const content = boxen.mock.calls[0][0];
+    expect(content).toContain('Error one');
+    expect(content).toContain('Reminder text');
+  });
 });
