ai-index/bin/ai-index.js

AI-powered local code indexing and search system for any codebase

#!/usr/bin/env node

import path from 'path';
import { fileURLToPath } from 'url';
import { spawn } from 'child_process';
import readline from 'readline';
import fs from 'fs/promises';
import { loadConfig, saveConfig, isConfigured, getConfigPath } from '../lib/config.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

async function getVersion() {
  try {
    const packageJsonPath = path.join(__dirname, '..', 'package.json');
    const content = await fs.readFile(packageJsonPath, 'utf-8');
    const pkg = JSON.parse(content);
    return pkg.version;
  } catch {
    return 'unknown';
  }
}

function question(rl, prompt) {
  return new Promise((resolve) => {
    rl.question(prompt, resolve);
  });
}

// Configuration function removed - now uses defaults

async function runCommand(command, args) {
  // Map command names to script names
  const scriptMap = {
    'index': 'build_index.js',
    'query': 'query.js',
    'smart-index': 'smart-indexer.js',
    'smart-query': 'smart-query.js',
    'call-chain': 'call-chain.js'
  };
  
  const scriptPath = path.join(__dirname, `../lib/${scriptMap[command]}`);
  const child = spawn('node', [scriptPath, ...args], {
    stdio: 'inherit',
    cwd: process.cwd()
  });
  
  child.on('exit', (code) => {
    process.exit(code);
  });
}

async function showHelp() {
  const version = await getVersion();
  console.log(`
🤖 ai-index v${version} - Local AI-powered code indexing and search

Usage:
  ai-index index [folder]         Index with basic chunking (legacy)
  ai-index query [options]        Basic search (legacy)
  
  ai-index smart-index [options]  Smart AST-based indexing (recommended)
  ai-index smart-query [options]  AI-optimized search (recommended)
  ai-index call-chain [options]   Function dependency analysis
  ai-index --help                 Show this help message

Smart Commands (Recommended):
  smart-index [folder]            Index with AST analysis & symbol extraction
    --watch, -w                   Enable continuous file monitoring
    --entry, -e <file>            Specify entry point(s) for targeted indexing
  
  smart-query --q "query"         Semantic search with AI-optimized output
    --k <number>                  Number of results (default: 10)
    --symbol                      Search symbols only
    --exact                       Exact symbol name match
  
  call-chain <function-name>      Show function call chain analysis
    --list                        List all functions in codebase

Examples:
  ai-index smart-index --watch    # Index with file monitoring
  ai-index smart-index -e src/index.js -e src/api.js
  ai-index smart-query --q "authentication middleware"
  ai-index smart-query --q "User" --symbol --exact
  ai-index call-chain calculateProfit  # Show call chain for function
  ai-index call-chain --list      # List all functions

Legacy Commands:
  ai-index index                  # Basic indexing
  ai-index query --q "query"      # Basic search

Indexes are stored locally using folder names as keys.
`);
}

async function main() {
  const args = process.argv.slice(2);
  const command = args[0];
  const commandArgs = args.slice(1);
  
  if (!command || command === '--help' || command === '-h') {
    await showHelp();
    return;
  }
  
  switch (command) {
    case 'index':
      await runCommand('index', commandArgs);
      break;
      
    case 'query':
      await runCommand('query', commandArgs);
      break;
      
    case 'smart-index':
      await runCommand('smart-index', commandArgs);
      break;
      
    case 'smart-query':
      await runCommand('smart-query', commandArgs);
      break;
      
    case 'call-chain':
      await runCommand('call-chain', commandArgs);
      break;
      
    default:
      console.error(`❌ Unknown command: ${command}`);
      console.error('');
      console.error('Run "ai-index --help" to see available commands.');
      process.exit(1);
  }
}

main().catch(err => {
  console.error('❌ Unexpected error:', err.message);
  process.exit(1);
});