trident-git 0.2.0

package/src/app/api/git/diff/route.ts

@@ -0,0 +1,104 @@
+import { NextResponse } from 'next/server';
+import { GitService } from '@/lib/git';
+import { getImageMimeType, isImageFile } from '@/lib/utils';
+import { handleGitError } from '@/lib/api-utils';
+import fs from 'node:fs';
+import pathLib from 'path';
+
+function toImageSide(buffer: Buffer | null, mimeType: string) {
+  if (!buffer) return null;
+  return {
+    mimeType,
+    base64: buffer.toString('base64'),
+  };
+}
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const repoPath = searchParams.get('path');
+  const filePath = searchParams.get('file');
+  const commitHash = searchParams.get('commit');
+
+  if (!repoPath) {
+    return NextResponse.json({ error: 'Repo path is required' }, { status: 400 });
+  }
+
+  // Check if path exists
+  if (!fs.existsSync(repoPath)) {
+    return NextResponse.json({ error: `Path not found: ${repoPath}` }, { status: 404 });
+  }
+
+  try {
+    const git = new GitService(repoPath);
+
+    // If commit hash is provided, get commit diff
+    if (commitHash) {
+      // If file path is also provided, get diff for that specific file in the commit
+      if (filePath) {
+        if (isImageFile(filePath)) {
+          const mimeType = getImageMimeType(filePath);
+          const [beforeBuffer, afterBuffer, diff] = await Promise.all([
+            git.getFileContentBuffer(filePath, `${commitHash}^`),
+            git.getFileContentBuffer(filePath, commitHash),
+            git.getCommitFilePatch(commitHash, filePath),
+          ]);
+
+          return NextResponse.json({
+            left: '',
+            right: '',
+            diff,
+            imageDiff: {
+              left: toImageSide(beforeBuffer, mimeType),
+              right: toImageSide(afterBuffer, mimeType),
+            },
+          });
+        }
+
+        const { before, after, diff } = await git.getCommitFileDiff(commitHash, filePath);
+        return NextResponse.json({ left: before, right: after, diff });
+      }
+      
+      // Otherwise, get the list of files changed in the commit
+      const { files, diff } = await git.getCommitDiff(commitHash);
+      return NextResponse.json({ files, diff });
+    }
+
+    // Original behavior: diff against working directory
+    if (!filePath) {
+      return NextResponse.json({ error: 'File path is required' }, { status: 400 });
+    }
+
+    const diff = await git.getDiff(filePath);
+
+    if (isImageFile(filePath)) {
+      const mimeType = getImageMimeType(filePath);
+      const fullPath = pathLib.join(repoPath, filePath);
+      const [leftBuffer, rightBuffer] = await Promise.all([
+        git.getFileContentBuffer(filePath, 'HEAD'),
+        fs.existsSync(fullPath) ? fs.promises.readFile(fullPath) : Promise.resolve(null),
+      ]);
+
+      return NextResponse.json({
+        diff,
+        left: '',
+        right: '',
+        imageDiff: {
+          left: toImageSide(leftBuffer, mimeType),
+          right: toImageSide(rightBuffer, mimeType),
+        },
+      });
+    }
+
+    // Get content for Diff Viewer
+    const left = await git.getFileContent(filePath, 'HEAD');
+    let right = '';
+    const fullPath = pathLib.join(repoPath, filePath);
+    if (fs.existsSync(fullPath)) {
+      right = await fs.promises.readFile(fullPath, 'utf-8');
+    }
+
+    return NextResponse.json({ diff, left, right });
+  } catch (error) {
+    return handleGitError(error);
+  }
+}

package/src/app/api/git/log/route.ts

@@ -0,0 +1,28 @@
+
+import { NextResponse } from 'next/server';
+import { GitService } from '@/lib/git';
+import { handleGitError } from '@/lib/api-utils';
+import fs from 'node:fs';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const path = searchParams.get('path');
+  const limit = searchParams.get('limit');
+
+  if (!path) {
+    return NextResponse.json({ error: 'Repo path is required' }, { status: 400 });
+  }
+
+  // Check if path exists
+  if (!fs.existsSync(path)) {
+    return NextResponse.json({ error: `Path not found: ${path}` }, { status: 404 });
+  }
+
+  try {
+    const git = new GitService(path);
+    const log = await git.getLog(limit ? parseInt(limit) : 50);
+    return NextResponse.json(log);
+  } catch (error) {
+    return handleGitError(error);
+  }
+}

