feat: add GitHub setup step and enhance setup flow

- Introduced a new GitHubSetupStep component for GitHub CLI configuration during the setup process.
- Updated SetupView to include the GitHub step in the setup flow, allowing users to skip or proceed based on their GitHub CLI status.
- Enhanced state management to track GitHub CLI installation and authentication status.
- Added logging for transitions between setup steps to improve user feedback.
- Updated related files to ensure cross-platform path normalization and compatibility.

apps/server/src/routes/worktree/routes/branch-tracking.ts

@@ -1,10 +1,8 @@
 /**
  * Branch tracking utilities
  *
- * Tracks active branches in external automaker storage so users
+ * Tracks active branches in .automaker so users
  * can switch between branches even after worktrees are removed.
- *
- * Data is stored outside the git repo to avoid worktree/symlink conflicts.
  */
 
 import { readFile, writeFile } from "fs/promises";
@@ -31,7 +29,7 @@ export async function getTrackedBranches(
   projectPath: string
 ): Promise<TrackedBranch[]> {
   try {
-    const filePath = await getBranchTrackingPath(projectPath);
+    const filePath = getBranchTrackingPath(projectPath);
     const content = await readFile(filePath, "utf-8");
     const data: BranchTrackingData = JSON.parse(content);
     return data.branches || [];

apps/server/src/routes/worktree/routes/create-pr.ts

@@ -111,7 +111,7 @@ export function createCreatePRHandler() {
         return;
       }
 
-      // Create PR using gh CLI
+      // Create PR using gh CLI or provide browser fallback
       const base = baseBranch || "main";
       const title = prTitle || branchName;
       const body = prBody || `Changes from branch ${branchName}`;
@@ -119,65 +119,97 @@ export function createCreatePRHandler() {
 
       let prUrl: string | null = null;
       let prError: string | null = null;
+      let browserUrl: string | null = null;
+      let ghCliAvailable = false;
+
+      // Check if gh CLI is available
       try {
-        // Check if gh CLI is available (use extended PATH for Homebrew/etc)
         await execAsync("command -v gh", { env: execEnv });
+        ghCliAvailable = true;
+      } catch {
+        ghCliAvailable = false;
+      }
 
-        // Check if this is a fork by looking for upstream remote
-        let upstreamRepo: string | null = null;
-        let originOwner: string | null = null;
-        try {
-          const { stdout: remotes } = await execAsync("git remote -v", {
-            cwd: worktreePath,
-            env: execEnv,
-          });
-
-          // Parse remotes to detect fork workflow
-          const lines = remotes.split("\n");
-          for (const line of lines) {
-            const match = line.match(/^(\w+)\s+.*[:/]([^/]+)\/([^/\s]+?)(?:\.git)?\s+\(fetch\)/);
-            if (match) {
-              const [, remoteName, owner] = match;
-              if (remoteName === "upstream") {
-                upstreamRepo = line.match(/[:/]([^/]+\/[^/\s]+?)(?:\.git)?\s+\(fetch\)/)?.[1] || null;
-              } else if (remoteName === "origin") {
-                originOwner = owner;
-              }
-            }
-          }
-        } catch {
-          // Couldn't parse remotes, continue without fork detection
-        }
-
-        // Build gh pr create command
-        let prCmd = `gh pr create --base "${base}"`;
-
-        // If this is a fork (has upstream remote), specify the repo and head
-        if (upstreamRepo && originOwner) {
-          // For forks: --repo specifies where to create PR, --head specifies source
-          prCmd += ` --repo "${upstreamRepo}" --head "${originOwner}:${branchName}"`;
-        } else {
-          // Not a fork, just specify the head branch
-          prCmd += ` --head "${branchName}"`;
-        }
-
-        prCmd += ` --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"')}" ${draftFlag}`;
-        prCmd = prCmd.trim();
-
-        console.log("[CreatePR] Running:", prCmd);
-        const { stdout: prOutput } = await execAsync(prCmd, {
+      // Get repository URL for browser fallback
+      let repoUrl: string | null = null;
+      let upstreamRepo: string | null = null;
+      let originOwner: string | null = null;
+      try {
+        const { stdout: remotes } = await execAsync("git remote -v", {
           cwd: worktreePath,
           env: execEnv,
         });
-        prUrl = prOutput.trim();
-      } catch (ghError: unknown) {
-        // gh CLI not available or PR creation failed
-        const err = ghError as { stderr?: string; message?: string };
-        prError = err.stderr || err.message || "PR creation failed";
-        console.warn("[CreatePR] gh CLI error:", prError);
+
+        // Parse remotes to detect fork workflow and get repo URL
+        const lines = remotes.split("\n");
+        for (const line of lines) {
+          const match = line.match(/^(\w+)\s+.*[:/]([^/]+)\/([^/\s]+?)(?:\.git)?\s+\(fetch\)/);
+          if (match) {
+            const [, remoteName, owner, repo] = match;
+            if (remoteName === "upstream") {
+              upstreamRepo = `${owner}/${repo}`;
+              repoUrl = `https://github.com/${owner}/${repo}`;
+            } else if (remoteName === "origin") {
+              originOwner = owner;
+              if (!repoUrl) {
+                repoUrl = `https://github.com/${owner}/${repo}`;
+              }
+            }
+          }
+        }
+      } catch {
+        // Couldn't parse remotes
       }
 
-      // Return result with any error info
+      // Construct browser URL for PR creation
+      if (repoUrl) {
+        const encodedTitle = encodeURIComponent(title);
+        const encodedBody = encodeURIComponent(body);
+
+        if (upstreamRepo && originOwner) {
+          // Fork workflow: PR to upstream from origin
+          browserUrl = `https://github.com/${upstreamRepo}/compare/${base}...${originOwner}:${branchName}?expand=1&title=${encodedTitle}&body=${encodedBody}`;
+        } else {
+          // Regular repo
+          browserUrl = `${repoUrl}/compare/${base}...${branchName}?expand=1&title=${encodedTitle}&body=${encodedBody}`;
+        }
+      }
+
+      if (ghCliAvailable) {
+        try {
+          // Build gh pr create command
+          let prCmd = `gh pr create --base "${base}"`;
+
+          // If this is a fork (has upstream remote), specify the repo and head
+          if (upstreamRepo && originOwner) {
+            // For forks: --repo specifies where to create PR, --head specifies source
+            prCmd += ` --repo "${upstreamRepo}" --head "${originOwner}:${branchName}"`;
+          } else {
+            // Not a fork, just specify the head branch
+            prCmd += ` --head "${branchName}"`;
+          }
+
+          prCmd += ` --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"')}" ${draftFlag}`;
+          prCmd = prCmd.trim();
+
+          console.log("[CreatePR] Running:", prCmd);
+          const { stdout: prOutput } = await execAsync(prCmd, {
+            cwd: worktreePath,
+            env: execEnv,
+          });
+          prUrl = prOutput.trim();
+        } catch (ghError: unknown) {
+          // gh CLI failed
+          const err = ghError as { stderr?: string; message?: string };
+          prError = err.stderr || err.message || "PR creation failed";
+          console.warn("[CreatePR] gh CLI error:", prError);
+        }
+      } else {
+        prError = "gh_cli_not_available";
+        console.log("[CreatePR] gh CLI not available, returning browser URL");
+      }
+
+      // Return result with browser fallback URL
       res.json({
         success: true,
         result: {
@@ -188,6 +220,8 @@ export function createCreatePRHandler() {
           prUrl,
           prCreated: !!prUrl,
           prError: prError || undefined,
+          browserUrl: browserUrl || undefined,
+          ghCliAvailable,
         },
       });
     } catch (error) {

apps/server/src/routes/worktree/routes/migrate.ts

@@ -1,63 +1,32 @@
 /**
- * POST /migrate endpoint - Migrate legacy .automaker data to external storage
+ * POST /migrate endpoint - Migration endpoint (no longer needed)
  *
- * This endpoint checks if there's legacy .automaker data in the project directory
- * and migrates it to the external ~/.automaker/projects/{project-id}/ location.
+ * This endpoint is kept for backwards compatibility but no longer performs
+ * any migration since .automaker is now stored in the project directory.
  */
 
 import type { Request, Response } from "express";
-import { getErrorMessage, logError } from "../common.js";
-import {
-  hasLegacyAutomakerDir,
-  migrateLegacyData,
-  getAutomakerDir,
-  getLegacyAutomakerDir,
-} from "../../../lib/automaker-paths.js";
+import { getAutomakerDir } from "../../../lib/automaker-paths.js";
 
 export function createMigrateHandler() {
   return async (req: Request, res: Response): Promise<void> => {
-    try {
-      const { projectPath } = req.body as { projectPath: string };
+    const { projectPath } = req.body as { projectPath: string };
 
-      if (!projectPath) {
-        res.status(400).json({
-          success: false,
-          error: "projectPath is required",
-        });
-        return;
-      }
-
-      // Check if migration is needed
-      const hasLegacy = await hasLegacyAutomakerDir(projectPath);
-
-      if (!hasLegacy) {
-        const automakerDir = await getAutomakerDir(projectPath);
-        res.json({
-          success: true,
-          migrated: false,
-          message: "No legacy .automaker directory found - nothing to migrate",
-          externalPath: automakerDir,
-        });
-        return;
-      }
-
-      // Perform migration
-      console.log(`[migrate] Starting migration for project: ${projectPath}`);
-      const legacyPath = await getLegacyAutomakerDir(projectPath);
-      const externalPath = await getAutomakerDir(projectPath);
-
-      await migrateLegacyData(projectPath);
-
-      res.json({
-        success: true,
-        migrated: true,
-        message: "Successfully migrated .automaker data to external storage",
-        legacyPath,
-        externalPath,
+    if (!projectPath) {
+      res.status(400).json({
+        success: false,
+        error: "projectPath is required",
       });
-    } catch (error) {
-      logError(error, "Migration failed");
-      res.status(500).json({ success: false, error: getErrorMessage(error) });
+      return;
     }
+
+    // Migration is no longer needed - .automaker is stored in project directory
+    const automakerDir = getAutomakerDir(projectPath);
+    res.json({
+      success: true,
+      migrated: false,
+      message: "No migration needed - .automaker is stored in project directory",
+      path: automakerDir,
+    });
   };
 }