PostHog
diff --git a/‎packages/core/package.json‎
Lines changed: 28 additions & 0 deletions b/‎packages/core/package.json‎
Lines changed: 28 additions & 0 deletions
diff --git a/‎packages/core/src/auth.ts‎
Lines changed: 106 additions & 0 deletions b/‎packages/core/src/auth.ts‎
Lines changed: 106 additions & 0 deletions
diff --git a/‎packages/core/src/bookmark-utils.ts‎
Lines changed: 106 additions & 0 deletions b/‎packages/core/src/bookmark-utils.ts‎
Lines changed: 106 additions & 0 deletions
@@ -0,0 +1,28 @@
+{
+  "name": "@array/core",
+  "version": "0.0.1",
+  "description": "Changeset management on top of jj (Jujutsu VCS)",
+  "type": "module",
+  "exports": {
+    "./commands/*": "./src/commands/*.ts",
+    "./*": "./src/*.ts"
+  },
+  "scripts": {
+    "build": "echo 'No build needed - using TypeScript sources directly'",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.5.0"
+  },
+  "dependencies": {
+    "@octokit/graphql": "^9.0.3",
+    "@octokit/graphql-schema": "^15.26.1",
+    "@octokit/rest": "^22.0.1",
+    "zod": "^3.24.1"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*"
+  ]
+}
@@ -0,0 +1,106 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { type CommandExecutor, shellExecutor } from "./executor";
+import { createError, err, ok, type Result } from "./result";
+
+const AuthStateSchema = z.object({
+  version: z.literal(1),
+  ghAuthenticated: z.boolean(),
+  username: z.string().optional(),
+});
+
+type AuthState = z.infer<typeof AuthStateSchema>;
+
+const AUTH_CONFIG_DIR = ".config/array";
+const AUTH_FILE = "auth.json";
+
+function getAuthPath(): string {
+  return join(homedir(), AUTH_CONFIG_DIR, AUTH_FILE);
+}
+
+export async function saveAuthState(state: AuthState): Promise<void> {
+  const authDir = join(homedir(), AUTH_CONFIG_DIR);
+  const authPath = getAuthPath();
+
+  await ensureDir(authDir);
+  await Bun.write(authPath, JSON.stringify(state, null, 2));
+}
+
+interface GhAuthStatus {
+  authenticated: boolean;
+  username?: string;
+  error?: string;
+}
+
+export async function checkGhAuth(
+  executor: CommandExecutor = shellExecutor,
+): Promise<GhAuthStatus> {
+  try {
+    const result = await executor.execute("gh", ["auth", "status"], {
+      cwd: process.cwd(),
+    });
+
+    if (result.exitCode === 0) {
+      const usernameMatch = result.stdout.match(
+        /Logged in to github\.com account (\S+)/,
+      );
+      const username = usernameMatch ? usernameMatch[1] : undefined;
+      return { authenticated: true, username };
+    }
+
+    return { authenticated: false, error: result.stderr };
+  } catch (e) {
+    return { authenticated: false, error: `Failed to check gh auth: ${e}` };
+  }
+}
+
+export async function ghAuthLogin(
+  executor: CommandExecutor = shellExecutor,
+): Promise<Result<string>> {
+  try {
+    const result = await executor.execute("gh", ["auth", "login", "--web"], {
+      cwd: process.cwd(),
+    });
+
+    if (result.exitCode !== 0) {
+      return err(
+        createError(
+          "COMMAND_FAILED",
+          result.stderr || "Failed to authenticate with GitHub",
+        ),
+      );
+    }
+
+    const status = await checkGhAuth(executor);
+    if (!status.authenticated) {
+      return err(createError("COMMAND_FAILED", "Authentication failed"));
+    }
+
+    return ok(status.username || "unknown");
+  } catch (e) {
+    return err(createError("COMMAND_FAILED", `Failed to authenticate: ${e}`));
+  }
+}
+
+export async function isGhInstalled(
+  executor: CommandExecutor = shellExecutor,
+): Promise<boolean> {
+  try {
+    const result = await executor.execute("which", ["gh"], {
+      cwd: process.cwd(),
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(dirPath: string): Promise<void> {
+  try {
+    const { mkdir } = await import("node:fs/promises");
+    await mkdir(dirPath, { recursive: true });
+  } catch {
+    // Directory might already exist
+  }
+}
@@ -0,0 +1,106 @@
+import { getPRForBranch, type PRStatus } from "./github";
+import { createError, err, ok, type Result } from "./result";
+
+/** Maximum number of suffix attempts before giving up on conflict resolution */
+const MAX_BOOKMARK_SUFFIX = 25;
+
+interface BookmarkConflictResult {
+  /** Original bookmark name before conflict resolution */
+  originalName: string;
+  /** Final resolved bookmark name (may have -2, -3, etc. suffix) */
+  resolvedName: string;
+  /** Whether the name was changed due to a conflict */
+  hadConflict: boolean;
+}
+
+/**
+ * Resolve bookmark name conflicts with existing closed/merged PRs on GitHub.
+ *
+ * When a bookmark name conflicts with a closed or merged PR, this function
+ * finds a unique name by appending -2, -3, etc. suffixes.
+ *
+ * @param bookmark - The bookmark name to check/resolve
+ * @param prCache - Optional pre-fetched PR cache to avoid redundant API calls
+ * @param assignedNames - Set of names already assigned in this batch (to avoid duplicates)
+ * @param cwd - Working directory (defaults to process.cwd())
+ * @returns The resolved bookmark name, or error if too many conflicts
+ */
+export async function resolveBookmarkConflict(
+  bookmark: string,
+  prCache?: Map<string, PRStatus>,
+  assignedNames?: Set<string>,
+  cwd = process.cwd(),
+): Promise<Result<BookmarkConflictResult>> {
+  // Check cache first, otherwise fetch from GitHub
+  let existingPR: PRStatus | null = null;
+  if (prCache) {
+    existingPR = prCache.get(bookmark) ?? null;
+  } else {
+    const prResult = await getPRForBranch(bookmark, cwd);
+    if (!prResult.ok) return prResult;
+    existingPR = prResult.value;
+  }
+
+  // No conflict if PR doesn't exist or is open
+  if (!existingPR || existingPR.state === "open") {
+    return ok({
+      originalName: bookmark,
+      resolvedName: bookmark,
+      hadConflict: false,
+    });
+  }
+
+  // PR exists and is closed/merged - find a unique suffix
+  const baseBookmark = bookmark;
+  let suffix = 2;
+
+  while (suffix <= MAX_BOOKMARK_SUFFIX) {
+    const candidateName = `${baseBookmark}-${suffix}`;
+
+    // Check if this candidate is already assigned in this batch
+    if (assignedNames?.has(candidateName)) {
+      suffix++;
+      continue;
+    }
+
+    // Check if this candidate has an existing PR
+    let candidatePR: PRStatus | null = null;
+    if (prCache) {
+      candidatePR = prCache.get(candidateName) ?? null;
+    } else {
+      const checkResult = await getPRForBranch(candidateName, cwd);
+      if (checkResult.ok) {
+        candidatePR = checkResult.value;
+      }
+    }
+
+    // Found an unused name
+    if (!candidatePR) {
+      return ok({
+        originalName: bookmark,
+        resolvedName: candidateName,
+        hadConflict: true,
+      });
+    }
+
+    suffix++;
+  }
+
+  // Exceeded max suffix attempts
+  return err(
+    createError(
+      "CONFLICT",
+      `Too many PR name conflicts for "${baseBookmark}". Clean up old PRs or use a different description.`,
+    ),
+  );
+}
+
+/**
+ * Check if a bookmark name is a remote-tracking bookmark (e.g., "feature@origin").
+ *
+ * Remote-tracking bookmarks have a @remote suffix pattern and should be
+ * excluded from local operations.
+ */
+export function isTrackingBookmark(bookmark: string): boolean {
+  return /@[a-zA-Z0-9_-]+$/.test(bookmark);
+}