tower-studio 0.1.1 → 0.1.3

package/src/lib/diff-parser.ts

@@ -0,0 +1,132 @@
+import { execFileSync } from "child_process";
+
+export interface DiffFile {
+  filename: string;
+  added: number;
+  removed: number;
+  isBinary: boolean;
+  patch: string; // unified diff content for this file
+}
+
+export interface DiffResponse {
+  files: DiffFile[];
+  totalAdded: number;
+  totalRemoved: number;
+  hasConflicts: boolean;
+  conflictFiles: string[];
+}
+
+/**
+ * Parse git diff --numstat and git diff --unified=3 output into structured DiffFile array.
+ * Returns data without hasConflicts/conflictFiles (those are added by the caller).
+ */
+export function parseDiffOutput(
+  numstat: string,
+  unifiedDiff: string
+): Omit<DiffResponse, "hasConflicts" | "conflictFiles"> {
+  // Parse numstat: each line is `{added}\t{removed}\t{filename}`
+  // Binary files have `-\t-\t{filename}`
+  const numstatEntries: Array<{
+    filename: string;
+    added: number;
+    removed: number;
+    isBinary: boolean;
+  }> = [];
+
+  for (const line of numstat.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split("\t");
+    if (parts.length < 3) continue;
+    const [addedStr, removedStr, ...filenameParts] = parts;
+    const filename = filenameParts.join("\t");
+    if (addedStr === "-" && removedStr === "-") {
+      numstatEntries.push({ filename, added: 0, removed: 0, isBinary: true });
+    } else {
+      numstatEntries.push({
+        filename,
+        added: parseInt(addedStr, 10) || 0,
+        removed: parseInt(removedStr, 10) || 0,
+        isBinary: false,
+      });
+    }
+  }
+
+  // Parse unified diff: split on lines matching `^diff --git a/.+ b/.+`
+  const DIFF_GIT_HEADER = /^diff --git a\/.+ b\/.+$/m;
+  const diffHeaderRegex = /^diff --git a\/(.+) b\/(.+)$/;
+
+  // Split into segments per file
+  const patchMap = new Map<string, string>();
+
+  if (unifiedDiff.trim()) {
+    const isTruncationNeeded = unifiedDiff.length > 500 * 1024; // 500KB
+
+    // Split at each diff --git header line
+    const segments = unifiedDiff.split(/(?=^diff --git )/m);
+    for (const segment of segments) {
+      if (!segment.trim()) continue;
+      const firstLine = segment.split("\n")[0];
+      const match = diffHeaderRegex.exec(firstLine);
+      if (!match) continue;
+      const filename = match[2]; // Use b/ filename
+
+      let patch = segment;
+      if (isTruncationNeeded) {
+        const lines = segment.split("\n");
+        if (lines.length > 200) {
+          patch = lines.slice(0, 200).join("\n") + "\n... (truncated)";
+        }
+      }
+      patchMap.set(filename, patch);
+    }
+  }
+
+  // Match numstat entries to unified diff segments by filename
+  const files: DiffFile[] = numstatEntries.map((entry) => ({
+    filename: entry.filename,
+    added: entry.added,
+    removed: entry.removed,
+    isBinary: entry.isBinary,
+    patch: patchMap.get(entry.filename) ?? "",
+  }));
+
+  const totalAdded = files.reduce((sum, f) => sum + f.added, 0);
+  const totalRemoved = files.reduce((sum, f) => sum + f.removed, 0);
+
+  return { files, totalAdded, totalRemoved };
+}
+
+/**
+ * Check if merging worktreeBranch into baseBranch would produce conflicts.
+ * Uses `git merge-tree --write-tree` for a dry-run conflict check.
+ */
+export function checkConflicts(
+  localPath: string,
+  baseBranch: string,
+  worktreeBranch: string
+): { hasConflicts: boolean; conflictFiles: string[] } {
+  try {
+    execFileSync(
+      "git", ["merge-tree", "--write-tree", baseBranch, worktreeBranch],
+      { cwd: localPath, encoding: "utf-8", timeout: 10000, stdio: "pipe" }
+    );
+    return { hasConflicts: false, conflictFiles: [] };
+  } catch (err: unknown) {
+    // Exit code 1 means conflicts exist — parse stdout for CONFLICT lines
+    const output =
+      err instanceof Error && "stdout" in err
+        ? String((err as NodeJS.ErrnoException & { stdout?: string }).stdout ?? "")
+        : "";
+    const conflictFiles = output
+      .split("\n")
+      .filter((line) => line.includes("CONFLICT"))
+      .map((line) => {
+        // Lines look like: "CONFLICT (content): Merge conflict in path/to/file"
+        const match = line.match(/CONFLICT.*?:\s*(.+)$/);
+        return match ? match[1].trim() : line.trim();
+      })
+      .filter(Boolean);
+    return { hasConflicts: true, conflictFiles };
+  }
+}

