octocode-cli 1.2.5 → 1.2.7

package/skills/octocode-code-engineer/src/index.ts

@@ -0,0 +1,403 @@
+import { isDirectRun } from './common/is-direct-run.js';
+import {
+  buildConsumedFromModule,
+  computeHotFiles,
+  detectAwaitInLoop,
+  detectBarrelExplosion,
+  detectBoundaryViolations,
+  detectCognitiveComplexity,
+  detectCommonJsInEsm,
+  detectCriticalPaths,
+  detectDeadExports,
+  detectDeadFiles,
+  detectDeadReExports,
+  detectDependencyCycles,
+  detectDistanceFromMainSequence,
+  detectDuplicateFlowStructures,
+  detectDuplicateFunctionBodies,
+  detectEmptyCatchBlocks,
+  detectExcessiveParameters,
+  detectExportStarLeak,
+  detectFeatureEnvy,
+  detectFunctionOptimization,
+  detectGodFunctions,
+  detectGodModuleCoupling,
+  detectGodModules,
+  detectHighCoupling,
+  detectHighHalsteadEffort,
+  detectImportSideEffectRisk,
+  detectLayerViolations,
+  detectListenerLeakRisk,
+  detectLowCohesion,
+  detectLowMaintainability,
+  detectMegaFolders,
+  detectMessageChains,
+  detectMissingErrorBoundary,
+  detectNamespaceImport,
+  detectOrphanModules,
+  detectPromiseMisuse,
+  detectSdpViolations,
+  detectSimilarFunctionBodies,
+  detectSwitchNoDefault,
+  detectSyncIo,
+  detectTestOnlyModules,
+  detectTypeAssertionEscape,
+  detectUnboundedCollection,
+  detectUnclearedTimers,
+  detectUnreachableModules,
+  detectUnsafeAny,
+  detectUntestedCriticalCode,
+  detectUnusedNpmDeps,
+} from './detectors/index.js';
+import {
+  detectCommandInjectionRisk,
+  detectDebugLogLeakage,
+  detectEvalUsage,
+  detectHardcodedSecrets,
+  detectInputPassthroughRisk,
+  detectPathTraversalRisk,
+  detectPrototypePollutionRisk,
+  detectSensitiveDataLogging,
+  detectSqlInjectionRisk,
+  detectUnsafeHtml,
+  detectUnsafeRegex,
+  detectUnvalidatedInputSink,
+} from './detectors/security.js';
+import {
+  detectExcessiveMocking,
+  detectFakeTimersWithoutRestore,
+  detectFocusedTests,
+  detectLowAssertionDensity,
+  detectMissingMockRestoration,
+  detectMissingTestCleanup,
+  detectSharedMutableState,
+  detectTestNoAssertion,
+} from './detectors/test-quality.js';
+import { diversifyFindings } from './reporting/summary-md.js';
+import { SEVERITY_ORDER } from './types/index.js';
+
+import type {
+  AnalysisOptions,
+  DependencyState,
+  DependencySummary,
+  DuplicateGroup,
+  FileCriticality,
+  FileEntry,
+  Finding,
+  FlowMapEntry,
+  RedundantFlowGroup,
+} from './types/index.js';
+
+export {
+  buildDependencySummary,
+  computeDependencyCycles,
+  computeDependencyCriticalPaths,
+} from './analysis/dependency-summary.js';
+export {
+  REPORT_SCHEMA_VERSION,
+  ARCHITECTURE_CATEGORIES,
+  CODE_QUALITY_CATEGORIES,
+  DEAD_CODE_CATEGORIES,
+  SECURITY_CATEGORIES,
+  TEST_QUALITY_CATEGORIES,
+  writeMultiFileReport,
+  generateMermaidGraph,
+} from './reporting/writer.js';
+export type { FullReport } from './reporting/writer.js';
+export {
+  severityBreakdown,
+  categoryBreakdown,
+  computeHealthScore,
+  collectTagCloud,
+  formatFileSize,
+  diversifyFindings,
+  diverseTopRecommendations,
+  generateSummaryMd,
+} from './reporting/summary-md.js';
+export type { SummaryMdOptions } from './reporting/summary-md.js';
+
+export function buildIssueCatalog(
+  duplicates: DuplicateGroup[],
+  controlDuplicates: RedundantFlowGroup[],
+  fileSummaries: FileEntry[],
+  dependencySummary: DependencySummary,
+  dependencyState: DependencyState,
+  options: AnalysisOptions,
+  pkgJsonDeps: Record<string, string> = {},
+  pkgJsonDevDeps: Record<string, string> = {},
+  fileCriticalityByPath: Map<string, FileCriticality> = new Map(),
+  semanticFindings: Array<Omit<Finding, 'id'>> = [],
+  flowMap: Map<string, FlowMapEntry[]> = new Map(),
+  additionalFindings: Array<Omit<Finding, 'id'>> = []
+): {
+  allFindings: Array<Omit<Finding, 'id'>>;
+  findings: Finding[];
+  byFile: Map<string, string[]>;
+  totalBeforeTruncation: number;
+  droppedCategories: string[];
+} {
+  const rawFindings: Array<Omit<Finding, 'id'>> = [];
+
+  const addFinding = (finding: Omit<Finding, 'id'>): void => {
+    if (options.features && !options.features.has(finding.category)) return;
+    rawFindings.push(finding);
+  };
+
+  const { production: consumedFromModule, test: testConsumedFromModule } =
+    buildConsumedFromModule(dependencyState);
+
+  for (const f of detectDuplicateFunctionBodies(duplicates)) addFinding(f);
+  for (const f of detectDuplicateFlowStructures(
+    controlDuplicates,
+    options.flowDupThreshold
+  ))
+    addFinding(f);
+  for (const f of detectFunctionOptimization(
+    fileSummaries,
+    options.criticalComplexityThreshold
+  ))
+    addFinding(f);
+  for (const f of detectTestOnlyModules(dependencySummary)) addFinding(f);
+  for (const f of detectDependencyCycles(dependencySummary, dependencyState))
+    addFinding(f);
+  for (const f of detectCriticalPaths(
+    dependencySummary,
+    dependencyState,
+    options.criticalComplexityThreshold
+  ))
+    addFinding(f);
+  for (const f of detectDeadFiles(dependencySummary, dependencyState))
+    addFinding(f);
+  for (const f of detectDeadExports(
+    dependencyState,
+    consumedFromModule,
+    testConsumedFromModule
+  ))
+    addFinding(f);
+  for (const f of detectDeadReExports(dependencyState, consumedFromModule))
+    addFinding(f);
+  for (const f of detectSdpViolations(
+    dependencyState,
+    options.sdpMinDelta,
+    options.sdpMaxSourceInstability
+  ))
+    addFinding(f);
+  for (const f of detectHighCoupling(
+    dependencyState,
+    options.couplingThreshold
+  ))
+    addFinding(f);
+  for (const f of detectGodModuleCoupling(
+    dependencyState,
+    options.fanInThreshold,
+    options.fanOutThreshold
+  ))
+    addFinding(f);
+  for (const f of detectOrphanModules(dependencyState)) addFinding(f);
+  for (const f of detectUnreachableModules(dependencyState)) addFinding(f);
+
+  for (const f of detectUnusedNpmDeps(
+    dependencyState.externalCounts,
+    pkgJsonDeps,
+    pkgJsonDevDeps
+  ))
+    addFinding(f);
+  for (const f of detectBoundaryViolations(dependencyState)) addFinding(f);
+  for (const f of detectBarrelExplosion(
+    dependencyState,
+    options.barrelSymbolThreshold
+  ))
+    addFinding(f);
+  for (const f of detectGodModules(
+    fileSummaries,
+    dependencyState,
+    options.godModuleStatements,
+    options.godModuleExports
+  ))
+    addFinding(f);
+  for (const f of detectMegaFolders(fileSummaries)) addFinding(f);
+  for (const f of detectGodFunctions(
+    fileSummaries,
+    options.godFunctionStatements,
+    options.godFunctionMiThreshold
+  ))
+    addFinding(f);
+  for (const f of detectCognitiveComplexity(
+    fileSummaries,
+    options.cognitiveComplexityThreshold
+  ))
+    addFinding(f);
+  if (options.layerOrder.length >= 2) {
+    for (const f of detectLayerViolations(dependencyState, options.layerOrder))
+      addFinding(f);
+  }
+  for (const f of detectLowCohesion(dependencyState)) addFinding(f);
+  for (const f of detectDistanceFromMainSequence(dependencyState))
+    addFinding(f);
+  for (const f of detectFeatureEnvy(dependencyState)) addFinding(f);
+
+  const hotFilesForDetector = computeHotFiles(
+    dependencyState,
+    dependencySummary,
+    fileCriticalityByPath
+  );
+  for (const f of detectUntestedCriticalCode(
+    dependencyState,
+    hotFilesForDetector,
+    fileCriticalityByPath
+  ))
+    addFinding(f);
+
+  for (const f of detectImportSideEffectRisk(
+    fileSummaries,
+    dependencyState,
+    dependencySummary,
+    hotFilesForDetector
+  ))
+    addFinding(f);
+
+  for (const f of detectNamespaceImport(dependencyState)) addFinding(f);
+  for (const f of detectCommonJsInEsm(dependencyState)) addFinding(f);
+  for (const f of detectExportStarLeak(dependencyState)) addFinding(f);
+
+  for (const f of detectExcessiveParameters(
+    fileSummaries,
+    options.parameterThreshold
+  ))
+    addFinding(f);
+  for (const f of detectEmptyCatchBlocks(fileSummaries)) addFinding(f);
+  for (const f of detectSwitchNoDefault(fileSummaries)) addFinding(f);
+  for (const f of detectUnsafeAny(fileSummaries, options.anyThreshold))
+    addFinding(f);
+  for (const f of detectHighHalsteadEffort(
+    fileSummaries,
+    options.halsteadEffortThreshold
+  ))
+    addFinding(f);
+  for (const f of detectLowMaintainability(
+    fileSummaries,
+    options.maintainabilityIndexThreshold
+  ))
+    addFinding(f);
+  for (const f of detectTypeAssertionEscape(fileSummaries)) addFinding(f);
+  for (const f of detectMissingErrorBoundary(fileSummaries)) addFinding(f);
+  for (const f of detectPromiseMisuse(fileSummaries)) addFinding(f);
+
+  for (const f of detectAwaitInLoop(fileSummaries)) addFinding(f);
+  for (const f of detectSyncIo(fileSummaries)) addFinding(f);
+  for (const f of detectUnclearedTimers(fileSummaries)) addFinding(f);
+  for (const f of detectListenerLeakRisk(fileSummaries)) addFinding(f);
+  for (const f of detectUnboundedCollection(fileSummaries)) addFinding(f);
+  for (const f of detectMessageChains(fileSummaries)) addFinding(f);
+  for (const f of detectSimilarFunctionBodies(
+    flowMap,
+    options.similarityThreshold
+  ))
+    addFinding(f);
+
+  for (const f of detectHardcodedSecrets(fileSummaries)) addFinding(f);
+  for (const f of detectEvalUsage(fileSummaries)) addFinding(f);
+  for (const f of detectUnsafeHtml(fileSummaries)) addFinding(f);
+  for (const f of detectSqlInjectionRisk(fileSummaries)) addFinding(f);
+  for (const f of detectUnsafeRegex(fileSummaries)) addFinding(f);
+  for (const f of detectUnvalidatedInputSink(fileSummaries)) addFinding(f);
+  for (const f of detectInputPassthroughRisk(fileSummaries)) addFinding(f);
+  for (const f of detectPrototypePollutionRisk(fileSummaries)) addFinding(f);
+  for (const f of detectPathTraversalRisk(fileSummaries)) addFinding(f);
+  for (const f of detectCommandInjectionRisk(fileSummaries)) addFinding(f);
+  for (const f of detectDebugLogLeakage(fileSummaries)) addFinding(f);
+  for (const f of detectSensitiveDataLogging(fileSummaries)) addFinding(f);
+
+  for (const f of detectLowAssertionDensity(fileSummaries)) addFinding(f);
+  for (const f of detectTestNoAssertion(fileSummaries)) addFinding(f);
+  for (const f of detectExcessiveMocking(fileSummaries, options.mockThreshold))
+    addFinding(f);
+  for (const f of detectSharedMutableState(fileSummaries)) addFinding(f);
+  for (const f of detectMissingTestCleanup(fileSummaries)) addFinding(f);
+  for (const f of detectFocusedTests(fileSummaries)) addFinding(f);
+  for (const f of detectFakeTimersWithoutRestore(fileSummaries)) addFinding(f);
+  for (const f of detectMissingMockRestoration(fileSummaries)) addFinding(f);
+
+  for (const f of semanticFindings) addFinding(f);
+  for (const f of additionalFindings) addFinding(f);
+
+  const sorted = rawFindings.sort((a, b) => {
+    const bySeverity = SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity];
+    if (bySeverity !== 0) return bySeverity;
+    if (a.category < b.category) return -1;
+    if (a.category > b.category) return 1;
+    return 0;
+  });
+
+  const { findings: truncated, totalBeforeTruncation, droppedCategories } =
+    applyFindingsLimit(sorted, options);
+  const { findings, byFile } = assignFindingIds(truncated);
+
+  return {
+    allFindings: sorted,
+    findings,
+    byFile,
+    totalBeforeTruncation,
+    droppedCategories,
+  };
+}
+
+export function applyFindingsLimit<T extends Omit<Finding, 'id'>>(
+  sorted: T[],
+  options: Pick<AnalysisOptions, 'findingsLimit' | 'noDiversify'>
+): {
+  findings: T[];
+  totalBeforeTruncation: number;
+  droppedCategories: string[];
+} {
+  const totalBeforeTruncation = sorted.length;
+  const allCategoriesBefore = new Set(sorted.map(f => f.category));
+  const limit = options.findingsLimit;
+  const truncated =
+    !Number.isFinite(limit) || limit == null
+      ? sorted
+      : options.noDiversify
+        ? sorted.slice(0, limit)
+        : diversifyFindings(sorted, limit);
+  const categoriesAfter = new Set(truncated.map(f => f.category));
+  const droppedCategories = [...allCategoriesBefore].filter(
+    c => !categoriesAfter.has(c)
+  );
+
+  return {
+    findings: truncated,
+    totalBeforeTruncation,
+    droppedCategories,
+  };
+}
+
+export function assignFindingIds(
+  rawFindings: Array<Omit<Finding, 'id'>>
+): {
+  findings: Finding[];
+  byFile: Map<string, string[]>;
+} {
+  const findings: Finding[] = [];
+  const byFile = new Map<string, string[]>();
+
+  for (const [i, raw] of rawFindings.entries()) {
+    const id = `AST-ISSUE-${String(i + 1).padStart(4, '0')}`;
+    const full: Finding = { id, ...raw };
+    findings.push(full);
+    if (full.file) {
+      if (!byFile.has(full.file)) byFile.set(full.file, []);
+      byFile.get(full.file)!.push(id);
+    }
+  }
+
+  return { findings, byFile };
+}
+
+if (isDirectRun(import.meta.url)) {
+  import('./pipeline/main.js')
+    .then(m => m.main())
+    .catch((error: unknown) => {
+      console.error(error);
+      process.exit(1);
+    });
+}

