worktree-compose 0.1.0

package/dist/commands/clean.js

@@ -0,0 +1,49 @@
+import { getRepoRoot, getRepoName } from "../compose/detect.js";
+import { getNonMainWorktrees } from "../git/worktree.js";
+import { composeProjectName } from "../utils/sanitize.js";
+import { exec, execSafe } from "../utils/exec.js";
+import * as log from "../utils/log.js";
+export function cleanCommand() {
+    const repoRoot = getRepoRoot();
+    const repoName = getRepoName(repoRoot);
+    const worktrees = getNonMainWorktrees(repoRoot);
+    const currentWt = execSafe("git rev-parse --show-toplevel") ?? repoRoot;
+    for (let i = 0; i < worktrees.length; i++) {
+        const wt = worktrees[i];
+        const idx = i + 1;
+        const project = composeProjectName(repoName, idx, wt.branch);
+        log.info(`Stopping containers for ${project}...`);
+        try {
+            exec(`docker compose -p "${project}" down`, { cwd: wt.path });
+        }
+        catch {
+            // already stopped
+        }
+        if (wt.path === currentWt) {
+            log.warn(`Skipping removal of current worktree: ${wt.path}`);
+            continue;
+        }
+        log.info(`Removing worktree: ${wt.path}`);
+        try {
+            exec(`git -C "${repoRoot}" worktree remove "${wt.path}" --force`);
+        }
+        catch {
+            log.warn(`Could not remove ${wt.path}`);
+        }
+    }
+    execSafe(`git -C "${repoRoot}" worktree prune`);
+    const staleContainers = execSafe(`docker ps -aq --filter "label=com.docker.compose.project" --filter "name=-wt-"`);
+    if (staleContainers) {
+        log.info("Removing stale worktree containers...");
+        execSafe(`docker rm -f ${staleContainers}`);
+    }
+    const staleNetworks = execSafe(`docker network ls -q --filter "name=${repoName}-wt-"`);
+    if (staleNetworks) {
+        execSafe(`docker network rm ${staleNetworks}`);
+    }
+    const staleVolumes = execSafe(`docker volume ls -q --filter "name=${repoName}-wt-"`);
+    if (staleVolumes) {
+        execSafe(`docker volume rm ${staleVolumes}`);
+    }
+    log.success("Cleanup complete.");
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): void;

package/dist/commands/list.js

@@ -0,0 +1,71 @@
+import Table from "cli-table3";
+import chalk from "chalk";
+import { buildContext } from "../context.js";
+import { allocateWorktreePorts } from "../ports/allocate.js";
+import { composeProjectName } from "../utils/sanitize.js";
+import { execSafe } from "../utils/exec.js";
+import { warn } from "../utils/log.js";
+import { suggestEnvVar } from "../ports/extract.js";
+function isWorktreeUp(projectName, wtPath) {
+    const result = execSafe(`docker compose -p "${projectName}" ps --format json`, { cwd: wtPath });
+    return result !== null && result.length > 2;
+}
+export function listCommand() {
+    const ctx = buildContext();
+    const rawPorts = ctx.portMappings.filter((m) => m.envVar === null);
+    for (const p of rawPorts) {
+        warn(`Service "${p.serviceName}" uses a raw port mapping (${p.raw}). ` +
+            `To enable port isolation, change it to: "\${${suggestEnvVar(p.serviceName)}:-${p.defaultPort}}:${p.containerPort}"`);
+    }
+    if (ctx.worktrees.length === 0) {
+        console.log("\nNo extra worktrees found. Create one with:\n  git worktree add ../my-branch my-branch\n");
+        return;
+    }
+    const table = new Table({
+        head: [
+            chalk.white("Index"),
+            chalk.white("Branch"),
+            chalk.white("Status"),
+            chalk.white("URL"),
+            chalk.white("Ports"),
+        ],
+    });
+    const overridable = ctx.portMappings.filter((m) => m.envVar !== null);
+    const defaultPorts = overridable
+        .map((m) => `${m.serviceName}:${m.defaultPort}`)
+        .join(" ");
+    table.push([
+        chalk.dim("-"),
+        chalk.dim("main"),
+        chalk.dim("-"),
+        chalk.dim("-"),
+        chalk.dim(defaultPorts),
+    ]);
+    for (let i = 0; i < ctx.worktrees.length; i++) {
+        const wt = ctx.worktrees[i];
+        const idx = i + 1;
+        const project = composeProjectName(ctx.repoName, idx, wt.branch);
+        const allocations = allocateWorktreePorts(ctx.portMappings, idx);
+        const up = isWorktreeUp(project, wt.path);
+        const ports = allocations
+            .map((a) => `${a.serviceName}:${a.port}`)
+            .join(" ");
+        const frontendAlloc = allocations.find((a) => a.serviceName.includes("frontend") ||
+            a.serviceName.includes("web") ||
+            a.serviceName.includes("app") ||
+            a.serviceName.includes("ui"));
+        const url = frontendAlloc
+            ? `http://localhost:${frontendAlloc.port}`
+            : allocations.length > 0
+                ? `http://localhost:${allocations[allocations.length - 1].port}`
+                : "-";
+        table.push([
+            String(idx),
+            wt.branch,
+            up ? chalk.green("up") : chalk.red("down"),
+            up ? chalk.underline(url) : chalk.dim(url),
+            ports,
+        ]);
+    }
+    console.log(table.toString());
+}

