octocode-cli 1.2.5 → 1.2.7

package/skills/octocode-code-engineer/src/ast/helpers.test.ts

@@ -0,0 +1,185 @@
+import * as ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+import { getFunctionName, isFunctionLike } from './helpers.js';
+
+function parse(code: string): ts.SourceFile {
+  return ts.createSourceFile('test.ts', code, ts.ScriptTarget.ESNext, true);
+}
+
+function findFirst(
+  node: ts.Node,
+  predicate: (n: ts.Node) => boolean
+): ts.Node | undefined {
+  if (predicate(node)) return node;
+  let found: ts.Node | undefined;
+  ts.forEachChild(node, child => {
+    if (!found) found = findFirst(child, predicate);
+  });
+  return found;
+}
+
+describe('isFunctionLike', () => {
+  it('returns true for FunctionDeclaration', () => {
+    const sf = parse('function foo() {}');
+    const node = findFirst(sf, ts.isFunctionDeclaration)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for FunctionExpression', () => {
+    const sf = parse('const fn = function() {};');
+    const node = findFirst(sf, ts.isFunctionExpression)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for ArrowFunction', () => {
+    const sf = parse('const fn = () => {};');
+    const node = findFirst(sf, ts.isArrowFunction)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for MethodDeclaration', () => {
+    const sf = parse('class C { doStuff() {} }');
+    const node = findFirst(sf, ts.isMethodDeclaration)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for ConstructorDeclaration', () => {
+    const sf = parse('class C { constructor() {} }');
+    const node = findFirst(sf, ts.isConstructorDeclaration)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for GetAccessor', () => {
+    const sf = parse('class C { get val() { return 1; } }');
+    const node = findFirst(sf, ts.isGetAccessor)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns true for SetAccessor', () => {
+    const sf = parse('class C { set val(v: number) {} }');
+    const node = findFirst(sf, ts.isSetAccessor)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(true);
+  });
+
+  it('returns false for VariableStatement', () => {
+    const sf = parse('const x = 1;');
+    const node = findFirst(sf, ts.isVariableStatement)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(false);
+  });
+
+  it('returns false for ClassDeclaration', () => {
+    const sf = parse('class C {}');
+    const node = findFirst(sf, ts.isClassDeclaration)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(false);
+  });
+
+  it('returns false for PropertyAssignment', () => {
+    const sf = parse('const o = { a: 1 };');
+    const node = findFirst(sf, ts.isPropertyAssignment)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(false);
+  });
+
+  it('returns false for Identifier', () => {
+    const sf = parse('const x = 1;');
+    const node = findFirst(sf, ts.isIdentifier)!;
+    expect(node).toBeDefined();
+    expect(isFunctionLike(node)).toBe(false);
+  });
+});
+
+describe('getFunctionName', () => {
+  it('resolves named function declaration', () => {
+    const sf = parse('function foo() {}');
+    const node = findFirst(sf, ts.isFunctionDeclaration)!;
+    expect(getFunctionName(node, sf)).toBe('foo');
+  });
+
+  it('resolves arrow function in variable', () => {
+    const sf = parse('const bar = () => {};');
+    const node = findFirst(sf, ts.isArrowFunction)!;
+    expect(getFunctionName(node, sf)).toBe('bar');
+  });
+
+  it('resolves function expression in variable', () => {
+    const sf = parse('const baz = function() {};');
+    const node = findFirst(sf, ts.isFunctionExpression)!;
+    expect(getFunctionName(node, sf)).toBe('baz');
+  });
+
+  it('resolves method declaration', () => {
+    const sf = parse('class C { doStuff() {} }');
+    const node = findFirst(sf, ts.isMethodDeclaration)!;
+    expect(getFunctionName(node, sf)).toBe('doStuff');
+  });
+
+  it('resolves property assignment', () => {
+    const sf = parse('const obj = { handler: function() {} };');
+    const node = findFirst(sf, ts.isFunctionExpression)!;
+    expect(getFunctionName(node, sf)).toBe('handler');
+  });
+
+  it('resolves property declaration in class', () => {
+    const sf = parse('class C { prop = () => {} }');
+    const node = findFirst(sf, ts.isArrowFunction)!;
+    expect(getFunctionName(node, sf)).toBe('prop');
+  });
+
+  it('resolves get accessor', () => {
+    const sf = parse('class C { get val() { return 1; } }');
+    const node = findFirst(sf, ts.isGetAccessor)!;
+    expect(getFunctionName(node, sf)).toBe('val');
+  });
+
+  it('resolves set accessor', () => {
+    const sf = parse('class C { set val(v: number) {} }');
+    const node = findFirst(sf, ts.isSetAccessor)!;
+    expect(getFunctionName(node, sf)).toBe('val');
+  });
+
+  it('returns <anonymous> for anonymous arrow not in variable', () => {
+    const sf = parse('[1, 2].map(() => {});');
+    const node = findFirst(sf, ts.isArrowFunction)!;
+    expect(getFunctionName(node, sf)).toBe('<anonymous>');
+  });
+
+  it('returns <anonymous> for constructor', () => {
+    const sf = parse('class C { constructor() {} }');
+    const node = findFirst(sf, ts.isConstructorDeclaration)!;
+    expect(getFunctionName(node, sf)).toBe('<anonymous>');
+  });
+
+  it('resolves named function expression', () => {
+    const sf = parse('const fn = function namedFn() {};');
+    const node = findFirst(sf, ts.isFunctionExpression)!;
+    expect(getFunctionName(node, sf)).toBe('namedFn');
+  });
+
+  it('returns <anonymous> for IIFE', () => {
+    const sf = parse('(function() {})();');
+    const node = findFirst(sf, ts.isFunctionExpression)!;
+    expect(getFunctionName(node, sf)).toBe('<anonymous>');
+  });
+
+  it('resolves arrow in destructured assignment', () => {
+    const sf = parse('const { onLoad } = { onLoad: () => {} };');
+    const node = findFirst(sf, ts.isArrowFunction)!;
+    expect(getFunctionName(node, sf)).toBe('onLoad');
+  });
+
+  it('returns <anonymous> for method with computed property name', () => {
+    const sf = parse('class C { ["method"]() {} }');
+    const node = findFirst(sf, ts.isMethodDeclaration)!;
+    expect(getFunctionName(node, sf)).toBe('<anonymous>');
+  });
+});

