cli-app-commonjs.js

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const readline = require('readline');
const { Pinecone } = require('@pinecone-database/pinecone');

// Configuration
const PINECONE_API_KEY = 'pcsk_52AbGy_CDjDs6zTiABmKYor3xnxxh6qkYQFQEwsNmg9XCQwprpfv4NCWmk6TDnJ3jTECE4';
const PINECONE_INDEX = 'code-embedddings';
const PINECONE_HOST = 'https://code-embedddings-r7rx8or.svc.aped-4627-b74a.pinecone.io';
const PINECONE_DIMENSION = 768;
const PINECONE_METRIC = 'cosine';
const PINECONE_CLOUD = 'aws';
const PINECONE_REGION = 'us-east-1';
const OLLAMA_URL = 'http://localhost:11434/api/generate';
const OLLAMA_MODEL = 'deepseek-r1:8b';

// Initialize the CLI interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function main() {
  console.log('\n------ Code AI Assistant CLI (Simple Mode) ------');
  console.log('1. Test Pinecone Connection');
  console.log('2. Test Ollama Connection');
  console.log('3. Index a File');
  console.log('4. Query Similar Code');
  console.log('5. Exit');
  console.log('----------------------------------------------\n');
  
  rl.question('Choose an option (1-5): ', async (answer) => {
    switch (answer) {
      case '1':
        try {
          console.log('Testing Pinecone connection...');
          
          // Create Pinecone client
          const pc = new Pinecone({
            apiKey: PINECONE_API_KEY
          });
          
          // List indexes
          console.log('Listing indexes...');
          const indexes = await pc.listIndexes();
          console.log('Available indexes:', JSON.stringify(indexes, null, 2));
          
          // Check if our index exists
          const indexExists = indexes.indexes?.some(idx => idx.name === PINECONE_INDEX);
          if (indexExists) {
            console.log(`Index '${PINECONE_INDEX}' exists!`);
            
            // Get index reference
            const index = pc.index(PINECONE_INDEX);
            
            // Get index stats
            const stats = await index.describeIndexStats();
            console.log('Index statistics:', JSON.stringify(stats, null, 2));
            console.log(`Total vectors in index: ${stats.totalRecordCount}`);
          } else {
            console.log(`Index '${PINECONE_INDEX}' does not exist. Please create it in the Pinecone dashboard.`);
          }
          
          console.log('Pinecone connection successful!');
          await showMenu();
        } catch (error) {
          console.error('Failed to connect to Pinecone:', error);
          await showMenu();
        }
        break;
        
      case '2':
        try {
          console.log('Testing Ollama connection...');
          const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
          
          const response = await fetch(OLLAMA_URL, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
            },
            body: JSON.stringify({
              model: OLLAMA_MODEL,
              prompt: 'Say hello and introduce yourself in one sentence',
              stream: false
            }),
          });
          
          if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
          }
          
          const data = await response.json();
          console.log('Ollama response:', data.response);
          await showMenu();
        } catch (error) {
          console.error('Failed to connect to Ollama:', error);
          console.log('Make sure Ollama is running and the deepseek-r1:8b model is available');
          console.log('Install Ollama from https://ollama.ai/download');
          console.log('Then run: ollama pull deepseek-r1:8b');
          await showMenu();
        }
        break;
        
      case '3':
        // Index a file
        rl.question('Enter path to the file you want to index: ', async (filePath) => {
          try {
            await indexFile(filePath);
            await showMenu();
          } catch (error) {
            console.error('Error indexing file:', error);
            await showMenu();
          }
        });
        break;
        
      case '4':
        // Query similar code
        rl.question('Enter path to the file with code you want to find similar code for: ', async (filePath) => {
          try {
            if (!fs.existsSync(filePath)) {
              throw new Error(`File not found: ${filePath}`);
            }
            
            const code = fs.readFileSync(filePath, 'utf8');
            rl.question('Enter your question about this code: ', async (question) => {
              try {
                await querySimilarCode(code, question);
                await showMenu();
              } catch (error) {
                console.error('Error querying similar code:', error);
                await showMenu();
              }
            });
          } catch (error) {
            console.error('Error reading file:', error);
            await showMenu();
          }
        });
        break;
        
      case '5':
        console.log('Goodbye!');
        rl.close();
        process.exit(0);
        break;
        
      default:
        console.log('Invalid option. Please try again.');
        await showMenu();
        break;
    }
  });
}