package/dist/commands/promote.d.ts

@@ -0,0 +1 @@
+export declare function promoteCommand(index: number): void;

package/dist/commands/promote.js

@@ -0,0 +1,35 @@
+import { getRepoRoot } from "../compose/detect.js";
+import { getWorktreeByIndex, getWorktreeBranch, } from "../git/worktree.js";
+import { getChangedFiles, getLocalDirtyFiles, findConflicts, promoteFiles, } from "../git/promote.js";
+import * as log from "../utils/log.js";
+export function promoteCommand(index) {
+    const repoRoot = getRepoRoot();
+    const wt = getWorktreeByIndex(repoRoot, index);
+    if (!wt) {
+        log.error(`Worktree index ${index} not found. Run 'wtc list' to see available worktrees.`);
+        process.exit(1);
+    }
+    const currentBranch = getWorktreeBranch(repoRoot);
+    const displayCurrent = currentBranch === "HEAD" ? "detached HEAD" : currentBranch;
+    log.info(`Promoting worktree ${index} (${wt.branch}) into ${displayCurrent}`);
+    const files = getChangedFiles(repoRoot, wt.path, currentBranch, wt.branch);
+    if (files.length === 0) {
+        log.info("No changes to promote.");
+        return;
+    }
+    const dirtyFiles = getLocalDirtyFiles(repoRoot);
+    const conflicts = findConflicts(files, dirtyFiles);
+    if (conflicts.length > 0) {
+        log.error("Abort: the following files have uncommitted changes and would be overwritten:");
+        for (const f of conflicts) {
+            console.log(`  ${f}`);
+        }
+        console.log("\nCommit or stash your local changes first, then re-run promote.");
+        process.exit(1);
+    }
+    promoteFiles(repoRoot, wt.path, files);
+    log.success(`Promoted ${files.length} file(s). Changes are uncommitted in ${currentBranch}.`);
+    for (const f of files) {
+        console.log(`  ${f}`);
+    }
+}

package/dist/commands/restart.d.ts

@@ -0,0 +1 @@
+export declare function restartCommand(indices: number[]): void;

package/dist/commands/restart.js

