github-issue-tower-defence-management 1.40.0 → 1.42.0

package/src/adapter/entry-points/cli/index.test.ts

@@ -128,13 +128,17 @@ describe('CLI', () => {
         awaitingWorkspaceStatus: 'Awaiting',
         preparationStatus: 'Preparing',
         defaultAgentName: 'agent1',
-        logFilePath: '/path/to/log.txt',
+        defaultLlmModelName: 'claude-opus-4-5',
+        defaultLlmAgentName: 'aw',
         maximumPreparingIssuesCount: 10,
         allowIssueCacheMinutes: 5,
+        utilizationPercentageThreshold: 80,
+        allowedIssueAuthors: 'user1,user2',
         awaitingQualityCheckStatus: 'Awaiting QC',
         thresholdForAutoReject: 5,
         workflowBlockerResolvedWebhookUrl: 'https://example.com/webhook',
         projectName: 'test-project',
+        codexHomeCandidates: ['.codex-dev1', '.codex-main'],
       };
       writeConfig(config);
 
@@ -143,6 +147,42 @@ describe('CLI', () => {
       expect(result).toEqual(config);
     });
 
+    it('should load codexHomeCandidates string array from config file', () => {
+      const config = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+      };
+      writeConfig(config);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toEqual([
+        '.codex-dev1',
+        '.codex-dev2',
+        '.codex-main',
+      ]);
+    });
+
+    it('should return undefined codexHomeCandidates when not in config', () => {
+      writeConfig(defaultConfig);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toBeUndefined();
+    });
+
+    it('should return undefined codexHomeCandidates when array contains non-string items', () => {
+      const config = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', 123],
+      };
+      writeConfig(config);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toBeUndefined();
+    });
+
     it('should return empty config for empty YAML', () => {
       fs.writeFileSync(configFilePath, '');
 
@@ -168,7 +208,8 @@ describe('CLI', () => {
       const config = {
         maximumPreparingIssuesCount: 'abc',
         allowIssueCacheMinutes: 'def',
-        thresholdForAutoReject: 'ghi',
+        utilizationPercentageThreshold: 'ghi',
+        thresholdForAutoReject: 'jkl',
       };
       writeConfig(config);
 
@@ -176,6 +217,7 @@ describe('CLI', () => {
 
       expect(result.maximumPreparingIssuesCount).toBeUndefined();
       expect(result.allowIssueCacheMinutes).toBeUndefined();
+      expect(result.utilizationPercentageThreshold).toBeUndefined();
       expect(result.thresholdForAutoReject).toBeUndefined();
     });
 
@@ -274,14 +316,14 @@ defaultAgentName: 'readme-agent'
       const readme = `<details>
 <summary>config</summary>
 maximumPreparingIssuesCount: 15
-allowIssueCacheMinutes: 10
+utilizationPercentageThreshold: 80
 thresholdForAutoReject: 5
 </details>`;
 
       const result = parseProjectReadmeConfig(readme);
 
       expect(result.maximumPreparingIssuesCount).toBe(15);
-      expect(result.allowIssueCacheMinutes).toBe(10);
+      expect(result.utilizationPercentageThreshold).toBe(80);
       expect(result.thresholdForAutoReject).toBe(5);
     });
 
@@ -295,6 +337,24 @@ defaultAgentName: 'case-test-agent'
 
       expect(result.defaultAgentName).toBe('case-test-agent');
     });
+
+    it('should parse codexHomeCandidates string array from README config', () => {
+      const readme = `<details>
+<summary>config</summary>
+codexHomeCandidates:
+  - .codex-dev1
+  - .codex-dev2
+  - .codex-main
+</details>`;
+
+      const result = parseProjectReadmeConfig(readme);
+
+      expect(result.codexHomeCandidates).toEqual([
+        '.codex-dev1',
+        '.codex-dev2',
+        '.codex-main',
+      ]);
+    });
   });
 
   describe('mergeConfigs', () => {
@@ -446,9 +506,13 @@ defaultAgentName: 'case-test-agent'
         awaitingWorkspaceStatus: 'Awaiting',
         preparationStatus: 'Preparing',
         defaultAgentName: 'agent1',
-        logFilePath: undefined,
+        defaultLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: configFilePath,
         maximumPreparingIssuesCount: null,
-        allowIssueCacheMinutes: 0,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
       });
     });
 
