octocode-cli 1.2.6 → 1.2.8

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

@@ -0,0 +1,199 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  formatAstTreeSearchOutput,
+  parseAstTreeSearchArgs,
+  resolveAstTreeInput,
+  searchAstTree,
+  validateAstTreeSearchOptions,
+} from './tree-search.js';
+
+describe('ast-tree-search', () => {
+  let tmpDir: string;
+  let scanRoot: string;
+  let latestScanDir: string;
+  let olderScanDir: string;
+  let astTreePath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ast-tree-search-'));
+    scanRoot = path.join(tmpDir, '.octocode', 'scan');
+    olderScanDir = path.join(scanRoot, '2026-03-18T10-00-00-000Z');
+    latestScanDir = path.join(scanRoot, '2026-03-19T10-00-00-000Z');
+
+    fs.mkdirSync(olderScanDir, { recursive: true });
+    fs.mkdirSync(latestScanDir, { recursive: true });
+
+    fs.writeFileSync(path.join(olderScanDir, 'ast-trees.txt'), '## pkg — src/older.ts\nFunctionDeclaration[1:2]\n', 'utf8');
+
+    astTreePath = path.join(latestScanDir, 'ast-trees.txt');
+    fs.writeFileSync(astTreePath, [
+      '## pkg — src/main.ts',
+      'SourceFile[1:50]',
+      '  FunctionDeclaration[3:12]',
+      '    IfStatement[5:7] ...',
+      '  ClassDeclaration[14:30]',
+      '## pkg — src/utils.ts',
+      'SourceFile[1:40]',
+      '  function_declaration[4:8]',
+      '  ArrowFunction[10:12]',
+      '  WhileStatement[14:18]',
+      '',
+    ].join('\n'), 'utf8');
+
+    const olderTime = new Date('2026-03-18T10:00:00.000Z');
+    const newerTime = new Date('2026-03-19T10:00:00.000Z');
+    fs.utimesSync(path.join(olderScanDir, 'ast-trees.txt'), olderTime, olderTime);
+    fs.utimesSync(path.join(latestScanDir, 'ast-trees.txt'), newerTime, newerTime);
+    fs.utimesSync(olderScanDir, olderTime, olderTime);
+    fs.utimesSync(latestScanDir, newerTime, newerTime);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('parses limit, file, and section flags', () => {
+    const { opts } = parseAstTreeSearchArgs([
+      '--input', scanRoot,
+      '--kind', 'FunctionDeclaration',
+      '--file', 'src/main',
+      '--section', 'pkg',
+      '--limit', '10',
+      '--context', '2',
+      '--json',
+      '--ignore-case',
+    ]);
+
+    expect(opts.input).toBe(scanRoot);
+    expect(opts.kind).toBe('FunctionDeclaration');
+    expect(opts.file).toBe('src/main');
+    expect(opts.section).toBe('pkg');
+    expect(opts.limit).toBe(10);
+    expect(opts.context).toBe(2);
+    expect(opts.json).toBe(true);
+    expect(opts.ignoreCase).toBe(true);
+  });
+
+  it('rejects invalid search options', () => {
+    expect(() => validateAstTreeSearchOptions({
+      input: scanRoot,
+      pattern: null,
+      kind: null,
+      context: 0,
+      json: false,
+      ignoreCase: false,
+      limit: 50,
+      file: null,
+      section: null,
+    })).toThrow('Must provide --pattern or --kind');
+  });
+
+  it('resolves the latest scan from the scan root', () => {
+    const resolved = resolveAstTreeInput(scanRoot);
+    expect(resolved.selectionMode).toBe('latest-scan');
+    expect(resolved.inputFile).toBe(astTreePath);
+  });
+
+  it('resolves a specific scan directory', () => {
+    const resolved = resolveAstTreeInput(latestScanDir);
+    expect(resolved.selectionMode).toBe('scan-dir');
+    expect(resolved.inputFile).toBe(astTreePath);
+  });
+
+  it('resolves a direct ast-trees.txt input path', () => {
+    const resolved = resolveAstTreeInput(astTreePath);
+    expect(resolved.selectionMode).toBe('direct-file');
+    expect(resolved.inputFile).toBe(astTreePath);
+  });
+
+  it('matches kind queries with PascalCase and snake_case node names', () => {
+    const result = searchAstTree(resolveAstTreeInput(scanRoot), {
+      input: scanRoot,
+      pattern: null,
+      kind: 'function_declaration',
+      context: 0,
+      json: false,
+      ignoreCase: false,
+      limit: 0,
+      file: null,
+      section: null,
+    });
+
+    expect(result.totalMatches).toBe(2);
+    expect(result.matches.map((match) => match.file)).toEqual([
+      'src/main.ts',
+      'src/utils.ts',
+    ]);
+  });
+
+  it('filters by file and section regexes', () => {
+    const result = searchAstTree(resolveAstTreeInput(scanRoot), {
+      input: scanRoot,
+      pattern: 'FunctionDeclaration|function_declaration|ArrowFunction',
+      kind: null,
+      context: 0,
+      json: false,
+      ignoreCase: false,
+      limit: 0,
+      file: 'src/utils',
+      section: 'pkg',
+    });
+
+    expect(result.totalMatches).toBe(2);
+    expect(result.matches.every((match) => match.file === 'src/utils.ts')).toBe(true);
+  });
+
+  it('enforces the default limit and reports truncation metadata', () => {
+    const repeatedAst = [
+      '## pkg — src/many.ts',
+      'SourceFile[1:200]',
+      ...Array.from({ length: 60 }, (_, index) => `  FunctionDeclaration[${index + 1}:${index + 2}]`),
+      '',
+    ].join('\n');
+    fs.writeFileSync(astTreePath, repeatedAst, 'utf8');
+
+    const result = searchAstTree(resolveAstTreeInput(astTreePath), {
+      input: astTreePath,
+      pattern: null,
+      kind: 'FunctionDeclaration',
+      context: 0,
+      json: false,
+      ignoreCase: false,
+      limit: 50,
+      file: null,
+      section: null,
+    });
+
+    expect(result.totalMatches).toBe(60);
+    expect(result.returnedMatches).toBe(50);
+    expect(result.truncated).toBe(true);
+  });
+
+  it('formats output with selected file information and compact summary', () => {
+    const opts = {
+      input: scanRoot,
+      pattern: 'IfStatement|WhileStatement',
+      kind: null,
+      context: 1,
+      json: false,
+      ignoreCase: false,
+      limit: 25,
+      file: null,
+      section: null,
+    };
+    const result = searchAstTree(resolveAstTreeInput(scanRoot), opts);
+    const text = formatAstTreeSearchOutput(result, opts);
+
+    expect(text).toContain('Requested input:');
+    expect(text).toContain('Selected AST file:');
+    expect(text).toContain('Matches: 2 total, showing 2');
+    expect(text).toContain('Matched files: 2');
+    expect(text).toContain('src/main.ts');
+    expect(text).toContain('src/utils.ts');
+  });
+});