@@ -0,0 +1,6 @@
+import { stopCommand } from "./stop.js";
+import { startCommand } from "./start.js";
+export function restartCommand(indices) {
+    stopCommand(indices);
+    startCommand(indices);
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(indices: number[]): void;

package/dist/commands/start.js

@@ -0,0 +1,37 @@
+import { buildContext, filterWorktrees } from "../context.js";
+import { allocateWorktreePorts } from "../ports/allocate.js";
+import { composeProjectName } from "../utils/sanitize.js";
+import { execLive } from "../utils/exec.js";
+import { syncWorktreeFiles } from "../sync/files.js";
+import { copyBaseEnv, injectPortOverrides } from "../sync/env.js";
+import * as log from "../utils/log.js";
+import { listCommand } from "./list.js";
+export function startCommand(indices) {
+    const ctx = buildContext();
+    if (ctx.worktrees.length === 0) {
+        log.warn("No extra worktrees found. Create one with:\n  git worktree add ../my-branch my-branch");
+        return;
+    }
+    const targets = filterWorktrees(ctx.worktrees, indices);
+    for (const wt of targets) {
+        const idx = ctx.worktrees.indexOf(wt) + 1;
+        const project = composeProjectName(ctx.repoName, idx, wt.branch);
+        const allocations = allocateWorktreePorts(ctx.portMappings, idx);
+        log.header(`Worktree ${idx}: ${wt.branch}`);
+        log.info(`Path:    ${wt.path}`);
+        log.info(`Project: ${project}`);
+        log.info(`Ports:   ${allocations.map((a) => `${a.envVar}=${a.port}`).join(" ")}`);
+        syncWorktreeFiles(ctx.repoRoot, wt.path, ctx.composeFile, ctx.config.sync);
+        log.success("Synced infrastructure files");
+        copyBaseEnv(ctx.repoRoot, wt.path);
+        injectPortOverrides(`${wt.path}/.env`, allocations, ctx.config.envOverrides);
+        log.success("Injected port overrides into .env");
+        execLive(`docker compose -p "${project}" up -d --build`, {
+            cwd: wt.path,
+            env: { ...process.env, COMPOSE_PROJECT_NAME: project },
+        });
+        log.success(`Worktree ${idx} started`);
+    }
+    console.log("");
+    listCommand();
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare function stopCommand(indices: number[]): void;

package/dist/commands/stop.js

@@ -0,0 +1,24 @@
+import { buildContext, filterWorktrees } from "../context.js";
+import { composeProjectName } from "../utils/sanitize.js";
+import { execLive } from "../utils/exec.js";
+import * as log from "../utils/log.js";
+export function stopCommand(indices) {
+    const ctx = buildContext();
+    if (ctx.worktrees.length === 0) {
+        log.warn("No worktrees to stop.");
+        return;
+    }
+    const targets = filterWorktrees(ctx.worktrees, indices);
+    for (const wt of targets) {
+        const idx = ctx.worktrees.indexOf(wt) + 1;
+        const project = composeProjectName(ctx.repoName, idx, wt.branch);
+        log.info(`Stopping ${project}...`);
+        try {
+            execLive(`docker compose -p "${project}" down`, { cwd: wt.path });
+            log.success(`Stopped worktree ${idx} (${wt.branch})`);
+        }
+        catch {
+            log.warn(`Could not stop ${project} (may already be stopped)`);
+        }
+    }
+}

package/dist/compose/detect.d.ts

@@ -0,0 +1,3 @@
+export declare function getRepoRoot(cwd?: string): string;
+export declare function getRepoName(repoRoot: string): string;
+export declare function detectComposeFile(repoRoot: string): string | null;

package/dist/compose/detect.js

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+import { exec } from "../utils/exec.js";
+const COMPOSE_FILENAMES = [
+    "compose.yaml",
+    "compose.yml",
+    "docker-compose.yaml",
+    "docker-compose.yml",
+];
+export function getRepoRoot(cwd) {
+    return exec("git rev-parse --show-toplevel", {
+        cwd: cwd ?? process.cwd(),
+    });
+}
+export function getRepoName(repoRoot) {
+    return path.basename(repoRoot);
+}
+export function detectComposeFile(repoRoot) {
+    for (const name of COMPOSE_FILENAMES) {
+        const full = path.join(repoRoot, name);
+        if (fs.existsSync(full))
+            return full;
+    }
+    return null;
+}

package/dist/compose/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ComposeFile } from "./types.js";
+export declare function parseComposeFile(composePath: string): ComposeFile;

package/dist/compose/parse.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import { parse as parseYaml } from "yaml";
+function parseServicePorts(ports) {
+    if (!Array.isArray(ports))
+        return [];
+    return ports.flatMap((p) => {
+        if (typeof p === "string")
+            return [p];
+        if (typeof p === "number")
+            return [String(p)];
+        if (typeof p === "object" && p !== null) {
+            const obj = p;
+            if (obj.published != null && obj.target != null) {
+                return [`${obj.published}:${obj.target}`];
+            }
+        }
+        return [];
+    });
+}
+function parseServiceBuild(build) {
+    if (typeof build === "string") {
+        return { context: build };
+    }
+    if (typeof build === "object" && build !== null) {
+        const obj = build;
+        return {
+            context: typeof obj.context === "string" ? obj.context : undefined,
+            dockerfile: typeof obj.dockerfile === "string" ? obj.dockerfile : undefined,
+        };
+    }
+    return undefined;
+}
+function parseEnvFile(envFile) {
+    if (typeof envFile === "string")
+        return [envFile];
+    if (Array.isArray(envFile)) {
+        return envFile.filter((e) => typeof e === "string");
+    }
+    return undefined;
+}
+export function parseComposeFile(composePath) {
+    const raw = fs.readFileSync(composePath, "utf-8");
+    const doc = parseYaml(raw, { uniqueKeys: false });
+    if (!doc || typeof doc !== "object" || !("services" in doc)) {
+        return { services: [], composePath };
+    }
+    const servicesObj = doc.services;
+    const services = Object.entries(servicesObj).map(([name, svc]) => ({
+        name,
+        ports: parseServicePorts(svc.ports),
+        build: parseServiceBuild(svc.build),
+        envFile: parseEnvFile(svc.env_file),
+    }));
+    return { services, composePath };
+}

package/dist/compose/types.d.ts

@@ -0,0 +1,13 @@
+export interface ComposeService {
+    name: string;
+    ports: string[];
+    build?: {
+        context?: string;
+        dockerfile?: string;
+    };
+    envFile?: string[];
+}
+export interface ComposeFile {
+    services: ComposeService[];
+    composePath: string;
+}

package/dist/compose/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+export interface WtcConfig {
+    sync?: string[];
+    envOverrides?: Record<string, string>;
+}
+export declare function loadConfig(repoRoot: string): WtcConfig;

package/dist/config.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+export function loadConfig(repoRoot) {
+    const rcPath = path.join(repoRoot, ".wtcrc.json");
+    if (fs.existsSync(rcPath)) {
+        return JSON.parse(fs.readFileSync(rcPath, "utf-8"));
+    }
+    const pkgPath = path.join(repoRoot, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.wtc && typeof pkg.wtc === "object") {
+            return pkg.wtc;
+        }
+    }
+    return {};
+}

