2026 AI Coding Assistants Deep Review & Integration Tutorial: Cursor, Copilot, Windsurf, Claude Code Compared

Create a user authentication module:
- JWT token-based auth
- Support email and phone number login
- Include password reset flow
- Follow RESTful conventions
- Use TypeScript + Express

# Install Node.js 20+
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

# Create project
mkdir xidao-coding-assistant && cd xidao-coding-assistant
npm init -y

# Install dependencies
npm install openai dotenv readline-sync chalk ora

# .env
XIDAO_API_KEY=your_api_key_here
XIDAO_BASE_URL=https://api.xidao.online/v1
DEFAULT_MODEL=claude-4.7-sonnet
MAX_CONTEXT_TOKENS=100000

require('dotenv').config();
const OpenAI = require('openai');
const readline = require('readline');
const chalk = require('chalk');
const ora = require('ora');
const fs = require('fs');
const path = require('path');

// Initialize XiDao client (OpenAI SDK compatible)
const client = new OpenAI({
  apiKey: process.env.XIDAO_API_KEY,
  baseURL: process.env.XIDAO_BASE_URL,
});

// Coding assistant system prompt
const SYSTEM_PROMPT = `You are an expert AI coding assistant. Your capabilities include:
1. Writing high-quality, maintainable code
2. Code review and optimization suggestions
3. Bug diagnosis and fixes
4. Architecture design and technical planning
5. Technical documentation

Rules:
- Always format code with Markdown code blocks
- Explain your approach before providing code
- Consider edge cases and error handling
- Follow language best practices and design patterns
- Pay special attention to security for security-related code`;

// Project context collector
class ProjectContext {
  constructor(projectPath) {
    this.projectPath = projectPath;
    this.files = new Map();
    this.structure = '';
  }

  scanProject(extensions = ['.js', '.ts', '.py', '.go', '.rs', '.java']) {
    const scan = (dir, depth = 0) => {
      if (depth > 3) return '';
      let result = '';
      try {
        const items = fs.readdirSync(dir);
        for (const item of items) {
          if (item.startsWith('node_modules') || item.startsWith('.git')) continue;
          const fullPath = path.join(dir, item);
          const stat = fs.statSync(fullPath);
          const indent = '  '.repeat(depth);
          if (stat.isDirectory()) {
            result += `${indent}📁 ${item}/\n`;
            result += scan(fullPath, depth + 1);
          } else if (extensions.some(ext => item.endsWith(ext))) {
            result += `${indent}📄 ${item}\n`;
            this.files.set(fullPath, null);
          }
        }
      } catch (e) {}
      return result;
    };
    this.structure = scan(this.projectPath);
    return this.structure;
  }

  getFileContent(filePath) {
    if (!this.files.has(filePath)) return null;
    if (this.files.get(filePath) === null) {
      const content = fs.readFileSync(filePath, 'utf-8');
      this.files.set(filePath, content.slice(0, 5000));
    }
    return this.files.get(filePath);
  }
}

// Chat manager
class ChatManager {
  constructor() {
    this.messages = [];
    this.maxMessages = 50;
  }

  addMessage(role, content) {
    this.messages.push({ role, content });
    if (this.messages.length > this.maxMessages) {
      this.messages = [this.messages[0], ...this.messages.slice(-this.maxMessages + 2)];
    }
  }

  getMessages() {
    return [{ role: 'system', content: SYSTEM_PROMPT }, ...this.messages];
  }

  clear() { this.messages = []; }
}

// Main interaction loop
async function main() {
  console.log(chalk.cyan.bold('\n🤖 XiDao AI Coding Assistant v2.0\n'));
  console.log(chalk.gray('Powered by Claude 4.7 | Type /help for commands\n'));

  const chatManager = new ChatManager();
  const projectContext = new ProjectContext(process.cwd());

  const shouldScan = readlineSync.keyInYN('Scan current directory as project context?');
  if (shouldScan) {
    const spinner = ora('Scanning project structure...').start();
    const structure = projectContext.scanProject();
    spinner.succeed(`Scan complete: ${projectContext.files.size} code files found`);
    chatManager.addMessage('user', `Current project structure:\n${structure}`);
  }

  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

  const askQuestion = () => {
    rl.question(chalk.green('You > '), async (input) => {
      if (!input.trim()) return askQuestion();

      if (input === '/exit') {
        console.log(chalk.yellow('\n👋 Goodbye!'));
        rl.close();
        return;
      }
      if (input === '/clear') {
        chatManager.clear();
        console.log(chalk.gray('Chat history cleared\n'));
        return askQuestion();
      }
      if (input === '/help') {
        console.log(chalk.cyan(`
Commands:
  /clear  - Clear chat history
  /model  - Switch model
  /file   - Load file into context
  /exit   - Exit
        `));
        return askQuestion();
      }

      if (input.startsWith('/file ')) {
        const filePath = input.slice(6).trim();
        try {
          const content = fs.readFileSync(filePath, 'utf-8');
          chatManager.addMessage('user', `Reference file (${filePath}):\n\`\`\`\n${content}\n\`\`\``);
          console.log(chalk.gray(`Loaded file: ${filePath}\n`));
        } catch (e) {
          console.log(chalk.red(`File read failed: ${e.message}\n`));
        }
        return askQuestion();
      }

      chatManager.addMessage('user', input);
      const spinner = ora(chalk.blue('Thinking...')).start();

      try {
        const response = await client.chat.completions.create({
          model: process.env.DEFAULT_MODEL || 'claude-4.7-sonnet',
          messages: chatManager.getMessages(),
          max_tokens: 4096,
          temperature: 0.3,
        });

        spinner.stop();
        const reply = response.choices[0].message.content;
        chatManager.addMessage('assistant', reply);
        console.log(`\n${chalk.blue('AI >')} ${reply}\n`);
      } catch (error) {
        spinner.fail(chalk.red(`Request failed: ${error.message}`));
      }

      askQuestion();
    });
  };

  askQuestion();
}

