@strayl/coregit 0.1.0

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/usage.d.ts

@@ -0,0 +1,9 @@
+import type { HttpClient } from "./http";
+import type { CoregitResult, PaginationOptions, UsageDetailsResponse, UsageSummary } from "./types";
+export declare class UsageClient {
+    private http;
+    constructor(http: HttpClient);
+    summary(period?: string): Promise<CoregitResult<UsageSummary>>;
+    details(opts?: PaginationOptions): Promise<CoregitResult<UsageDetailsResponse>>;
+}
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,EACb,MAAM,SAAS,CAAC;AAEjB,qBAAa,WAAW;IACV,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAEpC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;IAK9D,OAAO,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;CAOhF"}

package/dist/usage.js

@@ -0,0 +1,19 @@
+export class UsageClient {
+    constructor(http) {
+        this.http = http;
+    }
+    summary(period) {
+        const qs = period ? `?period=${encodeURIComponent(period)}` : "";
+        return this.http.request("GET", `/v1/usage${qs}`);
+    }
+    details(opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set("offset", String(opts.offset));
+        const qs = params.toString();
+        return this.http.request("GET", `/v1/usage/details${qs ? `?${qs}` : ""}`);
+    }
+}
+//# sourceMappingURL=usage.js.map

package/dist/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,WAAW;IACtB,YAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAExC,OAAO,CAAC,MAAe;QACrB,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,WAAW,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAe,KAAK,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,OAAO,CAAC,IAAwB;QAC9B,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QACrC,IAAI,IAAI,EAAE,KAAK,KAAK,SAAS;YAAE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACvE,IAAI,IAAI,EAAE,MAAM,KAAK,SAAS;YAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1E,MAAM,EAAE,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAuB,KAAK,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAClG,CAAC;CACF"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@strayl/coregit",
+  "version": "0.1.0",
+  "description": "Official TypeScript SDK for the Coregit API",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "keywords": [
+    "coregit",
+    "git",
+    "api",
+    "sdk",
+    "serverless"
+  ],
+  "author": "Strayl",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  }
+}

package/src/branches.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "./http";
+import type {
+  Branch,
+  BranchListResponse,
+  CoregitResult,
+  CreateBranchInput,
+  MergeInput,
+  MergeResult,
+} from "./types";
+
+export class BranchesClient {
+  constructor(private http: HttpClient) {}
+
+  create(repoSlug: string, input: CreateBranchInput): Promise<CoregitResult<Branch & { created: boolean }>> {
+    return this.http.request("POST", `/v1/repos/${encodeURIComponent(repoSlug)}/branches`, input);
+  }
+
+  list(repoSlug: string): Promise<CoregitResult<BranchListResponse>> {
+    return this.http.request<BranchListResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/branches`);
+  }
+
+  get(repoSlug: string, name: string): Promise<CoregitResult<Branch>> {
+    return this.http.request<Branch>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/branches/${encodeURIComponent(name)}`);
+  }
+
+  delete(repoSlug: string, name: string): Promise<CoregitResult<{ deleted: boolean; name: string }>> {
+    return this.http.request("DELETE", `/v1/repos/${encodeURIComponent(repoSlug)}/branches/${encodeURIComponent(name)}`);
+  }
+
+  merge(repoSlug: string, sourceBranch: string, opts?: MergeInput): Promise<CoregitResult<MergeResult>> {
+    return this.http.request<MergeResult>(
+      "POST",
+      `/v1/repos/${encodeURIComponent(repoSlug)}/branches/${encodeURIComponent(sourceBranch)}/merge`,
+      opts,
+    );
+  }
+}

package/src/commits.ts

@@ -0,0 +1,28 @@
+import type { HttpClient } from "./http";
+import type {
+  Commit,
+  CommitListResponse,
+  CommitResult,
+  CoregitResult,
+  CreateCommitInput,
+} from "./types";
+
+export class CommitsClient {
+  constructor(private http: HttpClient) {}
+
+  create(repoSlug: string, input: CreateCommitInput): Promise<CoregitResult<CommitResult>> {
+    return this.http.request<CommitResult>("POST", `/v1/repos/${encodeURIComponent(repoSlug)}/commits`, input);
+  }
+
+  list(repoSlug: string, opts?: { ref?: string; limit?: number }): Promise<CoregitResult<CommitListResponse>> {
+    const params = new URLSearchParams();
+    if (opts?.ref) params.set("ref", opts.ref);
+    if (opts?.limit !== undefined) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.http.request<CommitListResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/commits${qs ? `?${qs}` : ""}`);
+  }
+
+  get(repoSlug: string, sha: string): Promise<CoregitResult<Commit>> {
+    return this.http.request<Commit>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/commits/${sha}`);
+  }
+}

