skannr 0.1.5 → 0.2.0

package/src/languages/lang-config.ts

@@ -0,0 +1,113 @@
+/**
+ * Per-language AST node type mappings for tree-sitter grammars.
+ * Adding a new language = adding one entry to this map.
+ */
+
+export interface LangConfig {
+  /** Language identifier. */
+  id: string;
+  /** File extensions this language handles (lowercase, with dot). */
+  extensions: string[];
+  /** Filename of the .wasm grammar (relative to grammars/ dir). */
+  grammarFile: string;
+  /** AST node types that represent top-level function declarations. */
+  functionTypes: string[];
+  /** AST node types that represent class declarations. */
+  classTypes: string[];
+  /** AST node types that represent methods inside classes. */
+  methodTypes: string[];
+  /** AST node types that represent import statements. */
+  importTypes: string[];
+  /** AST node types that represent interface/protocol declarations. */
+  interfaceTypes: string[];
+  /** AST node types that represent type alias declarations. */
+  typeTypes: string[];
+  /** The field name used to extract the symbol name (usually 'name'). */
+  nameField: string;
+  /** The field name for the function/method body (usually 'body' or 'block'). */
+  bodyField: string;
+  /** The field name for class body. */
+  classBodyField: string;
+  /** The field name for function parameters. */
+  parametersField: string;
+  /** The field name for return type annotation (if the language supports it). */
+  returnTypeField: string;
+}
+
+export const LANG_CONFIGS: Record<string, LangConfig> = {
+  python: {
+    id: 'python',
+    extensions: ['.py', '.pyi'],
+    grammarFile: 'tree-sitter-python.wasm',
+    functionTypes: ['function_definition'],
+    classTypes: ['class_definition'],
+    methodTypes: ['function_definition'],
+    importTypes: ['import_statement', 'import_from_statement'],
+    interfaceTypes: [],
+    typeTypes: [],
+    nameField: 'name',
+    bodyField: 'body',
+    classBodyField: 'body',
+    parametersField: 'parameters',
+    returnTypeField: 'return_type',
+  },
+  go: {
+    id: 'go',
+    extensions: ['.go'],
+    grammarFile: 'tree-sitter-go.wasm',
+    functionTypes: ['function_declaration'],
+    classTypes: ['type_declaration'],
+    methodTypes: ['method_declaration'],
+    importTypes: ['import_declaration'],
+    interfaceTypes: ['type_declaration'],
+    typeTypes: ['type_declaration'],
+    nameField: 'name',
+    bodyField: 'body',
+    classBodyField: 'body',
+    parametersField: 'parameters',
+    returnTypeField: 'result',
+  },
+  rust: {
+    id: 'rust',
+    extensions: ['.rs'],
+    grammarFile: 'tree-sitter-rust.wasm',
+    functionTypes: ['function_item'],
+    classTypes: ['struct_item', 'enum_item'],
+    methodTypes: ['function_item'],
+    importTypes: ['use_declaration'],
+    interfaceTypes: ['trait_item'],
+    typeTypes: ['type_item'],
+    nameField: 'name',
+    bodyField: 'body',
+    classBodyField: 'body',
+    parametersField: 'parameters',
+    returnTypeField: 'return_type',
+  },
+  java: {
+    id: 'java',
+    extensions: ['.java'],
+    grammarFile: 'tree-sitter-java.wasm',
+    functionTypes: ['method_declaration', 'constructor_declaration'],
+    classTypes: ['class_declaration', 'enum_declaration'],
+    methodTypes: ['method_declaration', 'constructor_declaration'],
+    importTypes: ['import_declaration'],
+    interfaceTypes: ['interface_declaration'],
+    typeTypes: [],
+    nameField: 'name',
+    bodyField: 'body',
+    classBodyField: 'body',
+    parametersField: 'parameters',
+    returnTypeField: 'type',
+  },
+};
+
+/** Get the language config for a file extension, or null if unsupported. */
+export function getLangConfigForExt(ext: string): LangConfig | null {
+  const lower = ext.toLowerCase();
+  for (const config of Object.values(LANG_CONFIGS)) {
+    if (config.extensions.includes(lower)) {
+      return config;
+    }
+  }
+  return null;
+}

package/src/languages/registry.ts