main().catch(console.error);

// vscode-extension/src/extension.js
const vscode = require('vscode');
const OpenAI = require('openai');

let client;

function activate(context) {
  const config = vscode.workspace.getConfiguration('xidao');
  client = new OpenAI({
    apiKey: config.get('apiKey'),
    baseURL: config.get('baseUrl') || 'https://api.xidao.online/v1',
  });

  // Register inline completion provider
  const completionProvider = vscode.languages.registerInlineCompletionItemProvider(
    { pattern: '**' },
    {
      async provideInlineCompletionItems(document, position) {
        const prefix = document.getText(
          new vscode.Range(Math.max(0, position.line - 50), 0, position.line, position.character)
        );

        const response = await client.chat.completions.create({
          model: config.get('model') || 'claude-4.7-sonnet',
          messages: [
            { role: 'system', content: 'You are a code completion assistant. Output only the completion code, no explanations.' },
            { role: 'user', content: `Complete the following code:\n${prefix}` },
          ],
          max_tokens: 256,
          temperature: 0.1,
        });

        const text = response.choices[0].message.content;
        return [new vscode.InlineCompletionItem(text, new vscode.Range(position, position))];
      },
    }
  );

  // Register chat command
  const chatCommand = vscode.commands.registerCommand('xidao.chat', async () => {
    const editor = vscode.window.activeTextEditor;
    const selection = editor?.document.getText(editor.selection);
    const question = await vscode.window.showInputBox({
      prompt: 'Ask XiDao AI',
      placeholder: 'e.g., Explain what this code does',
    });

    if (!question) return;

    const panel = vscode.window.createWebviewPanel('xidaoChat', 'XiDao AI Chat', vscode.ViewColumn.Beside, {});

    const prompt = selection
      ? `About this code:\n\`\`\`\n${selection}\n\`\`\`\n\n${question}`
      : question;

    const response = await client.chat.completions.create({
      model: config.get('model') || 'claude-4.7-sonnet',
      messages: [{ role: 'user', content: prompt }],
      max_tokens: 2048,
    });

    panel.webview.html = `<html><body><pre>${response.choices[0].message.content}</pre></body></html>`;
  });

  context.subscriptions.push(completionProvider, chatCommand);
}

module.exports = { activate };

# Run the CLI assistant
node assistant.js

# For VS Code: Ctrl+Shift+P → "XiDao: Chat"

// rag-assistant.js
const { ChromaClient } = require('chromadb');

class RAGCodingAssistant {
  constructor(client, projectPath) {
    this.client = client;
    this.projectPath = projectPath;
    this.chroma = new ChromaClient();
    this.collection = null;
  }

  async init() {
    this.collection = await this.chroma.getOrCreateCollection({
      name: 'codebase',
    });

    // Index project code
    const files = this.scanProject();
    for (const [filePath, content] of files) {
      const chunks = this.chunkCode(content, filePath);
      for (const chunk of chunks) {
        await this.collection.add({
          ids: [`${filePath}-${chunk.startLine}`],
          documents: [chunk.text],
          metadatas: [{ filePath, startLine: chunk.startLine }],
        });
      }
    }
  }

  async query(question) {
    // Retrieve relevant code snippets
    const results = await this.collection.query({
      queryTexts: [question],
      nResults: 5,
    });

    const context = results.documents[0]
      .map((doc, i) => `File: ${results.metadatas[0][i].filePath}\n${doc}`)
      .join('\n---\n');

    // Generate answer
    const response = await this.client.chat.completions.create({
      model: 'claude-4.7-sonnet',
      messages: [
        { role: 'system', content: 'You are a project code assistant. Answer questions based on the provided code context.' },
        { role: 'user', content: `Project code context:\n${context}\n\nQuestion: ${question}` },
      ],
    });

    return response.choices[0].message.content;
  }

  chunkCode(content, filePath, maxLines = 50) {
    const lines = content.split('\n');
    const chunks = [];
    for (let i = 0; i < lines.length; i += maxLines) {
      chunks.push({ text: lines.slice(i, i + maxLines).join('\n'), startLine: i + 1 });
    }
    return chunks;
  }
}