package/src/diff.ts

@@ -0,0 +1,11 @@
+import type { HttpClient } from "./http";
+import type { CoregitResult, DiffResponse } from "./types";
+
+export class DiffClient {
+  constructor(private http: HttpClient) {}
+
+  compare(repoSlug: string, base: string, head: string): Promise<CoregitResult<DiffResponse>> {
+    const params = new URLSearchParams({ base, head });
+    return this.http.request<DiffResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/diff?${params}`);
+  }
+}

package/src/files.ts

@@ -0,0 +1,25 @@
+import type { HttpClient } from "./http";
+import type {
+  BlobResponse,
+  CoregitResult,
+  RefsResponse,
+  TreeResponse,
+} from "./types";
+
+export class FilesClient {
+  constructor(private http: HttpClient) {}
+
+  tree(repoSlug: string, ref?: string, path?: string): Promise<CoregitResult<TreeResponse>> {
+    const refPart = ref ? `/${encodeURIComponent(ref)}` : "";
+    const pathPart = path ? `/${path}` : "";
+    return this.http.request<TreeResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/tree${refPart}${pathPart}`);
+  }
+
+  blob(repoSlug: string, ref: string, path: string): Promise<CoregitResult<BlobResponse>> {
+    return this.http.request<BlobResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/blob/${encodeURIComponent(ref)}/${path}`);
+  }
+
+  refs(repoSlug: string): Promise<CoregitResult<RefsResponse>> {
+    return this.http.request<RefsResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/refs`);
+  }
+}

package/src/http.ts