@@ -1,49 +1,65 @@
-import { LanguageAdapter } from './LanguageAdapter';
-import { TypeScriptAdapter } from './TypeScriptAdapter';
-import { PythonAdapter } from './PythonAdapter';
-import { GenericAdapter } from './GenericAdapter';
-import * as path from 'path';
-
-const adapters: LanguageAdapter[] = [
-  new TypeScriptAdapter(),
-  new PythonAdapter(),
-];
-
-const generic = new GenericAdapter();
-
-export function getAdapter(filePath: string): LanguageAdapter {
-  const ext = path.extname(filePath).toLowerCase();
-  return adapters.find((a) => a.extensions.includes(ext)) ?? generic;
-}
-
-export function detectRepoLanguages(root: string): string[] {
-  const fs = require('fs');
-  const extCount: Record<string, number> = {};
-  walkAndCount(root, extCount, 0, 3);
-  return Object.entries(extCount)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 3)
-    .map(([ext]) => ext);
-}
-
-function walkAndCount(dir: string, counts: Record<string, number>, depth: number, maxDepth: number): void {
-  if (depth > maxDepth) return;
-  const fs = require('fs');
-  const path = require('path');
-  const ignored = new Set(['node_modules', '.git', 'dist', 'build', 'vendor', '__pycache__']);
-  try {
-    for (const entry of fs.readdirSync(dir)) {
-      if (ignored.has(entry)) continue;
-      const full = path.join(dir, entry);
-      const stat = fs.statSync(full);
-      if (stat.isDirectory()) {
-        walkAndCount(full, counts, depth + 1, maxDepth);
-      } else {
-        const ext = path.extname(entry).toLowerCase();
-        if (ext) counts[ext] = (counts[ext] ?? 0) + 1;
-      }
-    }
-  } catch {
-    // Ignore unreadable directories.
-  }
-}
+/**
+ * Language adapter registry.
+ * Routes files to the appropriate parser based on extension.
+ */
+
+import { LanguageAdapter } from './LanguageAdapter';
+import { TypeScriptAdapter } from './TypeScriptAdapter';
+import { TreeSitterAdapter } from './TreeSitterAdapter';
+import { GenericAdapter } from './GenericAdapter';
+import { LANG_CONFIGS } from './lang-config';
+import * as path from 'path';
+
+const tsAdapter = new TypeScriptAdapter();
+const treeSitterAdapter = new TreeSitterAdapter(Object.values(LANG_CONFIGS));
+const generic = new GenericAdapter();
+
+// Initialize tree-sitter WASM in background (non-blocking).
+treeSitterAdapter.initializeSync();
+
+const adapters: LanguageAdapter[] = [
+  tsAdapter,
+  treeSitterAdapter,
+];
+
+export function getAdapter(filePath: string): LanguageAdapter {
+  const ext = path.extname(filePath).toLowerCase();
+  return adapters.find((a) => a.extensions.includes(ext)) ?? generic;
+}
+
+/** Await full initialization of WASM-based adapters. */
+export async function initializeAdapters(): Promise<void> {
+  await treeSitterAdapter.initialize();
+}
+
+export function detectRepoLanguages(root: string): string[] {
+  const fs = require('fs');
+  const extCount: Record<string, number> = {};
+  walkAndCount(root, extCount, 0, 3);
+  return Object.entries(extCount)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3)
+    .map(([ext]) => ext);
+}
+
+function walkAndCount(dir: string, counts: Record<string, number>, depth: number, maxDepth: number): void {
+  if (depth > maxDepth) return;
+  const fs = require('fs');
+  const path = require('path');
+  const ignored = new Set(['node_modules', '.git', 'dist', 'build', 'vendor', '__pycache__']);
+  try {
+    for (const entry of fs.readdirSync(dir)) {
+      if (ignored.has(entry)) continue;
+      const full = path.join(dir, entry);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        walkAndCount(full, counts, depth + 1, maxDepth);
+      } else {
+        const ext = path.extname(entry).toLowerCase();
+        if (ext) counts[ext] = (counts[ext] ?? 0) + 1;
+      }
+    }
+  } catch {
+    // Ignore unreadable directories.
+  }
+}

package/src/languages/PythonAdapter.ts

