octocode-cli 1.2.8 → 1.2.9

package/skills/{octocode-code-engineer → octocode-engineer}/src/pipeline/cli.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { parseArgs } from './cli.js';
+import { parseArgs, HELP_TEXT } from './cli.js';
+import { OptionsError } from './create-options.js';
 import { DEFAULT_OPTS } from '../types/index.js';
 
 describe('parseArgs', () => {
@@ -12,9 +13,9 @@ describe('parseArgs', () => {
     expect(opts.graph).toBe(false);
     expect(opts.parser).toBe('auto');
     expect(opts.findingsLimit).toBe(Infinity);
-    expect(opts.minFunctionStatements).toBe(6);
-    expect(opts.minFlowStatements).toBe(6);
-    expect(opts.criticalComplexityThreshold).toBe(30);
+    expect(opts.thresholds.minFunctionStatements).toBe(6);
+    expect(opts.thresholds.minFlowStatements).toBe(6);
+    expect(opts.thresholds.criticalComplexityThreshold).toBe(30);
     expect(opts.deepLinkTopN).toBe(12);
     expect(opts.treeDepth).toBe(4);
     expect(opts.packageRoot).toMatch(/packages$/);
@@ -64,18 +65,18 @@ describe('parseArgs', () => {
 
   it('parses --min-function-statements', () => {
     expect(
-      parseArgs(['--min-function-statements', '12']).minFunctionStatements
+      parseArgs(['--min-function-statements', '12']).thresholds.minFunctionStatements
     ).toBe(12);
   });
 
   it('parses --min-flow-statements', () => {
-    expect(parseArgs(['--min-flow-statements', '8']).minFlowStatements).toBe(8);
+    expect(parseArgs(['--min-flow-statements', '8']).thresholds.minFlowStatements).toBe(8);
   });
 
   it('parses --critical-complexity-threshold', () => {
     expect(
       parseArgs(['--critical-complexity-threshold', '25'])
-        .criticalComplexityThreshold
+        .thresholds.criticalComplexityThreshold
     ).toBe(25);
   });
 
@@ -88,56 +89,56 @@ describe('parseArgs', () => {
   });
 
   it('parses --coupling-threshold', () => {
-    expect(parseArgs(['--coupling-threshold', '20']).couplingThreshold).toBe(
+    expect(parseArgs(['--coupling-threshold', '20']).thresholds.couplingThreshold).toBe(
       20
     );
   });
 
   it('parses --fan-in-threshold', () => {
-    expect(parseArgs(['--fan-in-threshold', '25']).fanInThreshold).toBe(25);
+    expect(parseArgs(['--fan-in-threshold', '25']).thresholds.fanInThreshold).toBe(25);
   });
 
   it('parses --fan-out-threshold', () => {
-    expect(parseArgs(['--fan-out-threshold', '18']).fanOutThreshold).toBe(18);
+    expect(parseArgs(['--fan-out-threshold', '18']).thresholds.fanOutThreshold).toBe(18);
   });
 
   it('parses --god-module-statements', () => {
     expect(
-      parseArgs(['--god-module-statements', '600']).godModuleStatements
+      parseArgs(['--god-module-statements', '600']).thresholds.godModuleStatements
     ).toBe(600);
   });
 
   it('parses --god-module-exports', () => {
-    expect(parseArgs(['--god-module-exports', '30']).godModuleExports).toBe(30);
+    expect(parseArgs(['--god-module-exports', '30']).thresholds.godModuleExports).toBe(30);
   });
 
   it('parses --god-function-statements', () => {
     expect(
-      parseArgs(['--god-function-statements', '150']).godFunctionStatements
+      parseArgs(['--god-function-statements', '150']).thresholds.godFunctionStatements
     ).toBe(150);
   });
 
   it('parses --cognitive-complexity-threshold', () => {
     expect(
       parseArgs(['--cognitive-complexity-threshold', '20'])
-        .cognitiveComplexityThreshold
+        .thresholds.cognitiveComplexityThreshold
     ).toBe(20);
   });
 
   it('parses --barrel-symbol-threshold', () => {
     expect(
-      parseArgs(['--barrel-symbol-threshold', '50']).barrelSymbolThreshold
+      parseArgs(['--barrel-symbol-threshold', '50']).thresholds.barrelSymbolThreshold
     ).toBe(50);
   });
 
   it('parses --layer-order as comma-separated list', () => {
     const opts = parseArgs(['--layer-order', 'ui,service,repository']);
-    expect(opts.layerOrder).toEqual(['ui', 'service', 'repository']);
+    expect(opts.thresholds.layerOrder).toEqual(['ui', 'service', 'repository']);
   });
 
   it('trims whitespace in --layer-order values', () => {
     const opts = parseArgs(['--layer-order', ' ui , service , repo ']);
-    expect(opts.layerOrder).toEqual(['ui', 'service', 'repo']);
+    expect(opts.thresholds.layerOrder).toEqual(['ui', 'service', 'repo']);
   });
 
   it('parses --features with pillar name', () => {
@@ -220,20 +221,20 @@ describe('parseArgs', () => {
       'no',
     ]);
     expect(opts.findingsLimit).toBe(DEFAULT_OPTS.findingsLimit);
-    expect(opts.couplingThreshold).toBe(DEFAULT_OPTS.couplingThreshold);
-    expect(opts.fanInThreshold).toBe(DEFAULT_OPTS.fanInThreshold);
-    expect(opts.fanOutThreshold).toBe(DEFAULT_OPTS.fanOutThreshold);
-    expect(opts.godModuleStatements).toBe(DEFAULT_OPTS.godModuleStatements);
-    expect(opts.godModuleExports).toBe(DEFAULT_OPTS.godModuleExports);
-    expect(opts.godFunctionStatements).toBe(DEFAULT_OPTS.godFunctionStatements);
-    expect(opts.cognitiveComplexityThreshold).toBe(
-      DEFAULT_OPTS.cognitiveComplexityThreshold
+    expect(opts.thresholds.couplingThreshold).toBe(DEFAULT_OPTS.thresholds.couplingThreshold);
+    expect(opts.thresholds.fanInThreshold).toBe(DEFAULT_OPTS.thresholds.fanInThreshold);
+    expect(opts.thresholds.fanOutThreshold).toBe(DEFAULT_OPTS.thresholds.fanOutThreshold);
+    expect(opts.thresholds.godModuleStatements).toBe(DEFAULT_OPTS.thresholds.godModuleStatements);
+    expect(opts.thresholds.godModuleExports).toBe(DEFAULT_OPTS.thresholds.godModuleExports);
+    expect(opts.thresholds.godFunctionStatements).toBe(DEFAULT_OPTS.thresholds.godFunctionStatements);
+    expect(opts.thresholds.cognitiveComplexityThreshold).toBe(
+      DEFAULT_OPTS.thresholds.cognitiveComplexityThreshold
     );
-    expect(opts.barrelSymbolThreshold).toBe(DEFAULT_OPTS.barrelSymbolThreshold);
-    expect(opts.minFunctionStatements).toBe(DEFAULT_OPTS.minFunctionStatements);
-    expect(opts.minFlowStatements).toBe(DEFAULT_OPTS.minFlowStatements);
-    expect(opts.criticalComplexityThreshold).toBe(
-      DEFAULT_OPTS.criticalComplexityThreshold
+    expect(opts.thresholds.barrelSymbolThreshold).toBe(DEFAULT_OPTS.thresholds.barrelSymbolThreshold);
+    expect(opts.thresholds.minFunctionStatements).toBe(DEFAULT_OPTS.thresholds.minFunctionStatements);
+    expect(opts.thresholds.minFlowStatements).toBe(DEFAULT_OPTS.thresholds.minFlowStatements);
+    expect(opts.thresholds.criticalComplexityThreshold).toBe(
+      DEFAULT_OPTS.thresholds.criticalComplexityThreshold
     );
     expect(opts.deepLinkTopN).toBe(DEFAULT_OPTS.deepLinkTopN);
     expect(opts.treeDepth).toBe(DEFAULT_OPTS.treeDepth);
@@ -260,8 +261,8 @@ describe('parseArgs', () => {
     expect(opts.graph).toBe(true);
     expect(opts.parser).toBe('typescript');
     expect(opts.findingsLimit).toBe(100);
-    expect(opts.couplingThreshold).toBe(10);
-    expect(opts.layerOrder).toEqual(['a', 'b', 'c']);
+    expect(opts.thresholds.couplingThreshold).toBe(10);
+    expect(opts.thresholds.layerOrder).toEqual(['a', 'b', 'c']);
   });
 
   it('sets packageRoot relative to root', () => {
@@ -282,12 +283,12 @@ describe('parseArgs', () => {
 
   it('--override-chain-threshold sets threshold', () => {
     const opts = parseArgs(['--override-chain-threshold', '5']);
-    expect(opts.overrideChainThreshold).toBe(5);
+    expect(opts.thresholds.overrideChainThreshold).toBe(5);
   });
 
   it('NaN guards for semantic thresholds', () => {
     const opts = parseArgs(['--override-chain-threshold', 'xyz']);
-    expect(opts.overrideChainThreshold).toBe(3);
+    expect(opts.thresholds.overrideChainThreshold).toBe(3);
   });
 
   it('--no-diversify sets noDiversify to true', () => {
@@ -360,8 +361,8 @@ describe('parseArgs', () => {
       '30',
     ]);
     expect(opts.findingsLimit).toBe(10);
-    expect(opts.minFunctionStatements).toBe(8);
-    expect(opts.criticalComplexityThreshold).toBe(30);
+    expect(opts.thresholds.minFunctionStatements).toBe(8);
+    expect(opts.thresholds.criticalComplexityThreshold).toBe(30);
   });
 
   it('parses --secret-entropy-threshold 4.0 and --similarity-threshold 0.9', () => {
@@ -371,16 +372,16 @@ describe('parseArgs', () => {
       '--similarity-threshold',
       '0.9',
     ]);
-    expect(opts.secretEntropyThreshold).toBe(4);
-    expect(opts.similarityThreshold).toBe(0.9);
+    expect(opts.thresholds.secretEntropyThreshold).toBe(4);
+    expect(opts.thresholds.similarityThreshold).toBe(0.9);
   });
 
   it('parses float flags with decimal values', () => {
     expect(
-      parseArgs(['--secret-entropy-threshold', '5.5']).secretEntropyThreshold
+      parseArgs(['--secret-entropy-threshold', '5.5']).thresholds.secretEntropyThreshold
     ).toBe(5.5);
     expect(
-      parseArgs(['--similarity-threshold', '0.75']).similarityThreshold
+      parseArgs(['--similarity-threshold', '0.75']).thresholds.similarityThreshold
     ).toBe(0.75);
   });
 
@@ -398,7 +399,7 @@ describe('parseArgs', () => {
     expect(opts.parser).toBe('typescript');
     expect(opts.root).toBe('/some/path');
     expect(opts.out).toBe('result.json');
-    expect(opts.layerOrder).toEqual(['ui', 'service', 'repo']);
+    expect(opts.thresholds.layerOrder).toEqual(['ui', 'service', 'repo']);
   });
 
   it('parses --out=output.json form', () => {
@@ -436,6 +437,24 @@ describe('parseArgs', () => {
     }
   });
 
+  it('parses --scope with Windows absolute paths without splitting drive letters', () => {
+    const opts = parseArgs(['--scope=C:\\repo\\pkg\\src\\a.ts']);
+    expect(opts.scope).toBeInstanceOf(Array);
+    expect(opts.scope).toHaveLength(1);
+    expect(opts.scopeSymbols).toBeNull();
+    expect(opts.scope![0]).toContain('C:\\repo\\pkg\\src\\a.ts');
+  });
+
+  it('parses --scope with Windows absolute path and file:symbol syntax', () => {
+    const opts = parseArgs(['--scope=C:\\repo\\pkg\\src\\a.ts:initSession']);
+    expect(opts.scope).toBeInstanceOf(Array);
+    expect(opts.scope).toHaveLength(1);
+    expect(opts.scopeSymbols).toBeInstanceOf(Map);
+    const [filePath, symbols] = [...opts.scopeSymbols!.entries()][0];
+    expect(filePath).toContain('C:\\repo\\pkg\\src\\a.ts');
+    expect(symbols).toEqual(['initSession']);
+  });
+
   it('parses --features with pillar name architecture', () => {
     const opts = parseArgs(['--features=architecture']);
     expect(opts.features).toBeInstanceOf(Set);
@@ -472,22 +491,250 @@ describe('parseArgs', () => {
     expect(opts.includeTests).toBe(true);
   });
 
-  it('throws when --features and --exclude are both provided', () => {
-    const exitSpy = vi
-      .spyOn(process, 'exit')
-      .mockImplementation((() => {}) as never);
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    parseArgs(['--features=architecture', '--exclude=dead-code']);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      '--features and --exclude are mutually exclusive. Use one or the other.'
-    );
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    exitSpy.mockRestore();
-    consoleSpy.mockRestore();
+  it('throws OptionsError when --features and --exclude are both provided', () => {
+    expect(() =>
+      parseArgs(['--features=architecture', '--exclude=dead-code'])
+    ).toThrow(OptionsError);
+    expect(() =>
+      parseArgs(['--features=architecture', '--exclude=dead-code'])
+    ).toThrow('mutually exclusive');
+  });
+
+  it('exports HELP_TEXT as a constant', () => {
+    expect(typeof HELP_TEXT).toBe('string');
+    expect(HELP_TEXT).toContain('--root');
+    expect(HELP_TEXT).toContain('--scope');
+    expect(HELP_TEXT).toContain('--features');
   });
 
   it('auto-enables includeTests when features include any test-quality category', () => {
     const opts = parseArgs(['--features=missing-mock-restoration']);
     expect(opts.includeTests).toBe(true);
   });
+
+  describe('Tier 1+2 flags', () => {
+    it('--affected defaults to HEAD', () => {
+      const opts = parseArgs(['--affected']);
+      expect(opts.affected).toBe('HEAD');
+    });
+
+    it('--affected accepts revision', () => {
+      const opts = parseArgs(['--affected', 'main']);
+      expect(opts.affected).toBe('main');
+    });
+
+    it('--affected=value inline syntax', () => {
+      const opts = parseArgs(['--affected=HEAD~3']);
+      expect(opts.affected).toBe('HEAD~3');
+    });
+
+    it('--save-baseline sets boolean', () => {
+      const opts = parseArgs(['--save-baseline']);
+      expect(opts.saveBaseline).toBe(true);
+    });
+
+    it('--ignore-known defaults to .octocode/baseline.json', () => {
+      const opts = parseArgs(['--ignore-known']);
+      expect(opts.ignoreKnown).toBe('.octocode/baseline.json');
+    });
+
+    it('--ignore-known accepts custom path', () => {
+      const opts = parseArgs(['--ignore-known', 'my-baseline.json']);
+      expect(opts.ignoreKnown).toBe('my-baseline.json');
+    });
+
+    it('--reporter accepts valid formats', () => {
+      expect(parseArgs(['--reporter', 'compact']).reporter).toBe('compact');
+      expect(parseArgs(['--reporter', 'github-actions']).reporter).toBe('github-actions');
+      expect(parseArgs(['--reporter', 'default']).reporter).toBe('default');
+    });
+
+    it('--focus sets module path', () => {
+      const opts = parseArgs(['--focus', 'src/session.ts']);
+      expect(opts.focus).toBe('src/session.ts');
+    });
+
+    it('--focus=value inline syntax', () => {
+      const opts = parseArgs(['--focus=src/session.ts']);
+      expect(opts.focus).toBe('src/session.ts');
+    });
+
+    it('--focus-depth sets depth', () => {
+      const opts = parseArgs(['--focus-depth', '3']);
+      expect(opts.focusDepth).toBe(3);
+    });
+
+    it('--collapse sets folder depth', () => {
+      const opts = parseArgs(['--collapse', '2']);
+      expect(opts.collapse).toBe(2);
+    });
+
+    it('--collapse=N inline syntax', () => {
+      const opts = parseArgs(['--collapse=3']);
+      expect(opts.collapse).toBe(3);
+    });
+
+    it('--at-least sets score threshold', () => {
+      const opts = parseArgs(['--at-least', '60']);
+      expect(opts.atLeast).toBe(60);
+    });
+
+    it('--at-least=N inline syntax', () => {
+      const opts = parseArgs(['--at-least=75']);
+      expect(opts.atLeast).toBe(75);
+    });
+
+    it('--config sets config file path', () => {
+      const opts = parseArgs(['--config', '.my-config.json']);
+      expect(opts.configFile).toBe('.my-config.json');
+    });
+
+    it('new flags have correct defaults', () => {
+      const opts = parseArgs([]);
+      expect(opts.affected).toBeNull();
+      expect(opts.saveBaseline).toBe(false);
+      expect(opts.ignoreKnown).toBeNull();
+      expect(opts.reporter).toBe('default');
+      expect(opts.focus).toBeNull();
+      expect(opts.focusDepth).toBe(1);
+      expect(opts.collapse).toBeNull();
+      expect(opts.atLeast).toBeNull();
+      expect(opts.configFile).toBeNull();
+    });
+
+    it('HELP_TEXT includes new flags', () => {
+      expect(HELP_TEXT).toContain('--affected');
+      expect(HELP_TEXT).toContain('--save-baseline');
+      expect(HELP_TEXT).toContain('--ignore-known');
+      expect(HELP_TEXT).toContain('--reporter');
+      expect(HELP_TEXT).toContain('--focus');
+      expect(HELP_TEXT).toContain('--focus-depth');
+      expect(HELP_TEXT).toContain('--collapse');
+      expect(HELP_TEXT).toContain('--at-least');
+      expect(HELP_TEXT).toContain('--config');
+    });
+
+    it('--affected does not consume the next flag as revision', () => {
+      const opts = parseArgs(['--affected', '--graph']);
+      expect(opts.affected).toBe('HEAD');
+      expect(opts.graph).toBe(true);
+    });
+
+    it('--ignore-known does not consume the next flag as path', () => {
+      const opts = parseArgs(['--ignore-known', '--graph']);
+      expect(opts.ignoreKnown).toBe('.octocode/baseline.json');
+      expect(opts.graph).toBe(true);
+    });
+  });
+
+  describe('documented common profiles parse without error', () => {
+    it('CI gate profile', () => {
+      const opts = parseArgs(['--reporter', 'github-actions', '--at-least', '60']);
+      expect(opts.reporter).toBe('github-actions');
+      expect(opts.atLeast).toBe(60);
+    });
+
+    it('PR diff check profile', () => {
+      const opts = parseArgs(['--affected', 'HEAD~1', '--reporter', 'compact']);
+      expect(opts.affected).toBe('HEAD~1');
+      expect(opts.reporter).toBe('compact');
+    });
+
+    it('progressive adoption save profile', () => {
+      const opts = parseArgs(['--save-baseline']);
+      expect(opts.saveBaseline).toBe(true);
+    });
+
+    it('progressive adoption check profile', () => {
+      const opts = parseArgs(['--ignore-known', '--at-least', '60']);
+      expect(opts.ignoreKnown).toBe('.octocode/baseline.json');
+      expect(opts.atLeast).toBe(60);
+    });
+
+    it('module zoom profile', () => {
+      const opts = parseArgs([
+        '--graph',
+        '--focus', 'src/session.ts',
+        '--focus-depth', '2',
+      ]);
+      expect(opts.graph).toBe(true);
+      expect(opts.focus).toBe('src/session.ts');
+      expect(opts.focusDepth).toBe(2);
+    });
+
+    it('high-level arch profile', () => {
+      const opts = parseArgs(['--graph', '--collapse', '2']);
+      expect(opts.graph).toBe(true);
+      expect(opts.collapse).toBe(2);
+    });
+
+    it('full combination profile', () => {
+      const opts = parseArgs([
+        '--affected', 'main',
+        '--reporter', 'compact',
+        '--save-baseline',
+        '--at-least', '70',
+        '--graph',
+        '--focus', 'src/tools',
+        '--focus-depth', '3',
+        '--config', '.my-scan.json',
+      ]);
+      expect(opts.affected).toBe('main');
+      expect(opts.reporter).toBe('compact');
+      expect(opts.saveBaseline).toBe(true);
+      expect(opts.atLeast).toBe(70);
+      expect(opts.graph).toBe(true);
+      expect(opts.focus).toBe('src/tools');
+      expect(opts.focusDepth).toBe(3);
+      expect(opts.configFile).toBe('.my-scan.json');
+    });
+  });
+
+  describe('v2 quality threshold flags', () => {
+    it('parses --deep-nesting-threshold', () => {
+      expect(
+        parseArgs(['--deep-nesting-threshold', '8']).thresholds.deepNestingThreshold
+      ).toBe(8);
+    });
+
+    it('parses --multiple-return-threshold', () => {
+      expect(
+        parseArgs(['--multiple-return-threshold', '10']).thresholds.multipleReturnThreshold
+      ).toBe(10);
+    });
+
+    it('parses --magic-string-min-occurrences', () => {
+      expect(
+        parseArgs(['--magic-string-min-occurrences', '5']).thresholds.magicStringMinOccurrences
+      ).toBe(5);
+    });
+
+    it('parses --boolean-param-threshold', () => {
+      expect(
+        parseArgs(['--boolean-param-threshold', '4']).thresholds.booleanParamThreshold
+      ).toBe(4);
+    });
+
+    it('defaults are correct for new thresholds', () => {
+      const opts = parseArgs([]);
+      expect(opts.thresholds.deepNestingThreshold).toBe(5);
+      expect(opts.thresholds.multipleReturnThreshold).toBe(6);
+      expect(opts.thresholds.magicStringMinOccurrences).toBe(3);
+      expect(opts.thresholds.booleanParamThreshold).toBe(3);
+    });
+
+    it('warns on unknown flags', () => {
+      const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      parseArgs(['--sematic']);
+      expect(spy).toHaveBeenCalledWith(expect.stringContaining('unknown flag'));
+      spy.mockRestore();
+    });
+
+    it('new threshold flags appear in HELP_TEXT', () => {
+      expect(HELP_TEXT).toContain('--deep-nesting-threshold');
+      expect(HELP_TEXT).toContain('--multiple-return-threshold');
+      expect(HELP_TEXT).toContain('--magic-string-min-occurrences');
+      expect(HELP_TEXT).toContain('--boolean-param-threshold');
+    });
+  });
 });