Integrations

GitHub Integration

Full GitHub integration with OAuth login, repository analysis, issue creation, and PR automation.

Setup Steps

Install GitHub CLI

# macOS
brew install gh

# Ubuntu/Debian
sudo apt install gh

# Windows
winget install gh

Authenticate with GitHub

# Interactive login
gh auth login

# Choose:
# - GitHub.com
# - HTTPS
# - Authenticate via browser

Configure ChaozCode

# Add your GitHub token
export GITHUB_TOKEN=$(gh auth token)

# Or add to environment file
echo "GITHUB_TOKEN=$(gh auth token)" >> ~/.chaozcode/env

Test Connection

curl -X POST https://api.chaozcode.com/v1/integrations/github/test \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"github_token": "YOUR_GITHUB_TOKEN"}'

Available Features

Feature	Description	API Endpoint
Repository Analysis	Analyze entire codebase structure	`/codebase/analyze`
Issue Creation	Create issues from AI analysis	`/github/issues`
PR Automation	Auto-generate pull requests	`/github/pulls`
Code Review	AI-powered PR reviews	`/github/review`
Commit Analysis	Understand commit history	`/github/commits`

OAuth Setup (For Apps)

If building an app that uses ChaozCode + GitHub:

// OAuth configuration
const oauthConfig = {
  clientId: 'YOUR_GITHUB_CLIENT_ID',
  redirectUri: 'https://yourapp.com/callback',
  scope: 'repo,read:org,gist',
  authUrl: 'https://github.com/login/oauth/authorize'
};

// Generate authorization URL
const authUrl = `${oauthConfig.authUrl}?client_id=${oauthConfig.clientId}&redirect_uri=${oauthConfig.redirectUri}&scope=${oauthConfig.scope}`;

// Exchange code for token (server-side)
const response = await fetch('https://github.com/login/oauth/access_token', {
  method: 'POST',
  headers: { 'Accept': 'application/json' },
  body: JSON.stringify({
    client_id: oauthConfig.clientId,
    client_secret: process.env.GITHUB_CLIENT_SECRET,
    code: authCode
  })
});

VS Code Extension

Native VS Code extension for inline AI assistance, code completion, and Memory Spine integration.

Installation

Install from Marketplace
Search "ChaozCode" in VS Code Extensions or run:
```
code --install-extension chaozcode.chaozcode-vscode
```

Configure API Key

Open VS Code Settings (Cmd/Ctrl + ,) and search for "ChaozCode":

// settings.json
{
  "chaozcode.apiKey": "YOUR_API_KEY",
  "chaozcode.endpoint": "https://api.chaozcode.com",
  "chaozcode.memorySpine.enabled": true,
  "chaozcode.autoComplete.enabled": true
}

Enable Features
- Inline completions: chaozcode.inlineCompletions.enabled
- Code actions: chaozcode.codeActions.enabled
- Memory context: chaozcode.memorySpine.autoContext

Keyboard Shortcuts

Shortcut	Action
`Ctrl+Shift+C`	Open ChaozCode panel
`Ctrl+Shift+G`	Generate code from comment
`Ctrl+Shift+E`	Explain selected code
`Ctrl+Shift+R`	Refactor selection
`Ctrl+Shift+T`	Generate tests
`Ctrl+Shift+M`	Search Memory Spine

Commands

// Available VS Code commands
ChaozCode: Generate Code          // Generate code from natural language
ChaozCode: Explain Code           // Explain selected code
ChaozCode: Refactor               // Suggest refactoring
ChaozCode: Generate Tests         // Create unit tests
ChaozCode: Search Memory          // Search Memory Spine
ChaozCode: Store to Memory        // Save code/context to Memory Spine
ChaozCode: Analyze File           // Full file analysis
ChaozCode: Code Review            // AI code review

CLI Integration

Powerful CLI for terminal-based workflows, scripting, and CI/CD integration.

Installation

# Install via npm
npm install -g @chaozcode/cli

# Or via pip
pip install chaozcode-cli

# Or via Homebrew
brew install chaozcode/tap/chaozcode

Configuration

# Interactive setup
chaozcode config

# Manual configuration
chaozcode config set api_key YOUR_API_KEY
chaozcode config set endpoint https://api.chaozcode.com

# View configuration
chaozcode config list

Available Commands

# Query the AI
chaozcode query "How do I implement authentication?"

# Analyze codebase
chaozcode analyze .

# Search Memory Spine
chaozcode memory search "API implementation"

# Store to Memory
chaozcode memory store "Important context" --tags api,auth

# Generate code
chaozcode generate "REST API for user management" -o src/users/

# Run agent
chaozcode agent run explore "find all TypeScript files"

# Interactive mode
chaozcode chat

Shell Integration

# Bash completion
source <(chaozcode completion bash)
echo 'source <(chaozcode completion bash)' >> ~/.bashrc

# Zsh completion
source <(chaozcode completion zsh)
echo 'source <(chaozcode completion zsh)' >> ~/.zshrc

# Fish completion
chaozcode completion fish | source
chaozcode completion fish > ~/.config/fish/completions/chaozcode.fish

Slack Integration

Bring ChaozCode into your Slack workspace for team collaboration and AI assistance.

Setup Steps

Add to Slack
Click "Add to Slack" from the ChaozCode integrations dashboard or use:
```
https://api.chaozcode.com/integrations/slack/install?team=YOUR_TEAM
```
Configure Permissions
Grant the following OAuth scopes:
- chat:write - Send messages
- commands - Slash commands
- app_mentions:read - Respond to @mentions
- channels:history - Read channel context
Set Default Channel
```
/chaozcode config channel #engineering
```

Slash Commands

