@atercates/claude-deck 0.2.1

package/lib/panes.ts

@@ -0,0 +1,232 @@
+// Multi-pane layout types and helpers
+
+export type PaneLayout = PaneLayoutLeaf | PaneLayoutSplit;
+
+export interface PaneLayoutLeaf {
+  type: "leaf";
+  paneId: string;
+}
+
+export interface PaneLayoutSplit {
+  type: "split";
+  direction: "horizontal" | "vertical";
+  children: PaneLayout[];
+  sizes: number[];
+}
+
+export interface TabData {
+  id: string;
+  sessionId: string | null;
+  sessionName: string | null;
+  claudeProjectName: string | null;
+  workingDirectory: string | null;
+  attachedTmux: string | null;
+  detachedTmux: string | null;
+  detachedSessionId: string | null;
+}
+
+export interface PaneData {
+  tabs: TabData[];
+  activeTabId: string;
+}
+
+export interface PaneState {
+  layout: PaneLayout;
+  focusedPaneId: string;
+  panes: Record<string, PaneData>;
+}
+
+// Generate unique tab ID
+export function generateTabId(): string {
+  return `tab-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+// Create a new tab
+export function createTab(): TabData {
+  return {
+    id: generateTabId(),
+    sessionId: null,
+    sessionName: null,
+    claudeProjectName: null,
+    workingDirectory: null,
+    attachedTmux: null,
+    detachedTmux: null,
+    detachedSessionId: null,
+  };
+}
+
+// Create initial pane data with one tab
+export function createPaneData(): PaneData {
+  const tab = createTab();
+  return {
+    tabs: [tab],
+    activeTabId: tab.id,
+  };
+}
+
+export const MAX_PANES = 4;
+
+// Generate unique pane ID
+export function generatePaneId(): string {
+  return `pane-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+// Create initial state with single pane
+export function createInitialPaneState(): PaneState {
+  const paneId = generatePaneId();
+  return {
+    layout: { type: "leaf", paneId },
+    focusedPaneId: paneId,
+    panes: {
+      [paneId]: createPaneData(),
+    },
+  };
+}
+
+// Count total panes in layout
+export function countPanes(layout: PaneLayout): number {
+  if (layout.type === "leaf") {
+    return 1;
+  }
+  return layout.children.reduce((sum, child) => sum + countPanes(child), 0);
+}
+
+// Find and replace a pane in the layout
+export function replacePane(
+  layout: PaneLayout,
+  targetPaneId: string,
+  newLayout: PaneLayout
+): PaneLayout {
+  if (layout.type === "leaf") {
+    return layout.paneId === targetPaneId ? newLayout : layout;
+  }
+  return {
+    ...layout,
+    children: layout.children.map((child) =>
+      replacePane(child, targetPaneId, newLayout)
+    ),
+  };
+}
+
+// Split a pane
+export function splitPane(
+  state: PaneState,
+  paneId: string,
+  direction: "horizontal" | "vertical"
+): PaneState | null {
+  if (countPanes(state.layout) >= MAX_PANES) {
+    return null; // Max panes reached
+  }
+
+  const newPaneId = generatePaneId();
+  const newSplit: PaneLayoutSplit = {
+    type: "split",
+    direction,
+    children: [
+      { type: "leaf", paneId },
+      { type: "leaf", paneId: newPaneId },
+    ],
+    sizes: [50, 50],
+  };
+
+  return {
+    layout: replacePane(state.layout, paneId, newSplit),
+    focusedPaneId: newPaneId,
+    panes: {
+      ...state.panes,
+      [newPaneId]: createPaneData(),
+    },
+  };
+}
+
+// Remove a pane from layout and return the remaining layout
+function removePaneFromLayout(
+  layout: PaneLayout,
+  paneId: string
+): PaneLayout | null {
+  if (layout.type === "leaf") {
+    return layout.paneId === paneId ? null : layout;
+  }
+
+  const newChildren: PaneLayout[] = [];
+  for (const child of layout.children) {
+    const result = removePaneFromLayout(child, paneId);
+    if (result !== null) {
+      newChildren.push(result);
+    }
+  }
+
+  if (newChildren.length === 0) {
+    return null;
+  }
+  if (newChildren.length === 1) {
+    return newChildren[0]; // Collapse single-child splits
+  }
+
+  // Redistribute sizes
+  const totalSize = layout.sizes.reduce((a, b) => a + b, 0);
+  const newSizes = newChildren.map(() => totalSize / newChildren.length);
+
+  return {
+    ...layout,
+    children: newChildren,
+    sizes: newSizes,
+  };
+}
+
+// Close a pane
+export function closePane(state: PaneState, paneId: string): PaneState | null {
+  if (countPanes(state.layout) <= 1) {
+    return null; // Can't close last pane
+  }
+
+  const newLayout = removePaneFromLayout(state.layout, paneId);
+  if (!newLayout) {
+    return null;
+  }
+
+  const { [paneId]: _, ...remainingPanes } = state.panes;
+
+  // If focused pane was closed, focus first remaining pane
+  let newFocusedId = state.focusedPaneId;
+  if (paneId === state.focusedPaneId) {
+    newFocusedId = Object.keys(remainingPanes)[0];
+  }
+
+  return {
+    layout: newLayout,
+    focusedPaneId: newFocusedId,
+    panes: remainingPanes,
+  };
+}
+
+// Get all pane IDs from layout
+export function getAllPaneIds(layout: PaneLayout): string[] {
+  if (layout.type === "leaf") {
+    return [layout.paneId];
+  }
+  return layout.children.flatMap(getAllPaneIds);
+}
+
+// localStorage key for persisting pane state
+const PANE_STATE_KEY = "claude-deck-pane-state";
+
+export function savePaneState(state: PaneState): void {
+  try {
+    localStorage.setItem(PANE_STATE_KEY, JSON.stringify(state));
+  } catch {
+    // localStorage might be unavailable
+  }
+}
+
+export function loadPaneState(): PaneState | null {
+  try {
+    const saved = localStorage.getItem(PANE_STATE_KEY);
+    if (saved) {
+      return JSON.parse(saved);
+    }
+  } catch {
+    // localStorage might be unavailable or data corrupt
+  }
+  return null;
+}

package/lib/ports.ts

@@ -0,0 +1,97 @@
+/**
+ * Port Management for Dev Servers
+ *
+ * Assigns unique ports to worktree sessions to avoid conflicts.
+ */
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import { getDb } from "./db";
+
+const execAsync = promisify(exec);
+
+// Port range for dev servers
+const BASE_PORT = 3100;
+const PORT_INCREMENT = 10;
+const MAX_PORT = 3900;
+
+/**
+ * Check if a port is in use
+ */
+export async function isPortInUse(port: number): Promise<boolean> {
+  try {
+    const { stdout } = await execAsync(
+      `lsof -i :${port} -sTCP:LISTEN 2>/dev/null | head -1`,
+      { timeout: 5000 }
+    );
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get all ports currently assigned to sessions
+ */
+export async function getAssignedPorts(): Promise<number[]> {
+  const rows = getDb()
+    .prepare(
+      "SELECT dev_server_port FROM sessions WHERE dev_server_port IS NOT NULL"
+    )
+    .all() as Array<{ dev_server_port: number }>;
+  return rows.map((s) => s.dev_server_port);
+}
+
+/**
+ * Find the next available port
+ */
+export async function findAvailablePort(): Promise<number> {
+  const assignedPorts = new Set(await getAssignedPorts());
+
+  for (let port = BASE_PORT; port <= MAX_PORT; port += PORT_INCREMENT) {
+    // Skip if already assigned to a session
+    if (assignedPorts.has(port)) {
+      continue;
+    }
+
+    // Check if port is actually in use (by something outside ClaudeDeck)
+    if (!(await isPortInUse(port))) {
+      return port;
+    }
+  }
+
+  // Fallback: return a random port in range
+  return BASE_PORT + Math.floor(Math.random() * 80) * PORT_INCREMENT;
+}
+
+/**
+ * Assign a port to a session
+ */
+export async function assignPort(sessionId: string): Promise<number> {
+  const port = await findAvailablePort();
+  getDb()
+    .prepare("UPDATE sessions SET dev_server_port = ? WHERE id = ?")
+    .run(port, sessionId);
+  return port;
+}
+
+/**
+ * Release a port from a session
+ */
+export async function releasePort(sessionId: string): Promise<void> {
+  getDb()
+    .prepare("UPDATE sessions SET dev_server_port = NULL WHERE id = ?")
+    .run(sessionId);
+}
+
+/**
+ * Get the port assigned to a session
+ */
+export async function getSessionPort(
+  sessionId: string
+): Promise<number | null> {
+  const result = getDb()
+    .prepare("SELECT dev_server_port FROM sessions WHERE id = ?")
+    .get(sessionId) as { dev_server_port: number | null } | undefined;
+  return result?.dev_server_port || null;
+}

package/lib/pr-generation.ts

@@ -0,0 +1,307 @@
+import { execSync } from "child_process";
+
+export interface GeneratedPRContent {
+  title: string;
+  description: string;
+}
+
+/**
+ * Generate PR title and description using Claude CLI or fallback heuristics
+ */
+export async function generatePRContent(
+  workingDir: string,
+  baseBranch: string = "main"
+): Promise<GeneratedPRContent> {
+  try {
+    // Get git context
+    const { diff, commits, changedFiles } = getGitContext(
+      workingDir,
+      baseBranch
+    );
+
+    if (!diff && commits.length === 0) {
+      return generateFallbackContent(changedFiles);
+    }
+
+    // Try Claude CLI first
+    try {
+      const result = await generateWithClaude(workingDir, diff, commits);
+      if (result) {
+        return result;
+      }
+    } catch (error) {
+      console.debug("Claude CLI generation failed, using fallback", error);
+    }
+
+    // Fallback to heuristic generation
+    return generateHeuristicContent(diff, commits, changedFiles);
+  } catch (error) {
+    console.error("Failed to generate PR content", error);
+    return generateFallbackContent([]);
+  }
+}
+
+/**
+ * Get git context for PR generation
+ */
+function getGitContext(
+  workingDir: string,
+  baseBranch: string
+): { diff: string; commits: string[]; changedFiles: string[] } {
+  let diff = "";
+  let commits: string[] = [];
+  let changedFiles: string[] = [];
+
+  try {
+    // Try to get the remote base branch reference
+    let baseBranchRef = baseBranch;
+    try {
+      execSync(`git rev-parse --verify origin/${baseBranch}`, {
+        cwd: workingDir,
+        stdio: "pipe",
+      });
+      baseBranchRef = `origin/${baseBranch}`;
+    } catch {
+      // Fall back to local branch
+      try {
+        execSync(`git rev-parse --verify ${baseBranch}`, {
+          cwd: workingDir,
+          stdio: "pipe",
+        });
+      } catch {
+        // Base branch doesn't exist
+        return { diff, commits, changedFiles };
+      }
+    }
+
+    // Get diff stats
+    try {
+      diff = execSync(`git diff ${baseBranchRef}...HEAD --stat`, {
+        cwd: workingDir,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+      });
+    } catch {}
+
+    // Get changed files
+    try {
+      const filesOut = execSync(
+        `git diff --name-only ${baseBranchRef}...HEAD`,
+        {
+          cwd: workingDir,
+          encoding: "utf-8",
+        }
+      );
+      changedFiles = filesOut
+        .split("\n")
+        .map((f) => f.trim())
+        .filter(Boolean);
+    } catch {}
+
+    // Get commit messages
+    try {
+      const commitsOut = execSync(
+        `git log ${baseBranchRef}..HEAD --pretty=format:"%s"`,
+        {
+          cwd: workingDir,
+          encoding: "utf-8",
+        }
+      );
+      commits = commitsOut
+        .split("\n")
+        .map((c) => c.trim())
+        .filter(Boolean);
+    } catch {}
+
+    // Also include uncommitted changes
+    try {
+      const workingDiff = execSync("git diff --stat", {
+        cwd: workingDir,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      if (workingDiff) {
+        diff = diff ? `${diff}\n${workingDiff}` : workingDiff;
+      }
+
+      const uncommittedFiles = execSync("git diff --name-only", {
+        cwd: workingDir,
+        encoding: "utf-8",
+      })
+        .split("\n")
+        .map((f) => f.trim())
+        .filter(Boolean);
+
+      changedFiles = [...new Set([...changedFiles, ...uncommittedFiles])];
+    } catch {}
+  } catch (error) {
+    console.warn("Failed to get git context", error);
+  }
+
+  return { diff, commits, changedFiles };
+}
+
+/**
+ * Generate PR content using Claude CLI
+ */
+async function generateWithClaude(
+  workingDir: string,
+  diff: string,
+  commits: string[]
+): Promise<GeneratedPRContent | null> {
+  // Check if Claude CLI is available
+  try {
+    execSync("claude --version", { stdio: "pipe", timeout: 5000 });
+  } catch {
+    return null;
+  }
+
+  const prompt = buildPRPrompt(diff, commits);
+
+  try {
+    // Use claude CLI with --print flag for non-interactive output
+    const output = execSync(`claude --print "${prompt.replace(/"/g, '\\"')}"`, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: 30000,
+      maxBuffer: 1024 * 1024,
+    });
+
+    return parseClaudeResponse(output);
+  } catch (error) {
+    console.debug("Claude CLI invocation failed", error);
+    return null;
+  }
+}
+
+/**
+ * Build prompt for PR generation
+ */
+function buildPRPrompt(diff: string, commits: string[]): string {
+  const commitContext =
+    commits.length > 0
+      ? `Commits:\n${commits.map((c) => `- ${c}`).join("\n")}`
+      : "";
+  const diffContext = diff
+    ? `Diff summary:\n${diff.substring(0, 2000)}${diff.length > 2000 ? "..." : ""}`
+    : "";
+
+  return `Generate a concise PR title and description based on these changes:
+
+${commitContext}
+
+${diffContext}
+
+Respond ONLY with valid JSON in this exact format:
+{"title": "A concise PR title (max 72 chars)", "description": "A markdown description with ## headers and - bullet points"}`;
+}
+
+/**
+ * Parse Claude response into PR content
+ */
+function parseClaudeResponse(response: string): GeneratedPRContent | null {
+  try {
+    // Extract JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed.title && parsed.description) {
+        let description = String(parsed.description);
+        // Handle escaped newlines
+        description = description.replace(/\\n/g, "\n");
+        description = description.replace(/\\\\n/g, "\n");
+        return {
+          title: parsed.title.trim(),
+          description: description.trim(),
+        };
+      }
+    }
+  } catch (error) {
+    console.debug("Failed to parse Claude response", error);
+  }
+  return null;
+}
+
+/**
+ * Generate PR content using heuristics
+ */
+function generateHeuristicContent(
+  diff: string,
+  commits: string[],
+  changedFiles: string[]
+): GeneratedPRContent {
+  // Use first commit as title
+  let title = "chore: update code";
+  if (commits.length > 0) {
+    title = commits[0];
+    if (title.length > 72) {
+      title = title.substring(0, 69) + "...";
+    }
+  } else if (changedFiles.length > 0) {
+    const fileName = changedFiles[0].split("/").pop() || "files";
+    title = `chore: update ${fileName}`;
+  }
+
+  // Build description
+  const parts: string[] = [];
+
+  if (commits.length > 0) {
+    parts.push("## Changes\n");
+    commits.forEach((commit) => parts.push(`- ${commit}`));
+  }
+
+  if (changedFiles.length > 0) {
+    parts.push("\n## Files Changed\n");
+    changedFiles.slice(0, 15).forEach((file) => parts.push(`- \`${file}\``));
+    if (changedFiles.length > 15) {
+      parts.push(`\n... and ${changedFiles.length - 15} more files`);
+    }
+  }
+
+  // Parse diff stats
+  if (diff) {
+    const statsMatch = diff.match(
+      /(\d+)\s+files? changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/
+    );
+    if (statsMatch) {
+      const fileCount = parseInt(statsMatch[1] || "0", 10);
+      const insertions = parseInt(statsMatch[2] || "0", 10);
+      const deletions = parseInt(statsMatch[3] || "0", 10);
+
+      if (fileCount > 0 || insertions > 0 || deletions > 0) {
+        parts.push("\n## Summary\n");
+        if (fileCount > 0) {
+          parts.push(
+            `- ${fileCount} file${fileCount !== 1 ? "s" : ""} changed`
+          );
+        }
+        const changes: string[] = [];
+        if (insertions > 0) changes.push(`+${insertions}`);
+        if (deletions > 0) changes.push(`-${deletions}`);
+        if (changes.length > 0) {
+          parts.push(`- ${changes.join(", ")} lines`);
+        }
+      }
+    }
+  }
+
+  const description = parts.join("\n") || "No description available.";
+  return { title, description };
+}
+
+/**
+ * Fallback content when no context available
+ */
+function generateFallbackContent(changedFiles: string[]): GeneratedPRContent {
+  const title =
+    changedFiles.length > 0
+      ? `chore: update ${changedFiles[0].split("/").pop() || "files"}`
+      : "chore: update code";
+
+  const description =
+    changedFiles.length > 0
+      ? `Updated ${changedFiles.length} file${changedFiles.length !== 1 ? "s" : ""}.`
+      : "No changes detected.";
+
+  return { title, description };
+}