codanna 0.9.19

Code Intelligence for Large Language Models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

/**
 * HTTP request helpers
 * Fetch wrapper with common patterns
 */

const DEFAULT_HEADERS = {
  'Content-Type': 'application/json',
};

export class HttpError extends Error {
  constructor(message, status, data) {
    super(message);
    this.name = 'HttpError';
    this.status = status;
    this.data = data;
  }
}

async function handleResponse(response) {
  const contentType = response.headers.get('content-type') || '';

  let data;
  if (contentType.includes('application/json')) {
    data = await response.json();
  } else if (contentType.includes('text/')) {
    data = await response.text();
  } else {
    data = await response.blob();
  }

  if (!response.ok) {
    throw new HttpError(
      data.message || response.statusText,
      response.status,
      data
    );
  }

  return data;
}

function buildUrl(url, params) {
  if (!params || Object.keys(params).length === 0) {
    return url;
  }

  const searchParams = new URLSearchParams();
  for (const [key, value] of Object.entries(params)) {
    if (value !== undefined && value !== null) {
      if (Array.isArray(value)) {
        value.forEach((v) => searchParams.append(key, v));
      } else {
        searchParams.append(key, value);
      }
    }
  }

  const separator = url.includes('?') ? '&' : '?';
  return `${url}${separator}${searchParams.toString()}`;
}

export async function request(url, options = {}) {
  const {
    method = 'GET',
    headers = {},
    body,
    params,
    timeout = 30000,
    ...rest
  } = options;

  const finalUrl = buildUrl(url, params);

  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);

  try {
    const response = await fetch(finalUrl, {
      method,
      headers: { ...DEFAULT_HEADERS, ...headers },
      body: body ? JSON.stringify(body) : undefined,
      signal: controller.signal,
      ...rest,
    });

    return await handleResponse(response);
  } finally {
    clearTimeout(timeoutId);
  }
}

export function get(url, params, options = {}) {
  return request(url, { ...options, method: 'GET', params });
}

export function post(url, body, options = {}) {
  return request(url, { ...options, method: 'POST', body });
}

export function put(url, body, options = {}) {
  return request(url, { ...options, method: 'PUT', body });
}

export function patch(url, body, options = {}) {
  return request(url, { ...options, method: 'PATCH', body });
}

export function del(url, options = {}) {
  return request(url, { ...options, method: 'DELETE' });
}

/**
 * Create an API client with base URL
 */
export function createClient(baseUrl, defaultOptions = {}) {
  const makeRequest = (method) => (path, bodyOrParams, options = {}) => {
    const url = `${baseUrl}${path}`;
    const merged = { ...defaultOptions, ...options };

    if (method === 'GET') {
      return request(url, { ...merged, method, params: bodyOrParams });
    }
    return request(url, { ...merged, method, body: bodyOrParams });
  };

  return {
    get: makeRequest('GET'),
    post: makeRequest('POST'),
    put: makeRequest('PUT'),
    patch: makeRequest('PATCH'),
    delete: (path, options) => request(`${baseUrl}${path}`, { ...defaultOptions, ...options, method: 'DELETE' }),
  };
}