xcode-build-queue 0.1.0

package/dist/utils.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.BQ_LOCK_FILE = exports.BQ_PID_FILE = exports.BQ_LOGS_DIR = exports.BQ_RESULTS_DIR = exports.BQ_ACTIVE_DIR = exports.BQ_QUEUE_DIR = exports.BQ_CONFIG_PATH = exports.BQ_HOME = void 0;
+exports.ensureDirs = ensureDirs;
+exports.generateJobId = generateJobId;
+exports.expandPath = expandPath;
+exports.run = run;
+exports.spawnWithLog = spawnWithLog;
+exports.isProcessAlive = isProcessAlive;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+// Paths
+const home = (0, node_os_1.homedir)();
+exports.BQ_HOME = process.env.BQ_HOME || (0, node_path_1.join)(home, ".bq");
+exports.BQ_CONFIG_PATH = (0, node_path_1.join)(exports.BQ_HOME, "config.json");
+exports.BQ_QUEUE_DIR = (0, node_path_1.join)(exports.BQ_HOME, "queue");
+exports.BQ_ACTIVE_DIR = (0, node_path_1.join)(exports.BQ_HOME, "active");
+exports.BQ_RESULTS_DIR = (0, node_path_1.join)(exports.BQ_HOME, "results");
+exports.BQ_LOGS_DIR = (0, node_path_1.join)(exports.BQ_HOME, "logs");
+exports.BQ_PID_FILE = (0, node_path_1.join)(exports.BQ_HOME, "daemon.pid");
+exports.BQ_LOCK_FILE = (0, node_path_1.join)(exports.BQ_HOME, "daemon.lock");
+// Colors
+// Prefix for all log/status output
+const PREFIX = "xbq";
+const c = {
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    blue: (s) => `\x1b[34m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+exports.log = {
+    info: (msg) => console.log(`${c.blue(`[${PREFIX}]`)} ${msg}`),
+    ok: (msg) => console.log(`${c.green(`[${PREFIX}]`)} ${msg}`),
+    warn: (msg) => console.log(`${c.yellow(`[${PREFIX}]`)} ${msg}`),
+    error: (msg) => console.error(`${c.red(`[${PREFIX}]`)} ${msg}`),
+    status: (msg) => console.log(`${c.cyan(`[${PREFIX}]`)} ${msg}`),
+    dim: (msg) => console.log(`${c.dim(`[${PREFIX}] ${msg}`)}`),
+};
+function ensureDirs() {
+    for (const dir of [exports.BQ_HOME, exports.BQ_QUEUE_DIR, exports.BQ_ACTIVE_DIR, exports.BQ_RESULTS_DIR, exports.BQ_LOGS_DIR]) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+}
+function generateJobId() {
+    const now = new Date();
+    const ts = now.toISOString().replace(/[-:T]/g, "").slice(0, 14);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${ts}-${rand}`;
+}
+function expandPath(p) {
+    return p.startsWith("~") ? (0, node_path_1.join)(home, p.slice(1)) : p;
+}
+/**
+ * Run a command and return stdout. Throws on non-zero exit.
+ */
+function run(cmd, opts) {
+    try {
+        return (0, node_child_process_1.execSync)(cmd, {
+            cwd: opts?.cwd,
+            encoding: "utf-8",
+            stdio: opts?.quiet ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "inherit"],
+        }).trim();
+    }
+    catch (err) {
+        const e = err;
+        throw new Error(`Command failed: ${cmd}\n${e.stderr || e.message}`);
+    }
+}
+/**
+ * Spawn a long-running process and stream output to a log file + optional callback.
+ */
+function spawnWithLog(cmd, args, opts) {
+    return new Promise((resolve) => {
+        const logStream = require("node:fs").createWriteStream(opts.logPath, { flags: "a" });
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        const handleData = (data) => {
+            const text = data.toString();
+            output += text;
+            logStream.write(text);
+            if (opts.onLine) {
+                for (const line of text.split("\n").filter(Boolean)) {
+                    opts.onLine(line);
+                }
+            }
+        };
+        child.stdout?.on("data", handleData);
+        child.stderr?.on("data", handleData);
+        child.on("close", (code) => {
+            logStream.end();
+            resolve({ exitCode: code ?? 1, output });
+        });
+        child.on("error", (err) => {
+            logStream.end();
+            output += `\nProcess error: ${err.message}`;
+            resolve({ exitCode: 1, output });
+        });
+    });
+}
+/**
+ * Check if a process with the given PID is alive.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/worktree.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Create a new worktree and optionally start Claude Code in it.
+ */
+export declare function createWorktree(name?: string, opts?: {
+    startClaude?: boolean;
+}): string;
+/**
+ * List all worktrees.
+ */
+export declare function listWorktrees(): void;
+/**
+ * Clean up worktrees that have been merged or are stale.
+ */
+export declare function cleanWorktrees(opts?: {
+    force?: boolean;
+    maxAgeDays?: number;
+}): void;

