skannr 0.1.6 → 0.2.0

package/tests/blast-radius.test.ts

@@ -1,290 +0,0 @@
-/**
- * Unit tests for blast-radius core logic.
- *
- * Integration tests that exercise the full pipeline (computeBlastRadius) require
- * native tree-sitter bindings; they are marked separately and may be skipped in
- * environments without a C++ build toolchain.
- */
-
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-// Mock tree-sitter to avoid native build dependency in unit tests.
-jest.mock('tree-sitter', () => ({}), { virtual: true });
-jest.mock('tree-sitter-python', () => ({}), { virtual: true });
-jest.mock('../src/languages/PythonAdapter', () => ({
-  PythonAdapter: class {
-    name = 'python';
-    extensions = ['.py', '.pyi'];
-    canHandle() { return false; }
-    generateSkeleton() { return { skeleton: '', lineRanges: [] }; }
-    extractSymbols() { return []; }
-    extractImports() { return []; }
-  },
-}));
-
-import {
-  buildReverseGraph,
-  traverseAffected,
-  computeBlastRadius,
-  formatBlastRadiusText,
-  formatBlastRadiusJson,
-} from '../src/blast-radius';
-
-describe('blast-radius', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'blast-radius-'));
-    const { execSync } = require('child_process');
-    execSync('git init', { cwd: tempDir, stdio: 'ignore' });
-    execSync('git config user.email "test@test.com"', { cwd: tempDir, stdio: 'ignore' });
-    execSync('git config user.name "Test"', { cwd: tempDir, stdio: 'ignore' });
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  // -------------------------------------------------------------------------
-  // buildReverseGraph
-  // -------------------------------------------------------------------------
-  describe('buildReverseGraph', () => {
-    it('inverts a forward dependency map', () => {
-      const forward = new Map<string, string[]>([
-        ['A.ts', ['B.ts', 'C.ts']],
-        ['D.ts', ['C.ts']],
-      ]);
-
-      const reverse = buildReverseGraph(forward);
-
-      expect(reverse.get('B.ts')).toEqual(['A.ts']);
-      expect(reverse.get('C.ts')!.sort()).toEqual(['A.ts', 'D.ts']);
-    });
-
-    it('returns empty map for empty input', () => {
-      const reverse = buildReverseGraph(new Map());
-      expect(reverse.size).toBe(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // traverseAffected — N-hop BFS on reverse graph
-  // -------------------------------------------------------------------------
-  describe('traverseAffected', () => {
-    it('returns correct files at each hop distance', () => {
-      // Graph: A imports B, B imports C, D imports C
-      // Reverse: C ← [B, D], B ← [A]
-      const reverseGraph = new Map<string, string[]>([
-        ['C.ts', ['B.ts', 'D.ts']],
-        ['B.ts', ['A.ts']],
-      ]);
-
-      // Changed: C.ts. With 2 hops:
-      //   Hop 1: B.ts, D.ts (they import C)
-      //   Hop 2: A.ts (imports B)
-      const affected = traverseAffected(['C.ts'], reverseGraph, 2);
-
-      expect(affected.get('B.ts')).toBe(1);
-      expect(affected.get('D.ts')).toBe(1);
-      expect(affected.get('A.ts')).toBe(2);
-      expect(affected.has('C.ts')).toBe(false); // seed excluded
-      expect(affected.size).toBe(3);
-    });
-
-    it('respects max hops limit', () => {
-      const reverseGraph = new Map<string, string[]>([
-        ['C.ts', ['B.ts']],
-        ['B.ts', ['A.ts']],
-      ]);
-
-      const affected = traverseAffected(['C.ts'], reverseGraph, 1);
-
-      expect(affected.get('B.ts')).toBe(1);
-      expect(affected.has('A.ts')).toBe(false); // beyond 1 hop
-      expect(affected.size).toBe(1);
-    });
-
-    it('does not revisit already-visited nodes (handles cycles)', () => {
-      // Cycle: A → B → C → A (in reverse: A ← C, C ← B, B ← A)
-      const reverseGraph = new Map<string, string[]>([
-        ['A.ts', ['C.ts']],
-        ['C.ts', ['B.ts']],
-        ['B.ts', ['A.ts']],
-      ]);
-
-      const affected = traverseAffected(['A.ts'], reverseGraph, 3);
-
-      // C at hop 1, B at hop 2. A is the seed so excluded.
-      expect(affected.get('C.ts')).toBe(1);
-      expect(affected.get('B.ts')).toBe(2);
-      expect(affected.size).toBe(2);
-    });
-
-    it('returns empty map when no reverse edges exist', () => {
-      const reverseGraph = new Map<string, string[]>();
-      const affected = traverseAffected(['isolated.ts'], reverseGraph, 3);
-      expect(affected.size).toBe(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Risk score on known input/output
-  // -------------------------------------------------------------------------
-  describe('risk score computation (integration)', () => {
-    it('computes expected risk for a file with one dependent and no tests', () => {
-      const srcDir = path.join(tempDir, 'src');
-      fs.mkdirSync(srcDir);
-
-      fs.writeFileSync(
-        path.join(srcDir, 'core.ts'),
-        'export function compute(): number { return 42; }\n',
-      );
-      fs.writeFileSync(
-        path.join(srcDir, 'app.ts'),
-        'import { compute } from "./core";\nexport const result = compute();\n',
-      );
-
-      // Commit so HEAD exists.
-      const { execSync } = require('child_process');
-      execSync('git add .', { cwd: tempDir, stdio: 'ignore' });
-      execSync('git commit -m "init"', { cwd: tempDir, stdio: 'ignore' });
-
-      const diff = [
-        'diff --git a/src/core.ts b/src/core.ts',
-        'index 1234567..abcdefg 100644',
-        '--- a/src/core.ts',
-        '+++ b/src/core.ts',
-        '@@ -1 +1 @@',
-        '-export function compute(): number { return 42; }',
-        '+export function compute(): number { return 99; }',
-      ].join('\n');
-
-      const result = computeBlastRadius({
-        root: tempDir,
-        diffContent: diff,
-        hops: 2,
-      });
-
-      expect(result.changedFiles).toContain('src/core.ts');
-      // app.ts imports core.ts → should be affected at hop 1.
-      const appNode = result.affectedNodes.find((n) => n.file.includes('app'));
-      expect(appNode).toBeDefined();
-      expect(appNode!.hopDistance).toBe(1);
-
-      // No test files exist → untestedRatio = 1.
-      expect(result.formulaInputs.untestedRatio).toBe(1);
-
-      // Risk must be > 0 and ≤ 10.
-      expect(result.riskScore).toBeGreaterThan(0);
-      expect(result.riskScore).toBeLessThanOrEqual(10);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Zero affected nodes edge cases
-  // -------------------------------------------------------------------------
-  describe('zero affected nodes', () => {
-    it('returns risk score 0 when diff is empty', () => {
-      const result = computeBlastRadius({
-        root: tempDir,
-        diffContent: '',
-        hops: 2,
-      });
-
-      expect(result.riskScore).toBe(0);
-      expect(result.changedFiles).toEqual([]);
-      expect(result.affectedNodes).toEqual([]);
-      expect(result.summary).toContain('No changed files');
-    });
-
-    it('returns risk score 0 when changed file has no dependents', () => {
-      const srcDir = path.join(tempDir, 'src');
-      fs.mkdirSync(srcDir);
-      fs.writeFileSync(
-        path.join(srcDir, 'isolated.ts'),
-        'export const x = 1;\n',
-      );
-
-      const diff = [
-        'diff --git a/src/isolated.ts b/src/isolated.ts',
-        'index 1234567..abcdefg 100644',
-        '--- a/src/isolated.ts',
-        '+++ b/src/isolated.ts',
-        '@@ -1 +1 @@',
-        '-export const x = 1;',
-        '+export const x = 2;',
-      ].join('\n');
-
-      const result = computeBlastRadius({
-        root: tempDir,
-        diffContent: diff,
-        hops: 2,
-      });
-
-      expect(result.riskScore).toBe(0);
-      expect(result.changedFiles).toContain('src/isolated.ts');
-      expect(result.affectedNodes).toEqual([]);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Output formatting
-  // -------------------------------------------------------------------------
-  describe('formatters', () => {
-    it('formatBlastRadiusText produces readable output', () => {
-      const mockResult = {
-        riskScore: 4.2,
-        summary: 'Risk 4.2/10 (moderate): 1 file(s) changed, 2 downstream affected, 1 untested.',
-        changedFiles: ['src/core.ts'],
-        changedSymbols: [{ name: 'compute', kind: 'function' as const, file: 'src/core.ts' }],
-        affectedNodes: [
-          { file: 'src/app.ts', hopDistance: 1, centrality: 0.8, hasTest: true },
-          { file: 'src/cli.ts', hopDistance: 2, centrality: 0.3, hasTest: false },
-        ],
-        formulaInputs: {
-          normalizedAffectedCount: 0.1,
-          avgCentrality: 0.55,
-          untestedRatio: 0.5,
-          normalizedMaxHopSpread: 1.0,
-        },
-        hops: 2,
-      };
-
-      const text = formatBlastRadiusText(mockResult);
-
-      expect(text).toContain('Risk Score: 4.2/10');
-      expect(text).toContain('src/core.ts');
-      expect(text).toContain('src/app.ts');
-      expect(text).toContain('[NO TEST]');
-      expect(text).toContain('Hop 1');
-      expect(text).toContain('Hop 2');
-    });
-
-    it('formatBlastRadiusJson produces valid JSON', () => {
-      const mockResult = {
-        riskScore: 0,
-        summary: 'No changed files detected in diff.',
-        changedFiles: [],
-        changedSymbols: [],
-        affectedNodes: [],
-        formulaInputs: {
-          normalizedAffectedCount: 0,
-          avgCentrality: 0,
-          untestedRatio: 0,
-          normalizedMaxHopSpread: 0,
-        },
-        hops: 2,
-      };
-
-      const json = formatBlastRadiusJson(mockResult);
-      const parsed = JSON.parse(json);
-
-      expect(parsed.riskScore).toBe(0);
-      expect(parsed.affectedNodes).toEqual([]);
-    });
-  });
-});

package/tests/fixtures/sample.py

@@ -1,17 +0,0 @@
-import os
-
-
-class UserStore:
-    def __init__(self, root: str) -> None:
-        self.root = root
-
-    def path_for(self, user_id: str) -> str:
-        return os.path.join(self.root, user_id)
-
-
-def normalize_username(value: str) -> str:
-    return value.strip().lower()
-
-
-def can_login(enabled: bool, attempts: int) -> bool:
-    return enabled and attempts < 5

package/tests/fixtures/sample.ts

@@ -1,13 +0,0 @@
-import { readFileSync } from 'fs';
-
-export class SampleService {
-  constructor(private readonly source: string) {}
-
-  load(): string {
-    return readFileSync(this.source, 'utf-8');
-  }
-}
-
-export function formatMessage(name: string): string {
-  return `hello ${name}`;
-}

package/tests/fixtures/src/api/routes.ts

@@ -1 +0,0 @@
-export const routes = ['/health', '/users'];

package/tests/fixtures/src/auth/permission.ts

@@ -1,3 +0,0 @@
-export function hasPermission(role: string, action: string): boolean {
-  return role === 'admin' || action === 'read';
-}

package/tests/python-adapter.test.ts

@@ -1,31 +0,0 @@
-import { PythonAdapter } from '../src/languages/PythonAdapter';
-
-describe('PythonAdapter (tree-sitter)', () => {
-  const adapter = new PythonAdapter();
-
-  it('extracts skeleton for class and nested method', () => {
-    const src = [
-      'class Calculator:',
-      '    def add(self, a: int, b: int) -> int:',
-      '        return a + b',
-      '',
-    ].join('\n');
-    const { skeleton } = adapter.generateSkeleton(src, 'calc.py');
-    expect(skeleton).toContain('class Calculator:');
-    expect(skeleton).toContain('def add(self, a: int, b: int) -> int:');
-    expect(skeleton).toContain('...');
-    expect(skeleton).not.toContain('return a + b');
-  });
-
-  it('extracts imports via AST', () => {
-    const src = 'from os.path import join\nimport sys\n';
-    expect(adapter.extractImports(src)).toEqual(expect.arrayContaining(['os.path', 'sys']));
-  });
-
-  it('extracts symbols', () => {
-    const src = 'class A:\n    pass\ndef f():\n    pass\n';
-    const syms = adapter.extractSymbols(src);
-    expect(syms.some((s) => s.name === 'A' && s.kind === 'class')).toBe(true);
-    expect(syms.some((s) => s.name === 'f' && s.kind === 'function')).toBe(true);
-  });
-});

package/tests/ranker-enhanced.test.ts

@@ -1,70 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { rankFilesEnhanced } from '../src/ranker-enhanced';
-
-describe('rankFilesEnhanced hybrid retrieval', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ranker-enhanced-'));
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it('prioritizes files aligned with auth intent', () => {
-    const authFile = path.join(tempDir, 'auth-permissions.ts');
-    const genericFile = path.join(tempDir, 'utility.ts');
-
-    fs.writeFileSync(
-      authFile,
-      [
-        'export class AuthorizationService {',
-        '  checkPermission(user: string, action: string): boolean {',
-        '    return !!user && !!action;',
-        '  }',
-        '}',
-      ].join('\n'),
-      'utf-8'
-    );
-
-    fs.writeFileSync(
-      genericFile,
-      [
-        'export function sum(a: number, b: number): number {',
-        '  return a + b;',
-        '}',
-      ].join('\n'),
-      'utf-8'
-    );
-
-    const ranked = rankFilesEnhanced(
-      [authFile, genericFile],
-      'how are permissions validated for users?',
-      2,
-      tempDir
-    );
-
-    expect(ranked.length).toBe(2);
-    expect(path.basename(ranked[0].path)).toBe('auth-permissions.ts');
-    expect(ranked[0].why.length).toBeGreaterThan(0);
-    expect(ranked[1].why.length).toBeGreaterThan(0);
-  });
-
-  it('returns deterministic ordering for equal scores', () => {
-    const aFile = path.join(tempDir, 'a.ts');
-    const bFile = path.join(tempDir, 'b.ts');
-
-    fs.writeFileSync(aFile, 'export const a = 1;', 'utf-8');
-    fs.writeFileSync(bFile, 'export const b = 2;', 'utf-8');
-
-    const ranked = rankFilesEnhanced([bFile, aFile], 'zzzz-unmatched-term', 2, tempDir);
-
-    expect(ranked.length).toBe(2);
-    expect(ranked[0].path <= ranked[1].path).toBe(true);
-  });
-});

package/tests/ranker.test.ts

@@ -1,79 +0,0 @@
-/**
- * Tests for file ranking functionality
- */
-
-import { calculateRelevanceScore, rankFiles } from '../src/ranker';
-
-describe('calculateRelevanceScore', () => {
-  it('should return 0 for null content', () => {
-    const score = calculateRelevanceScore('/path/to/file.ts', null, 'test question');
-    expect(score).toBe(0);
-  });
-
-  it('should return higher score for filename matches', () => {
-    const filePath = '/src/authentication/auth-service.ts';
-    const content = 'export class Service {}';
-    const score = calculateRelevanceScore(filePath, content, 'authentication');
-    expect(score).toBeGreaterThanOrEqual(0.3);
-  });
-
-  it('should return higher score for content matches', () => {
-    const filePath = '/src/service.ts';
-    const content = `
-      export class AuthService {
-        async login() { }
-        async logout() { }
-        authenticate() { }
-      }
-    `;
-    const score = calculateRelevanceScore(filePath, content, 'authentication login');
-    expect(score).toBeGreaterThan(0);
-  });
-
-  it('should return neutral score for empty question', () => {
-    const score = calculateRelevanceScore('/path/to/file.ts', 'content', '');
-    expect(score).toBe(0.5);
-  });
-
-  it('should handle multiple word questions', () => {
-    const filePath = '/src/user/profile.ts';
-    const content = 'export class UserProfile {}';
-    const score = calculateRelevanceScore(filePath, content, 'user profile settings');
-    expect(score).toBeGreaterThan(0);
-  });
-});
-
-describe('rankFiles', () => {
-  it('should return empty array for no files', () => {
-    const ranked = rankFiles([], 'test question', 10);
-    expect(ranked).toEqual([]);
-  });
-
-  it('should limit results to requested number', () => {
-    // Create mock files - note: rankFiles reads from filesystem
-    // For a real test, we'd need actual files, but this tests the logic
-    const files = [
-      '/test/auth.ts',
-      '/test/user.ts',
-      '/test/service.ts',
-    ];
-
-    // Mock would be needed here for a full test
-    // This is a placeholder to show the structure
-    const ranked = rankFiles(files, 'test', 2);
-    expect(ranked.length).toBeLessThanOrEqual(2);
-    ranked.forEach((r) => {
-      expect(typeof r.why).toBe('string');
-      expect(r.why.length).toBeGreaterThan(0);
-    });
-  });
-
-  it('should sort by score descending', () => {
-    const files = ['/test/file1.ts', '/test/file2.ts'];
-    const ranked = rankFiles(files, 'test', 10);
-
-    for (let i = 1; i < ranked.length; i++) {
-      expect(ranked[i - 1].score).toBeGreaterThanOrEqual(ranked[i].score);
-    }
-  });
-});

package/tests/scanner.scope.test.ts

@@ -1,67 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { discoverModules, scanFiles } from '../src/scanner';
-
-const rootDir = path.join(__dirname, 'fixtures');
-
-describe('generic scanner', () => {
-  it('discovers modules from common source folders', () => {
-    const modules = discoverModules(rootDir);
-    expect(modules).toContain('auth');
-    expect(modules).toContain('api');
-  });
-
-  it('scans only requested module keys', () => {
-    const files = scanFiles(rootDir, {
-      moduleKeys: ['auth'],
-      moduleDefinitions: {
-        auth: ['src/auth'],
-      },
-      extensions: ['.ts'],
-    });
-    expect(files.length).toBeGreaterThan(0);
-    files.forEach((file) => {
-      expect(file.startsWith(path.join(rootDir, 'src/auth'))).toBe(true);
-    });
-  });
-
-  it('returns empty array on invalid root', () => {
-    const invalidRoot = path.join(__dirname, 'missing-fixtures');
-    const files = scanFiles(invalidRoot, { extensions: ['.ts'] });
-    expect(files).toEqual([]);
-  });
-
-  it('excludes common ignored folders', () => {
-    const files = scanFiles(rootDir, { extensions: ['.ts'] });
-    const excludedDir = path.join(rootDir, 'node_modules');
-
-    files.forEach((file) => {
-      expect(file.startsWith(excludedDir)).toBe(false);
-    });
-  });
-
-  it('respects root .gitignore', () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'skannr-gitignore-'));
-    try {
-      fs.writeFileSync(path.join(tmp, 'kept.ts'), 'export const kept = 1;\n');
-      fs.writeFileSync(path.join(tmp, 'dropped.ts'), 'export const dropped = 2;\n');
-      fs.writeFileSync(
-        path.join(tmp, '.gitignore'),
-        ['dropped.ts', 'ignored-dir/', ''].join('\n'),
-        'utf-8',
-      );
-      fs.mkdirSync(path.join(tmp, 'ignored-dir'), { recursive: true });
-      fs.writeFileSync(path.join(tmp, 'ignored-dir', 'nope.ts'), 'export const nope = 3;\n');
-
-      const files = scanFiles(tmp, { extensions: ['.ts'] });
-      const rel = (abs: string) => path.relative(tmp, abs).split(path.sep).join('/');
-
-      expect(files.some((f) => rel(f) === 'kept.ts')).toBe(true);
-      expect(files.some((f) => rel(f) === 'dropped.ts')).toBe(false);
-      expect(files.some((f) => rel(f).startsWith('ignored-dir/'))).toBe(false);
-    } finally {
-      fs.rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-});

package/tests/setup-fixtures.js

@@ -1,29 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-// The fake repo root expected by the tests
-const root = path.join(__dirname, 'fixtures');
-
-const dirs = [
-  'src/auth',
-  'src/api',
-  'node_modules',
-];
-
-const files = [
-  'src/auth/permission.ts',
-  'src/api/routes.ts',
-  'node_modules/ignored.ts',
-];
-
-console.log(`Creating test fixtures in: ${root}`);
-
-dirs.forEach((dir) => {
-  fs.mkdirSync(path.join(root, dir), { recursive: true });
-});
-
-files.forEach((file) => {
-  fs.writeFileSync(path.join(root, file), '// test file content');
-});
-
-console.log('✅ Fixtures created successfully.');