package/skills/octocode-code-engineer/src/ast/helpers.ts

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+
+export function isFunctionLike(node: ts.Node): boolean {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isArrowFunction(node) ||
+    ts.isMethodDeclaration(node) ||
+    ts.isConstructorDeclaration(node) ||
+    ts.isGetAccessor(node) ||
+    ts.isSetAccessor(node)
+  );
+}
+
+export function getFunctionName(
+  node: ts.Node,
+  sourceFile: ts.SourceFile
+): string {
+  if ('name' in node && node.name && ts.isIdentifier(node.name as ts.Node))
+    return (node.name as ts.Identifier).getText(sourceFile);
+
+  const parent = node.parent;
+  if (
+    parent &&
+    ts.isVariableDeclaration(parent) &&
+    parent.name &&
+    ts.isIdentifier(parent.name)
+  ) {
+    return parent.name.getText(sourceFile);
+  }
+
+  if (
+    parent &&
+    ts.isPropertyAssignment(parent) &&
+    ts.isIdentifier(parent.name)
+  ) {
+    return parent.name.getText(sourceFile);
+  }
+
+  if (
+    parent &&
+    ts.isPropertyDeclaration(parent) &&
+    parent.name &&
+    ts.isIdentifier(parent.name)
+  ) {
+    return parent.name.getText(sourceFile);
+  }
+
+  if (parent && ts.isMethodDeclaration(parent) && parent.name) {
+    return parent.name.getText(sourceFile);
+  }
+
+  if (parent && ts.isGetAccessor(parent) && parent.name) {
+    return parent.name.getText(sourceFile);
+  }
+
+  if (parent && ts.isSetAccessor(parent) && parent.name) {
+    return parent.name.getText(sourceFile);
+  }
+
+  return '<anonymous>';
+}

package/skills/octocode-code-engineer/src/ast/metrics.test.ts