@@ -1,285 +0,0 @@
-import * as path from 'path';
-import Parser = require('tree-sitter');
-import { LanguageAdapter, SkeletonResult, Symbol } from './LanguageAdapter';
-
-type SyntaxNode = Parser.SyntaxNode;
-
-let pythonLanguage: Parser.Language | undefined;
-
-function ensureParserLoaded(): void {
-  if (!pythonLanguage) {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    pythonLanguage = require('tree-sitter-python') as Parser.Language;
-  }
-}
-
-function getParser(): Parser {
-  ensureParserLoaded();
-  const parser = new Parser();
-  parser.setLanguage(pythonLanguage!);
-  return parser;
-}
-
-function collapseOneLineBody(line: string): string {
-  const idx = line.indexOf(':');
-  if (idx === -1) {
-    return line;
-  }
-  return `${line.slice(0, idx + 1)} ...`;
-}
-
-function baseIndent(line: string | undefined): string {
-  if (!line) {
-    return '';
-  }
-  return line.match(/^(\s*)/)?.[1] ?? '';
-}
-
-interface SkeletonState {
-  lines: string[];
-  keep: Set<number>;
-  replace: Map<number, string>;
-  ellipsisAfter: Set<number>;
-}
-
-function addRange(state: SkeletonState, start: number, end: number): void {
-  const max = state.lines.length - 1;
-  const lo = Math.max(0, start);
-  const hi = Math.min(max, end);
-  for (let i = lo; i <= hi; i++) {
-    state.keep.add(i);
-  }
-}
-
-function emitFunctionHeader(state: SkeletonState, node: SyntaxNode): void {
-  const body = node.childForFieldName('body');
-  const start = node.startPosition.row;
-  if (!body) {
-    addRange(state, start, node.endPosition.row);
-    return;
-  }
-  if (body.startPosition.row > start) {
-    addRange(state, start, body.startPosition.row - 1);
-    state.ellipsisAfter.add(body.startPosition.row - 1);
-    return;
-  }
-  state.replace.set(start, collapseOneLineBody(state.lines[start]));
-}
-
-function emitClassHeaderLines(state: SkeletonState, node: SyntaxNode): void {
-  const body = node.childForFieldName('body');
-  const start = node.startPosition.row;
-  if (!body) {
-    addRange(state, start, node.endPosition.row);
-    return;
-  }
-  if (body.startPosition.row > start) {
-    addRange(state, start, body.startPosition.row - 1);
-    return;
-  }
-  state.replace.set(start, collapseOneLineBody(state.lines[start]));
-}
-
-function processDecoratedDefinition(state: SkeletonState, node: SyntaxNode): void {
-  for (const child of node.namedChildren) {
-    if (child.type === 'decorator') {
-      addRange(state, child.startPosition.row, child.endPosition.row);
-    } else {
-      processStatement(state, child);
-    }
-  }
-}
-
-function processStatement(state: SkeletonState, node: SyntaxNode): void {
-  switch (node.type) {
-    case 'import_statement':
-    case 'import_from_statement':
-      addRange(state, node.startPosition.row, node.endPosition.row);
-      return;
-    case 'type_alias_statement':
-      addRange(state, node.startPosition.row, node.endPosition.row);
-      return;
-    case 'decorated_definition':
-      processDecoratedDefinition(state, node);
-      return;
-    case 'function_definition':
-      emitFunctionHeader(state, node);
-      return;
-    case 'class_definition': {
-      emitClassHeaderLines(state, node);
-      const body = node.childForFieldName('body');
-      if (body?.type !== 'block') {
-        return;
-      }
-      const start = node.startPosition.row;
-      const meaningful = body.namedChildren.filter(
-        (c: SyntaxNode) => c.type !== 'pass_statement',
-      );
-      if (meaningful.length === 0) {
-        if (body.startPosition.row > start) {
-          state.ellipsisAfter.add(body.startPosition.row - 1);
-        } else if (!state.replace.has(start)) {
-          state.replace.set(start, collapseOneLineBody(state.lines[start]));
-        }
-        return;
-      }
-      for (const st of body.namedChildren) {
-        processStatement(state, st);
-      }
-      return;
-    }
-    case 'expression_statement': {
-      const hasAssign = node.namedChildren.some(
-        (c: SyntaxNode) => c.type === 'assignment',
-      );
-      if (hasAssign) {
-        addRange(state, node.startPosition.row, node.endPosition.row);
-      }
-      return;
-    }
-    default:
-      return;
-  }
-}
-
-function buildSkeletonAst(content: string): string {
-  const parser = getParser();
-  const tree = parser.parse(content);
-  const lines = content.split(/\r?\n/);
-  const state: SkeletonState = {
-    lines,
-    keep: new Set<number>(),
-    replace: new Map<number, string>(),
-    ellipsisAfter: new Set<number>(),
-  };
-
-  if (tree.rootNode.type === 'module') {
-    for (const child of tree.rootNode.namedChildren) {
-      processStatement(state, child);
-    }
-  }
-
-  const out: string[] = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (state.replace.has(i)) {
-      out.push(state.replace.get(i)!);
-      continue;
-    }
-    if (state.keep.has(i)) {
-      out.push(lines[i]);
-      if (state.ellipsisAfter.has(i)) {
-        const ind = baseIndent(lines[i]);
-        out.push(`${ind}    ...`);
-      }
-    }
-  }
-
-  return out.join('\n').trim();
-}
-
-function walkImports(node: SyntaxNode, acc: Set<string>): void {
-  if (node.type === 'import_from_statement') {
-    const mod = node.childForFieldName('module_name');
-    if (mod) {
-      acc.add(mod.text);
-    }
-  } else if (node.type === 'import_statement') {
-    for (const child of node.namedChildren) {
-      if (child.type === 'dotted_name') {
-        acc.add(child.text);
-      } else if (child.type === 'aliased_import') {
-        const n = child.childForFieldName('name');
-        if (n?.type === 'dotted_name') {
-          acc.add(n.text);
-        }
-      }
-    }
-  }
-  for (const child of node.namedChildren) {
-    walkImports(child, acc);
-  }
-}
-
-function walkSymbols(node: SyntaxNode, symbols: Symbol[]): void {
-  if (node.type === 'function_definition') {
-    const nameNode = node.childForFieldName('name');
-    if (nameNode) {
-      symbols.push({
-        name: nameNode.text,
-        kind: 'function',
-        line: node.startPosition.row + 1,
-      });
-    }
-  } else if (node.type === 'class_definition') {
-    const nameNode = node.childForFieldName('name');
-    if (nameNode) {
-      symbols.push({
-        name: nameNode.text,
-        kind: 'class',
-        line: node.startPosition.row + 1,
-      });
-    }
-  } else if (node.type === 'type_alias_statement') {
-    const left = node.childForFieldName('left');
-    if (left) {
-      symbols.push({
-        name: left.text,
-        kind: 'type',
-        line: node.startPosition.row + 1,
-      });
-    }
-  } else if (node.type === 'assignment') {
-    const left = node.childForFieldName('left');
-    if (left?.type === 'identifier') {
-      symbols.push({
-        name: left.text,
-        kind: 'variable',
-        line: node.startPosition.row + 1,
-      });
-    }
-  }
-  for (const child of node.namedChildren) {
-    walkSymbols(child, symbols);
-  }
-}
-
-export class PythonAdapter implements LanguageAdapter {
-  name = 'python';
-  extensions = ['.py', '.pyi'];
-
-  canHandle(filePath: string): boolean {
-    return this.extensions.includes(path.extname(filePath).toLowerCase());
-  }
-
-  generateSkeleton(content: string, _filePath: string, _rootDir?: string): SkeletonResult {
-    try {
-      return { skeleton: buildSkeletonAst(content) };
-    } catch {
-      return { skeleton: content.split('\n').slice(0, 50).join('\n') };
-    }
-  }
-
-  extractSymbols(content: string): Symbol[] {
-    try {
-      const parser = getParser();
-      const tree = parser.parse(content);
-      const symbols: Symbol[] = [];
-      walkSymbols(tree.rootNode, symbols);
-      return symbols;
-    } catch {
-      return [];
-    }
-  }
-
-  extractImports(content: string): string[] {
-    try {
-      const parser = getParser();
-      const tree = parser.parse(content);
-      const mods = new Set<string>();
-      walkImports(tree.rootNode, mods);
-      return [...mods];
-    } catch {
-      return [];
-    }
-  }
-}