package/dist/context.d.ts

@@ -0,0 +1,14 @@
+import type { ComposeFile } from "./compose/types.js";
+import type { PortMapping } from "./ports/types.js";
+import type { WtcConfig } from "./config.js";
+import type { WorktreeInfo } from "./git/worktree.js";
+export interface WtcContext {
+    repoRoot: string;
+    repoName: string;
+    composeFile: ComposeFile;
+    portMappings: PortMapping[];
+    config: WtcConfig;
+    worktrees: WorktreeInfo[];
+}
+export declare function buildContext(): WtcContext;
+export declare function filterWorktrees(worktrees: WorktreeInfo[], indices: number[]): WorktreeInfo[];

package/dist/context.js

@@ -0,0 +1,29 @@
+import { getRepoRoot, getRepoName, detectComposeFile } from "./compose/detect.js";
+import { parseComposeFile } from "./compose/parse.js";
+import { extractPortMappings } from "./ports/extract.js";
+import { loadConfig } from "./config.js";
+import { getNonMainWorktrees } from "./git/worktree.js";
+export function buildContext() {
+    const repoRoot = getRepoRoot();
+    const repoName = getRepoName(repoRoot);
+    const composePath = detectComposeFile(repoRoot);
+    if (!composePath) {
+        throw new Error(`No compose file found in ${repoRoot}. Expected one of: compose.yaml, compose.yml, docker-compose.yaml, docker-compose.yml`);
+    }
+    const composeFile = parseComposeFile(composePath);
+    const portMappings = extractPortMappings(composeFile.services);
+    const config = loadConfig(repoRoot);
+    const worktrees = getNonMainWorktrees(repoRoot);
+    return { repoRoot, repoName, composeFile, portMappings, config, worktrees };
+}
+export function filterWorktrees(worktrees, indices) {
+    if (indices.length === 0)
+        return worktrees;
+    return indices
+        .map((i) => {
+        const wt = worktrees[i - 1];
+        if (!wt)
+            throw new Error(`Worktree index ${i} not found. Run 'wtc list' to see available worktrees.`);
+        return wt;
+    });
+}

package/dist/git/promote.d.ts

@@ -0,0 +1,4 @@
+export declare function getChangedFiles(repoRoot: string, wtPath: string, currentBranch: string, wtBranch: string): string[];
+export declare function getLocalDirtyFiles(repoRoot: string): string[];
+export declare function findConflicts(files: string[], dirtyFiles: string[]): string[];
+export declare function promoteFiles(repoRoot: string, wtPath: string, files: string[]): void;