async function showMenu() {
  console.log('\n------ Code AI Assistant CLI (Simple Mode) ------');
  console.log('1. Test Pinecone Connection');
  console.log('2. Test Ollama Connection');
  console.log('3. Index a File');
  console.log('4. Query Similar Code');
  console.log('5. Exit');
  console.log('----------------------------------------------\n');
  
  rl.question('Choose an option (1-5): ', async (answer) => {
    switch (answer) {
      case '1':
        try {
          console.log('Testing Pinecone connection...');
          
          // Create Pinecone client
          const pc = new Pinecone({
            apiKey: PINECONE_API_KEY
          });
          
          // List indexes
          console.log('Listing indexes...');
          const indexes = await pc.listIndexes();
          console.log('Available indexes:', JSON.stringify(indexes, null, 2));
          
          // Check if our index exists
          const indexExists = indexes.indexes?.some(idx => idx.name === PINECONE_INDEX);
          if (indexExists) {
            console.log(`Index '${PINECONE_INDEX}' exists!`);
            
            // Get index reference
            const index = pc.index(PINECONE_INDEX);
            
            // Get index stats
            const stats = await index.describeIndexStats();
            console.log('Index statistics:', JSON.stringify(stats, null, 2));
            console.log(`Total vectors in index: ${stats.totalRecordCount}`);
          } else {
            console.log(`Index '${PINECONE_INDEX}' does not exist. Please create it in the Pinecone dashboard.`);
          }
          
          console.log('Pinecone connection successful!');
          await showMenu();
        } catch (error) {
          console.error('Failed to connect to Pinecone:', error);
          await showMenu();
        }
        break;
        
      case '2':
        try {
          console.log('Testing Ollama connection...');
          const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
          
          const response = await fetch(OLLAMA_URL, {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
            },
            body: JSON.stringify({
              model: OLLAMA_MODEL,
              prompt: 'Say hello and introduce yourself in one sentence',
              stream: false
            }),
          });
          
          if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
          }
          
          const data = await response.json();
          console.log('Ollama response:', data.response);
          await showMenu();
        } catch (error) {
          console.error('Failed to connect to Ollama:', error);
          console.log('Make sure Ollama is running and the deepseek-r1:8b model is available');
          console.log('Install Ollama from https://ollama.ai/download');
          console.log('Then run: ollama pull deepseek-r1:8b');
          await showMenu();
        }
        break;
        
      case '3':
        // Index a file
        rl.question('Enter path to the file you want to index: ', async (filePath) => {
          try {
            await indexFile(filePath);
            await showMenu();
          } catch (error) {
            console.error('Error indexing file:', error);
            await showMenu();
          }
        });
        break;
        
      case '4':
        // Query similar code
        rl.question('Enter path to the file with code you want to find similar code for: ', async (filePath) => {
          try {
            if (!fs.existsSync(filePath)) {
              throw new Error(`File not found: ${filePath}`);
            }
            
            const code = fs.readFileSync(filePath, 'utf8');
            rl.question('Enter your question about this code: ', async (question) => {
              try {
                await querySimilarCode(code, question);
                await showMenu();
              } catch (error) {
                console.error('Error querying similar code:', error);
                await showMenu();
              }
            });
          } catch (error) {
            console.error('Error reading file:', error);
            await showMenu();
          }
        });
        break;
        
      case '5':
        console.log('Goodbye!');
        rl.close();
        process.exit(0);
        break;
        
      default:
        console.log('Invalid option. Please try again.');
        await showMenu();
        break;
    }
  });
}

async function loadTransformers() {
  try {
    console.log('Loading transformers...');
    const { pipeline } = await import('@xenova/transformers');
    console.log('Initializing CodeT5-small model...');
    const embeddingModel = await pipeline('feature-extraction', 'Salesforce/codet5-small');
    console.log('Model loaded successfully!');
    return embeddingModel;
  } catch (error) {
    console.error('Error loading transformers:', error);
    throw new Error('Failed to load the embedding model');
  }
}

async function generateEmbedding(text, embeddingModel) {
  try {
    // Generate embeddings using the model
    const output = await embeddingModel(text, { pooling: 'mean', normalize: true });
    
    // Convert to array format
    const embedding = Array.from(output.data);
    return embedding;
  } catch (error) {
    console.error('Error generating embedding:', error);
    throw new Error('Failed to generate embedding');
  }
}

