@ghcrawl/api-core 0.1.0

package/src/openai/provider.ts

@@ -0,0 +1,141 @@
+import OpenAI from 'openai';
+import { APIConnectionError, APIConnectionTimeoutError, APIError, RateLimitError } from 'openai/error';
+import { zodTextFormat } from 'openai/helpers/zod';
+import { z } from 'zod';
+
+export type SummaryResult = {
+  problemSummary: string;
+  solutionSummary: string;
+  maintainerSignalSummary: string;
+  dedupeSummary: string;
+};
+
+export type SummaryUsage = {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cachedInputTokens: number;
+  reasoningTokens: number;
+};
+
+export type AiProvider = {
+  checkAuth: () => Promise<void>;
+  summarizeThread: (params: { model: string; text: string }) => Promise<{ summary: SummaryResult; usage?: SummaryUsage }>;
+  embedTexts: (params: { model: string; texts: string[] }) => Promise<number[][]>;
+};
+
+const summarySchema = z.object({
+  problem_summary: z.string(),
+  solution_summary: z.string(),
+  maintainer_signal_summary: z.string(),
+  dedupe_summary: z.string(),
+});
+
+export class OpenAiProvider implements AiProvider {
+  private readonly client: OpenAI;
+
+  constructor(apiKey: string) {
+    this.client = new OpenAI({ apiKey });
+  }
+
+  async checkAuth(): Promise<void> {
+    await this.client.models.list();
+  }
+
+  async summarizeThread(params: { model: string; text: string }): Promise<{ summary: SummaryResult; usage?: SummaryUsage }> {
+    const format = zodTextFormat(summarySchema, 'ghcrawl_thread_summary');
+    let lastError: Error | null = null;
+
+    for (const [attemptIndex, maxOutputTokens] of [500, 900, 1400].entries()) {
+      try {
+        const response = await this.client.responses.create({
+          model: params.model,
+          input: [
+            {
+              role: 'system',
+              content: [
+                {
+                  type: 'input_text',
+                  text:
+                    'Summarize this GitHub issue or pull request thread. Return concise JSON only with keys problem_summary, solution_summary, maintainer_signal_summary, dedupe_summary. Each field should be plain text, no markdown, and usually 1-3 sentences.',
+                },
+              ],
+            },
+            {
+              role: 'user',
+              content: [{ type: 'input_text', text: params.text }],
+            },
+          ],
+          text: {
+            format,
+            verbosity: 'low',
+          },
+          max_output_tokens: maxOutputTokens,
+        });
+
+        const raw = response.output_text ?? '';
+        const parsed = summarySchema.parse(JSON.parse(raw));
+
+        return {
+          summary: {
+            problemSummary: parsed.problem_summary,
+            solutionSummary: parsed.solution_summary,
+            maintainerSignalSummary: parsed.maintainer_signal_summary,
+            dedupeSummary: parsed.dedupe_summary,
+          },
+          usage: response.usage
+            ? {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+                totalTokens: response.usage.total_tokens,
+                cachedInputTokens: response.usage.input_tokens_details?.cached_tokens ?? 0,
+                reasoningTokens: response.usage.output_tokens_details?.reasoning_tokens ?? 0,
+              }
+            : undefined,
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attemptIndex === 2) {
+          break;
+        }
+      }
+    }
+
+    throw new Error(`OpenAI summarization failed after 3 attempts: ${lastError?.message ?? 'unknown error'}`);
+  }
+
+  async embedTexts(params: { model: string; texts: string[] }): Promise<number[][]> {
+    if (params.texts.length === 0) {
+      return [];
+    }
+
+    let lastError: Error | null = null;
+    for (const attempt of [1, 2, 3, 4, 5]) {
+      try {
+        const response = await this.client.embeddings.create({
+          model: params.model,
+          input: params.texts,
+        });
+
+        return response.data.map((item) => item.embedding);
+      } catch (error) {
+        const shouldRetry =
+          error instanceof RateLimitError ||
+          error instanceof APIConnectionError ||
+          error instanceof APIConnectionTimeoutError ||
+          (error instanceof APIError && typeof error.status === 'number' && error.status >= 500);
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!shouldRetry || attempt === 5) {
+          break;
+        }
+        await sleep(1000 * 2 ** (attempt - 1));
+      }
+    }
+
+    throw new Error(`OpenAI embeddings failed after 5 attempts: ${lastError?.message ?? 'unknown error'}`);
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/search/exact.test.ts

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { cosineSimilarity, rankNearestNeighbors } from './exact.js';
+
+test('cosine similarity is 1 for identical embeddings', () => {
+  assert.equal(cosineSimilarity([1, 0], [1, 0]), 1);
+});
+
+test('nearest neighbors sorts by similarity descending', () => {
+  const ranked = rankNearestNeighbors(
+    [
+      { id: 1, embedding: [1, 0] },
+      { id: 2, embedding: [0.9, 0.1] },
+      { id: 3, embedding: [0, 1] },
+    ],
+    { targetEmbedding: [1, 0], limit: 2, skipId: 1 },
+  );
+
+  assert.equal(ranked[0]?.item.id, 2);
+  assert.equal(ranked[1]?.item.id, 3);
+});

package/src/search/exact.ts

@@ -0,0 +1,28 @@
+export function cosineSimilarity(left: number[], right: number[]): number {
+  if (left.length !== right.length) {
+    throw new Error('Embedding dimensions do not match');
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    dot += left[index] * right[index];
+    leftNorm += left[index] * left[index];
+    rightNorm += right[index] * right[index];
+  }
+  if (leftNorm === 0 || rightNorm === 0) return 0;
+  return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+
+export function rankNearestNeighbors<T extends { id: number; embedding: number[] }>(
+  items: T[],
+  params: { targetEmbedding: number[]; limit: number; minScore?: number; skipId?: number },
+): Array<{ item: T; score: number }> {
+  const minScore = params.minScore ?? -1;
+  return items
+    .filter((item) => item.id !== params.skipId)
+    .map((item) => ({ item, score: cosineSimilarity(params.targetEmbedding, item.embedding) }))
+    .filter((entry) => entry.score >= minScore)
+    .sort((left, right) => right.score - left.score)
+    .slice(0, params.limit);
+}