package/tests/agent.tools.test.ts

@@ -1,81 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { CodeAnalysisAgent } from '../src/agent';
-import { buildSkeletonWithMapping, saveMappingToFile, type SymbolMapping } from '../src/mapper';
-
-describe('CodeAnalysisAgent local tool wrappers', () => {
-  let tempDir: string;
-  let sampleFile: string;
-  let mappingPath: string;
-  let agent: CodeAnalysisAgent;
-
-  beforeAll(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'uca-agent-test-'));
-    sampleFile = path.join(tempDir, 'sample.ts');
-    mappingPath = path.join(tempDir, 'code-analyzer.mapping.json');
-
-    fs.writeFileSync(
-      sampleFile,
-      [
-        'export class AuthService {',
-        '  login(user: string): boolean {',
-        '    return user.length > 0;',
-        '  }',
-        '}',
-        '',
-        'export function sendMessage(room: string, text: string): string {',
-        '  return `${room}:${text}`;',
-        '}',
-      ].join('\n'),
-      'utf-8'
-    );
-
-    const mappingResult = buildSkeletonWithMapping(sampleFile, tempDir);
-    const mapping: SymbolMapping = {
-      generatedAt: new Date().toISOString(),
-      rootPath: tempDir,
-      files: {
-        'sample.ts': {
-          originalPath: sampleFile,
-          symbols: mappingResult.symbols,
-        },
-      },
-    };
-
-    saveMappingToFile(mapping, mappingPath);
-
-    agent = new CodeAnalysisAgent('test-api-key');
-    agent.loadMapping(mappingPath);
-  });
-
-  afterAll(() => {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it('searchSymbols should find matching symbols', () => {
-    const result = agent.searchSymbols('login');
-    expect(result.error).toBeUndefined();
-    expect(result.count).toBeGreaterThan(0);
-
-    const found = result.results.some((item: any) => item.symbolId === 'AuthService.login');
-    expect(found).toBe(true);
-  });
-
-  it('getSymbolDetails should return implementation with location', () => {
-    const result = agent.getSymbolDetails('sendMessage');
-    expect(result.error).toBeUndefined();
-    expect(result.content).toContain('return `${room}:${text}`;');
-    expect(result.location.file).toBe('sample.ts');
-  });
-
-  it('analyzeFileDependencies should return symbol list for file', () => {
-    const result = agent.analyzeFileDependencies('sample.ts');
-    expect(result.error).toBeUndefined();
-    expect(result.file).toBe('sample.ts');
-    expect(Array.isArray(result.symbols)).toBe(true);
-    expect(result.symbols.length).toBeGreaterThan(0);
-  });
-});

