@atercates/claude-deck 0.2.1

package/app/api/files/content/route.ts

@@ -0,0 +1,76 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFileContent, writeFileContent } from "@/lib/files";
+
+/**
+ * GET /api/files/content?path=...
+ * Read file contents
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Path parameter is required" },
+        { status: 400 }
+      );
+    }
+
+    // Expand ~ to home directory
+    const expandedPath = path.replace(/^~/, process.env.HOME || "");
+
+    const result = readFileContent(expandedPath);
+
+    return NextResponse.json({
+      ...result,
+      path: expandedPath,
+    });
+  } catch (error) {
+    console.error("Error reading file:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to read file" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/files/content
+ * Write file contents
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path, content } = body;
+
+    if (!path) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    if (content === undefined) {
+      return NextResponse.json(
+        { error: "Content is required" },
+        { status: 400 }
+      );
+    }
+
+    // Expand ~ to home directory
+    const expandedPath = path.replace(/^~/, process.env.HOME || "");
+
+    const result = writeFileContent(expandedPath, content);
+
+    return NextResponse.json({
+      ...result,
+      path: expandedPath,
+    });
+  } catch (error) {
+    console.error("Error writing file:", error);
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Failed to write file",
+      },
+      { status: 500 }
+    );
+  }
+}

package/app/api/files/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listDirectory } from "@/lib/files";
+
+/**
+ * GET /api/files?path=...&recursive=true
+ * List directory contents
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+    const recursive = searchParams.get("recursive") === "true";
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Path parameter is required" },
+        { status: 400 }
+      );
+    }
+
+    // Expand ~ to home directory
+    const expandedPath = path.replace(/^~/, process.env.HOME || "");
+
+    const files = listDirectory(expandedPath, {
+      recursive,
+      maxDepth: recursive ? 2 : 1,
+    });
+
+    return NextResponse.json({ files, path: expandedPath });
+  } catch (error) {
+    console.error("Error listing directory:", error);
+    return NextResponse.json(
+      { error: "Failed to list directory" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/files/upload-temp/route.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+export async function POST(request: Request) {
+  try {
+    const { filename, base64, mimeType } = await request.json();
+
+    if (!base64) {
+      return NextResponse.json({ error: "No image data" }, { status: 400 });
+    }
+
+    // Create temp directory for screenshots if it doesn't exist
+    const tempDir = path.join(os.tmpdir(), "claude-deck-screenshots");
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+
+    // Generate unique filename
+    const ext = mimeType?.split("/")[1] || "png";
+    const safeName = filename?.replace(/[^a-zA-Z0-9.-]/g, "_") || "screenshot";
+    const uniqueName = `${Date.now()}-${safeName}`;
+    const finalName = uniqueName.endsWith(`.${ext}`)
+      ? uniqueName
+      : `${uniqueName}.${ext}`;
+    const filePath = path.join(tempDir, finalName);
+
+    // Decode base64 and write file
+    const buffer = Buffer.from(base64, "base64");
+    fs.writeFileSync(filePath, buffer);
+
+    return NextResponse.json({ path: filePath });
+  } catch (error) {
+    console.error("Upload error:", error);
+    return NextResponse.json(
+      { error: "Failed to save image" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/check/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  isGitRepo,
+  getBranches,
+  getDefaultBranch,
+  getCurrentBranch,
+} from "@/lib/git";
+
+/**
+ * POST /api/git/check
+ * Check if a path is a git repository and return branch info
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path: dirPath } = body;
+
+    if (!dirPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    // Check if it's a git repo
+    const isRepo = await isGitRepo(dirPath);
+
+    if (!isRepo) {
+      return NextResponse.json({
+        isGitRepo: false,
+        branches: [],
+        defaultBranch: null,
+        currentBranch: null,
+      });
+    }
+
+    // Get branch info
+    const [branches, defaultBranch, currentBranch] = await Promise.all([
+      getBranches(dirPath),
+      getDefaultBranch(dirPath),
+      getCurrentBranch(dirPath),
+    ]);
+
+    return NextResponse.json({
+      isGitRepo: true,
+      branches,
+      defaultBranch,
+      currentBranch,
+    });
+  } catch (error) {
+    console.error("Error checking git repo:", error);
+    return NextResponse.json(
+      { error: "Failed to check git repository" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/clone/route.ts

@@ -0,0 +1,99 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as path from "path";
+import * as fs from "fs/promises";
+
+const execAsync = promisify(exec);
+
+/**
+ * POST /api/git/clone
+ * Clone a git repository into a target directory
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { url, directory } = body;
+
+    if (!url) {
+      return NextResponse.json(
+        { error: "Repository URL is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!directory) {
+      return NextResponse.json(
+        { error: "Target directory is required" },
+        { status: 400 }
+      );
+    }
+
+    // Resolve ~ to home directory
+    const resolvedDir = directory.replace(/^~/, process.env.HOME || "");
+
+    // Verify parent directory exists
+    try {
+      await fs.access(resolvedDir);
+    } catch {
+      return NextResponse.json(
+        { error: `Directory does not exist: ${directory}` },
+        { status: 400 }
+      );
+    }
+
+    // Extract repo name from URL for the clone target
+    const repoName = extractRepoName(url);
+    if (!repoName) {
+      return NextResponse.json(
+        { error: "Could not determine repository name from URL" },
+        { status: 400 }
+      );
+    }
+
+    const clonePath = path.join(resolvedDir, repoName);
+
+    // Check if target already exists
+    try {
+      await fs.access(clonePath);
+      return NextResponse.json(
+        { error: `Directory already exists: ${clonePath}` },
+        { status: 409 }
+      );
+    } catch {
+      // Good - doesn't exist yet
+    }
+
+    // Clone the repository
+    const { stderr } = await execAsync(`git clone "${url}" "${clonePath}"`, {
+      timeout: 120000,
+    });
+
+    // git clone outputs progress to stderr, not an error
+    if (stderr && stderr.includes("fatal:")) {
+      return NextResponse.json({ error: stderr.trim() }, { status: 500 });
+    }
+
+    return NextResponse.json({
+      path: clonePath,
+      name: repoName,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to clone repository";
+    console.error("Error cloning repository:", message);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+function extractRepoName(url: string): string | null {
+  // https://github.com/user/repo.git or https://github.com/user/repo
+  // git@github.com:user/repo.git
+  const match = url.match(
+    /(?:[\w.-]+\/([\w.-]+?)(?:\.git)?$|:([\w.-]+\/)([\w.-]+?)(?:\.git)?$)/
+  );
+  if (match) {
+    return match[1] || match[3] || null;
+  }
+  return null;
+}

package/app/api/git/commit/route.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  commit,
+  isGitRepo,
+  isMainBranch,
+  createBranch,
+  getGitStatus,
+  expandPath,
+} from "@/lib/git-status";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const {
+      path: rawPath,
+      message,
+      branchName,
+    } = body as {
+      path: string;
+      message: string;
+      branchName?: string;
+    };
+
+    if (!rawPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    if (!message) {
+      return NextResponse.json(
+        { error: "Commit message is required" },
+        { status: 400 }
+      );
+    }
+
+    const path = expandPath(rawPath);
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    // Check if there are staged changes
+    const status = getGitStatus(path);
+    if (status.staged.length === 0) {
+      return NextResponse.json(
+        { error: "No staged changes to commit" },
+        { status: 400 }
+      );
+    }
+
+    // Create new branch if on main/master and branch name provided
+    let newBranch = false;
+    if (branchName && isMainBranch(path)) {
+      createBranch(path, branchName);
+      newBranch = true;
+    }
+
+    // Commit
+    const output = commit(path, message);
+
+    return NextResponse.json({
+      success: true,
+      output,
+      newBranch,
+      branchName: newBranch ? branchName : undefined,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to commit" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/discard/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { discardChanges, isGitRepo, expandPath } from "@/lib/git-status";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path: rawPath, file } = body as { path: string; file: string };
+
+    if (!rawPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    if (!file) {
+      return NextResponse.json({ error: "File is required" }, { status: 400 });
+    }
+
+    const path = expandPath(rawPath);
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    discardChanges(path, file);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "Failed to discard changes",
+      },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/file-content/route.ts

@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from "next/server";
+import { execSync } from "child_process";
+import { expandPath } from "@/lib/git-status";
+
+/**
+ * GET /api/git/file-content?path=...&file=...
+ * Get file content from git HEAD (original version before changes)
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+    const file = searchParams.get("file");
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Path parameter is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!file) {
+      return NextResponse.json(
+        { error: "File parameter is required" },
+        { status: 400 }
+      );
+    }
+
+    const expandedPath = expandPath(path);
+
+    try {
+      // Get file content from HEAD
+      const content = execSync(`git show HEAD:"${file}"`, {
+        cwd: expandedPath,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      });
+
+      return NextResponse.json({ content });
+    } catch (gitError: unknown) {
+      // File might be new (not in HEAD)
+      const errorMessage =
+        gitError instanceof Error ? gitError.message : String(gitError);
+
+      if (
+        errorMessage.includes("does not exist") ||
+        errorMessage.includes("fatal:")
+      ) {
+        return NextResponse.json({ content: "", isNew: true });
+      }
+
+      throw gitError;
+    }
+  } catch (error) {
+    console.error("Error getting file content from git:", error);
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "Failed to get file content",
+      },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/history/[hash]/diff/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCommitFileDiff } from "@/lib/git-history";
+
+interface RouteParams {
+  params: Promise<{ hash: string }>;
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { hash } = await params;
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+    const file = searchParams.get("file");
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Missing path parameter" },
+        { status: 400 }
+      );
+    }
+
+    if (!file) {
+      return NextResponse.json(
+        { error: "Missing file parameter" },
+        { status: 400 }
+      );
+    }
+
+    const diff = getCommitFileDiff(path, hash, file);
+    return NextResponse.json({ diff });
+  } catch (error) {
+    console.error("Error getting commit file diff:", error);
+    return NextResponse.json(
+      { error: "Failed to get commit file diff" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/history/[hash]/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCommitDetail } from "@/lib/git-history";
+
+interface RouteParams {
+  params: Promise<{ hash: string }>;
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { hash } = await params;
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Missing path parameter" },
+        { status: 400 }
+      );
+    }
+
+    const commit = getCommitDetail(path, hash);
+    if (!commit) {
+      return NextResponse.json({ error: "Commit not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ commit });
+  } catch (error) {
+    console.error("Error getting commit detail:", error);
+    return NextResponse.json(
+      { error: "Failed to get commit detail" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/history/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCommitHistory } from "@/lib/git-history";
+
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get("path");
+    const limitStr = searchParams.get("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : 30;
+
+    if (!path) {
+      return NextResponse.json(
+        { error: "Missing path parameter" },
+        { status: 400 }
+      );
+    }
+
+    const commits = getCommitHistory(path, limit);
+    return NextResponse.json({ commits });
+  } catch (error) {
+    console.error("Error getting commit history:", error);
+    return NextResponse.json(
+      { error: "Failed to get commit history" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/git/multi-status/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getProjectRepositories, getProject } from "@/lib/projects";
+import { getMultiRepoGitStatus } from "@/lib/multi-repo-git";
+import { expandPath } from "@/lib/git-status";
+import type { ProjectRepository } from "@/lib/db";
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const projectId = searchParams.get("projectId");
+    const fallbackPath = searchParams.get("fallbackPath");
+
+    if (!projectId && !fallbackPath) {
+      return NextResponse.json(
+        { error: "Either projectId or fallbackPath is required" },
+        { status: 400 }
+      );
+    }
+
+    let repositories: ProjectRepository[] = [];
+
+    if (projectId) {
+      const project = await getProject(projectId);
+      if (!project) {
+        return NextResponse.json(
+          { error: "Project not found" },
+          { status: 404 }
+        );
+      }
+      repositories = await getProjectRepositories(projectId);
+    }
+
+    const expandedFallback = fallbackPath
+      ? expandPath(fallbackPath)
+      : undefined;
+    const status = getMultiRepoGitStatus(repositories, expandedFallback);
+
+    return NextResponse.json(status);
+  } catch (error) {
+    console.error("Error fetching multi-repo git status:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch git status" },
+      { status: 500 }
+    );
+  }
+}