package/dist/worktree.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorktree = createWorktree;
+exports.listWorktrees = listWorktrees;
+exports.cleanWorktrees = cleanWorktrees;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const config_js_1 = require("./config.js");
+const setup_claude_js_1 = require("./setup-claude.js");
+const utils_js_1 = require("./utils.js");
+const WORKTREE_DIR_NAME = "worktrees";
+function getWorktreeBase() {
+    const mainRepo = (0, config_js_1.getMainRepo)();
+    const parent = (0, node_path_1.join)(mainRepo, "..");
+    const repoName = (0, node_path_1.basename)(mainRepo);
+    return (0, node_path_1.join)(parent, `${repoName}-worktrees`);
+}
+/**
+ * Create a new worktree and optionally start Claude Code in it.
+ */
+function createWorktree(name, opts) {
+    const mainRepo = (0, config_js_1.getMainRepo)();
+    const base = getWorktreeBase();
+    // Generate name if not provided
+    if (!name) {
+        const ts = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 12);
+        const rand = Math.random().toString(36).slice(2, 6);
+        name = `session-${ts}-${rand}`;
+    }
+    const worktreePath = (0, node_path_1.join)(base, name);
+    if ((0, node_fs_1.existsSync)(worktreePath)) {
+        utils_js_1.log.warn(`Worktree already exists: ${worktreePath}`);
+        if (opts?.startClaude) {
+            launchClaude(worktreePath);
+        }
+        return worktreePath;
+    }
+    // Fetch latest first
+    utils_js_1.log.info("Fetching latest...");
+    (0, utils_js_1.run)("git fetch --all --prune", { cwd: mainRepo, quiet: true });
+    // Get default branch
+    const defaultBranch = getDefaultBranch(mainRepo);
+    // Create worktree with a new branch based on default branch
+    const branchName = name;
+    utils_js_1.log.info(`Creating worktree: ${name} (from ${defaultBranch})`);
+    try {
+        (0, utils_js_1.run)(`git worktree add -b ${branchName} "${worktreePath}" origin/${defaultBranch}`, { cwd: mainRepo, quiet: true });
+    }
+    catch {
+        // Branch might already exist
+        try {
+            (0, utils_js_1.run)(`git worktree add "${worktreePath}" ${branchName}`, { cwd: mainRepo, quiet: true });
+        }
+        catch (err) {
+            utils_js_1.log.error(`Failed to create worktree: ${err}`);
+            process.exit(1);
+        }
+    }
+    utils_js_1.log.ok(`Worktree created: ${worktreePath}`);
+    utils_js_1.log.dim(`Branch: ${branchName}`);
+    // Auto-inject xbq instructions into CLAUDE.md
+    (0, setup_claude_js_1.setupClaude)(worktreePath);
+    if (opts?.startClaude) {
+        launchClaude(worktreePath);
+    }
+    return worktreePath;
+}
+/**
+ * List all worktrees.
+ */
+function listWorktrees() {
+    const mainRepo = (0, config_js_1.getMainRepo)();
+    const worktrees = getWorktrees(mainRepo);
+    if (worktrees.length === 0) {
+        utils_js_1.log.info("No worktrees found");
+        return;
+    }
+    console.log();
+    for (const wt of worktrees) {
+        const icon = wt.isMain ? "📦" : "🌿";
+        const age = getAge(wt.path);
+        const status = wt.isMain ? "(main)" : age;
+        console.log(`  ${icon} ${wt.branch.padEnd(30)} ${wt.path}`);
+        console.log(`     ${wt.head.slice(0, 8)} ${status}`);
+    }
+    console.log();
+}
+/**
+ * Clean up worktrees that have been merged or are stale.
+ */
+function cleanWorktrees(opts) {
+    const mainRepo = (0, config_js_1.getMainRepo)();
+    const defaultBranch = getDefaultBranch(mainRepo);
+    const worktrees = getWorktrees(mainRepo).filter(wt => !wt.isMain);
+    if (worktrees.length === 0) {
+        utils_js_1.log.info("No worktrees to clean");
+        return;
+    }
+    const maxAge = (opts?.maxAgeDays ?? 7) * 86400 * 1000;
+    let cleaned = 0;
+    for (const wt of worktrees) {
+        const shouldClean = shouldCleanWorktree(wt, mainRepo, defaultBranch, maxAge, opts?.force);
+        if (shouldClean.clean) {
+            utils_js_1.log.info(`Removing: ${wt.branch} — ${shouldClean.reason}`);
+            try {
+                (0, utils_js_1.run)(`git worktree remove "${wt.path}" --force`, { cwd: mainRepo, quiet: true });
+                // Also delete the branch if it was merged
+                if (shouldClean.reason.includes("merged")) {
+                    try {
+                        (0, utils_js_1.run)(`git branch -d ${wt.branch}`, { cwd: mainRepo, quiet: true });
+                    }
+                    catch {
+                        // Branch might not exist or can't be deleted
+                    }
+                }
+                cleaned++;
+            }
+            catch (err) {
+                utils_js_1.log.warn(`Could not remove ${wt.branch}: ${err}`);
+            }
+        }
+    }
+    if (cleaned > 0) {
+        utils_js_1.log.ok(`Cleaned ${cleaned} worktree(s)`);
+        // Prune stale worktree refs
+        (0, utils_js_1.run)("git worktree prune", { cwd: mainRepo, quiet: true });
+    }
+    else {
+        utils_js_1.log.info("Nothing to clean");
+    }
+}
+function shouldCleanWorktree(wt, mainRepo, defaultBranch, maxAge, force) {
+    // Check if branch is merged into default branch
+    try {
+        const merged = (0, utils_js_1.run)(`git branch --merged origin/${defaultBranch}`, { cwd: mainRepo, quiet: true });
+        if (merged.split("\n").some(b => b.trim() === wt.branch)) {
+            return { clean: true, reason: "merged into " + defaultBranch };
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Check if worktree has no uncommitted changes and is old
+    if (force) {
+        return { clean: true, reason: "force clean" };
+    }
+    // Check age
+    try {
+        const stat = (0, node_fs_1.statSync)(wt.path);
+        const age = Date.now() - stat.mtimeMs;
+        if (age > maxAge) {
+            // Check for uncommitted changes
+            const status = (0, utils_js_1.run)("git status --porcelain", { cwd: wt.path, quiet: true });
+            if (status.length === 0) {
+                return { clean: true, reason: `stale (${Math.round(age / 86400000)}d old, no changes)` };
+            }
+        }
+    }
+    catch {
+        // Can't stat, probably already gone
+        return { clean: true, reason: "path inaccessible" };
+    }
+    return { clean: false, reason: "" };
+}
+function getWorktrees(mainRepo) {
+    const output = (0, utils_js_1.run)("git worktree list --porcelain", { cwd: mainRepo, quiet: true });
+    const worktrees = [];
+    let current = {};
+    for (const line of output.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current.path)
+                worktrees.push(current);
+            current = { path: line.slice(9), isMain: false };
+        }
+        else if (line.startsWith("HEAD ")) {
+            current.head = line.slice(5);
+        }
+        else if (line.startsWith("branch ")) {
+            current.branch = line.slice(7).replace("refs/heads/", "");
+        }
+        else if (line === "bare") {
+            current.isMain = true;
+            current.branch = current.branch || "(bare)";
+        }
+    }
+    if (current.path)
+        worktrees.push(current);
+    // Mark the main repo
+    if (worktrees.length > 0) {
+        worktrees[0].isMain = true;
+    }
+    return worktrees;
+}
+function getDefaultBranch(repoPath) {
+    try {
+        const ref = (0, utils_js_1.run)("git symbolic-ref refs/remotes/origin/HEAD", { cwd: repoPath, quiet: true });
+        return ref.replace("refs/remotes/origin/", "");
+    }
+    catch {
+        // Try common defaults
+        for (const branch of ["master", "main", "develop"]) {
+            try {
+                (0, utils_js_1.run)(`git rev-parse --verify origin/${branch}`, { cwd: repoPath, quiet: true });
+                return branch;
+            }
+            catch {
+                continue;
+            }
+        }
+        return "master";
+    }
+}
+function getAge(path) {
+    try {
+        const stat = (0, node_fs_1.statSync)(path);
+        const days = Math.round((Date.now() - stat.mtimeMs) / 86400000);
+        if (days === 0)
+            return "today";
+        if (days === 1)
+            return "1 day ago";
+        return `${days} days ago`;
+    }
+    catch {
+        return "unknown";
+    }
+}
+function launchClaude(worktreePath) {
+    utils_js_1.log.info(`Starting Claude Code in ${worktreePath}`);
+    try {
+        (0, node_child_process_1.execSync)(`claude`, {
+            cwd: worktreePath,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        // Claude exited, that's fine
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "xcode-build-queue",
+  "version": "0.1.0",
+  "description": "Serial build queue for Xcode projects with git worktrees",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a-ulkhan/xbq.git"
+  },
+  "keywords": [
+    "xcode",
+    "build",
+    "queue",
+    "worktree",
+    "swift",
+    "ios"
+  ],
+  "bin": {
+    "xbq": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "dev": "tsx src/cli.ts",
+    "watch": "tsc --watch"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}