@atercates/claude-deck 0.2.1

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

@@ -0,0 +1,164 @@
+import { NextRequest, NextResponse } from "next/server";
+import { isGitRepo } from "@/lib/git-status";
+import {
+  checkGhCli,
+  getCommitsSinceBase,
+  generatePRTitle,
+  generatePRBody,
+  getPRForBranch,
+  createPR,
+  getCurrentBranch,
+  getBaseBranch,
+} from "@/lib/pr";
+import { generatePRContent } from "@/lib/pr-generation";
+
+// GET /api/git/pr - Get PR status (fast - no AI generation)
+// Use ?generate=true to also generate suggested title/body (slow - uses Claude CLI)
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const path = searchParams.get("path");
+  const shouldGenerate = searchParams.get("generate") === "true";
+
+  if (!path) {
+    return NextResponse.json({ error: "Path is required" }, { status: 400 });
+  }
+
+  if (!isGitRepo(path)) {
+    return NextResponse.json(
+      { error: "Not a git repository" },
+      { status: 400 }
+    );
+  }
+
+  if (!checkGhCli()) {
+    return NextResponse.json(
+      {
+        error:
+          "GitHub CLI not installed or not authenticated. Run 'gh auth login' first.",
+      },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const branch = getCurrentBranch(path);
+    const baseBranch = getBaseBranch(path);
+
+    // Check if on main/master (can't create PR from there)
+    if (branch === "main" || branch === "master") {
+      return NextResponse.json(
+        { error: "Cannot create PR from main/master branch" },
+        { status: 400 }
+      );
+    }
+
+    // Check if PR already exists
+    const existingPR = getPRForBranch(path, branch);
+
+    // Get commits for listing
+    const commits = getCommitsSinceBase(path, baseBranch);
+
+    // Only generate suggested content if explicitly requested (for PR creation flow)
+    let suggestedTitle: string | undefined;
+    let suggestedBody: string | undefined;
+
+    if (shouldGenerate) {
+      try {
+        const generated = await generatePRContent(path, baseBranch);
+        suggestedTitle = generated.title;
+        suggestedBody = generated.description;
+      } catch {
+        // Fallback to simple heuristic
+        suggestedTitle = generatePRTitle(commits, branch);
+        suggestedBody = generatePRBody(commits);
+      }
+    }
+
+    return NextResponse.json({
+      branch,
+      baseBranch,
+      existingPR,
+      commits: commits.map((c) => ({ hash: c.hash, subject: c.subject })),
+      ...(suggestedTitle && { suggestedTitle }),
+      ...(suggestedBody && { suggestedBody }),
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Failed to get PR info",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/git/pr - Create a new PR
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const {
+      path,
+      title,
+      description,
+      baseBranch: customBase,
+    } = body as {
+      path: string;
+      title: string;
+      description: string;
+      baseBranch?: string;
+    };
+
+    if (!path) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    if (!title) {
+      return NextResponse.json({ error: "Title is required" }, { status: 400 });
+    }
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    if (!checkGhCli()) {
+      return NextResponse.json(
+        { error: "GitHub CLI not installed or not authenticated" },
+        { status: 400 }
+      );
+    }
+
+    const branch = getCurrentBranch(path);
+    const baseBranch = customBase || getBaseBranch(path);
+
+    // Check if on main/master
+    if (branch === "main" || branch === "master") {
+      return NextResponse.json(
+        { error: "Cannot create PR from main/master branch" },
+        { status: 400 }
+      );
+    }
+
+    // Check if PR already exists
+    const existingPR = getPRForBranch(path, branch);
+    if (existingPR) {
+      return NextResponse.json(
+        { error: "PR already exists for this branch", pr: existingPR },
+        { status: 409 }
+      );
+    }
+
+    // Create the PR
+    const pr = createPR(path, branch, baseBranch, title, description || "");
+
+    return NextResponse.json({ pr }, { status: 201 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json(
+      { error: `Failed to create PR: ${message}` },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  push,
+  isGitRepo,
+  hasUpstream,
+  getRemoteUrl,
+  getGitStatus,
+  expandPath,
+} from "@/lib/git-status";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path: rawPath } = body as { path: string };
+
+    if (!rawPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    const path = expandPath(rawPath);
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    // Check if remote exists
+    const remoteUrl = getRemoteUrl(path);
+    if (!remoteUrl) {
+      return NextResponse.json(
+        { error: "No remote origin configured" },
+        { status: 400 }
+      );
+    }
+
+    // Check if there are commits to push
+    const status = getGitStatus(path);
+    if (status.ahead === 0) {
+      return NextResponse.json({
+        success: true,
+        message: "Already up to date",
+        pushed: false,
+      });
+    }
+
+    // Push (set upstream if needed)
+    const needsUpstream = !hasUpstream(path);
+    const output = push(path, needsUpstream);
+
+    return NextResponse.json({
+      success: true,
+      output,
+      pushed: true,
+      setUpstream: needsUpstream,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to push" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,40 @@
+import { NextRequest, NextResponse } from "next/server";
+import { stageFile, stageAll, isGitRepo, expandPath } from "@/lib/git-status";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path: rawPath, files } = body as { path: string; files?: string[] };
+
+    if (!rawPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    const path = expandPath(rawPath);
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    // Stage specific files or all
+    if (files && files.length > 0) {
+      for (const file of files) {
+        stageFile(path, file);
+      }
+    } else {
+      stageAll(path);
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Failed to stage files",
+      },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getGitStatus,
+  isGitRepo,
+  getFileDiff,
+  getUntrackedFileDiff,
+  expandPath,
+} from "@/lib/git-status";
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const rawPath = searchParams.get("path");
+  const filePath = searchParams.get("file");
+  const staged = searchParams.get("staged") === "true";
+
+  if (!rawPath) {
+    return NextResponse.json({ error: "Path is required" }, { status: 400 });
+  }
+
+  const path = expandPath(rawPath);
+
+  if (!isGitRepo(path)) {
+    return NextResponse.json(
+      { error: "Not a git repository" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    // If file is specified, return diff for that file
+    if (filePath) {
+      const isUntracked = searchParams.get("untracked") === "true";
+      const diff = isUntracked
+        ? getUntrackedFileDiff(path, filePath)
+        : getFileDiff(path, filePath, staged);
+      return NextResponse.json({ diff });
+    }
+
+    // Otherwise return full status
+    const status = getGitStatus(path);
+    return NextResponse.json(status);
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "Failed to get git status",
+      },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  unstageFile,
+  unstageAll,
+  isGitRepo,
+  expandPath,
+} from "@/lib/git-status";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { path: rawPath, files } = body as { path: string; files?: string[] };
+
+    if (!rawPath) {
+      return NextResponse.json({ error: "Path is required" }, { status: 400 });
+    }
+
+    const path = expandPath(rawPath);
+
+    if (!isGitRepo(path)) {
+      return NextResponse.json(
+        { error: "Not a git repository" },
+        { status: 400 }
+      );
+    }
+
+    // Unstage specific files or all
+    if (files && files.length > 0) {
+      for (const file of files) {
+        unstageFile(path, file);
+      }
+    } else {
+      unstageAll(path);
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "Failed to unstage files",
+      },
+      { status: 500 }
+    );
+  }
+}

package/app/api/groups/[...path]/route.ts

@@ -0,0 +1,136 @@
+import { NextResponse } from "next/server";
+import { queries, type Group } from "@/lib/db";
+
+// GET /api/groups/[...path] - Get a single group
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  const { path: pathParts } = await params;
+  const path = pathParts.join("/");
+
+  try {
+    const group = await queries.getGroup(path) as Group | undefined;
+
+    if (!group) {
+      return NextResponse.json({ error: "Group not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({
+      group: { ...group, expanded: Boolean(group.expanded) },
+    });
+  } catch (error) {
+    console.error("Error fetching group:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch group" },
+      { status: 500 }
+    );
+  }
+}
+
+// PATCH /api/groups/[...path] - Update group (name, expanded, order)
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  const { path: pathParts } = await params;
+  const path = pathParts.join("/");
+
+  try {
+    const body = await request.json();
+    const { name, expanded, sort_order } = body;
+
+    // Check if group exists
+    const group = await queries.getGroup(path) as Group | undefined;
+    if (!group) {
+      return NextResponse.json({ error: "Group not found" }, { status: 404 });
+    }
+
+    // Protect default group from being renamed
+    if (path === "sessions" && name !== undefined && name !== "Sessions") {
+      return NextResponse.json(
+        { error: "Cannot rename the default group" },
+        { status: 400 }
+      );
+    }
+
+    // Update name
+    if (name !== undefined) {
+      await queries.updateGroupName(name, path);
+    }
+
+    // Update expanded state
+    if (expanded !== undefined) {
+      await queries.updateGroupExpanded(!!expanded, path);
+    }
+
+    // Update sort order
+    if (sort_order !== undefined) {
+      await queries.updateGroupOrder(sort_order, path);
+    }
+
+    const updatedGroup = await queries.getGroup(path) as Group;
+    return NextResponse.json({
+      group: { ...updatedGroup, expanded: Boolean(updatedGroup.expanded) },
+    });
+  } catch (error) {
+    console.error("Error updating group:", error);
+    return NextResponse.json(
+      { error: "Failed to update group" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/groups/[...path] - Delete group (moves sessions to parent or default)
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  const { path: pathParts } = await params;
+  const path = pathParts.join("/");
+
+  try {
+    // Protect default group
+    if (path === "sessions") {
+      return NextResponse.json(
+        { error: "Cannot delete the default group" },
+        { status: 400 }
+      );
+    }
+
+    // Check if group exists
+    const group = await queries.getGroup(path) as Group | undefined;
+    if (!group) {
+      return NextResponse.json({ error: "Group not found" }, { status: 404 });
+    }
+
+    // Find parent group or use default
+    const pathParts2 = path.split("/");
+    pathParts2.pop();
+    const parentPath =
+      pathParts2.length > 0 ? pathParts2.join("/") : "sessions";
+
+    // Move all sessions in this group to parent
+    await queries.moveSessionsToGroup(parentPath, path);
+
+    // Also move sessions from any subgroups
+    const allGroups = await queries.getAllGroups() as Group[];
+    const subgroups = allGroups.filter((g) => g.path.startsWith(path + "/"));
+    for (const subgroup of subgroups) {
+      await queries.moveSessionsToGroup(parentPath, subgroup.path);
+      await queries.deleteGroup(subgroup.path);
+    }
+
+    // Delete the group
+    await queries.deleteGroup(path);
+
+    return NextResponse.json({ success: true, movedTo: parentPath });
+  } catch (error) {
+    console.error("Error deleting group:", error);
+    return NextResponse.json(
+      { error: "Failed to delete group" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/groups/route.ts

@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import { queries, type Group } from "@/lib/db";
+
+// GET /api/groups - List all groups
+export async function GET() {
+  try {
+    const groups = await queries.getAllGroups() as Group[];
+
+    // Convert expanded from 0/1 to boolean
+    const formattedGroups = groups.map((g) => ({
+      ...g,
+      expanded: Boolean(g.expanded),
+    }));
+
+    return NextResponse.json({ groups: formattedGroups });
+  } catch (error) {
+    console.error("Error fetching groups:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch groups" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/groups - Create a new group
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { name, parentPath } = body;
+
+    if (!name || typeof name !== "string") {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    // Sanitize name to create path
+    const sanitizedName = name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "");
+
+    if (!sanitizedName) {
+      return NextResponse.json(
+        { error: "Invalid group name" },
+        { status: 400 }
+      );
+    }
+
+    // Build full path
+    const path = parentPath ? `${parentPath}/${sanitizedName}` : sanitizedName;
+
+    // Check if group already exists
+    const existing = await queries.getGroup(path) as Group | undefined;
+    if (existing) {
+      return NextResponse.json(
+        { error: "Group already exists", group: existing },
+        { status: 409 }
+      );
+    }
+
+    // If parent path specified, ensure parent exists
+    if (parentPath) {
+      const parent = await queries.getGroup(parentPath) as Group | undefined;
+      if (!parent) {
+        return NextResponse.json(
+          { error: "Parent group does not exist" },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Get max sort order for new group
+    const groups = await queries.getAllGroups() as Group[];
+    const maxOrder = groups.reduce((max, g) => Math.max(max, g.sort_order), 0);
+
+    // Create the group
+    await queries.createGroup(path, name, maxOrder + 1);
+
+    const newGroup = await queries.getGroup(path) as Group;
+    return NextResponse.json(
+      {
+        group: { ...newGroup, expanded: Boolean(newGroup.expanded) },
+      },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error("Error creating group:", error);
+    return NextResponse.json(
+      { error: "Failed to create group" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/orchestrate/spawn/route.ts

@@ -0,0 +1,45 @@
+import { NextResponse } from "next/server";
+import { spawnWorker } from "@/lib/orchestration";
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const {
+      conductorSessionId,
+      task,
+      workingDirectory,
+      branchName,
+      useWorktree = true,
+      model = "sonnet",
+      agentType = "claude",
+    } = body;
+
+    if (!conductorSessionId || !task || !workingDirectory) {
+      return NextResponse.json(
+        {
+          error:
+            "Missing required fields: conductorSessionId, task, workingDirectory",
+        },
+        { status: 400 }
+      );
+    }
+
+    const session = await spawnWorker({
+      conductorSessionId,
+      task,
+      workingDirectory,
+      branchName,
+      useWorktree,
+      model,
+      agentType,
+    });
+
+    return NextResponse.json({ session });
+  } catch (error) {
+    console.error("Failed to spawn worker:", error);
+    return NextResponse.json(
+      { error: "Failed to spawn worker" },
+      { status: 500 }
+    );
+  }
+}