package/skills/octocode-code-engineer/src/ast/tree-search.ts

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { isDirectRun } from '../common/is-direct-run.js';
+
+export interface AstTreeSearchOptions {
+  input: string;
+  pattern: string | null;
+  kind: string | null;
+  context: number;
+  json: boolean;
+  ignoreCase: boolean;
+  limit: number;
+  file: string | null;
+  section: string | null;
+}
+
+export interface AstTreeContextLine {
+  lineNumber: number;
+  line: string;
+}
+
+export interface AstTreeMatch {
+  section: string;
+  file: string | null;
+  lineNumber: number;
+  line: string;
+  context: AstTreeContextLine[];
+}
+
+export interface ResolvedAstTreeInput {
+  requestedInput: string;
+  inputFile: string;
+  selectionMode: 'direct-file' | 'scan-dir' | 'latest-scan';
+}
+
+export interface AstTreeSearchResult {
+  requestedInput: string;
+  inputFile: string;
+  selectionMode: ResolvedAstTreeInput['selectionMode'];
+  query: string;
+  limit: number;
+  totalMatches: number;
+  returnedMatches: number;
+  truncated: boolean;
+  uniqueFiles: number;
+  matches: AstTreeMatch[];
+}
+
+function printAstTreeSearchHelp(): void {
+  console.log(`
+ast-tree-search — Search generated ast-trees.txt output
+
+Usage:
+  node scripts/ast/tree-search.js [options]
+
+Options:
+  --input, -i <path>       Path to ast-trees.txt, a scan directory, or .octocode/scan (default: .octocode/scan)
+  --pattern, -p <regex>    Regex to match against AST tree lines
+  --kind, -k <kind>        Match a node kind (supports snake_case or PascalCase)
+  --file <regex>           Filter matches to section file paths that match the regex
+  --section <regex>        Filter matches to section headers that match the regex
+  --limit <n>              Max matches to return (default: 50, 0 = all)
+  --context, -C <n>        Context lines around each match (default: 0)
+  --json                   Output matches as JSON
+  --ignore-case            Case-insensitive pattern matching
+  --help, -h               Show this message
+
+Examples:
+  node scripts/ast/tree-search.js -i .octocode/scan -k function_declaration --limit 25
+  node scripts/ast/tree-search.js -i .octocode/scan/2026-03-18T23-43-21-490Z -k ClassDeclaration --file 'src/index'
+  node scripts/ast/tree-search.js -i .octocode/scan -p 'IfStatement|SwitchStatement' --section 'src/'
+`);
+}
+
+function parseArgValue(arg: string, argv: string[], index: number): { value: string; nextIndex: number } {
+  const equalsIndex = arg.indexOf('=');
+  if (equalsIndex !== -1) {
+    return { value: arg.slice(equalsIndex + 1), nextIndex: index };
+  }
+
+  return { value: argv[index + 1] || '', nextIndex: index + 1 };
+}
+
+export function parseAstTreeSearchArgs(argv: string[]): { opts: AstTreeSearchOptions; showHelp: boolean } {
+  const opts: AstTreeSearchOptions = {
+    input: '.octocode/scan',
+    pattern: null,
+    kind: null,
+    context: 0,
+    json: false,
+    ignoreCase: false,
+    limit: 50,
+    file: null,
+    section: null,
+  };
+
+  let showHelp = false;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '--json') {
+      opts.json = true;
+      continue;
+    }
+    if (arg === '--ignore-case') {
+      opts.ignoreCase = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      showHelp = true;
+      continue;
+    }
+
+    if (arg === '--input' || arg === '-i' || arg.startsWith('--input=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      opts.input = parsed.value;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--pattern' || arg === '-p' || arg.startsWith('--pattern=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      opts.pattern = parsed.value;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--kind' || arg === '-k' || arg.startsWith('--kind=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      opts.kind = parsed.value;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--file' || arg.startsWith('--file=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      opts.file = parsed.value;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--section' || arg.startsWith('--section=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      opts.section = parsed.value;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--limit' || arg.startsWith('--limit=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      const parsedLimit = Number.parseInt(parsed.value, 10);
+      opts.limit = Number.isFinite(parsedLimit) ? parsedLimit : 50;
+      i = parsed.nextIndex;
+      continue;
+    }
+    if (arg === '--context' || arg === '-C' || arg.startsWith('--context=')) {
+      const parsed = parseArgValue(arg, argv, i);
+      const parsedContext = Number.parseInt(parsed.value, 10);
+      opts.context = Number.isFinite(parsedContext) ? parsedContext : 0;
+      i = parsed.nextIndex;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return { opts, showHelp };
+}
+
+export function validateAstTreeSearchOptions(opts: AstTreeSearchOptions): void {
+  if (!opts.pattern && !opts.kind) {
+    throw new Error('Must provide --pattern or --kind');
+  }
+  if (!Number.isFinite(opts.context) || opts.context < 0) {
+    throw new Error('--context must be a non-negative integer');
+  }
+  if (!Number.isFinite(opts.limit) || opts.limit < 0) {
+    throw new Error('--limit must be a non-negative integer');
+  }
+}
+
+function toSnakeCase(value: string): string {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[-\s]+/g, '_')
+    .toLowerCase();
+}
+
+function toPascalCase(value: string): string {
+  return value
+    .split('_')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function buildRegex(pattern: string | null, flags: string, label: string): RegExp | null {
+  if (!pattern) return null;
+  try {
+    return new RegExp(pattern, flags);
+  } catch (error) {
+    throw new Error(`Invalid ${label} regex: ${(error as Error).message}`);
+  }
+}
+
+function parseSectionFile(section: string): string | null {
+  const marker = ' — ';
+  const index = section.indexOf(marker);
+  if (index === -1) return null;
+  return section.slice(index + marker.length).trim() || null;
+}
+
+export function resolveAstTreeInput(inputPath: string): ResolvedAstTreeInput {
+  const requestedInput = path.resolve(inputPath);
+  if (!fs.existsSync(requestedInput)) {
+    throw new Error(`Input does not exist: ${requestedInput}`);
+  }
+
+  const stat = fs.statSync(requestedInput);
+  if (stat.isFile()) {
+    return {
+      requestedInput,
+      inputFile: requestedInput,
+      selectionMode: 'direct-file',
+    };
+  }
+
+  const directAstFile = path.join(requestedInput, 'ast-trees.txt');
+  if (fs.existsSync(directAstFile) && fs.statSync(directAstFile).isFile()) {
+    return {
+      requestedInput,
+      inputFile: directAstFile,
+      selectionMode: 'scan-dir',
+    };
+  }
+
+  const candidates = fs.readdirSync(requestedInput, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(requestedInput, entry.name, 'ast-trees.txt'))
+    .filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+    .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+
+  if (candidates.length === 0) {
+    throw new Error(`No ast-trees.txt found under: ${requestedInput}`);
+  }
+
+  return {
+    requestedInput,
+    inputFile: candidates[0],
+    selectionMode: 'latest-scan',
+  };
+}
+
+export function searchAstTree(
+  resolved: ResolvedAstTreeInput,
+  opts: AstTreeSearchOptions,
+): AstTreeSearchResult {
+  const flags = opts.ignoreCase ? 'i' : '';
+  const patternRegex = buildRegex(opts.pattern, flags, 'pattern');
+  const fileRegex = buildRegex(opts.file, flags, 'file');
+  const sectionRegex = buildRegex(opts.section, flags, 'section');
+
+  let kindRegex: RegExp | null = null;
+  if (opts.kind) {
+    const snake = toSnakeCase(opts.kind);
+    const pascal = toPascalCase(snake);
+    kindRegex = new RegExp(`\\b(?:${escapeRegExp(snake)}|${escapeRegExp(pascal)})\\b`, flags);
+  }
+
+  const lines = fs.readFileSync(resolved.inputFile, 'utf8').split(/\r?\n/);
+  const allMatches: AstTreeMatch[] = [];
+  let currentSection = '';
+  let currentFile: string | null = null;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+
+    if (line.startsWith('## ')) {
+      currentSection = line.slice(3).trim();
+      currentFile = parseSectionFile(currentSection);
+    }
+
+    if (patternRegex && !patternRegex.test(line)) continue;
+    if (kindRegex && !kindRegex.test(line)) continue;
+    if (sectionRegex && !sectionRegex.test(currentSection)) continue;
+    if (fileRegex && !fileRegex.test(currentFile ?? '')) continue;
+
+    const start = Math.max(0, index - opts.context);
+    const end = Math.min(lines.length, index + opts.context + 1);
+
+    allMatches.push({
+      section: currentSection,
+      file: currentFile,
+      lineNumber: index + 1,
+      line,
+      context: lines.slice(start, end).map((contextLine, offset) => ({
+        lineNumber: start + offset + 1,
+        line: contextLine,
+      })),
+    });
+  }
+
+  const returnedMatches = opts.limit === 0 ? allMatches : allMatches.slice(0, opts.limit);
+  const uniqueFiles = new Set(allMatches.map((match) => match.file).filter(Boolean)).size;
+  const queryParts = [
+    opts.kind ? `kind=${opts.kind}` : null,
+    opts.pattern ? `pattern=${opts.pattern}` : null,
+    opts.file ? `file=${opts.file}` : null,
+    opts.section ? `section=${opts.section}` : null,
+  ].filter(Boolean);
+
+  return {
+    requestedInput: resolved.requestedInput,
+    inputFile: resolved.inputFile,
+    selectionMode: resolved.selectionMode,
+    query: queryParts.join(', '),
+    limit: opts.limit,
+    totalMatches: allMatches.length,
+    returnedMatches: returnedMatches.length,
+    truncated: returnedMatches.length < allMatches.length,
+    uniqueFiles,
+    matches: returnedMatches,
+  };
+}
+
+export function formatAstTreeSearchOutput(result: AstTreeSearchResult, opts: AstTreeSearchOptions): string {
+  const lines: string[] = [];
+
+  lines.push(`\nAST tree search: ${result.query}`);
+  lines.push(`Requested input: ${result.requestedInput}`);
+  lines.push(`Selected AST file: ${result.inputFile} (${result.selectionMode})`);
+  lines.push(`Matches: ${result.totalMatches} total, showing ${result.returnedMatches}${result.truncated ? ` (limit ${result.limit})` : ''}`);
+  lines.push(`Matched files: ${result.uniqueFiles}\n`);
+
+  let currentSection = '';
+  for (const match of result.matches) {
+    if (match.section !== currentSection) {
+      currentSection = match.section;
+      lines.push(`-- ${currentSection || '(no section)'} --`);
+    }
+
+    if (opts.context > 0) {
+      for (const contextLine of match.context) {
+        const marker = contextLine.lineNumber === match.lineNumber ? '>' : ' ';
+        lines.push(` ${marker} ${String(contextLine.lineNumber).padStart(4)} | ${contextLine.line}`);
+      }
+      lines.push('');
+      continue;
+    }
+
+    const fileLabel = match.file ? ` (${match.file})` : '';
+    lines.push(`  L${match.lineNumber}${fileLabel}  ${match.line}`);
+  }
+
+  if (result.totalMatches === 0) {
+    lines.push('No matches found.');
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+async function main(): Promise<void> {
+  try {
+    const { opts, showHelp } = parseAstTreeSearchArgs(process.argv.slice(2));
+    if (showHelp) {
+      printAstTreeSearchHelp();
+      return;
+    }
+
+    validateAstTreeSearchOptions(opts);
+    const resolved = resolveAstTreeInput(opts.input);
+    const result = searchAstTree(resolved, opts);
+
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    console.log(formatAstTreeSearchOutput(result, opts));
+  } catch (error) {
+    console.error((error as Error).message);
+    process.exit(1);
+  }
+}
+
+if (isDirectRun(import.meta.url)) {
+  void main();
+}