Command	Description
`/chaoz ask [question]`	Ask ChaozCode anything
`/chaoz analyze [url/repo]`	Analyze a repository
`/chaoz search [query]`	Search Memory Spine
`/chaoz status`	Check system status
`/chaoz help`	Show available commands

Message Mentions

Mention @ChaozCode in any channel to get AI assistance:

@ChaozCode how do I optimize this SQL query?

@ChaozCode please review the PR at https://github.com/...

@ChaozCode what's the status of the API service?

CI/CD Integration

Integrate ChaozCode into your GitHub Actions workflows for automated code review, analysis, and documentation.

Basic Workflow

# .github/workflows/chaozcode.yml
name: ChaozCode Analysis

on:
  pull_request:
    types: [opened, synchronize]
  push:
    branches: [main]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: ChaozCode Analysis
        uses: chaozcode/action@v1
        with:
          api_key: ${{ secrets.CHAOZCODE_API_KEY }}
          task: analyze
          
      - name: Code Review
        uses: chaozcode/action@v1
        with:
          api_key: ${{ secrets.CHAOZCODE_API_KEY }}
          task: review
          github_token: ${{ secrets.GITHUB_TOKEN }}

Available Actions

Task	Description	Options
`analyze`	Full codebase analysis	path, depth, output
`review`	AI code review on PR	severity, auto_comment
`test`	Generate/validate tests	framework, coverage_min
`docs`	Generate documentation	format, output_dir
`security`	Security analysis	severity, fail_on

ChaozCode integration for GitLab CI/CD pipelines.

# .gitlab-ci.yml
stages:
  - analyze
  - review

chaozcode-analyze:
  stage: analyze
  image: chaozcode/cli:latest
  script:
    - chaozcode config set api_key $CHAOZCODE_API_KEY
    - chaozcode analyze . --output report.json
  artifacts:
    paths:
      - report.json

chaozcode-review:
  stage: review
  image: chaozcode/cli:latest
  script:
    - chaozcode review --mr $CI_MERGE_REQUEST_IID
  only:
    - merge_requests

ChaozCode integration for Jenkins pipelines.

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        CHAOZCODE_API_KEY = credentials('chaozcode-api-key')
    }
    
    stages {
        stage('ChaozCode Analysis') {
            steps {
                sh '''
                    npm install -g @chaozcode/cli
                    chaozcode analyze . --output analysis.json
                '''
            }
        }
        
        stage('Code Review') {
            when {
                changeRequest()
            }
            steps {
                sh 'chaozcode review --pr ${CHANGE_ID}'
            }
        }
    }
    
    post {
        always {
            archiveArtifacts artifacts: 'analysis.json', fingerprint: true
        }
    }
}

SDK Integration

🟨 JavaScript/TypeScript

npm install @chaozcode/sdk

import { ChaozCode } from '@chaozcode/sdk';

const client = new ChaozCode({
  apiKey: process.env.CHAOZCODE_API_KEY
});

const result = await client.query({
  prompt: "Explain this code",
  context: codeString
});

🐍 Python

pip install chaozcode

from chaozcode import ChaozCode

client = ChaozCode(
    api_key=os.environ["CHAOZCODE_API_KEY"]
)

result = client.query(
    prompt="Explain this code",
    context=code_string
)

🔵 Go

go get github.com/chaozcode/chaozcode-go

import "github.com/chaozcode/chaozcode-go"

client := chaozcode.NewClient(
    os.Getenv("CHAOZCODE_API_KEY"),
)

result, err := client.Query(ctx, &chaozcode.QueryRequest{
    Prompt:  "Explain this code",
    Context: codeString,
})

🦀 Rust

// Cargo.toml
[dependencies]
chaozcode = "0.1"

use chaozcode::Client;

let client = Client::new(
    std::env::var("CHAOZCODE_API_KEY")?
);

let result = client.query(
    "Explain this code",
    Some(code_string)
).await?;

Webhooks

Receive real-time notifications for events in your ChaozCode workspace.

Webhook Events

Event	Description	Payload
`memory.stored`	New memory stored	id, content, tags
`query.completed`	Query finished processing	query_id, result
`agent.completed`	Agent task completed	agent_id, output
`analysis.ready`	Code analysis ready	analysis_id, summary
`alert.triggered`	System alert triggered	alert_type, message

Setting Up Webhooks

// Register a webhook
const webhook = await client.webhooks.create({
  url: 'https://yourapp.com/webhooks/chaozcode',
  events: ['memory.stored', 'query.completed'],
  secret: 'your-webhook-secret'
});

// Webhook payload example
{
  "event": "memory.stored",
  "timestamp": "2026-01-30T10:00:00Z",
  "data": {
    "id": "mem_abc123",
    "content": "API authentication pattern",
    "tags": ["api", "auth"]
  },
  "signature": "sha256=abc123..."
}

Verifying Webhooks

// Node.js example
const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  hmac.update(payload);
  const expectedSig = 'sha256=' + hmac.digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSig)
  );
}

GitHub Integration

GitHub

Setup Steps

Available Features

OAuth Setup (For Apps)

VS Code Extension

Visual Studio Code

Installation

Keyboard Shortcuts

Commands

CLI Integration

Command Line Interface

Installation

Configuration

Available Commands

Shell Integration

Slack Integration

Slack

Setup Steps

Slash Commands

Message Mentions

CI/CD Integration

GitHub Actions

Basic Workflow

Available Actions

GitLab CI

Jenkins

SDK Integration

🟨 JavaScript/TypeScript

🐍 Python

🔵 Go

🦀 Rust

Webhooks

Webhook Events

Setting Up Webhooks

Verifying Webhooks