@@ -0,0 +1,82 @@
+import type { FetchLike, CoregitResult, CoregitError } from "./types";
+
+export function resolveFetch(custom?: FetchLike): FetchLike {
+  if (custom) return custom;
+  if (typeof fetch === "function") {
+    return fetch.bind(globalThis);
+  }
+  throw new Error("fetch is not available. Provide a custom implementation via options.fetch");
+}
+
+export function toCoregitError(status: number, payload?: any): CoregitError {
+  if (payload && typeof payload === "object") {
+    if (typeof payload.error === "string") {
+      return { message: payload.error, status };
+    }
+    if (payload.error?.message) {
+      return { message: String(payload.error.message), code: payload.error.code, status };
+    }
+    if (payload.message) {
+      return { message: String(payload.message), status };
+    }
+  }
+  return { message: "Request failed", status };
+}
+
+export class HttpClient {
+  private fetch: FetchLike;
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(baseUrl: string, apiKey: string, fetchImpl: FetchLike) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+    this.fetch = fetchImpl;
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<CoregitResult<T>> {
+    const headers: Record<string, string> = {
+      "x-api-key": this.apiKey,
+    };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+
+    const response = await this.fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+
+    const contentType = response.headers.get("content-type");
+    let payload: any = null;
+    if (contentType && contentType.includes("application/json")) {
+      payload = await response.json();
+    } else {
+      const text = await response.text();
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = null;
+      }
+    }
+
+    if (!response.ok) {
+      return {
+        data: null,
+        error: toCoregitError(response.status, payload),
+        status: response.status,
+      };
+    }
+
+    return {
+      data: payload as T,
+      error: null,
+      status: response.status,
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+import { HttpClient, resolveFetch } from "./http";
+import { ReposClient } from "./repos";
+import { BranchesClient } from "./branches";
+import { CommitsClient } from "./commits";
+import { FilesClient } from "./files";
+import { DiffClient } from "./diff";
+import { SnapshotsClient } from "./snapshots";
+import { UsageClient } from "./usage";
+import type { CoregitClientOptions } from "./types";
+
+const DEFAULT_BASE_URL = "https://api.coregit.dev";
+
+export class CoregitClient {
+  readonly repos: ReposClient;
+  readonly branches: BranchesClient;
+  readonly commits: CommitsClient;
+  readonly files: FilesClient;
+  readonly diff: DiffClient;
+  readonly snapshots: SnapshotsClient;
+  readonly usage: UsageClient;
+
+  constructor(options: CoregitClientOptions) {
+    if (!options.apiKey) {
+      throw new Error("apiKey is required to initialize CoregitClient");
+    }
+
+    const fetchImpl = resolveFetch(options.fetch);
+    const http = new HttpClient(
+      options.baseUrl ?? DEFAULT_BASE_URL,
+      options.apiKey,
+      fetchImpl,
+    );
+
+    this.repos = new ReposClient(http);
+    this.branches = new BranchesClient(http);
+    this.commits = new CommitsClient(http);
+    this.files = new FilesClient(http);
+    this.diff = new DiffClient(http);
+    this.snapshots = new SnapshotsClient(http);
+    this.usage = new UsageClient(http);
+  }
+}
+
+export function createCoregitClient(options: CoregitClientOptions): CoregitClient {
+  return new CoregitClient(options);
+}
+
+export * from "./types";
+export { ReposClient } from "./repos";
+export { BranchesClient } from "./branches";
+export { CommitsClient } from "./commits";
+export { FilesClient } from "./files";
+export { DiffClient } from "./diff";
+export { SnapshotsClient } from "./snapshots";
+export { UsageClient } from "./usage";

package/src/repos.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "./http";
+import type {
+  CoregitResult,
+  CreateRepoInput,
+  PaginationOptions,
+  Repo,
+  RepoListResponse,
+  UpdateRepoInput,
+} from "./types";
+
+export class ReposClient {
+  constructor(private http: HttpClient) {}
+
+  create(input: CreateRepoInput): Promise<CoregitResult<Repo>> {
+    return this.http.request<Repo>("POST", "/v1/repos", input);
+  }
+
+  list(opts?: PaginationOptions): Promise<CoregitResult<RepoListResponse>> {
+    const params = new URLSearchParams();
+    if (opts?.limit !== undefined) params.set("limit", String(opts.limit));
+    if (opts?.offset !== undefined) params.set("offset", String(opts.offset));
+    const qs = params.toString();
+    return this.http.request<RepoListResponse>("GET", `/v1/repos${qs ? `?${qs}` : ""}`);
+  }
+
+  get(slug: string): Promise<CoregitResult<Repo>> {
+    return this.http.request<Repo>("GET", `/v1/repos/${encodeURIComponent(slug)}`);
+  }
+
+  update(slug: string, input: UpdateRepoInput): Promise<CoregitResult<Repo>> {
+    return this.http.request<Repo>("PATCH", `/v1/repos/${encodeURIComponent(slug)}`, input);
+  }
+
+  delete(slug: string): Promise<CoregitResult<{ deleted: boolean }>> {
+    return this.http.request<{ deleted: boolean }>("DELETE", `/v1/repos/${encodeURIComponent(slug)}`);
+  }
+}

package/src/snapshots.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "./http";
+import type {
+  CoregitResult,
+  CreateSnapshotInput,
+  RestoreInput,
+  RestoreResult,
+  Snapshot,
+  SnapshotListResponse,
+} from "./types";
+
+export class SnapshotsClient {
+  constructor(private http: HttpClient) {}
+
+  create(repoSlug: string, input: CreateSnapshotInput): Promise<CoregitResult<Snapshot>> {
+    return this.http.request<Snapshot>("POST", `/v1/repos/${encodeURIComponent(repoSlug)}/snapshots`, input);
+  }
+
+  list(repoSlug: string): Promise<CoregitResult<SnapshotListResponse>> {
+    return this.http.request<SnapshotListResponse>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/snapshots`);
+  }
+
+  get(repoSlug: string, name: string): Promise<CoregitResult<Snapshot>> {
+    return this.http.request<Snapshot>("GET", `/v1/repos/${encodeURIComponent(repoSlug)}/snapshots/${encodeURIComponent(name)}`);
+  }
+
+  delete(repoSlug: string, name: string): Promise<CoregitResult<{ deleted: boolean }>> {
+    return this.http.request("DELETE", `/v1/repos/${encodeURIComponent(repoSlug)}/snapshots/${encodeURIComponent(name)}`);
+  }
+
+  restore(repoSlug: string, name: string, opts?: RestoreInput): Promise<CoregitResult<RestoreResult>> {
+    return this.http.request<RestoreResult>(
+      "POST",
+      `/v1/repos/${encodeURIComponent(repoSlug)}/snapshots/${encodeURIComponent(name)}/restore`,
+      opts,
+    );
+  }
+}

package/src/types.ts

@@ -0,0 +1,239 @@
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+export interface CoregitClientOptions {
+  apiKey: string;
+  baseUrl?: string;
+  fetch?: FetchLike;
+}
+
+export interface CoregitResult<T> {
+  data: T | null;
+  error: CoregitError | null;
+  status: number;
+}
+
+export interface CoregitError {
+  message: string;
+  code?: string;
+  status?: number;
+}
+
+// --- Repos ---
+
+export interface CreateRepoInput {
+  slug: string;
+  description?: string;
+  default_branch?: string;
+  visibility?: "public" | "private";
+  init?: boolean;
+}
+
+export interface UpdateRepoInput {
+  description?: string;
+  visibility?: "public" | "private";
+  default_branch?: string;
+}
+
+export interface Repo {
+  id: string;
+  slug: string;
+  description: string | null;
+  default_branch: string;
+  visibility: string;
+  git_url: string;
+  api_url: string;
+  created_at: string;
+  updated_at?: string;
+  is_empty?: boolean;
+}
+
+export interface RepoListResponse {
+  repos: Repo[];
+  limit: number;
+  offset: number;
+}
+
+// --- Branches ---
+
+export interface CreateBranchInput {
+  name: string;
+  from?: string;
+  from_sha?: string;
+}
+
+export interface Branch {
+  name: string;
+  sha: string;
+}
+
+export interface BranchListResponse {
+  branches: Branch[];
+  default_branch: string;
+}
+
+export interface MergeInput {
+  target?: string;
+  strategy?: string;
+}
+
+export interface MergeResult {
+  merged: boolean;
+  sha: string;
+  strategy: string;
+}
+
+// --- Commits ---
+
+export interface FileChange {
+  path: string;
+  content?: string;
+  encoding?: "utf-8" | "base64";
+  action?: "delete";
+}
+
+export interface CreateCommitInput {
+  branch: string;
+  message: string;
+  author: { name: string; email: string };
+  changes: FileChange[];
+  parent_sha?: string;
+}
+
+export interface CommitResult {
+  sha: string;
+  tree_sha: string;
+  branch: string;
+  parent: string;
+}
+
+export interface Commit {
+  sha: string;
+  message: string;
+  tree: string;
+  author_name: string;
+  author_email: string;
+  timestamp: number;
+  parents: string[];
+}
+
+export interface CommitListResponse {
+  commits: Commit[];
+  ref: string;
+  has_more: boolean;
+}
+
+// --- Files ---
+
+export interface TreeEntry {
+  name: string;
+  path: string;
+  type: "folder" | "file";
+  sha: string;
+  mode: string;
+}
+
+export interface TreeResponse {
+  items: TreeEntry[];
+  path: string;
+  ref: string;
+  sha: string;
+}
+
+export interface BlobResponse {
+  content: string;
+  encoding: "utf-8" | "base64";
+  path: string;
+  sha: string;
+  size: number;
+}
+
+export interface Ref {
+  name: string;
+  sha: string;
+  type: "branch" | "tag";
+}
+
+export interface RefsResponse {
+  branches: Ref[];
+  tags: Ref[];
+  default_branch: string;
+}
+
+// --- Diff ---
+
+export interface DiffFile {
+  path: string;
+  status: "added" | "removed" | "modified";
+  old_sha: string | null;
+  new_sha: string | null;
+}
+
+export interface DiffResponse {
+  base: string;
+  head: string;
+  files: DiffFile[];
+  total_files_changed: number;
+  total_additions: number;
+  total_deletions: number;
+}
+
+// --- Snapshots ---
+
+export interface CreateSnapshotInput {
+  name: string;
+  branch?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface Snapshot {
+  name: string;
+  branch: string;
+  commit_sha: string;
+  metadata: Record<string, unknown> | null;
+  created_at: string;
+}
+
+export interface SnapshotListResponse {
+  snapshots: Snapshot[];
+}
+
+export interface RestoreInput {
+  target_branch?: string;
+}
+
+export interface RestoreResult {
+  restored: boolean;
+  branch: string;
+  sha: string;
+}
+
+// --- Usage ---
+
+export interface UsageSummary {
+  period: string;
+  api_calls: number;
+  repos_created: number;
+  storage_bytes: number;
+  git_transfer_bytes: number;
+}
+
+export interface UsageEvent {
+  id: number;
+  event_type: string;
+  quantity: number;
+  metadata: Record<string, unknown> | null;
+  recorded_at: string;
+}
+
+export interface UsageDetailsResponse {
+  events: UsageEvent[];
+  limit: number;
+  offset: number;
+}
+
+// --- Pagination ---
+
+export interface PaginationOptions {
+  limit?: number;
+  offset?: number;
+}

package/src/usage.ts

@@ -0,0 +1,24 @@
+import type { HttpClient } from "./http";
+import type {
+  CoregitResult,
+  PaginationOptions,
+  UsageDetailsResponse,
+  UsageSummary,
+} from "./types";
+
+export class UsageClient {
+  constructor(private http: HttpClient) {}
+
+  summary(period?: string): Promise<CoregitResult<UsageSummary>> {
+    const qs = period ? `?period=${encodeURIComponent(period)}` : "";
+    return this.http.request<UsageSummary>("GET", `/v1/usage${qs}`);
+  }
+
+  details(opts?: PaginationOptions): Promise<CoregitResult<UsageDetailsResponse>> {
+    const params = new URLSearchParams();
+    if (opts?.limit !== undefined) params.set("limit", String(opts.limit));
+    if (opts?.offset !== undefined) params.set("offset", String(opts.offset));
+    const qs = params.toString();
+    return this.http.request<UsageDetailsResponse>("GET", `/v1/usage/details${qs ? `?${qs}` : ""}`);
+  }
+}