Contributing to XendCode

February 10, 2026 · View on GitHub

Thank you for your interest in contributing to XendCode! This document provides guidelines and instructions for contributing.

🎯 Project Vision

XendCode aims to democratize AI-assisted coding by making it affordable for everyone. Our core principles:

Cost-First: Every feature should consider cost implications
Multi-Model: Support diverse AI providers
Transparency: Users should always know what they're using
Quality: Free doesn't mean low quality

🚀 Getting Started

Development Setup

Fork and Clone

git clone https://github.com/yourusername/xendcode.git
cd xendcode

Install Dependencies

npm install

Build Extension

npm run compile

Run in Development

Open project in VSCode
Press F5 to launch Extension Development Host
Test your changes

Project Structure

xendcode/
├── src/
│   ├── extension.ts          # Entry point
│   ├── core/                 # Core managers
│   │   ├── ModelManager.ts   # Model selection logic
│   │   ├── TokenManager.ts   # Token tracking
│   │   └── ContextManager.ts # Context optimization
│   ├── models/               # AI provider implementations
│   │   ├── OpenAIProvider.ts
│   │   ├── GeminiProvider.ts
│   │   └── ...
│   ├── providers/            # UI providers
│   │   ├── ChatProvider.ts
│   │   └── ...
│   └── types/                # TypeScript types
├── package.json              # Extension manifest
└── README.md

🤝 How to Contribute

1. Adding a New Model Provider

Want to add support for a new AI model? Great! Here's how:

Create Provider File

// src/models/YourModelProvider.ts
import { IModelProvider, ModelConfig, ... } from '../types';

export class YourModelProvider implements IModelProvider {
    // Implement all interface methods
}

Register in ModelManager

// src/core/ModelManager.ts
import { YourModelProvider } from '../models/YourModelProvider';

// In initializeProviders()
providers.push(
    new YourModelProvider(config.get('models.yourmodel.apiKey', ''))
);

Add Configuration

// package.json - in contributes.configuration.properties
"xendcode.models.yourmodel.apiKey": {
    "type": "string",
    "default": "",
    "description": "Your Model API Key"
}

Update Documentation

Add to README.md
Add to SETUP_GUIDE.md
Document free tier details

2. Improving Token Optimization

Token usage is critical for cost. Improvements welcome in:

src/core/ContextManager.ts - Better context selection
src/core/TokenManager.ts - More accurate tracking
Compression techniques
Semantic deduplication

3. Enhancing Model Selection

Better model routing = better cost/quality balance:

src/core/ModelManager.ts - Selection algorithms
Task type detection
Quality scoring
Cost prediction

4. UI Improvements

Chat interface enhancements
Better dashboard visualizations
Usage predictions
Settings UI

📝 Pull Request Process

Create Feature Branch

git checkout -b feature/your-feature-name

Make Changes

Write clean, documented code
Follow existing code style
Add TypeScript types

Test Thoroughly

Test in Extension Development Host
Verify no regressions
Test with multiple models

Commit with Clear Messages

git commit -m "Add: Support for NewModel provider"
git commit -m "Fix: Token counting for streaming responses"
git commit -m "Improve: Context selection algorithm"

Push and Create PR

git push origin feature/your-feature-name

Create PR on GitHub
Fill out PR template
Link related issues

Code Review

Address feedback
Update as needed
Maintain clean commit history

🎨 Code Style

TypeScript

// Use clear, descriptive names
async function selectOptimalModel(task: ModelCapability): Promise<IModelProvider> {
    // Implementation
}

// Add JSDoc comments for public APIs
/**
 * Records token usage for a model
 * @param model - Model name
 * @param tokensInput - Input tokens used
 * @param tokensOutput - Output tokens generated
 * @param cost - Estimated cost in USD
 */
async recordUsage(model: string, tokensInput: number, ...): Promise<void> {
    // Implementation
}

// Use interfaces for contracts
interface IModelProvider {
    getName(): string;
    complete(messages: ChatMessage[]): Promise<CompletionResponse>;
}

// Prefer async/await over promises
async function fetchData() {
    try {
        const result = await api.call();
        return result;
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}

File Organization

One class per file
Group related functionality
Keep files under 500 lines
Use meaningful folder structure

🐛 Reporting Bugs

Before Submitting

Check existing issues
Try latest version
Verify it's not a configuration issue

Bug Report Template

**Description**
Clear description of the bug

**To Reproduce**
1. Step 1
2. Step 2
3. See error

**Expected Behavior**
What should happen

**Actual Behavior**
What actually happens

**Environment**
- VSCode Version:
- XendCode Version:
- OS:
- Models Configured:

**Logs**
Paste relevant logs from VSCode Developer Console

💡 Feature Requests

We love new ideas! When requesting features:

Check Roadmap: Might already be planned
Describe Use Case: Why is this needed?
Cost Implications: How does it affect costs?
Alternative Solutions: What else did you consider?

Feature Request Template

**Feature Description**
What feature do you want?

**Use Case**
Why do you need this?

**Cost Impact**
How does this affect token usage/costs?

**Proposed Implementation**
Any ideas on how to implement?

**Alternatives**
What alternatives did you consider?