Adding Knowledge Connectors

const GITHUB = z.literal("github");

export const ConnectorTypeSchema = z.union([JIRA, CONFLUENCE, GITHUB]);

export const GithubConfigSchema = z.object({
  type: GITHUB,
  githubBaseUrl: z.string(),
  owner: z.string(),
  repo: z.string().optional(),
  labelsToSkip: z.array(z.string()).optional(),
});
export type GithubConfig = z.infer<typeof GithubConfigSchema>;

export const GithubCheckpointSchema = z.object({
  type: GITHUB,
  lastSyncedAt: z.string().optional(),
  lastIssueNumber: z.number().optional(),
});
export type GithubCheckpoint = z.infer<typeof GithubCheckpointSchema>;

export const ConnectorConfigSchema = z.discriminatedUnion("type", [
  JiraConfigSchema,
  ConfluenceConfigSchema,
  GithubConfigSchema, // <-- add here
]);

export const ConnectorCheckpointSchema = z.discriminatedUnion("type", [
  JiraCheckpointSchema,
  ConfluenceCheckpointSchema,
  GithubCheckpointSchema, // <-- add here
]);

import type {
  ConnectorCredentials,
  ConnectorDocument,
  ConnectorSyncBatch,
  GithubCheckpoint,
  GithubConfig,
} from "@/types/knowledge-connector";
import { GithubConfigSchema } from "@/types/knowledge-connector";
import { BaseConnector } from "../base-connector";

const BATCH_SIZE = 50;

export class GithubConnector extends BaseConnector {
  type = "github" as const;

  async validateConfig(
    config: Record<string, unknown>,
  ): Promise<{ valid: boolean; error?: string }> {
    const parsed = GithubConfigSchema.safeParse({ type: "github", ...config });
    if (!parsed.success) {
      return { valid: false, error: "Invalid GitHub configuration" };
    }
    if (!/^https?:\/\/.+/.test(parsed.data.githubBaseUrl)) {
      return {
        valid: false,
        error: "githubBaseUrl must be a valid HTTP(S) URL",
      };
    }
    return { valid: true };
  }

  async testConnection(params: {
    config: Record<string, unknown>;
    credentials: ConnectorCredentials;
  }): Promise<{ success: boolean; error?: string }> {
    // Make a lightweight API call to verify credentials
    try {
      const response = await this.fetchWithRetry(
        "https://api.github.com/user",
        {
          headers: {
            Authorization: `Bearer ${params.credentials.apiToken}`,
            Accept: "application/vnd.github.v3+json",
          },
        },
      );
      if (!response.ok) {
        return { success: false, error: `HTTP ${response.status}` };
      }
      return { success: true };
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      return { success: false, error: `Connection failed: ${message}` };
    }
  }

  async *sync(params: {
    config: Record<string, unknown>;
    credentials: ConnectorCredentials;
    checkpoint: Record<string, unknown> | null;
    startTime?: Date;
    endTime?: Date;
  }): AsyncGenerator<ConnectorSyncBatch> {
    const parsed = GithubConfigSchema.safeParse({
      type: "github",
      ...params.config,
    });
    if (!parsed.success) {
      throw new Error("Invalid GitHub configuration");
    }
    const config = parsed.data;
    const checkpoint = (params.checkpoint as GithubCheckpoint | null) ?? {
      type: "github" as const,
    };

    let page = 1;
    let hasMore = true;

    while (hasMore) {
      await this.rateLimit();

      const url = `${config.githubBaseUrl}/repos/${config.owner}/${config.repo}/issues?page=${page}&per_page=${BATCH_SIZE}&state=all&sort=updated&direction=asc`;
      const response = await this.fetchWithRetry(url, {
        headers: {
          Authorization: `Bearer ${params.credentials.apiToken}`,
          Accept: "application/vnd.github.v3+json",
        },
      });

      const issues = await response.json();
      const documents: ConnectorDocument[] = issues.map((issue: any) => ({
        id: String(issue.number),
        title: issue.title,
        content: `# ${issue.title}\n\n${issue.body ?? ""}`,
        sourceUrl: issue.html_url,
        metadata: { number: issue.number, state: issue.state },
        updatedAt: new Date(issue.updated_at),
      }));

      hasMore = issues.length >= BATCH_SIZE;
      page++;

      yield {
        documents,
        checkpoint: {
          type: "github",
          lastSyncedAt: new Date().toISOString(),
          lastIssueNumber:
            issues.length > 0
              ? issues[issues.length - 1].number
              : checkpoint.lastIssueNumber,
        },
        hasMore,
      };
    }
  }
}

import { GithubConnector } from "./github/github-connector";

const connectorRegistry: Record<ConnectorType, () => Connector> = {
  jira: () => new JiraConnector(),
  confluence: () => new ConfluenceConnector(),
  github: () => new GithubConnector(), // <-- add here
};

"use client";

import type { UseFormReturn } from "react-hook-form";
import {
  FormControl,
  FormDescription,
  FormField,
  FormItem,
  FormLabel,
  FormMessage,
} from "@/components/ui/form";
import { Input } from "@/components/ui/input";

interface GithubConfigFieldsProps {
  form: UseFormReturn<any>;
  prefix?: string;
}

export function GithubConfigFields({
  form,
  prefix = "config",
}: GithubConfigFieldsProps) {
  return (
    <div className="space-y-4">
      <FormField
        control={form.control}
        name={`${prefix}.githubBaseUrl`}
        rules={{ required: "Base URL is required" }}
        render={({ field }) => (
          <FormItem>
            <FormLabel>Base URL</FormLabel>
            <FormControl>
              <Input placeholder="https://api.github.com" {...field} />
            </FormControl>
            <FormDescription>
              GitHub API base URL. Use https://api.github.com for GitHub.com.
            </FormDescription>
            <FormMessage />
          </FormItem>
        )}
      />
      {/* Add fields for owner, repo, etc. */}
    </div>
  );
}

import { GithubConfigFields } from "./github-config-fields";

// In the SelectContent:
<SelectItem value="github">GitHub</SelectItem>;

// In the config step:
{
  step === 1 && connectorType === "github" && (
    <GithubConfigFields form={form} />
  );
}