@@ -0,0 +1,304 @@
+import * as ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+import {
+  collectMetrics,
+  computeHalstead,
+  computeMaintainabilityIndex,
+  countLinesInNode,
+} from './metrics.js';
+
+function parse(code: string): ts.SourceFile {
+  return ts.createSourceFile('test.ts', code, ts.ScriptTarget.ESNext, true);
+}
+
+function firstFn(sf: ts.SourceFile): ts.Node {
+  let fn: ts.Node | undefined;
+  ts.forEachChild(sf, n => {
+    if (!fn && ts.isFunctionDeclaration(n)) fn = n;
+  });
+  return fn!;
+}
+
+function findNode(
+  sf: ts.SourceFile,
+  predicate: (n: ts.Node) => boolean
+): ts.Node | undefined {
+  let found: ts.Node | undefined;
+  const visit = (n: ts.Node): void => {
+    if (found) return;
+    if (predicate(n)) {
+      found = n;
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(sf);
+  return found;
+}
+
+describe('collectMetrics', () => {
+  it('empty function → complexity 1, all zeros except', () => {
+    const sf = parse('function foo() {}');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(1);
+    expect(m.maxBranchDepth).toBe(0);
+    expect(m.maxLoopDepth).toBe(0);
+    expect(m.returns).toBe(0);
+    expect(m.awaits).toBe(0);
+    expect(m.calls).toBe(0);
+    expect(m.loops).toBe(0);
+  });
+
+  it('single if → complexity 2', () => {
+    const sf = parse('function foo() { if (x) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('nested if → depth 2', () => {
+    const sf = parse('function foo() { if (a) { if (b) {} } }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.maxBranchDepth).toBe(2);
+  });
+
+  it('for loop → loops 1, maxLoopDepth 1', () => {
+    const sf = parse('function foo() { for (let i = 0; i < 10; i++) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.loops).toBe(1);
+    expect(m.maxLoopDepth).toBe(1);
+  });
+
+  it('nested for loops → maxLoopDepth 2', () => {
+    const sf = parse(
+      'function foo() { for (let i = 0; i < 5; i++) { for (let j = 0; j < 5; j++) {} } }'
+    );
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.loops).toBe(2);
+    expect(m.maxLoopDepth).toBe(2);
+  });
+
+  it('while loop → complexity+1', () => {
+    const sf = parse('function foo() { while (x) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('do-while loop → complexity+1', () => {
+    const sf = parse('function foo() { do {} while (x); }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('switch statement → complexity+1', () => {
+    const sf = parse('function foo() { switch (x) { case 1: break; } }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('catch clause → complexity+1', () => {
+    const sf = parse('function foo() { try {} catch (e) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('ternary (ConditionalExpression) → complexity+1', () => {
+    const sf = parse('function foo() { return x ? 1 : 2; }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(2);
+  });
+
+  it('return/throw → returns', () => {
+    const sf = parse('function foo() { return 1; }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.returns).toBe(1);
+  });
+
+  it('throw → returns', () => {
+    const sf = parse('function foo() { throw new Error(); }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.returns).toBe(1);
+  });
+
+  it('await expression → awaits', () => {
+    const sf = parse('async function foo() { await bar(); }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.awaits).toBe(1);
+  });
+
+  it('call expression → calls', () => {
+    const sf = parse('function foo() { bar(); }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.calls).toBe(1);
+  });
+
+  it('logical && → complexity+1', () => {
+    const sf = parse('function foo() { if (a && b) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(3); // 1 base + 1 if + 1 &&
+  });
+
+  it('logical || → complexity+1', () => {
+    const sf = parse('function foo() { if (a || b) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.complexity).toBe(3); // 1 base + 1 if + 1 ||
+  });
+
+  it('for-in loop → loops 1', () => {
+    const sf = parse('function foo() { for (const k in obj) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.loops).toBe(1);
+    expect(m.maxLoopDepth).toBe(1);
+  });
+
+  it('for-of loop → loops 1', () => {
+    const sf = parse('function foo() { for (const x of arr) {} }');
+    const fn = firstFn(sf);
+    const m = collectMetrics(fn);
+    expect(m.loops).toBe(1);
+    expect(m.maxLoopDepth).toBe(1);
+  });
+});
+
+describe('computeHalstead', () => {
+  it('empty function → all zeros or near-zero', () => {
+    const sf = parse('function foo() {}');
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.operators).toBe(0);
+    expect(h.distinctOperators).toBe(0);
+    expect(h.vocabulary).toBeLessThanOrEqual(1);
+    expect(h.length).toBeLessThanOrEqual(1);
+    expect(h.volume).toBe(0);
+    expect(h.difficulty).toBe(0);
+    expect(h.effort).toBe(0);
+    expect(h.time).toBe(0);
+    expect(h.estimatedBugs).toBe(0);
+  });
+
+  it('simple expression a + b → distinct operators/operands', () => {
+    const sf = parse('function foo() { const x = a + b; }');
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.distinctOperators).toBeGreaterThan(0);
+    expect(h.distinctOperands).toBeGreaterThan(0);
+    expect(h.operators).toBeGreaterThan(0);
+    expect(h.operands).toBeGreaterThan(0);
+  });
+
+  it('repeated identifiers → distinct vs total count', () => {
+    const sf = parse('function foo() { const x = a + a + a; }');
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.operands).toBeGreaterThan(h.distinctOperands);
+  });
+
+  it('string and numeric literals counted as operands', () => {
+    const sf = parse('function foo() { const x = "hello" + 42; }');
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.operands).toBeGreaterThan(0);
+    expect(h.distinctOperands).toBeGreaterThan(0);
+  });
+
+  it('volume, difficulty, effort are > 0 for non-trivial code', () => {
+    const sf = parse('function foo() { const x = a + b * c; return x; }');
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.volume).toBeGreaterThan(0);
+    expect(h.difficulty).toBeGreaterThan(0);
+    expect(h.effort).toBeGreaterThan(0);
+  });
+
+  it('various operator tokens (=, ==, ===, +, -, *, /)', () => {
+    const sf = parse(
+      'function foo() { const x = a == b ? c : d; const y = a + b - c * d / e; }'
+    );
+    const fn = firstFn(sf);
+    const h = computeHalstead(fn);
+    expect(h.distinctOperators).toBeGreaterThan(2);
+    expect(h.operators).toBeGreaterThan(2);
+  });
+});
+
+describe('computeMaintainabilityIndex', () => {
+  it('MI for simple code → high score (near 100)', () => {
+    const mi = computeMaintainabilityIndex(1, 1, 1);
+    expect(mi).toBeGreaterThan(95);
+    expect(mi).toBeLessThanOrEqual(100);
+  });
+
+  it('MI for complex code → lower score', () => {
+    const simple = computeMaintainabilityIndex(100, 5, 50);
+    const complex = computeMaintainabilityIndex(5000, 30, 500);
+    expect(complex).toBeLessThan(simple);
+  });
+
+  it('MI never below 0', () => {
+    const mi = computeMaintainabilityIndex(100000, 100, 10000);
+    expect(mi).toBeGreaterThanOrEqual(0);
+  });
+
+  it('increasing halsteadVolume decreases MI', () => {
+    const low = computeMaintainabilityIndex(100, 5, 50);
+    const high = computeMaintainabilityIndex(5000, 5, 50);
+    expect(high).toBeLessThan(low);
+  });
+
+  it('increasing cyclomaticComplexity decreases MI', () => {
+    const low = computeMaintainabilityIndex(100, 5, 50);
+    const high = computeMaintainabilityIndex(100, 30, 50);
+    expect(high).toBeLessThan(low);
+  });
+
+  it('increasing linesOfCode decreases MI', () => {
+    const low = computeMaintainabilityIndex(100, 5, 50);
+    const high = computeMaintainabilityIndex(100, 5, 500);
+    expect(high).toBeLessThan(low);
+  });
+});
+
+describe('countLinesInNode', () => {
+  it('single line function → 1', () => {
+    const sf = parse('function foo() { return 1; }');
+    const fn = firstFn(sf);
+    const lines = countLinesInNode(sf, fn);
+    expect(lines).toBe(1);
+  });
+
+  it('multi-line function → correct count', () => {
+    const code = `function foo() {
+  const a = 1;
+  const b = 2;
+  return a + b;
+}`;
+    const sf = parse(code);
+    const fn = firstFn(sf);
+    const lines = countLinesInNode(sf, fn);
+    expect(lines).toBe(5);
+  });
+
+  it('inline function → 1', () => {
+    const sf = parse('const fn = () => 1;');
+    const fn = findNode(sf, ts.isArrowFunction)!;
+    const lines = countLinesInNode(sf, fn);
+    expect(lines).toBe(1);
+  });
+});