package/tests/benchmark.test.ts

@@ -1,31 +0,0 @@
-import { benchmarkProject } from '../src/benchmark';
-import * as path from 'path';
-
-describe('Benchmark Tests', () => {
-  it('BENCHMARK_SCENARIOS module keys are strings', () => {
-    const { BENCHMARK_SCENARIOS } = require('../src/benchmark');
-    BENCHMARK_SCENARIOS.forEach((scenario: { moduleKey: string }) => {
-      expect(typeof scenario.moduleKey).toBe('string');
-      expect(scenario.moduleKey.length).toBeGreaterThan(0);
-    });
-  });
-
-  it('Scenario path resolution is deterministic and scoped', async () => {
-    const fixtureRoot = path.join(__dirname, 'fixtures');
-    const moduleKey = 'src';
-
-    const benchmarkResult = await benchmarkProject(fixtureRoot, moduleKey, 'Test Project', 'authentication flow');
-
-    const expectedPath = path.join(fixtureRoot, 'src');
-    expect(benchmarkResult.projectRoot).toBe(expectedPath);
-
-    expect(benchmarkResult.top1KeywordCoverage).toBeGreaterThanOrEqual(0);
-    expect(benchmarkResult.top1KeywordCoverage).toBeLessThanOrEqual(1);
-    expect(benchmarkResult.avgTopKKeywordCoverage).toBeGreaterThanOrEqual(0);
-    expect(benchmarkResult.avgTopKKeywordCoverage).toBeLessThanOrEqual(1);
-    expect(benchmarkResult.pathIntentMatchRate).toBeGreaterThanOrEqual(0);
-    expect(benchmarkResult.pathIntentMatchRate).toBeLessThanOrEqual(1);
-    expect(benchmarkResult.directoryDiversity).toBeGreaterThanOrEqual(0);
-    expect(benchmarkResult.directoryDiversity).toBeLessThanOrEqual(1);
-  });
-});