octocode-cli 1.2.8 → 1.2.9

package/skills/{octocode-code-engineer → octocode-engineer}/src/ast/tree-sitter.test.ts

@@ -370,8 +370,7 @@ function f() {
       const maps = emptyMaps();
       const opts = {
         ...testOpts,
-        minFunctionStatements: 6,
-        minFlowStatements: 1,
+        thresholds: { ...testOpts.thresholds, minFunctionStatements: 6, minFlowStatements: 1 },
       };
       analyzeTreeSitterFile('/repo/src/big.ts', code, opts, 'test-pkg', maps);
       expect(maps.flowMap.size).toBeGreaterThan(0);
@@ -403,5 +402,122 @@ function f() {
       expect(result).not.toBeNull();
       expect(result!.functions[0].source).toBe('tree-sitter');
     });
+
+    it('computes cognitiveComplexity > 0 for nested control flow', () => {
+      const code = `function complexFn(x: number, y: boolean) {
+  if (x > 0) {           // +1
+    if (y) {              // +2 (1 + nesting=1)
+      for (let i = 0; i < x; i++) {  // +3 (1 + nesting=2)
+        if (i % 2 === 0) {           // +4 (1 + nesting=3)
+          console.log(i);
+        }
+      }
+    }
+  }
+  return x;
+}`;
+      const result = analyzeTreeSitterFile(
+        '/repo/src/cognitive.ts',
+        code,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      expect(result).not.toBeNull();
+      const fn = result!.functions[0];
+      expect(fn.cognitiveComplexity).toBeGreaterThanOrEqual(10);
+    });
+
+    it('computes cognitiveComplexity = 0 for simple linear function', () => {
+      const code = `function simple() {
+  const a = 1;
+  const b = 2;
+  return a + b;
+}`;
+      const result = analyzeTreeSitterFile(
+        '/repo/src/simple.ts',
+        code,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      expect(result).not.toBeNull();
+      expect(result!.functions[0].cognitiveComplexity).toBe(0);
+    });
+
+    it('handles else-if without double-counting nesting', () => {
+      const code = `function classify(x: number) {
+  if (x > 100) {
+    return 'high';
+  } else if (x > 50) {
+    return 'medium';
+  } else if (x > 0) {
+    return 'low';
+  } else {
+    return 'none';
+  }
+}`;
+      const result = analyzeTreeSitterFile(
+        '/repo/src/elseif.ts',
+        code,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      expect(result).not.toBeNull();
+      const fn = result!.functions[0];
+      expect(fn.cognitiveComplexity).toBeGreaterThan(0);
+      expect(fn.cognitiveComplexity).toBeLessThan(10);
+    });
+
+    it('increments for logical operators (&&, ||, ??)', () => {
+      const code = `function guard(a: any, b: any, c: any) {
+  if (a && b || c) {
+    return true;
+  }
+  return false;
+}`;
+      const result = analyzeTreeSitterFile(
+        '/repo/src/logical.ts',
+        code,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      expect(result).not.toBeNull();
+      const fn = result!.functions[0];
+      expect(fn.cognitiveComplexity).toBeGreaterThanOrEqual(3);
+    });
+
+    it('cognitiveComplexity reflects nesting depth penalty', () => {
+      const shallow = `function shallow(x: boolean) { if (x) { return 1; } return 0; }`;
+      const deep = `function deep(x: boolean, y: boolean) {
+  if (x) {
+    if (y) {
+      return 1;
+    }
+  }
+  return 0;
+}`;
+      const shallowResult = analyzeTreeSitterFile(
+        '/repo/src/shallow.ts',
+        shallow,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      const deepResult = analyzeTreeSitterFile(
+        '/repo/src/deep.ts',
+        deep,
+        testOpts,
+        'test-pkg',
+        null
+      );
+      expect(shallowResult).not.toBeNull();
+      expect(deepResult).not.toBeNull();
+      expect(deepResult!.functions[0].cognitiveComplexity).toBeGreaterThan(
+        shallowResult!.functions[0].cognitiveComplexity
+      );
+    });
   }
 );

package/skills/{octocode-code-engineer → octocode-engineer}/src/ast/tree-sitter.ts

@@ -127,6 +127,68 @@ function collectTreeSitterMetrics(
   return metrics;
 }
 
+const COGNITIVE_NESTING_TYPES = new Set([
+  'if_statement',
+  'for_statement',
+  'for_in_statement',
+  'for_of_statement',
+  'for_await_statement',
+  'while_statement',
+  'do_statement',
+  'catch_clause',
+  'conditional_expression',
+  'switch_statement',
+]);
+
+const COGNITIVE_LOGICAL_TYPES = new Set(['&&', '||', '??']);
+
+function computeTreeSitterCognitiveComplexity(node: SyntaxNode): number {
+  let total = 0;
+
+  const visit = (current: SyntaxNode, nesting: number): void => {
+    let increment = 0;
+    let nestable = false;
+
+    if (COGNITIVE_NESTING_TYPES.has(current.type)) {
+      increment = 1;
+      nestable = true;
+    }
+
+    if (current.type === 'binary_expression') {
+      for (const child of current.children) {
+        if (!child.isNamed && COGNITIVE_LOGICAL_TYPES.has(child.type)) {
+          increment = 1;
+          break;
+        }
+      }
+    }
+
+    if (
+      current.type === 'if_statement' &&
+      current.parent?.type === 'else_clause'
+    ) {
+      increment = 1;
+      nestable = false;
+    }
+
+    if (nestable) {
+      total += increment + nesting;
+      for (const child of current.children) {
+        visit(child, nesting + 1);
+      }
+      return;
+    }
+
+    total += increment;
+    for (const child of current.children) {
+      visit(child, nesting);
+    }
+  };
+
+  visit(node, 0);
+  return total;
+}
+
 function inferTreeSitterFunctionName(node: SyntaxNode, _text: string): string {
   const identifier = node.namedChildren.find(child =>
     ['identifier', 'property_identifier', 'type_identifier'].includes(
@@ -290,13 +352,13 @@ export function analyzeTreeSitterFile(
         awaits: metrics.awaits,
         calls: metrics.calls,
         loops: metrics.loops,
-        cognitiveComplexity: 0,
+        cognitiveComplexity: computeTreeSitterCognitiveComplexity(node),
         source: 'tree-sitter',
       };
 
       fileEntry.functions.push(entry);
 
-      if (maps && statementCount >= options.minFunctionStatements) {
+      if (maps && statementCount >= options.thresholds.minFunctionStatements) {
         const body = node.namedChildren.find(
           child => child.type === 'statement_block'
         );
@@ -325,7 +387,7 @@ export function analyzeTreeSitterFile(
       };
       fileEntry.flows.push(flowEntry);
 
-      if (maps && statementCount >= options.minFlowStatements) {
+      if (maps && statementCount >= options.thresholds.minFlowStatements) {
         const flowHash = makeTreeSitterFingerprint(node);
         increment(maps.controlMap, `${flowHash}|${node.type}`, {
           ...flowEntry,

package/skills/{octocode-code-engineer → octocode-engineer}/src/ast/ts-analyzer.test.ts

@@ -400,7 +400,7 @@ describe('analyzeSourceFile', () => {
       src,
       'pkg',
       summary,
-      { ...testOpts, minFunctionStatements: 6 },
+      { ...testOpts, thresholds: { ...testOpts.thresholds, minFunctionStatements: 6 } },
       maps,
       [],
       emptyProfile
@@ -1862,3 +1862,283 @@ describe('collectTestProfile (via analyzeSourceFile)', () => {
     );
   });
 });
+
+describe('collectSmartQualityData', () => {
+  it('collects magic strings from === comparisons', () => {
+    const code = `
+function check(status: string) {
+  if (status === 'active') { return 1; }
+  if (status === 'active') { return 2; }
+  if (status === 'inactive') { return 0; }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.magicStrings).toBeDefined();
+    expect(result.magicStrings!.length).toBeGreaterThanOrEqual(2);
+    expect(result.magicStrings!.some(ms => ms.value === 'active')).toBe(true);
+  });
+
+  it('collects magic strings from switch/case clauses', () => {
+    const code = `
+function handle(action: string) {
+  switch (action) {
+    case 'create': return 1;
+    case 'update': return 2;
+    case 'create': return 3;
+  }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.magicStrings).toBeDefined();
+    expect(result.magicStrings!.some(ms => ms.value === 'create')).toBe(true);
+  });
+
+  it('does not collect magic strings from test files', () => {
+    const code = `
+function check(s: string) {
+  if (s === 'test') return 1;
+  if (s === 'test') return 2;
+}`;
+    const src = ts.createSourceFile(
+      '/repo/src/__tests__/check.test.ts',
+      code,
+      ts.ScriptTarget.ESNext,
+      true
+    );
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.magicStrings).toBeUndefined();
+  });
+
+  it('collects catch-rethrow patterns', () => {
+    const code = `
+function risky() {
+  try {
+    doStuff();
+  } catch (e) {
+    throw e;
+  }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.catchRethrows).toBeDefined();
+    expect(result.catchRethrows!.length).toBe(1);
+  });
+
+  it('does not flag catch blocks that transform errors', () => {
+    const code = `
+function safe() {
+  try { doStuff(); } catch (e) { console.error(e); throw new Error('wrapped'); }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.catchRethrows).toBeUndefined();
+  });
+
+  it('does not flag catch blocks with multiple statements', () => {
+    const code = `
+function logged() {
+  try { doStuff(); } catch (e) { console.error(e); throw e; }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.catchRethrows).toBeUndefined();
+  });
+
+  it('collects boolean parameter clusters', () => {
+    const code = `
+function configure(verbose: boolean, debug: boolean, strict: boolean) {
+  return { verbose, debug, strict };
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.booleanParamClusters).toBeDefined();
+    expect(result.booleanParamClusters!.length).toBe(1);
+    expect(result.booleanParamClusters![0].booleanCount).toBe(3);
+    expect(result.booleanParamClusters![0].totalParams).toBe(3);
+  });
+
+  it('does not flag functions with fewer than 3 boolean params', () => {
+    const code = `function toggle(a: boolean, b: boolean) { return a && b; }`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.booleanParamClusters).toBeUndefined();
+  });
+
+  it('collects unhandled Promise.all calls', () => {
+    const code = `
+async function loadAll() {
+  const results = await Promise.all([fetch('/a'), fetch('/b')]);
+  return results;
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.promiseAllUnhandled).toBeDefined();
+    expect(result.promiseAllUnhandled!.length).toBe(1);
+    expect(result.promiseAllUnhandled![0].kind).toBe('Promise.all');
+  });
+
+  it('does not flag Promise.all inside try-catch', () => {
+    const code = `
+async function safeFetch() {
+  try {
+    const results = await Promise.all([fetch('/a')]);
+    return results;
+  } catch (e) {
+    return [];
+  }
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.promiseAllUnhandled).toBeUndefined();
+  });
+
+  it('does not flag Promise.all with .catch() chain', () => {
+    const code = `
+async function safeFetch() {
+  const results = await Promise.all([fetch('/a')]).catch(() => []);
+  return results;
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.promiseAllUnhandled).toBeUndefined();
+  });
+
+  it('detects Promise.race and Promise.any', () => {
+    const code = `
+async function raceAndAny() {
+  const first = await Promise.race([fetch('/a'), fetch('/b')]);
+  const any = await Promise.any([fetch('/c'), fetch('/d')]);
+}`;
+    const src = parse(code);
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.promiseAllUnhandled).toBeDefined();
+    expect(result.promiseAllUnhandled!.length).toBe(2);
+    const kinds = result.promiseAllUnhandled!.map(p => p.kind);
+    expect(kinds).toContain('Promise.race');
+    expect(kinds).toContain('Promise.any');
+  });
+
+  it('does not collect smart quality data from test files', () => {
+    const code = `
+function check(s: string) {
+  if (s === 'test') return 1;
+  if (s === 'test') return 2;
+  try { x(); } catch (e) { throw e; }
+}`;
+    const src = ts.createSourceFile(
+      '/repo/src/__tests__/check.test.ts',
+      code,
+      ts.ScriptTarget.ESNext,
+      true
+    );
+    const result = analyzeSourceFile(
+      src,
+      'pkg',
+      emptyPackageSummary(),
+      testOpts,
+      emptyMaps(),
+      [],
+      emptyProfile
+    );
+    expect(result.magicStrings).toBeUndefined();
+    expect(result.catchRethrows).toBeUndefined();
+    expect(result.booleanParamClusters).toBeUndefined();
+    expect(result.promiseAllUnhandled).toBeUndefined();
+  });
+});