API Reference

const response = await fetch('https://production-api.potpie.ai/api/v1/projects/list', {
  headers: {
    'Authorization': `Bearer ${process.env.POTPIE_API_KEY}`,
    'Content-Type': 'application/json'
  }
});

import fetch from 'node-fetch';

interface PotpieConfig {
  apiKey: string;
  baseUrl?: string;
}

class PotpieClient {
  private apiKey: string;
  private baseUrl: string;

  constructor(config: PotpieConfig) {
    this.apiKey = config.apiKey;
    this.baseUrl = config.baseUrl || 'https://production-api.potpie.ai';
  }

  private async request(endpoint: string, options: RequestInit = {}) {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers,
      },
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status} ${response.statusText}`);
    }

    return response.json();
  }

  // 1. Parse a repository
  async parseDirectory(data: {
    repo_name?: string;
    repo_path?: string;
    branch_name: string;
  }) {
    return this.request('/api/v1/parse', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  // 2. Check parsing status
  async getParsingStatus(projectId: string) {
    return this.request(`/api/v1/parsing-status/${projectId}`);
  }

  // 3. Wait for parsing to complete
  async waitForParsing(projectId: string, pollInterval = 5000) {
    while (true) {
      const status = await this.getParsingStatus(projectId);

      console.log(`Status: ${status.status} - ${status.progress}%`);

      if (status.status === 'ready') {
        return status;
      }

      if (status.status === 'failed') {
        throw new Error(`Parsing failed: ${status.error}`);
      }

      await new Promise(resolve => setTimeout(resolve, pollInterval));
    }
  }

  // 4. List all projects
  async listProjects() {
    return this.request('/api/v1/projects/list');
  }

  // 5. List available agents
  async listAgents() {
    return this.request('/api/v1/list-available-agents/');
  }

  // 6. Create a conversation
  async createConversation(data: {
    user_id: string;
    title: string;
    status: string;
    project_ids: string[];
    agent_ids: string[];
  }) {
    return this.request('/api/v1/conversations/', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  // 7. Send a message
  async postMessage(conversationId: string, content: string, nodeIds?: any[]) {
    return this.request(`/api/v1/conversations/${conversationId}/message/`, {
      method: 'POST',
      body: JSON.stringify({ content, node_ids: nodeIds }),
    });
  }

  // 8. Search codebase
  async searchCodebase(projectId: string, query: string) {
    return this.request('/api/v1/search', {
      method: 'POST',
      body: JSON.stringify({ project_id: projectId, query }),
    });
  }
}

// Usage example
async function main() {
  const client = new PotpieClient({
    apiKey: process.env.POTPIE_API_KEY!,
  });

  try {
    // Parse repository
    console.log('Starting repository parsing...');
    const parseResponse = await client.parseDirectory({
      repo_name: 'my-awesome-app',
      repo_path: '/path/to/repo',
      branch_name: 'main',
    });

    const projectId = parseResponse.project_id;
    console.log(`Project ID: ${projectId}`);

    // Wait for parsing to complete
    await client.waitForParsing(projectId);
    console.log('Parsing ready!');

    // List available agents
    const agents = await client.listAgents();
    console.log('Available agents:', agents);

    // Create conversation
    const conversation = await client.createConversation({
      user_id: 'user_123',
      title: 'Code Review Session',
      status: 'active',
      project_ids: [projectId],
      agent_ids: ['qna-agent'],
    });

    console.log(`Conversation ID: ${conversation.conversation_id}`);

    // Ask a question
    await client.postMessage(
      conversation.conversation_id,
      'How does authentication work in this codebase?'
    );

    console.log('Message sent successfully!');
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

try {
  const response = await fetch(endpoint, options);

  if (!response.ok) {
    if (response.status === 401) {
      throw new Error('Invalid API key');
    }
    if (response.status === 429) {
      throw new Error('Rate limit exceeded - please wait before retrying');
    }
    if (response.status === 404) {
      throw new Error('Resource not found');
    }
    throw new Error(`API error: ${response.status}`);
  }

  return await response.json();
} catch (error) {
  console.error('API request failed:', error);
  throw error;
}