package/skills/octocode-code-engineer/src/pipeline/cache.test.ts

@@ -0,0 +1,199 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  ANALYSIS_SCHEMA_VERSION,
+  clearCache,
+  createEmptyCache,
+  garbageCollect,
+  getCachedResult,
+  isCacheHit,
+  loadCache,
+  saveCache,
+  setCacheEntry,
+} from './cache.js';
+
+describe('cache', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cache-test-'));
+  });
+
+  describe('createEmptyCache', () => {
+    it('includes schemaVersion', () => {
+      const cache = createEmptyCache('/test');
+      expect(cache.schemaVersion).toBe(ANALYSIS_SCHEMA_VERSION);
+      expect(cache.version).toBe(1);
+      expect(cache.root).toBe('/test');
+      expect(cache.entries).toEqual({});
+    });
+  });
+
+  describe('loadCache', () => {
+    it('returns null for schema version mismatch', () => {
+      const cache = createEmptyCache(tmpDir);
+      saveCache(tmpDir, cache);
+
+      const cachePath = path.join(
+        tmpDir,
+        '.octocode',
+        'scan',
+        '.cache',
+        'analysis-cache.json'
+      );
+      const data = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      data.schemaVersion = '0.0.0';
+      fs.writeFileSync(cachePath, JSON.stringify(data), 'utf8');
+
+      expect(loadCache(tmpDir)).toBeNull();
+    });
+
+    it('returns null for version mismatch', () => {
+      const cache = createEmptyCache(tmpDir);
+      saveCache(tmpDir, cache);
+
+      const cachePath = path.join(
+        tmpDir,
+        '.octocode',
+        'scan',
+        '.cache',
+        'analysis-cache.json'
+      );
+      const data = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      data.version = 999;
+      fs.writeFileSync(cachePath, JSON.stringify(data), 'utf8');
+
+      expect(loadCache(tmpDir)).toBeNull();
+    });
+
+    it('returns null for root mismatch', () => {
+      const cache = createEmptyCache('/a');
+      saveCache(tmpDir, cache);
+
+      expect(loadCache('/b')).toBeNull();
+    });
+
+    it('returns valid cache', () => {
+      const cache = createEmptyCache(tmpDir);
+      setCacheEntry(
+        cache,
+        'file.ts',
+        { mtimeMs: 100, size: 50 },
+        { issues: [] }
+      );
+      saveCache(tmpDir, cache);
+
+      const loaded = loadCache(tmpDir);
+      expect(loaded).not.toBeNull();
+      expect(loaded!.root).toBe(tmpDir);
+      expect(loaded!.schemaVersion).toBe(ANALYSIS_SCHEMA_VERSION);
+      expect(loaded!.entries['file.ts'].result).toEqual({ issues: [] });
+    });
+  });
+
+  describe('setCacheEntry', () => {
+    it('sets lastAccessMs', () => {
+      const cache = createEmptyCache('/test');
+      const before = Date.now();
+      setCacheEntry(cache, 'a.ts', { mtimeMs: 1, size: 100 }, {});
+      const after = Date.now();
+
+      const entry = cache.entries['a.ts'];
+      expect(entry.lastAccessMs).toBeGreaterThanOrEqual(before);
+      expect(entry.lastAccessMs).toBeLessThanOrEqual(after);
+    });
+  });
+
+  describe('getCachedResult', () => {
+    it('refreshes lastAccessMs on read', () => {
+      const cache = createEmptyCache('/test');
+      setCacheEntry(cache, 'b.ts', { mtimeMs: 2, size: 200 }, { data: 1 });
+
+      cache.entries['b.ts'].lastAccessMs = 1000;
+
+      const before = Date.now();
+      const result = getCachedResult(cache, 'b.ts');
+      const after = Date.now();
+
+      expect(result).toEqual({ data: 1 });
+      expect(cache.entries['b.ts'].lastAccessMs).toBeGreaterThanOrEqual(before);
+      expect(cache.entries['b.ts'].lastAccessMs).toBeLessThanOrEqual(after);
+    });
+
+    it('returns undefined for missing entry', () => {
+      const cache = createEmptyCache('/test');
+      expect(getCachedResult(cache, 'missing.ts')).toBeUndefined();
+    });
+  });
+
+  describe('garbageCollect', () => {
+    it('removes old entries and keeps recent ones', () => {
+      const cache = createEmptyCache('/test');
+      setCacheEntry(cache, 'old.ts', { mtimeMs: 1, size: 100 }, {});
+      cache.entries['old.ts'].lastAccessMs =
+        Date.now() - 8 * 24 * 60 * 60 * 1000;
+
+      setCacheEntry(cache, 'recent.ts', { mtimeMs: 2, size: 200 }, {});
+
+      const removed = garbageCollect(cache);
+      expect(removed).toBe(1);
+      expect(cache.entries['old.ts']).toBeUndefined();
+      expect(cache.entries['recent.ts']).toBeDefined();
+    });
+
+    it('returns 0 when no entries are expired', () => {
+      const cache = createEmptyCache('/test');
+      setCacheEntry(cache, 'a.ts', { mtimeMs: 1, size: 100 }, {});
+      setCacheEntry(cache, 'b.ts', { mtimeMs: 2, size: 200 }, {});
+
+      const removed = garbageCollect(cache);
+      expect(removed).toBe(0);
+      expect(Object.keys(cache.entries)).toHaveLength(2);
+    });
+  });
+
+  describe('isCacheHit', () => {
+    it('returns true when mtime and size match', () => {
+      const cache = createEmptyCache('/test');
+      setCacheEntry(cache, 'x.ts', { mtimeMs: 10, size: 50 }, {});
+      expect(isCacheHit(cache, 'x.ts', { mtimeMs: 10, size: 50 })).toBe(true);
+    });
+
+    it('returns false when mtime differs', () => {
+      const cache = createEmptyCache('/test');
+      setCacheEntry(cache, 'x.ts', { mtimeMs: 10, size: 50 }, {});
+      expect(isCacheHit(cache, 'x.ts', { mtimeMs: 99, size: 50 })).toBe(false);
+    });
+
+    it('returns false for null cache', () => {
+      expect(isCacheHit(null, 'x.ts', { mtimeMs: 10, size: 50 })).toBe(false);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('removes the cache file', () => {
+      const cache = createEmptyCache(tmpDir);
+      saveCache(tmpDir, cache);
+
+      const cachePath = path.join(
+        tmpDir,
+        '.octocode',
+        'scan',
+        '.cache',
+        'analysis-cache.json'
+      );
+      expect(fs.existsSync(cachePath)).toBe(true);
+
+      clearCache(tmpDir);
+      expect(fs.existsSync(cachePath)).toBe(false);
+    });
+
+    it('does not throw if cache file does not exist', () => {
+      expect(() => clearCache(tmpDir)).not.toThrow();
+    });
+  });
+});