@@ -483,18 +547,23 @@ defaultAgentName: 'case-test-agent'
         awaitingWorkspaceStatus: 'Awaiting',
         preparationStatus: 'Preparing',
         defaultAgentName: 'override-agent',
-        logFilePath: undefined,
+        defaultLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: configFilePath,
         maximumPreparingIssuesCount: null,
-        allowIssueCacheMinutes: 0,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
       });
     });
 
-    it('should pass logFilePath from config file', async () => {
-      const configWithLog = {
+    it('should pass defaultLlmModelName and allowedIssueAuthors from config file', async () => {
+      const configWithLlm = {
         ...defaultConfig,
-        logFilePath: '/path/to/log.txt',
+        defaultLlmModelName: 'claude-opus-4-5',
+        allowedIssueAuthors: 'user1,user2',
       };
-      writeConfig(configWithLog);
+      writeConfig(configWithLlm);
 
       const mockRun = jest.fn().mockResolvedValue(undefined);
       const MockedStartPreparationUseCase = jest.mocked(
@@ -518,7 +587,8 @@ defaultAgentName: 'case-test-agent'
 
       expect(mockRun).toHaveBeenCalledWith(
         expect.objectContaining({
-          logFilePath: '/path/to/log.txt',
+          defaultLlmModelName: 'claude-opus-4-5',
+          allowedIssueAuthors: ['user1', 'user2'],
         }),
       );
     });
@@ -892,6 +962,107 @@ defaultAgentName: 'case-test-agent'
         }),
       );
     });