package/dist/git/promote.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+import { exec, execSafe } from "../utils/exec.js";
+const PROMOTE_EXCLUDES = new Set([
+    ".env",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+]);
+function resolveRef(repoRoot, ref) {
+    return exec(`git -C "${repoRoot}" rev-parse "${ref}"`);
+}
+export function getChangedFiles(repoRoot, wtPath, currentBranch, wtBranch) {
+    const currentRef = resolveRef(repoRoot, currentBranch === "HEAD" ? "HEAD" : currentBranch);
+    const wtRef = resolveRef(wtPath, "HEAD");
+    const mergeBase = exec(`git -C "${repoRoot}" merge-base "${currentRef}" "${wtRef}"`);
+    const committed = execSafe(`git -C "${wtPath}" diff --name-only "${mergeBase}" HEAD`) ?? "";
+    let uncommitted = "";
+    const hasStagedOrUnstaged = execSafe(`git -C "${wtPath}" diff --quiet`) === null ||
+        execSafe(`git -C "${wtPath}" diff --cached --quiet`) === null;
+    if (hasStagedOrUnstaged) {
+        uncommitted = execSafe(`git -C "${wtPath}" diff --name-only HEAD`) ?? "";
+    }
+    const untracked = execSafe(`git -C "${wtPath}" ls-files --others --exclude-standard`) ?? "";
+    const allFiles = [committed, uncommitted, untracked]
+        .join("\n")
+        .split("\n")
+        .map((f) => f.trim())
+        .filter(Boolean);
+    const unique = [...new Set(allFiles)];
+    return unique.filter((f) => !PROMOTE_EXCLUDES.has(f));
+}
+export function getLocalDirtyFiles(repoRoot) {
+    const unstaged = execSafe(`git -C "${repoRoot}" diff --name-only HEAD`) ?? "";
+    const staged = execSafe(`git -C "${repoRoot}" diff --cached --name-only HEAD`) ?? "";
+    return [...new Set([unstaged, staged].join("\n").split("\n"))]
+        .map((f) => f.trim())
+        .filter(Boolean);
+}
+export function findConflicts(files, dirtyFiles) {
+    const dirtySet = new Set(dirtyFiles);
+    return files.filter((f) => dirtySet.has(f));
+}
+export function promoteFiles(repoRoot, wtPath, files) {
+    for (const f of files) {
+        const src = path.join(wtPath, f);
+        const dst = path.join(repoRoot, f);
+        if (fs.existsSync(src)) {
+            fs.mkdirSync(path.dirname(dst), { recursive: true });
+            fs.copyFileSync(src, dst);
+        }
+        else {
+            if (fs.existsSync(dst))
+                fs.unlinkSync(dst);
+        }
+    }
+}

package/dist/git/worktree.d.ts

@@ -0,0 +1,10 @@
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    isMain: boolean;
+}
+export declare function getWorktrees(repoRoot: string): WorktreeInfo[];
+export declare function getNonMainWorktrees(repoRoot: string): WorktreeInfo[];
+export declare function getWorktreeByIndex(repoRoot: string, index: number): WorktreeInfo | null;
+export declare function getWorktreeBranch(wtPath: string): string;
+export declare function getWorktreeHead(wtPath: string): string;

package/dist/git/worktree.js

@@ -0,0 +1,40 @@
+import { exec, execSafe } from "../utils/exec.js";
+export function getWorktrees(repoRoot) {
+    const output = exec(`git -C "${repoRoot}" worktree list --porcelain`);
+    const blocks = output.split("\n\n").filter(Boolean);
+    const worktrees = [];
+    for (const block of blocks) {
+        const lines = block.split("\n");
+        let wtPath = "";
+        let branch = "detached";
+        for (const line of lines) {
+            if (line.startsWith("worktree ")) {
+                wtPath = line.slice("worktree ".length);
+            }
+            if (line.startsWith("branch ")) {
+                branch = line.slice("branch ".length).replace("refs/heads/", "");
+            }
+        }
+        if (wtPath) {
+            worktrees.push({
+                path: wtPath,
+                branch,
+                isMain: worktrees.length === 0,
+            });
+        }
+    }
+    return worktrees;
+}
+export function getNonMainWorktrees(repoRoot) {
+    return getWorktrees(repoRoot).filter((wt) => !wt.isMain);
+}
+export function getWorktreeByIndex(repoRoot, index) {
+    const nonMain = getNonMainWorktrees(repoRoot);
+    return nonMain[index - 1] ?? null;
+}
+export function getWorktreeBranch(wtPath) {
+    return (execSafe(`git -C "${wtPath}" rev-parse --abbrev-ref HEAD`) ?? "detached");
+}
+export function getWorktreeHead(wtPath) {
+    return exec(`git -C "${wtPath}" rev-parse HEAD`);
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;