function splitIntoChunks(text, filePath, language) {
  const lines = text.split('\n');
  const chunks = [];
  
  // Simple chunking strategy
  const maxChunkSize = 100; // Maximum lines per chunk
  const minChunkSize = 10;  // Minimum lines per chunk
  
  let currentChunk = [];
  let startLine = 0;
  
  for (let i = 0; i < lines.length; i++) {
    currentChunk.push(lines[i]);
    
    // Check if we need to create a new chunk
    if (currentChunk.length >= maxChunkSize) {
      chunks.push({
        content: currentChunk.join('\n'),
        filePath: filePath,
        startLine: startLine,
        endLine: i,
        language: language
      });
      
      currentChunk = [];
      startLine = i + 1;
    }
  }
  
  // Add the remaining lines as a chunk if not empty
  if (currentChunk.length >= minChunkSize) {
    chunks.push({
      content: currentChunk.join('\n'),
      filePath: filePath,
      startLine: startLine,
      endLine: lines.length - 1,
      language: language
    });
  }
  
  return chunks;
}

async function indexFile(filePath) {
  try {
    if (!fs.existsSync(filePath)) {
      throw new Error(`File not found: ${filePath}`);
    }
    
    // Create Pinecone client
    const pc = new Pinecone({
      apiKey: PINECONE_API_KEY
    });
    
    // Get index reference
    const index = pc.index(PINECONE_INDEX);
    
    // Load the model
    const embeddingModel = await loadTransformers();
    
    // Read the file
    const fileContent = fs.readFileSync(filePath, 'utf8');
    const fileName = path.basename(filePath);
    const language = path.extname(filePath).substring(1); // Remove the dot
    
    console.log(`Indexing file: ${filePath}`);
    console.log(`Language detected: ${language}`);
    
    // Split content into chunks
    const chunks = splitIntoChunks(fileContent, filePath, language);
    console.log(`Split file into ${chunks.length} chunks`);
    
    // Process each chunk
    for (const chunk of chunks) {
      // Generate unique ID for this chunk
      const id = crypto.createHash('md5').update(`${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`).digest('hex');
      
      // Get embedding for the chunk
      console.log(`Generating embedding for lines ${chunk.startLine}-${chunk.endLine}...`);
      const embedding = await generateEmbedding(chunk.content, embeddingModel);
      
      // Store in Pinecone
      console.log('Storing embedding in Pinecone...');
      await index.upsert([{
        id,
        values: embedding,
        metadata: chunk
      }]);
      
      console.log(`Indexed chunk from lines ${chunk.startLine}-${chunk.endLine}`);
    }
    
    console.log(`Successfully indexed file: ${filePath}`);
    
    // Get updated stats
    const stats = await index.describeIndexStats();
    console.log(`Total vectors in index: ${stats.totalRecordCount}`);
    
  } catch (error) {
    console.error(`Error indexing file ${filePath}:`, error);
    throw error;
  }
}

async function querySimilarCode(code, question) {
  try {
    // Create Pinecone client
    const pc = new Pinecone({
      apiKey: PINECONE_API_KEY
    });
    
    // Get index reference
    const index = pc.index(PINECONE_INDEX);
    
    // Load the model
    const embeddingModel = await loadTransformers();
    
    // Generate embedding for the code
    console.log('Generating embedding for the query code...');
    const embedding = await generateEmbedding(code, embeddingModel);
    
    // Query similar code
    console.log('Querying similar code from Pinecone...');
    const queryResult = await index.query({
      vector: embedding,
      topK: 5,
      includeMetadata: true
    });
    
    // Prepare context from matched chunks
    let context = '';
    if (queryResult.matches && queryResult.matches.length > 0) {
      context = queryResult.matches.map(match => {
        const metadata = match.metadata;
        return `From ${metadata.filePath} (lines ${metadata.startLine}-${metadata.endLine}):\n${metadata.content}`;
      }).join('\n\n');
      console.log(`Found ${queryResult.matches.length} similar code segments`);
    } else {
      context = 'No similar code found in the indexed files.';
      console.log('No similar code found');
    }
    
    // Call Ollama with the context and question
    console.log('Asking Ollama for explanation...');
    const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
    
    const response = await fetch(OLLAMA_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: OLLAMA_MODEL,
        prompt: `You are a programming assistant. Based on this context:\n\n${context}\n\nPlease answer: ${question}`,
        stream: false
      }),
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    
    const data = await response.json();
    
    console.log('\n------ AI Response ------');
    console.log(data.response);
    console.log('-------------------------\n');
    
  } catch (error) {
    console.error('Error querying similar code:', error);
    throw error;
  }
}

// Run the application
main();