package/src/app/api/git/status/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+import { GitService } from '@/lib/git';
+import { handleGitError } from '@/lib/api-utils';
+import fs from 'node:fs/promises';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const path = searchParams.get('path');
+
+  if (!path) {
+    return NextResponse.json({ error: 'Repo path is required' }, { status: 400 });
+  }
+
+  // Check if path exists
+  try {
+    await fs.access(path);
+  } catch {
+    return NextResponse.json({ error: `Path not found: ${path}` }, { status: 404 });
+  }
+
+  try {
+    const git = new GitService(path);
+    const status = await git.getStatus();
+    return NextResponse.json(status);
+  } catch (error) {
+    return handleGitError(error);
+  }
+}

package/src/app/api/repos/route.ts

@@ -0,0 +1,84 @@
+
+import { NextResponse } from 'next/server';
+import { getRepositories, addRepository, updateRepository, removeRepository } from '@/lib/store';
+import { z } from 'zod';
+
+const customScriptSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  target: z.literal('branch'),
+  action: z.literal('run-bash-script'),
+  content: z.string(),
+});
+
+export async function GET() {
+  const repos = getRepositories();
+  return NextResponse.json(repos);
+}
+
+const addRepoSchema = z.object({
+  path: z.string().min(1),
+  name: z.string().optional(),
+  displayName: z.string().nullable().optional(),
+});
+
+const updateRepoSchema = z.object({
+  path: z.string().min(1),
+  updates: z.object({
+    name: z.string().optional(),
+    displayName: z.string().nullable().optional(),
+    lastOpenedAt: z.string().optional(),
+    credentialId: z.string().optional().nullable(),
+    customScripts: z.array(customScriptSchema).optional(),
+    expandedFolders: z.array(z.string()).optional(),
+    visibilityMap: z.record(z.string(), z.enum(['visible', 'hidden'])).optional(),
+    localGroupExpanded: z.boolean().optional(),
+    remotesGroupExpanded: z.boolean().optional(),
+  }),
+});
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { path, name, displayName } = addRepoSchema.parse(body);
+    const repo = addRepository(path, name, displayName);
+    return NextResponse.json(repo);
+  } catch (error) {
+     if (error instanceof z.ZodError) {
+        return NextResponse.json({ error: error.issues }, { status: 400 });
+     }
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json();
+    const { path, updates } = updateRepoSchema.parse(body);
+    const repo = updateRepository(path, updates);
+    return NextResponse.json(repo);
+  } catch (error) {
+     if (error instanceof z.ZodError) {
+        return NextResponse.json({ error: error.issues }, { status: 400 });
+     }
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}
+
+const deleteRepoSchema = z.object({
+  path: z.string().min(1),
+});
+
+export async function DELETE(request: Request) {
+  try {
+    const body = await request.json();
+    const { path } = deleteRepoSchema.parse(body);
+    removeRepository(path);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 });
+    }
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}

package/src/app/api/settings/route.ts

@@ -0,0 +1,37 @@
+
+import { NextResponse } from 'next/server';
+import { getSettings, updateSettings, getDefaultRootFolder } from '@/lib/store';
+import { z } from 'zod';
+
+export async function GET() {
+  const settings = getSettings();
+  const resolvedDefaultFolder = getDefaultRootFolder();
+  return NextResponse.json({
+    ...settings,
+    resolvedDefaultFolder, // The actual folder that will be used (after fallback logic)
+  });
+}
+
+const updateSettingsSchema = z.object({
+  defaultRootFolder: z.string().nullable().optional(),
+  sidebarCollapsed: z.boolean().optional(),
+  historyPanelHeight: z.number().optional(),
+});
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json();
+    const updates = updateSettingsSchema.parse(body);
+    const settings = updateSettings(updates);
+    const resolvedDefaultFolder = getDefaultRootFolder();
+    return NextResponse.json({
+      ...settings,
+      resolvedDefaultFolder,
+    });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 });
+    }
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}