@illuma-ai/code-sandbox 1.0.0

package/src/services/git.ts

@@ -0,0 +1,415 @@
+/**
+ * GitService — GitHub API integration for loading and saving project files.
+ *
+ * Flow:
+ * - Clone: GET repo tree → GET file contents → return FileMap
+ * - Commit: POST branch → PUT files → POST PR
+ *
+ * All operations use the GitHub REST API (no git CLI needed).
+ * Works entirely in the browser — no server required.
+ */
+
+import type {
+  FileMap,
+  GitCommitRequest,
+  GitHubRepo,
+  GitPRRequest,
+  GitPRResult,
+} from "../types";
+
+const GITHUB_API = "https://api.github.com";
+
+/** File extensions to treat as text (others are skipped) */
+const TEXT_EXTENSIONS = new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".json",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".xml",
+  ".svg",
+  ".env",
+  ".gitignore",
+  ".eslintrc",
+  ".prettierrc",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".php",
+  ".sql",
+  ".graphql",
+  ".lock",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".vue",
+  ".svelte",
+  ".astro",
+]);
+
+/** Directories to skip when cloning */
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "coverage",
+  ".nyc_output",
+]);
+
+/** Max file size to fetch (skip large files) */
+const MAX_FILE_SIZE = 500_000; // 500KB
+
+/**
+ * GitHub API service for cloning repos and creating PRs.
+ *
+ * @example
+ * ```ts
+ * const git = new GitService('ghp_xxxxx');
+ * const files = await git.cloneRepo({ owner: 'user', repo: 'my-app' });
+ * // ... user edits files ...
+ * const pr = await git.createPR({
+ *   owner: 'user', repo: 'my-app',
+ *   branch: 'sandbox/changes', changes: editedFiles,
+ *   message: 'Update from sandbox', title: 'Sandbox changes',
+ * });
+ * ```
+ */
+export class GitService {
+  private token: string;
+
+  constructor(token: string) {
+    this.token = token;
+  }
+
+  // -------------------------------------------------------------------------
+  // Clone: fetch repo files as a FileMap
+  // -------------------------------------------------------------------------
+
+  /**
+   * Clone a GitHub repository into a flat file map.
+   *
+   * Uses the Git Trees API for a single request to get the full file listing,
+   * then fetches text file contents in parallel batches.
+   *
+   * @param repo - GitHub repository coordinates
+   * @param onProgress - Optional progress callback (0-100)
+   * @returns FileMap of path → content
+   */
+  async cloneRepo(
+    repo: GitHubRepo,
+    onProgress?: (percent: number, message: string) => void,
+  ): Promise<FileMap> {
+    const { owner, repo: repoName, branch = "main", path: subPath } = repo;
+
+    onProgress?.(5, "Fetching repository structure...");
+
+    // 1. Get the tree (recursive) for the branch
+    const treeUrl = `${GITHUB_API}/repos/${owner}/${repoName}/git/trees/${branch}?recursive=1`;
+    const treeRes = await this.fetch(treeUrl);
+    const treeData = await treeRes.json();
+
+    if (!treeData.tree) {
+      throw new Error(
+        `Failed to fetch repo tree: ${treeData.message || "Unknown error"}`,
+      );
+    }
+
+    // 2. Filter to text files, skip large/binary/excluded dirs
+    const filesToFetch: Array<{ path: string; sha: string; size: number }> = [];
+
+    for (const item of treeData.tree) {
+      if (item.type !== "blob") {
+        continue;
+      }
+
+      // Apply subPath filter if specified
+      if (subPath && !item.path.startsWith(subPath)) {
+        continue;
+      }
+
+      // Skip excluded directories
+      const parts = item.path.split("/");
+      if (parts.some((p: string) => SKIP_DIRS.has(p))) {
+        continue;
+      }
+
+      // Skip files that are too large
+      if (item.size > MAX_FILE_SIZE) {
+        continue;
+      }
+
+      // Only include text files
+      const ext = "." + item.path.split(".").pop()?.toLowerCase();
+      const basename = parts[parts.length - 1];
+      // Include files with known extensions, dotfiles, or extensionless config files
+      if (
+        TEXT_EXTENSIONS.has(ext) ||
+        basename.startsWith(".") ||
+        !basename.includes(".")
+      ) {
+        filesToFetch.push({ path: item.path, sha: item.sha, size: item.size });
+      }
+    }
+
+    onProgress?.(15, `Found ${filesToFetch.length} files to fetch...`);
+
+    // 3. Fetch file contents in parallel batches
+    const files: FileMap = {};
+    const batchSize = 20;
+
+    for (let i = 0; i < filesToFetch.length; i += batchSize) {
+      const batch = filesToFetch.slice(i, i + batchSize);
+
+      const results = await Promise.all(
+        batch.map(async (file) => {
+          try {
+            const contentUrl = `${GITHUB_API}/repos/${owner}/${repoName}/contents/${file.path}?ref=${branch}`;
+            const res = await this.fetch(contentUrl);
+            const data = await res.json();
+
+            if (data.encoding === "base64" && data.content) {
+              const content = atob(data.content.replace(/\n/g, ""));
+              // Strip subPath prefix if specified
+              const relativePath = subPath
+                ? file.path.replace(new RegExp(`^${subPath}/?`), "")
+                : file.path;
+              return { path: relativePath, content };
+            }
+            return null;
+          } catch {
+            return null;
+          }
+        }),
+      );
+
+      for (const result of results) {
+        if (result) {
+          files[result.path] = result.content;
+        }
+      }
+
+      const percent =
+        15 + Math.round(((i + batch.length) / filesToFetch.length) * 80);
+      onProgress?.(
+        percent,
+        `Fetching files... (${Math.min(i + batchSize, filesToFetch.length)}/${filesToFetch.length})`,
+      );
+    }
+
+    onProgress?.(100, `Loaded ${Object.keys(files).length} files`);
+
+    return files;
+  }
+
+  // -------------------------------------------------------------------------
+  // Commit + PR: write changes back to GitHub
+  // -------------------------------------------------------------------------
+
+  /**
+   * Create a new branch with file changes and open a pull request.
+   *
+   * Steps:
+   * 1. Get the base branch's HEAD SHA
+   * 2. Create a new branch from that SHA
+   * 3. For each changed file, update its contents on the new branch
+   * 4. Create a pull request
+   */
+  async createPR(request: GitPRRequest): Promise<GitPRResult> {
+    const {
+      owner,
+      repo,
+      branch,
+      baseBranch = "main",
+      changes,
+      message,
+      title,
+      body,
+    } = request;
+
+    // 1. Get base branch HEAD SHA
+    const refRes = await this.fetch(
+      `${GITHUB_API}/repos/${owner}/${repo}/git/ref/heads/${baseBranch}`,
+    );
+    const refData = await refRes.json();
+    const baseSha = refData.object.sha;
+
+    // 2. Create new branch
+    await this.fetch(`${GITHUB_API}/repos/${owner}/${repo}/git/refs`, {
+      method: "POST",
+      body: JSON.stringify({
+        ref: `refs/heads/${branch}`,
+        sha: baseSha,
+      }),
+    });
+
+    // 3. Commit each changed file
+    for (const [path, content] of Object.entries(changes)) {
+      // Get current file SHA (if it exists)
+      let fileSha: string | undefined;
+      try {
+        const fileRes = await this.fetch(
+          `${GITHUB_API}/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+        );
+        const fileData = await fileRes.json();
+        fileSha = fileData.sha;
+      } catch {
+        // File doesn't exist yet — that's fine, we'll create it
+      }
+
+      await this.fetch(
+        `${GITHUB_API}/repos/${owner}/${repo}/contents/${path}`,
+        {
+          method: "PUT",
+          body: JSON.stringify({
+            message,
+            content: btoa(content),
+            branch,
+            ...(fileSha ? { sha: fileSha } : {}),
+          }),
+        },
+      );
+    }
+
+    // 4. Create pull request
+    const prRes = await this.fetch(
+      `${GITHUB_API}/repos/${owner}/${repo}/pulls`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          title,
+          body:
+            body ||
+            `Changes from code sandbox.\n\nModified files:\n${Object.keys(
+              changes,
+            )
+              .map((p) => `- ${p}`)
+              .join("\n")}`,
+          head: branch,
+          base: baseBranch,
+        }),
+      },
+    );
+
+    const prData = await prRes.json();
+
+    return {
+      number: prData.number,
+      url: prData.html_url,
+      branch,
+    };
+  }
+
+  /**
+   * Commit changes without creating a PR.
+   */
+  async commit(request: GitCommitRequest): Promise<string> {
+    const {
+      owner,
+      repo,
+      branch,
+      baseBranch = "main",
+      changes,
+      message,
+    } = request;
+
+    // Get base SHA
+    const refRes = await this.fetch(
+      `${GITHUB_API}/repos/${owner}/${repo}/git/ref/heads/${baseBranch}`,
+    );
+    const refData = await refRes.json();
+    const baseSha = refData.object.sha;
+
+    // Create branch (may already exist)
+    try {
+      await this.fetch(`${GITHUB_API}/repos/${owner}/${repo}/git/refs`, {
+        method: "POST",
+        body: JSON.stringify({ ref: `refs/heads/${branch}`, sha: baseSha }),
+      });
+    } catch {
+      // Branch already exists — continue
+    }
+
+    // Commit files
+    for (const [path, content] of Object.entries(changes)) {
+      let fileSha: string | undefined;
+      try {
+        const fileRes = await this.fetch(
+          `${GITHUB_API}/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+        );
+        const fileData = await fileRes.json();
+        fileSha = fileData.sha;
+      } catch {
+        // New file
+      }
+
+      await this.fetch(
+        `${GITHUB_API}/repos/${owner}/${repo}/contents/${path}`,
+        {
+          method: "PUT",
+          body: JSON.stringify({
+            message,
+            content: btoa(content),
+            branch,
+            ...(fileSha ? { sha: fileSha } : {}),
+          }),
+        },
+      );
+    }
+
+    return branch;
+  }
+
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+
+  /** Fetch with auth headers */
+  private async fetch(url: string, init?: RequestInit): Promise<Response> {
+    const res = await fetch(url, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/vnd.github.v3+json",
+        "Content-Type": "application/json",
+        ...(init?.headers || {}),
+      },
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`GitHub API error ${res.status}: ${body}`);
+    }
+
+    return res;
+  }
+}