Centralized branch/directory constants and migration fix

Author: jonathanlab

apps/twig/src/main/index.ts

@@ -43,6 +43,7 @@ import {
 } from "./services/posthog-analytics.js";
 import type { TaskLinkService } from "./services/task-link/service";
 import type { UpdatesService } from "./services/updates/service.js";
+import { migrateStoredWorktreePaths } from "./utils/store.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -320,6 +321,9 @@ function createWindow(): void {
 }
 
 app.whenReady().then(() => {
+  // Migrate stored worktree paths from legacy directories (e.g., ~/.array -> ~/.twig)
+  migrateStoredWorktreePaths();
+
   createWindow();
   ensureClaudeConfigDir();
 

apps/twig/src/main/services/git/service.ts

@@ -2,6 +2,7 @@ import { exec, execFile, spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
+import { isTwigBranch } from "@shared/constants";
 import { injectable } from "inversify";
 import { TypedEventEmitter } from "../../lib/typed-event-emitter.js";
 import type {
@@ -190,7 +191,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
         .split("\n")
         .filter(Boolean)
         .map((branch) => branch.trim())
-        .filter((branch) => !branch.startsWith("array/"));
+        .filter((branch) => !isTwigBranch(branch));
     } catch {
       return [];
     }

apps/twig/src/main/services/settingsStore.ts

@@ -1,38 +1,43 @@
 import { existsSync, renameSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { DATA_DIR, LEGACY_DATA_DIRS } from "@shared/constants";
 import { app } from "electron";
 import Store from "electron-store";
 
 interface SettingsSchema {
   worktreeLocation: string;
 }
 
-const LEGACY_DIR_NAME = ".array";
-const CURRENT_DIR_NAME = ".twig";
-
 function getDefaultWorktreeLocation(): string {
-  return path.join(os.homedir(), CURRENT_DIR_NAME);
+  return path.join(os.homedir(), DATA_DIR);
 }
 
-function getLegacyWorktreeLocation(): string {
-  return path.join(os.homedir(), LEGACY_DIR_NAME);
+function getLegacyWorktreeLocations(): string[] {
+  return LEGACY_DATA_DIRS.map((dir) => path.join(os.homedir(), dir));
 }
 
 /**
- * Migrate ~/.array to ~/.twig if needed (one-time migration)
+ * Migrate legacy directories to current if needed (one-time migration)
  */
 function migrateWorktreeDirectory(): void {
-  const legacyPath = getLegacyWorktreeLocation();
   const newPath = getDefaultWorktreeLocation();
 
-  // Only migrate if legacy exists and new doesn't
-  if (existsSync(legacyPath) && !existsSync(newPath)) {
-    try {
-      renameSync(legacyPath, newPath);
-    } catch {
-      // If rename fails (e.g., cross-device), leave as-is
-      // User can manually migrate or continue using legacy location
+  // Only migrate if new path doesn't exist yet
+  if (existsSync(newPath)) {
+    return;
+  }
+
+  // Try to migrate from each legacy location (first one found wins)
+  for (const legacyPath of getLegacyWorktreeLocations()) {
+    if (existsSync(legacyPath)) {
+      try {
+        renameSync(legacyPath, newPath);
+        return;
+      } catch {
+        // If rename fails (e.g., cross-device), leave as-is
+        // User can manually migrate or continue using legacy location
+      }
     }
   }
 }
@@ -57,16 +62,18 @@ export const settingsStore = new Store<SettingsSchema>({
 });
 
 /**
- * Migrate stored worktree setting from ~/.array to ~/.twig if it was the default
+ * Migrate stored worktree setting from legacy to current if it was a legacy default
  */
 function migrateWorktreeSetting(): void {
   const stored = settingsStore.get("worktreeLocation");
-  const legacyDefault = getLegacyWorktreeLocation();
   const newDefault = getDefaultWorktreeLocation();
 
-  // If user had the legacy default, update to new default
-  if (stored === legacyDefault && existsSync(newDefault)) {
-    settingsStore.set("worktreeLocation", newDefault);
+  // If user had a legacy default, update to new default
+  for (const legacyPath of getLegacyWorktreeLocations()) {
+    if (stored === legacyPath && existsSync(newDefault)) {
+      settingsStore.set("worktreeLocation", newDefault);
+      return;
+    }
   }
 }
 
@@ -77,6 +84,24 @@ export function getWorktreeLocation(): string {
   return settingsStore.get("worktreeLocation", getDefaultWorktreeLocation());
 }
 
+/**
+ * Get all worktree locations to check (current + legacy).
+ * Use this when searching for existing worktrees for backwards compatibility.
+ */
+export function getAllWorktreeLocations(): string[] {
+  const primary = getWorktreeLocation();
+  const locations = [primary];
+
+  // Add legacy locations if they exist and aren't the primary
+  for (const legacyPath of getLegacyWorktreeLocations()) {
+    if (legacyPath !== primary && existsSync(legacyPath)) {
+      locations.push(legacyPath);
+    }
+  }
+
+  return locations;
+}
+
 export function setWorktreeLocation(location: string): void {
   settingsStore.set("worktreeLocation", location);
 }

apps/twig/src/main/utils/store.ts

@@ -1,4 +1,6 @@
+import * as os from "node:os";
 import { WorktreeManager } from "@posthog/agent";
+import { LEGACY_DATA_DIRS } from "@shared/constants";
 import { app } from "electron";
 import Store from "electron-store";
 import type {
@@ -75,6 +77,49 @@ export const foldersStore = new Store<FoldersSchema>({
 
 const log = logger.scope("store");
 
+/**
+ * Migrate stored worktree paths from legacy directories to current.
+ * This updates taskAssociations that have paths like ~/.array/... to ~/.twig/...
+ */
+export function migrateStoredWorktreePaths(): void {
+  const currentLocation = getWorktreeLocation();
+  const associations = foldersStore.get("taskAssociations", []);
+  let migrated = false;
+
+  const legacyPaths = LEGACY_DATA_DIRS.map((dir) => `${os.homedir()}/${dir}/`);
+  const currentPath = `${currentLocation}/`;
+
+  const updatedAssociations = associations.map((assoc) => {
+    if (!assoc.worktree?.worktreePath) return assoc;
+
+    for (const legacyPath of legacyPaths) {
+      if (assoc.worktree.worktreePath.startsWith(legacyPath)) {
+        const newWorktreePath = assoc.worktree.worktreePath.replace(
+          legacyPath,
+          currentPath,
+        );
+        log.info(
+          `Migrating worktree path: ${assoc.worktree.worktreePath} -> ${newWorktreePath}`,
+        );
+        migrated = true;
+        return {
+          ...assoc,
+          worktree: {
+            ...assoc.worktree,
+            worktreePath: newWorktreePath,
+          },
+        };
+      }
+    }
+    return assoc;
+  });
+
+  if (migrated) {
+    foldersStore.set("taskAssociations", updatedAssociations);
+    log.info("Worktree path migration complete");
+  }
+}
+
 export async function clearAllStoreData(): Promise<void> {
   const associations = foldersStore.get("taskAssociations", []);
   for (const assoc of associations) {

apps/twig/src/renderer/components/StatusBarMenu.tsx

@@ -4,7 +4,7 @@ export function StatusBarMenu() {
   return (
     <Button size="1" variant="ghost">
       <Code size="1" color="gray" variant="ghost">
-        ARRAY
+        TWIG
       </Code>
     </Button>
   );

apps/twig/src/renderer/features/sidebar/components/items/TaskItem.tsx

@@ -10,6 +10,7 @@ import {
 import { Tooltip } from "@radix-ui/themes";
 import { trpcVanilla } from "@renderer/trpc";
 import { formatRelativeTime } from "@renderer/utils/time";
+import { isTwigBranch } from "@shared/constants";
 import type { WorkspaceMode } from "@shared/types";
 import { selectFocusedBranch, useFocusStore } from "@stores/focusStore";
 import { useQuery } from "@tanstack/react-query";
@@ -156,15 +157,12 @@ export function TaskItem({
   const focusedBranch = useFocusStore(selectFocusedBranch(mainRepoPath ?? ""));
 
   const isCloudTask = workspaceMode === "cloud";
-  const isTwigBranch =
-    branchName?.startsWith("twig/") ||
-    branchName?.startsWith("array/") ||
-    branchName?.startsWith("posthog/");
+  const hasTwigBranch = branchName ? isTwigBranch(branchName) : false;
   // Only show "Watching" indicator for twig-created branches, not borrowed ones
   const isWatching = !!(
     branchName &&
     focusedBranch === branchName &&
-    isTwigBranch
+    hasTwigBranch
   );
 
   const activityText = isGenerating

apps/twig/src/renderer/features/workspace/components/FocusWorkspaceButton.tsx

@@ -1,5 +1,6 @@
 import { ArrowLeft, ArrowsClockwise, GitBranch } from "@phosphor-icons/react";
 import { Button, Spinner, Text, Tooltip } from "@radix-ui/themes";
+import { isTwigBranch } from "@shared/constants";
 import {
   selectIsFocusedOnWorktree,
   selectIsLoading,
@@ -10,15 +11,6 @@ import { toast } from "@utils/toast";
 import { useCallback } from "react";
 import { selectWorkspace, useWorkspaceStore } from "../stores/workspaceStore";
 
-/** Check if branch is a twig-created branch (not borrowed) */
-function isTwigBranch(branchName: string): boolean {
-  return (
-    branchName.startsWith("twig/") ||
-    branchName.startsWith("array/") ||
-    branchName.startsWith("posthog/")
-  );
-}
-
 interface FocusWorkspaceButtonProps {
   taskId: string;
   repoPath?: string;

apps/twig/src/shared/constants.ts

@@ -0,0 +1,22 @@
+/**
+ * Branch naming conventions.
+ * - Reading: Accept all prefixes for backwards compatibility
+ * - Writing: Always use BRANCH_PREFIX (twig/)
+ */
+export const BRANCH_PREFIX = "twig/";
+export const LEGACY_BRANCH_PREFIXES = ["array/", "posthog/"];
+
+export function isTwigBranch(branchName: string): boolean {
+  return (
+    branchName.startsWith(BRANCH_PREFIX) ||
+    LEGACY_BRANCH_PREFIXES.some((p) => branchName.startsWith(p))
+  );
+}
+
+/**
+ * Data directory conventions.
+ * - Reading: Accept all directories for backwards compatibility
+ * - Writing: Always use DATA_DIR (.twig)
+ */
+export const DATA_DIR = ".twig";
+export const LEGACY_DATA_DIRS = [".array"];

packages/agent/src/constants.ts

@@ -0,0 +1,18 @@
+/**
+ * Branch naming conventions.
+ * - Reading: Accept all prefixes for backwards compatibility
+ * - Writing: Always use BRANCH_PREFIX (twig/)
+ */
+export const BRANCH_PREFIX = "twig/";
+export const LEGACY_BRANCH_PREFIXES = ["array/", "posthog/"];
+
+export function isTwigBranch(branchName: string): boolean {
+  return (
+    branchName.startsWith(BRANCH_PREFIX) ||
+    LEGACY_BRANCH_PREFIXES.some((p) => branchName.startsWith(p))
+  );
+}
+
+export function makeBranchName(name: string): string {
+  return `${BRANCH_PREFIX}${name}`;
+}

packages/agent/src/worktree-manager.ts

@@ -3,6 +3,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { isTwigBranch, makeBranchName } from "./constants.js";
 import type { WorktreeInfo } from "./types.js";
 import { Logger } from "./utils/logger.js";
 
@@ -783,7 +784,7 @@ export class WorktreeManager {
     const worktreeName = await worktreeNamePromise;
     const baseBranch = await baseBranchPromise;
     const worktreePath = this.getWorktreePath(worktreeName);
-    const branchName = `twig/${worktreeName}`;
+    const branchName = makeBranchName(worktreeName);
 
     this.logger.info("Creating worktree", {
       worktreeName,
@@ -1073,25 +1074,19 @@ export class WorktreeManager {
         worktreePath &&
         path.resolve(worktreePath) === path.resolve(this.mainRepoPath);
       const isInWorktreeFolder = worktreePath?.startsWith(worktreeFolderPath);
-      const isTwigBranch =
-        branchName?.startsWith("twig/") ||
-        branchName?.startsWith("array/") ||
-        branchName?.startsWith("posthog/");
+      const hasTwigBranch = branchName ? isTwigBranch(branchName) : false;
 
       if (
         worktreePath &&
         branchName &&
         !isMainRepo &&
-        (isInWorktreeFolder || isTwigBranch)
+        (isInWorktreeFolder || hasTwigBranch)
       ) {
         const worktreeName = path.basename(worktreePath);
         // Infer ownership: twig/ prefixed branches are "created", others are "borrowed"
-        const branchOwnership =
-          branchName.startsWith("twig/") ||
-          branchName.startsWith("array/") ||
-          branchName.startsWith("posthog/")
-            ? "created"
-            : "borrowed";
+        const branchOwnership = isTwigBranch(branchName)
+          ? "created"
+          : "borrowed";
         worktrees.push({
           worktreePath,
           worktreeName,