package/src/lib/execution-summary.ts

@@ -0,0 +1,287 @@
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { db } from "@/lib/db";
+import { generateSummaryFromLog, generateDreamingInsight, type DreamingResult } from "@/lib/claude-session";
+
+const TERMINAL_LOG_MAX = 10 * 1024; // 10 KB
+
+/** Format dreaming insights into readable Markdown content */
+function formatDreamingContent(dream: DreamingResult): string {
+  const lines: string[] = [];
+  lines.push("## Summary");
+  lines.push(dream.summary);
+  lines.push("");
+
+  if (dream.insights.length > 0) {
+    lines.push("## Insights");
+    for (const insight of dream.insights) {
+      lines.push(`- **[${insight.type}]**: ${insight.content}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+interface GitStats {
+  commits: number;
+  filesChanged: number;
+  insertions: number;
+  deletions: number;
+}
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    timeout: 10_000,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+  }).trim();
+}
+
+function getMergeBase(cwd: string): string | null {
+  // Try common base branch names
+  for (const base of ["main", "master", "develop"]) {
+    try {
+      return runGit(["merge-base", "HEAD", base], cwd);
+    } catch {
+      // branch doesn't exist, try next
+    }
+  }
+  return null;
+}
+
+function captureGitLog(cwd: string): string | null {
+  try {
+    const mergeBase = getMergeBase(cwd);
+    if (mergeBase) {
+      const log = runGit(["log", "--oneline", `${mergeBase}..HEAD`], cwd);
+      if (log) return log;
+    }
+    // Fallback: last 3 commits
+    return runGit(["log", "--oneline", "-3"], cwd) || null;
+  } catch {
+    return null;
+  }
+}
+
+function captureGitStats(cwd: string): GitStats | null {
+  try {
+    let diffOutput: string;
+    const mergeBase = getMergeBase(cwd);
+    if (mergeBase) {
+      diffOutput = runGit(["diff", "--stat", `${mergeBase}..HEAD`], cwd);
+    } else {
+      // Fallback
+      diffOutput = runGit(["diff", "--stat", "HEAD~20", "HEAD"], cwd);
+    }
+    if (!diffOutput) return null;
+    return parseDiffStat(diffOutput);
+  } catch {
+    return null;
+  }
+}
+
+function parseDiffStat(output: string): GitStats | null {
+  // Match the summary line: "5 files changed, 47 insertions(+), 12 deletions(-)"
+  const lines = output.split("\n");
+  const summaryLine = lines[lines.length - 1];
+  if (!summaryLine) return null;
+
+  const filesMatch = summaryLine.match(/(\d+)\s+files?\s+changed/);
+  const insertionsMatch = summaryLine.match(/(\d+)\s+insertions?\(\+\)/);
+  const deletionsMatch = summaryLine.match(/(\d+)\s+deletions?\(-\)/);
+
+  if (!filesMatch && !insertionsMatch && !deletionsMatch) return null;
+
+  return {
+    commits: 0, // filled in by caller
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+    deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0,
+  };
+}
+
+function buildSummary(gitLog: string | null): string | null {
+  if (!gitLog) return null;
+  const lines = gitLog.split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+
+  // Extract commit message (after the short hash)
+  const firstMessage = lines[0].replace(/^[a-f0-9]+\s+/, "");
+  if (lines.length === 1) return firstMessage;
+  return `${lines.length} commits: ${firstMessage}`;
+}
+
+/** Strip ANSI escape sequences, cursor control, and OSC sequences from terminal output */
+function stripAnsi(str: string): string {
+  return str
+    // OSC sequences (e.g. title set): ESC ] ... ST/BEL
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+    // CSI sequences (e.g. colors, cursor): ESC [ ... final_byte
+    .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "")
+    // Other ESC sequences
+    .replace(/\x1b[^[\]()][^\x1b]*/g, "")
+    // Bare control chars (except \n \r \t)
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+    // Collapse multiple blank lines
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function trimTerminalBuffer(buffer: string): string {
+  const clean = stripAnsi(buffer);
+  if (clean.length <= TERMINAL_LOG_MAX) return clean;
+  return clean.slice(clean.length - TERMINAL_LOG_MAX);
+}
+
+/**
+ * Capture an execution summary after a PTY session ends.
+ * This function is designed to never throw — all errors are caught and logged.
+ */
+export async function captureExecutionSummary(
+  executionId: string,
+  _taskId: string,
+  exitCode: number,
+  terminalBuffer: string,
+  worktreePath: string | null
+): Promise<void> {
+  try {
+    console.error(`[captureExecutionSummary] Starting: exec=${executionId.slice(0, 8)} exit=${exitCode} buffer=${terminalBuffer.length}chars worktree=${worktreePath}`);
+
+    let gitLog: string | null = null;
+    let gitStats: GitStats | null = null;
+    let summary: string | null = null;
+
+    // Capture git data if we have a valid git worktree
+    if (worktreePath && existsSync(worktreePath)) {
+      try {
+        // Verify it's a git repo
+        runGit(["rev-parse", "--git-dir"], worktreePath);
+
+        gitLog = captureGitLog(worktreePath);
+        gitStats = captureGitStats(worktreePath);
+
+        // Fill in commit count from gitLog
+        if (gitStats && gitLog) {
+          const commitCount = gitLog.split("\n").filter(Boolean).length;
+          gitStats = { ...gitStats, commits: commitCount };
+        }
+
+        summary = buildSummary(gitLog);
+      } catch {
+        // Not a git repo or git not available — continue without git data
+      }
+    }
+
+    const terminalLog = trimTerminalBuffer(terminalBuffer);
+
+    // sessionId is now reported by PostToolUse hook → /api/internal/hooks/session
+    // No need to scan ~/.claude/projects/ directory here
+
+    // Phase 1: Immediate save — git data + terminal log (no blocking)
+    await db.taskExecution.update({
+      where: { id: executionId },
+      data: {
+        summary: summary ?? (gitLog ? buildSummary(gitLog) : null),
+        gitLog: gitLog ?? null,
+        gitStats: gitStats ? JSON.stringify(gitStats) : null,
+        exitCode,
+        terminalLog: terminalLog || null,
+      },
+    });
+
+    // Phase 2: Background AI summary — fire and forget, updates DB when done
+    // Dreaming (Phase 3) moved to captureTaskDreaming() — runs only on task DONE
+    if (terminalLog && worktreePath) {
+      console.error("[captureExecutionSummary] Starting background AI summary...");
+      generateSummaryFromLog(terminalLog, worktreePath)
+        .then(async (aiSummary) => {
+          if (aiSummary) {
+            console.error(`[captureExecutionSummary] AI summary ready: ${aiSummary.slice(0, 80)}`);
+            await db.taskExecution.update({
+              where: { id: executionId },
+              data: { summary: aiSummary },
+            });
+          }
+        })
+        .catch((err: unknown) => {
+          console.error("[captureExecutionSummary] Background AI summary failed:", err);
+        });
+    }
+  } catch (err: unknown) {
+    console.error("[captureExecutionSummary] Failed to capture summary:", err);
+  }
+}
+
+/**
+ * Run dreaming analysis on a completed task. Called once when task status → DONE.
+ * Collects terminal logs from all executions and generates a single insight note.
+ * Fire-and-forget — never throws.
+ */
+export async function captureTaskDreaming(taskId: string): Promise<void> {
+  try {
+    // Get all executions for this task
+    const task = await db.task.findUnique({
+      where: { id: taskId },
+      select: {
+        projectId: true,
+        executions: {
+          orderBy: { createdAt: "desc" },
+          select: { id: true, terminalLog: true, worktreePath: true, summary: true },
+        },
+      },
+    });
+    if (!task || task.executions.length === 0) return;
+
+    // Combine terminal logs from all executions (most recent first, cap at 8000 chars)
+    let combinedLog = "";
+    let worktreePath: string | null = null;
+    const summaries: string[] = [];
+    for (const exec of task.executions) {
+      if (exec.terminalLog) {
+        combinedLog += exec.terminalLog + "\n---\n";
+      }
+      if (exec.summary) {
+        summaries.push(exec.summary);
+      }
+      if (!worktreePath && exec.worktreePath) {
+        worktreePath = exec.worktreePath;
+      }
+    }
+    combinedLog = combinedLog.slice(-8000);
+    if (!combinedLog.trim()) return;
+
+    const combinedSummary = summaries.join("\n");
+    const effectivePath = worktreePath || process.cwd();
+
+    console.error(`[captureTaskDreaming] Starting for task=${taskId.slice(0, 8)}, ${task.executions.length} executions`);
+
+    const dream = await generateDreamingInsight(combinedLog, effectivePath, combinedSummary);
+    if (!dream || !dream.shouldCreateNote) {
+      console.error("[captureTaskDreaming] No note needed");
+      return;
+    }
+
+    // Create ProjectNote
+    const note = await db.projectNote.create({
+      data: {
+        title: dream.noteTitle || dream.summary.slice(0, 50),
+        content: formatDreamingContent(dream),
+        category: "session-insight",
+        projectId: task.projectId,
+        taskId,
+      },
+    });
+
+    // Link to the latest execution
+    const latestExecId = task.executions[0].id;
+    await db.taskExecution.update({
+      where: { id: latestExecId },
+      data: { insightNoteId: note.id },
+    });
+
+    console.error(`[captureTaskDreaming] Note created: ${note.id}`);
+  } catch (err: unknown) {
+    console.error("[captureTaskDreaming] Failed:", err);
+  }
+}

package/src/lib/file-serve-client.ts

@@ -0,0 +1,13 @@
+/**
+ * Browser-safe utility for converting local asset paths to API URLs.
+ * No Node.js dependencies — safe to import from "use client" components.
+ */
+export function localPathToApiUrl(src: string): string {
+  // Match assets/{projectId}/{filename} under storage/ (.tower/storage/assets/...)
+  // Also supports legacy data/assets/ paths for backward compatibility
+  const match = src.match(/(?:^|\/)(?:storage|data)\/assets\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    return `/api/files/assets/${match[1]}/${match[2]}`;
+  }
+  return src;
+}

package/src/lib/file-serve.ts

@@ -0,0 +1,32 @@
+import * as path from "node:path";
+import { getStorageDir } from "./tower-dir";
+
+const DATA_ROOT = getStorageDir();
+
+export const MIME_MAP: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+};
+
+export function resolveAssetPath(
+  projectId: string,
+  filename: string
+): { resolved: string | null; error: string | null } {
+  const resolved = path.resolve(DATA_ROOT, "assets", projectId, filename);
+  const safePrefix = path.resolve(DATA_ROOT, "assets") + path.sep;
+  if (!resolved.startsWith(safePrefix)) {
+    return { resolved: null, error: "Invalid path" };
+  }
+  return { resolved, error: null };
+}
+
+// Re-export from browser-safe module for backward compatibility
+export { localPathToApiUrl } from "./file-serve-client";

package/src/lib/file-utils.ts

@@ -0,0 +1,108 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getStorageDir } from "./tower-dir";
+
+const DATA_ROOT = getStorageDir();
+
+function assertWithinDataRoot(resolved: string): void {
+  if (!resolved.startsWith(DATA_ROOT + path.sep)) {
+    throw new Error("Path traversal detected");
+  }
+}
+
+export function getAssetsDir(projectId: string): string {
+  const dir = path.join(DATA_ROOT, "assets", projectId);
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+export function getCacheDir(taskId: string): string {
+  const dir = path.join(DATA_ROOT, "cache", taskId);
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+export function ensureAssetsDir(projectId: string): string {
+  const dir = getAssetsDir(projectId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function ensureCacheDir(taskId: string): string {
+  const dir = getCacheDir(taskId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function listAssetFiles(projectId: string): string[] {
+  const dir = getAssetsDir(projectId);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir);
+}
+
+export type CacheFileType = "images" | "files";
+
+export function getAssistantCacheDir(type: CacheFileType = "images"): string {
+  const now = new Date();
+  const ym = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+  const dir = path.join(DATA_ROOT, "cache", "assistant", ym, type);
+  assertWithinDataRoot(dir);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getAssistantCacheRoot(): string {
+  const dir = path.join(DATA_ROOT, "cache", "assistant");
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+const MEANINGLESS_STEMS = new Set([
+  "image", "screenshot", "img", "photo", "picture",
+  "clipboard", "paste", "untitled",
+]);
+
+export function buildCacheFilename(originalName: string, ext: string): string {
+  const stem = path.basename(originalName, path.extname(originalName));
+  const uuid8 = crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+
+  const stemLower = stem.toLowerCase();
+  const isMeaningless =
+    !stem ||
+    MEANINGLESS_STEMS.has(stemLower) ||
+    /^screenshot[\s_\-]/i.test(stem);
+
+  if (isMeaningless) {
+    return `tower_image-${uuid8}${ext}`;
+  }
+
+  const sanitized = stem
+    .replace(/[^\p{L}\p{N}]/gu, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+
+  const safeStem = sanitized || "file";
+  return `${safeStem}-${uuid8}${ext}`;
+}
+
+const CACHE_UUID_SUFFIX_RE = /-([0-9a-f]{8})(\.[^.]+)$/i;
+
+/**
+ * Strip the 8-hex UUID suffix added by buildCacheFilename.
+ * e.g. "设计稿-a1b2c3d4.png" → "设计稿.png"
+ *      "tower_image-a1b2c3d4.png" → "tower_image.png"
+ *      "already-clean.png" → "already-clean.png" (no change)
+ */
+export function stripCacheUuidSuffix(filename: string): string {
+  return filename.replace(CACHE_UUID_SUFFIX_RE, "$2");
+}
+
+/**
+ * Returns true if the absolute filePath is inside the assistant cache root.
+ * Used to gate UUID stripping — only strip for cache files.
+ */
+export function isAssistantCachePath(filePath: string): boolean {
+  const root = getAssistantCacheRoot();
+  return filePath.startsWith(root + path.sep);
+}

package/src/lib/fs-security.ts

@@ -0,0 +1,22 @@
+import path from "path";
+
+/**
+ * Validates that `relative` resolves to a path within `base`.
+ * Prevents path traversal attacks (e.g., ../../etc/passwd).
+ * Per D-02: used by all file operation server actions in Phase 20 and Phase 21 editor.
+ *
+ * @param base - Absolute base directory (the worktree root)
+ * @param relative - Relative path provided by client
+ * @returns Resolved absolute path guaranteed to be within base
+ * @throws Error if path escapes the base directory
+ */
+export function safeResolvePath(base: string, relative: string): string {
+  // Normalize base to remove trailing separator for consistent comparison
+  const normalizedBase = base.endsWith(path.sep) ? base.slice(0, -1) : base;
+  const resolved = path.resolve(normalizedBase, relative);
+  // Allow exact match (relative = "." resolves to base itself)
+  if (resolved !== normalizedBase && !resolved.startsWith(normalizedBase + path.sep)) {
+    throw new Error(`Path traversal attempt: ${relative}`);
+  }
+  return resolved;
+}

package/src/lib/fts.ts

@@ -0,0 +1,83 @@
+// src/lib/fts.ts — NO Next.js imports
+// FTS5 search helper and sync functions for notes_fts virtual table.
+// Accepts PrismaClient as a parameter (dependency injection) so it is safe
+// for both Next.js server actions and MCP stdio processes.
+import type { PrismaClient } from "@prisma/client";
+
+export interface FtsNoteResult {
+  note_id: string;
+  title: string;
+  content: string;
+}
+
+/**
+ * Search notes for a project using FTS5 (3+ chars) or LIKE fallback (< 3 chars).
+ * Returns an empty array for blank queries.
+ */
+export async function searchNotes(
+  db: PrismaClient,
+  projectId: string,
+  query: string
+): Promise<FtsNoteResult[]> {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+
+  if (trimmed.length < 3) {
+    // Fallback: LIKE search on the regular note table (FTS5 trigram needs 3+ chars)
+    return db.$queryRawUnsafe<FtsNoteResult[]>(
+      `SELECT id as note_id, title, content FROM "ProjectNote"
+       WHERE "projectId" = ? AND (title LIKE ? OR content LIKE ?)
+       LIMIT 20`,
+      projectId,
+      `%${trimmed}%`,
+      `%${trimmed}%`
+    );
+  }
+
+  // FTS5 trigram search (3+ chars)
+  return db.$queryRawUnsafe<FtsNoteResult[]>(
+    `SELECT f.note_id, f.title, f.content
+     FROM notes_fts f
+     JOIN "ProjectNote" n ON n.id = f.note_id
+     WHERE f.notes_fts MATCH ? AND n."projectId" = ?
+     ORDER BY rank
+     LIMIT 20`,
+    trimmed,
+    projectId
+  );
+}
+
+/**
+ * Insert or replace a note in the notes_fts virtual table.
+ * Performs delete-then-insert to avoid duplicate FTS rows on update.
+ */
+export async function syncNoteToFts(
+  db: PrismaClient,
+  note: { id: string; title: string; content: string }
+): Promise<void> {
+  // Delete existing entry if any, then insert fresh
+  await db.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    note.id
+  );
+  await db.$executeRawUnsafe(
+    "INSERT INTO notes_fts(note_id, title, content) VALUES (?, ?, ?)",
+    note.id,
+    note.title,
+    note.content
+  );
+}
+
+/**
+ * Remove a note from the notes_fts virtual table.
+ * Safe to call even if the note was never indexed.
+ */
+export async function deleteNoteFromFts(
+  db: PrismaClient,
+  noteId: string
+): Promise<void> {
+  await db.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    noteId
+  );
+}

package/src/lib/git-api.ts

@@ -0,0 +1,19 @@
+/**
+ * Client-side helper for calling the git API.
+ */
+export async function gitAction(
+  path: string,
+  action: string,
+  extra: Record<string, unknown> = {}
+) {
+  const res = await fetch("/api/git", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ action, path, ...extra }),
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    throw new Error(err.error || `${action} failed`);
+  }
+  return res.json();
+}