+
+    it('should pass codexHomeCandidates from config file', async () => {
+      const configWithCandidates = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+      };
+      writeConfig(configWithCandidates);
+
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+        }),
+      );
+    });
+
+    it('should pass codexHomeCandidates as null when not in config', async () => {
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: null,
+        }),
+      );
+    });
+
+    it('should pass codexHomeCandidates from README config', async () => {
+      const readmeContent = [
+        '# Project',
+        '<details>',
+        '<summary>config</summary>',
+        'codexHomeCandidates:',
+        '  - .codex-readme1',
+        '  - .codex-readme2',
+        '</details>',
+      ].join('\n');
+      mockFetchReturningReadme(readmeContent);
+
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: ['.codex-readme1', '.codex-readme2'],
+        }),
+      );
+    });
   });
 
   describe('notifyFinishedIssuePreparation', () => {

package/src/adapter/entry-points/cli/index.ts

@@ -26,14 +26,18 @@ type ConfigFile = {
   awaitingWorkspaceStatus?: string;
   preparationStatus?: string;
   defaultAgentName?: string;
-  logFilePath?: string;
+  defaultLlmModelName?: string;
+  defaultLlmAgentName?: string;
   maximumPreparingIssuesCount?: number;
   allowIssueCacheMinutes?: number;
+  utilizationPercentageThreshold?: number;
+  allowedIssueAuthors?: string;
   awaitingQualityCheckStatus?: string;
   thresholdForAutoReject?: number;
   workflowBlockerResolvedWebhookUrl?: string;
   projectName?: string;
   preparationProcessCheckCommand?: string;
+  codexHomeCandidates?: string[];
 };
 
 type StartDaemonOptions = {
@@ -41,9 +45,12 @@ type StartDaemonOptions = {
   awaitingWorkspaceStatus?: string;
   preparationStatus?: string;
   defaultAgentName?: string;
-  logFilePath?: string;
+  defaultLlmModelName?: string;
+  defaultLlmAgentName?: string;
   maximumPreparingIssuesCount?: string;
   allowIssueCacheMinutes?: string;
+  utilizationPercentageThreshold?: string;
+  allowedIssueAuthors?: string;
   preparationProcessCheckCommand?: string;
   configFilePath: string;
 };
@@ -75,6 +82,24 @@ const getNumberValue = (
   return typeof value === 'number' ? value : undefined;
 };
 
+const getStringArrayValue = (
+  obj: Record<string, unknown>,
+  key: string,
+): string[] | undefined => {
+  const value = obj[key];
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const strings: string[] = [];
+  for (const item of value) {
+    if (typeof item !== 'string') {
+      return undefined;
+    }
+    strings.push(item);
+  }
+  return strings;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
@@ -93,12 +118,18 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
       ),
       preparationStatus: getStringValue(parsed, 'preparationStatus'),
       defaultAgentName: getStringValue(parsed, 'defaultAgentName'),
-      logFilePath: getStringValue(parsed, 'logFilePath'),
+      defaultLlmModelName: getStringValue(parsed, 'defaultLlmModelName'),
+      defaultLlmAgentName: getStringValue(parsed, 'defaultLlmAgentName'),
       maximumPreparingIssuesCount: getNumberValue(
         parsed,
         'maximumPreparingIssuesCount',
       ),
       allowIssueCacheMinutes: getNumberValue(parsed, 'allowIssueCacheMinutes'),
+      utilizationPercentageThreshold: getNumberValue(
+        parsed,
+        'utilizationPercentageThreshold',
+      ),
+      allowedIssueAuthors: getStringValue(parsed, 'allowedIssueAuthors'),
       awaitingQualityCheckStatus: getStringValue(
         parsed,
         'awaitingQualityCheckStatus',
@@ -113,6 +144,7 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
         parsed,
         'preparationProcessCheckCommand',
       ),
+      codexHomeCandidates: getStringArrayValue(parsed, 'codexHomeCandidates'),
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -146,12 +178,18 @@ export const parseProjectReadmeConfig = (readme: string): ConfigFile => {
       ),
       preparationStatus: getStringValue(parsed, 'preparationStatus'),
       defaultAgentName: getStringValue(parsed, 'defaultAgentName'),
-      logFilePath: getStringValue(parsed, 'logFilePath'),
+      defaultLlmModelName: getStringValue(parsed, 'defaultLlmModelName'),
+      defaultLlmAgentName: getStringValue(parsed, 'defaultLlmAgentName'),
       maximumPreparingIssuesCount: getNumberValue(
         parsed,
         'maximumPreparingIssuesCount',
       ),
       allowIssueCacheMinutes: getNumberValue(parsed, 'allowIssueCacheMinutes'),
+      utilizationPercentageThreshold: getNumberValue(
+        parsed,
+        'utilizationPercentageThreshold',
+      ),
+      allowedIssueAuthors: getStringValue(parsed, 'allowedIssueAuthors'),
       awaitingQualityCheckStatus: getStringValue(
         parsed,
         'awaitingQualityCheckStatus',
@@ -165,6 +203,7 @@ export const parseProjectReadmeConfig = (readme: string): ConfigFile => {
         parsed,
         'preparationProcessCheckCommand',
       ),
+      codexHomeCandidates: getStringArrayValue(parsed, 'codexHomeCandidates'),
     };
   } catch {
     console.warn('Failed to parse YAML from project README config section');
@@ -190,10 +229,14 @@ export const mergeConfigs = (
     readmeOverrides.defaultAgentName ??
     cliOverrides.defaultAgentName ??
     configFile.defaultAgentName,
-  logFilePath:
-    readmeOverrides.logFilePath ??
-    cliOverrides.logFilePath ??
-    configFile.logFilePath,
+  defaultLlmModelName:
+    readmeOverrides.defaultLlmModelName ??
+    cliOverrides.defaultLlmModelName ??
+    configFile.defaultLlmModelName,
+  defaultLlmAgentName:
+    readmeOverrides.defaultLlmAgentName ??
+    cliOverrides.defaultLlmAgentName ??
+    configFile.defaultLlmAgentName,
   maximumPreparingIssuesCount:
     readmeOverrides.maximumPreparingIssuesCount ??
     cliOverrides.maximumPreparingIssuesCount ??
@@ -202,6 +245,14 @@ export const mergeConfigs = (
     readmeOverrides.allowIssueCacheMinutes ??
     cliOverrides.allowIssueCacheMinutes ??
     configFile.allowIssueCacheMinutes,
+  utilizationPercentageThreshold:
+    readmeOverrides.utilizationPercentageThreshold ??
+    cliOverrides.utilizationPercentageThreshold ??
+    configFile.utilizationPercentageThreshold,
+  allowedIssueAuthors:
+    readmeOverrides.allowedIssueAuthors ??
+    cliOverrides.allowedIssueAuthors ??
+    configFile.allowedIssueAuthors,
   awaitingQualityCheckStatus:
     readmeOverrides.awaitingQualityCheckStatus ??
     cliOverrides.awaitingQualityCheckStatus ??
@@ -219,6 +270,10 @@ export const mergeConfigs = (
     readmeOverrides.preparationProcessCheckCommand ??
     cliOverrides.preparationProcessCheckCommand ??
     configFile.preparationProcessCheckCommand,
+  codexHomeCandidates:
+    readmeOverrides.codexHomeCandidates ??
+    cliOverrides.codexHomeCandidates ??
+    configFile.codexHomeCandidates,
 });
 
 type GraphqlProjectV2ReadmeResponse = {
@@ -361,7 +416,8 @@ program
   )
   .option('--preparationStatus <status>', 'Status for issues in preparation')
   .option('--defaultAgentName <name>', 'Default agent name')
-  .option('--logFilePath <path>', 'Path to log file')
+  .option('--defaultLlmModelName <name>', 'Default LLM model name')
+  .option('--defaultLlmAgentName <name>', 'Default LLM agent name')
   .option(
     '--maximumPreparingIssuesCount <count>',
     'Maximum number of issues in preparation status (default: 6)',
@@ -370,6 +426,14 @@ program
     '--allowIssueCacheMinutes <minutes>',
     'Allow cache for issues in minutes (default: 0)',
   )
+  .option(
+    '--utilizationPercentageThreshold <percent>',
+    'Claude utilization percentage threshold (default: 90)',
+  )
+  .option(
+    '--allowedIssueAuthors <authors>',
+    'Comma-separated list of allowed issue authors',
+  )
   .option(
     '--preparationProcessCheckCommand <template>',
     'Shell command template with {URL} placeholder to check if a preparation process is alive',
@@ -388,13 +452,18 @@ program
       awaitingWorkspaceStatus: options.awaitingWorkspaceStatus,
       preparationStatus: options.preparationStatus,
       defaultAgentName: options.defaultAgentName,
-      logFilePath: options.logFilePath,
+      defaultLlmModelName: options.defaultLlmModelName,
+      defaultLlmAgentName: options.defaultLlmAgentName,
       maximumPreparingIssuesCount: options.maximumPreparingIssuesCount
         ? Number(options.maximumPreparingIssuesCount)
         : undefined,
       allowIssueCacheMinutes: options.allowIssueCacheMinutes
         ? Number(options.allowIssueCacheMinutes)
         : undefined,
+      utilizationPercentageThreshold: options.utilizationPercentageThreshold
+        ? Number(options.utilizationPercentageThreshold)
+        : undefined,
+      allowedIssueAuthors: options.allowedIssueAuthors,
       preparationProcessCheckCommand: options.preparationProcessCheckCommand,
     };
 
@@ -419,7 +488,6 @@ program
     const awaitingWorkspaceStatus = config.awaitingWorkspaceStatus;
     const preparationStatus = config.preparationStatus;
     const defaultAgentName = config.defaultAgentName;
-    const logFilePath = config.logFilePath;
 
     if (!projectUrl) {
       console.error(
@@ -484,6 +552,12 @@ program
     const projectRepository = {
       ...new GraphqlProjectRepository(...githubRepositoryParams),
       ...new CheerioProjectRepository(...githubRepositoryParams),
+      prepareStatus: async (
+        _name: string,
+        project: Project,
+      ): Promise<Project> => {
+        return project;
+      },
     };
     const apiV3IssueRepository = new ApiV3IssueRepository(
       ...githubRepositoryParams,
@@ -528,14 +602,32 @@ program
       localCommandRunner,
     );
 
+    const rawAllowedIssueAuthors = config.allowedIssueAuthors;
+    const allowedIssueAuthors = rawAllowedIssueAuthors
+      ? rawAllowedIssueAuthors
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : null;
+
+    const codexHomeCandidates =
+      config.codexHomeCandidates && config.codexHomeCandidates.length > 0
+        ? config.codexHomeCandidates
+        : null;
+
     await useCase.run({
       projectUrl,
       awaitingWorkspaceStatus,
       preparationStatus,
       defaultAgentName,
-      logFilePath: logFilePath ?? undefined,
+      defaultLlmModelName: config.defaultLlmModelName ?? null,
+      defaultLlmAgentName: config.defaultLlmAgentName ?? null,
+      configFilePath: options.configFilePath,
       maximumPreparingIssuesCount,
-      allowIssueCacheMinutes,
+      utilizationPercentageThreshold:
+        config.utilizationPercentageThreshold ?? 90,
+      allowedIssueAuthors,
+      codexHomeCandidates,
     });
   });
 

package/src/adapter/repositories/NodeLocalCommandRunner.test.ts

@@ -1,11 +1,11 @@
-const mockExecAsync = jest.fn();
+const mockExecFileAsync = jest.fn();
 
 jest.mock('child_process', () => ({
-  exec: jest.fn(),
+  execFile: jest.fn(),
 }));
 
 jest.mock('util', () => ({
-  promisify: jest.fn(() => mockExecAsync),
+  promisify: jest.fn(() => mockExecFileAsync),
 }));
 
 import { NodeLocalCommandRunner } from './NodeLocalCommandRunner';
@@ -20,19 +20,19 @@ describe('NodeLocalCommandRunner', () => {
 
   describe('runCommand', () => {
     it('should execute command successfully', async () => {
-      mockExecAsync.mockResolvedValue({
+      mockExecFileAsync.mockResolvedValue({
         stdout: 'command output',
         stderr: '',
       });
 
-      const result = await runner.runCommand('echo "test"');
+      const result = await runner.runCommand('echo', ['"test"']);
 
       expect(result).toEqual({
         stdout: 'command output',
         stderr: '',
         exitCode: 0,
       });
-      expect(mockExecAsync).toHaveBeenCalledWith('echo "test"');
+      expect(mockExecFileAsync).toHaveBeenCalledWith('echo', ['"test"']);
     });
 
     it('should handle command errors with exit code', async () => {
@@ -41,9 +41,9 @@ describe('NodeLocalCommandRunner', () => {
         stdout: 'partial output',
         stderr: 'error message',
       });
-      mockExecAsync.mockRejectedValue(error);
+      mockExecFileAsync.mockRejectedValue(error);
 
-      const result = await runner.runCommand('invalid-command');
+      const result = await runner.runCommand('invalid-command', []);
 
       expect(result).toEqual({
         stdout: 'partial output',
@@ -58,9 +58,9 @@ describe('NodeLocalCommandRunner', () => {
         stdout: '',
         stderr: 'command not found',
       });
-      mockExecAsync.mockRejectedValue(error);
+      mockExecFileAsync.mockRejectedValue(error);
 
-      const result = await runner.runCommand('nonexistent');
+      const result = await runner.runCommand('nonexistent', []);
 
       expect(result).toEqual({
         stdout: '',
@@ -70,9 +70,9 @@ describe('NodeLocalCommandRunner', () => {
     });
 
     it('should throw error if error format is unexpected', async () => {
-      mockExecAsync.mockRejectedValue(new Error('Unexpected error'));
+      mockExecFileAsync.mockRejectedValue(new Error('Unexpected error'));
 
-      await expect(runner.runCommand('command')).rejects.toThrow(
+      await expect(runner.runCommand('command', [])).rejects.toThrow(
         'Unexpected error',
       );
     });

package/src/adapter/repositories/NodeLocalCommandRunner.ts

@@ -1,17 +1,20 @@
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 export class NodeLocalCommandRunner implements LocalCommandRunner {
-  async runCommand(command: string): Promise<{
+  async runCommand(
+    program: string,
+    args: string[],
+  ): Promise<{
     stdout: string;
     stderr: string;
     exitCode: number;
   }> {
     try {
-      const { stdout, stderr } = await execAsync(command);
+      const { stdout, stderr } = await execFileAsync(program, args);
       return {
         stdout,
         stderr,

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -63,6 +63,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           isInProgress: false,
           isClosed: false,
           createdAt: new Date('2024-01-01T00:00:00Z'),
+          author: '',
         },
       },
       {
@@ -114,6 +115,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           isInProgress: false,
           isClosed: false,
           createdAt: new Date('2024-01-01T00:00:00Z'),
+          author: '',
         },
       },
     ];
@@ -244,6 +246,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         isInProgress: false,
         isClosed: false,
         createdAt: new Date('2024-01-01'),
+        author: '',
       };
       const statusId = 'new-status-id';