@taranek/orche 0.0.8

package/.orche.example.json

@@ -0,0 +1,10 @@
+{
+  "multiplexer": "auto",
+  "layout": {
+    "direction": "horizontal",
+    "panes": [
+      { "name": "agent", "command": "claude" },
+      { "name": "dev", "command": "yarn dev" }
+    ]
+  }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, watch, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import path from "node:path";
+import { createWorktree } from "./worktree.js";
+import { getMultiplexer } from "./multiplexer.js";
+import { buildLayout } from "./layout.js";
+import { getReviewBinaryPath } from "./review-manager.js";
+const CONFIG_NAME = ".orche.json";
+const CONFIG_LOCAL_NAME = ".orche.local.json";
+function die(msg) {
+    console.error(`error: ${msg}`);
+    process.exit(1);
+}
+function loadConfig(cwd) {
+    const localPath = path.join(cwd, CONFIG_LOCAL_NAME);
+    const configPath = path.join(cwd, CONFIG_NAME);
+    if (existsSync(localPath)) {
+        const raw = readFileSync(localPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    if (!existsSync(configPath)) {
+        die(`no ${CONFIG_NAME} found in ${cwd}`);
+    }
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+}
+function deliverReview(pendingPath) {
+    try {
+        const pending = JSON.parse(readFileSync(pendingPath, "utf-8"));
+        const { reviewPath, multiplexer, paneId, workspaceId } = pending;
+        const markdown = readFileSync(reviewPath, "utf-8");
+        if (multiplexer === "tmux" && paneId) {
+            // Use load-buffer/paste-buffer instead of send-keys to safely handle
+            // multi-line markdown with special characters
+            const tmpFile = pendingPath + ".tmp";
+            writeFileSync(tmpFile, markdown);
+            execFileSync("tmux", ["load-buffer", tmpFile]);
+            execFileSync("tmux", ["paste-buffer", "-t", paneId]);
+            execFileSync("tmux", ["send-keys", "-t", paneId, "Enter"]);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { }
+        }
+        else if (multiplexer === "cmux" && paneId) {
+            const escaped = markdown.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+            execFileSync("cmux", ["send", "--surface", paneId, ...(workspaceId ? ["--workspace", workspaceId] : []), "--", escaped]);
+            execFileSync("cmux", ["send-key", "--surface", paneId, ...(workspaceId ? ["--workspace", workspaceId] : []), "enter"]);
+        }
+        try {
+            unlinkSync(pendingPath);
+        }
+        catch { }
+        console.log("[review] delivered review to agent");
+    }
+    catch (err) {
+        console.error("[review] delivery failed:", err?.message ?? err);
+    }
+}
+async function runReview(worktreePath) {
+    const resolvedPath = path.resolve(worktreePath);
+    const args = ["--worktree=" + resolvedPath];
+    console.log(`opening review for ${worktreePath}...`);
+    // Watch for .pending files from the Electron app and deliver them
+    // (Electron can't access the cmux socket — only CLI processes can)
+    const repoRoot = getRepoRoot(resolvedPath);
+    const worktreeName = path.basename(resolvedPath);
+    const reviewsDir = path.join(repoRoot, ".orche", "reviews", worktreeName);
+    mkdirSync(reviewsDir, { recursive: true });
+    // CLI stays alive to watch for .pending files and deliver them via cmux/tmux
+    // (Electron can't access the cmux socket — only processes started inside cmux can)
+    const watcher = watch(reviewsDir, (event, filename) => {
+        if (event === "rename" && filename?.endsWith(".pending")) {
+            const pendingPath = path.join(reviewsDir, filename);
+            deliverReview(pendingPath);
+            watcher.close();
+            process.exit(0);
+        }
+    });
+    // Dev mode: launch electron from local monorepo
+    const cliDir = path.dirname(new URL(import.meta.url).pathname);
+    const localReviewDir = path.resolve(cliDir, "../../review");
+    const devReviewPath = process.env.ORCHE_REVIEW_DEV ||
+        (existsSync(path.join(localReviewDir, "package.json")) ? localReviewDir : undefined);
+    const debug = !!process.env.ORCHE_DEBUG;
+    if (devReviewPath) {
+        const electronBin = path.join(devReviewPath, "node_modules/.bin/electron");
+        if (debug)
+            console.error(`[review] launching: ${electronBin} ${[devReviewPath, ...args].join(" ")}`);
+        spawn(electronBin, [devReviewPath, ...args], {
+            stdio: ["ignore", "inherit", "inherit"],
+            env: { ...process.env, VITE_DEV_SERVER_URL: undefined },
+        });
+        return;
+    }
+    const binaryPath = await getReviewBinaryPath();
+    if (debug)
+        console.error(`[review] launching: ${binaryPath} ${args.join(" ")}`);
+    spawn(binaryPath, args, {
+        stdio: ["ignore", "inherit", "inherit"],
+    });
+}
+function getRepoRoot(cwd) {
+    // If we're inside an orche worktree, walk up to the real repo
+    const orcheIdx = cwd.indexOf("/.orche/worktrees/");
+    if (orcheIdx !== -1) {
+        return cwd.slice(0, orcheIdx);
+    }
+    return cwd;
+}
+function startSession() {
+    const cwd = getRepoRoot(process.cwd());
+    const repoName = path.basename(cwd);
+    const taskName = process.argv.slice(3).find((a) => !a.startsWith("--")) || "session";
+    const config = loadConfig(cwd);
+    const muxFlag = process.argv.includes("--tmux") ? "tmux" :
+        process.argv.includes("--cmux") ? "cmux" :
+            undefined;
+    const mux = getMultiplexer(muxFlag ?? config.multiplexer);
+    // 1. Create worktree
+    console.log(`creating worktree for "${taskName}"...`);
+    const { worktreePath } = createWorktree(cwd, taskName);
+    // 2. Create session
+    const sessionName = `${repoName}-${taskName}`.replace(/[^a-zA-Z0-9_-]/g, "-");
+    mux.createSession(sessionName, worktreePath);
+    console.log(`${mux.name} session: ${sessionName}`);
+    // 3. Build pane layout
+    buildLayout(mux, sessionName, config.layout, worktreePath);
+    // 4. Attach
+    mux.attach(sessionName);
+}
+function printUsage() {
+    console.log(`
+orche — orchestrate agents across git worktrees
+
+Usage:
+  orche start <task>         Start a new session for <task>
+  orche review [path]        Open the review UI for a worktree
+
+Examples:
+  orche start fix-auth       Create worktree + session for "fix-auth"
+  orche review               Review changes in current directory
+  orche review ./worktree    Review changes in a specific worktree
+
+Requires a ${CONFIG_NAME} file in the current directory.
+Use ${CONFIG_LOCAL_NAME} for local overrides (not committed).
+See .orche.example.json for the config format.
+`);
+}
+async function main() {
+    const subcommand = process.argv[2];
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        printUsage();
+        process.exit(0);
+    }
+    if (subcommand === "start") {
+        startSession();
+    }
+    else if (subcommand === "review") {
+        const explicitPath = process.argv[3] && !process.argv[3].startsWith("--")
+            ? process.argv[3]
+            : undefined;
+        const worktreePath = explicitPath || process.cwd();
+        await runReview(worktreePath);
+    }
+    else {
+        console.error(`Unknown command: ${subcommand}\nRun "orche --help" for usage.`);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`error: ${err.message}`);
+    process.exit(1);
+});

package/dist/layout.d.ts

@@ -0,0 +1,11 @@
+import { type PaneConfig, type SplitConfig } from "./types.js";
+import type { Multiplexer } from "./multiplexer.js";
+export interface SessionInfo {
+    multiplexer: string;
+    panes: Record<string, string>;
+    workspaceId?: string;
+}
+/**
+ * Recursively build a pane layout using the given multiplexer.
+ */
+export declare function buildLayout(mux: Multiplexer, session: string, node: PaneConfig | SplitConfig, worktreePath: string): void;

package/dist/layout.js

@@ -0,0 +1,69 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { isSplit } from "./types.js";
+/**
+ * Recursively build a pane layout using the given multiplexer.
+ */
+export function buildLayout(mux, session, node, worktreePath) {
+    const paneMap = {};
+    if (!isSplit(node)) {
+        const paneId = mux.getActivePaneId(session);
+        paneMap[node.name] = paneId;
+        mux.renamePaneTitle(paneId, node.name);
+        if (node.command)
+            mux.sendCommand(session, node.command);
+        saveSessionInfo(mux.name, paneMap, worktreePath);
+        return;
+    }
+    const paneIds = [mux.getActivePaneId(session)];
+    for (let i = 1; i < node.panes.length; i++) {
+        const child = node.panes[i];
+        const sizePercent = child.size ?? Math.floor(100 / (node.panes.length - i + 1));
+        mux.splitPane(paneIds[0], node.direction, sizePercent, worktreePath);
+        paneIds.push(mux.getActivePaneId(session));
+    }
+    const allPaneIds = mux.listPaneIds(session);
+    for (let i = 0; i < node.panes.length; i++) {
+        const child = node.panes[i];
+        const paneId = allPaneIds[i];
+        if (isSplit(child)) {
+            mux.focusPane(paneId);
+            collectPaneMap(mux, session, child, paneId, worktreePath, paneMap);
+        }
+        else {
+            paneMap[child.name] = paneId;
+            mux.renamePaneTitle(paneId, child.name);
+            if (child.command)
+                mux.sendCommand(paneId, child.command);
+        }
+    }
+    saveSessionInfo(mux.name, paneMap, worktreePath);
+}
+function collectPaneMap(mux, session, node, parentPaneId, worktreePath, paneMap) {
+    const paneIds = [parentPaneId];
+    for (let i = 1; i < node.panes.length; i++) {
+        const child = node.panes[i];
+        const sizePercent = child.size ?? Math.floor(100 / (node.panes.length - i + 1));
+        mux.splitPane(paneIds[i - 1], node.direction, sizePercent, worktreePath);
+        paneIds.push(mux.getActivePaneId(session));
+    }
+    for (let i = 0; i < node.panes.length; i++) {
+        const child = node.panes[i];
+        if (isSplit(child)) {
+            collectPaneMap(mux, session, child, paneIds[i], worktreePath, paneMap);
+        }
+        else {
+            paneMap[child.name] = paneIds[i];
+            mux.renamePaneTitle(paneIds[i], child.name);
+            if (child.command)
+                mux.sendCommand(paneIds[i], child.command);
+        }
+    }
+}
+function saveSessionInfo(multiplexer, panes, worktreePath) {
+    const orcheDir = path.join(worktreePath, ".orche");
+    mkdirSync(orcheDir, { recursive: true });
+    const workspaceId = process.env.CMUX_WORKSPACE_ID || undefined;
+    const info = { multiplexer, panes, workspaceId };
+    writeFileSync(path.join(orcheDir, "session.json"), JSON.stringify(info, null, 2));
+}

package/dist/multiplexer.d.ts

@@ -0,0 +1,16 @@
+import type { MultiplexerType } from "./types.js";
+export interface Multiplexer {
+    readonly name: string;
+    createSession(name: string, cwd: string): void;
+    killSession(name: string): void;
+    attach(name: string): void;
+    getActivePaneId(session: string): string;
+    listPaneIds(session: string): string[];
+    splitPane(target: string, direction: "horizontal" | "vertical", sizePercent: number, cwd: string): void;
+    focusPane(paneId: string): void;
+    renamePaneTitle(paneId: string, name: string): void;
+    sendCommand(target: string, command: string): void;
+    isInsideSession(): boolean;
+    detectFirstPane(): string | undefined;
+}
+export declare function getMultiplexer(preference?: MultiplexerType): Multiplexer;

package/dist/multiplexer.js

@@ -0,0 +1,30 @@
+import { execSync } from "node:child_process";
+import { TmuxMultiplexer } from "./multiplexers/tmux.js";
+import { CmuxMultiplexer } from "./multiplexers/cmux.js";
+function isAvailable(bin) {
+    try {
+        execSync(`which ${bin}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getMultiplexer(preference = "auto") {
+    if (preference === "tmux") {
+        if (!isAvailable("tmux"))
+            throw new Error("tmux not found — brew install tmux");
+        return new TmuxMultiplexer();
+    }
+    if (preference === "cmux") {
+        if (!isAvailable("cmux"))
+            throw new Error("cmux not found — https://cmux.com");
+        return new CmuxMultiplexer();
+    }
+    // auto: prefer cmux if available, fall back to tmux
+    if (isAvailable("cmux"))
+        return new CmuxMultiplexer();
+    if (isAvailable("tmux"))
+        return new TmuxMultiplexer();
+    throw new Error("no multiplexer found — install tmux (brew install tmux) or cmux (https://cmux.com)");
+}

package/dist/multiplexers/cmux.d.ts

@@ -0,0 +1,17 @@
+import type { Multiplexer } from "../multiplexer.js";
+export declare class CmuxMultiplexer implements Multiplexer {
+    readonly name = "cmux";
+    private surfaces;
+    createSession(_name: string, cwd: string): void;
+    killSession(_name: string): void;
+    attach(_name: string): void;
+    getActivePaneId(_session: string): string;
+    listPaneIds(_session: string): string[];
+    splitPane(_target: string, direction: "horizontal" | "vertical", _sizePercent: number, cwd: string): void;
+    focusPane(_paneId: string): void;
+    renamePaneTitle(paneId: string, name: string): void;
+    sendCommand(target: string, command: string): void;
+    isInsideSession(): boolean;
+    detectFirstPane(): string | undefined;
+    private findFirstSurface;
+}

package/dist/multiplexers/cmux.js

@@ -0,0 +1,126 @@
+import { execSync } from "node:child_process";
+const DEBUG = !!process.env.ORCHE_DEBUG;
+function log(...args) {
+    if (DEBUG)
+        console.error("[cmux]", ...args);
+}
+function run(cmd) {
+    log("$", cmd);
+    const out = execSync(cmd).toString().trim();
+    log("→", out.length > 200 ? out.slice(0, 200) + "…" : out);
+    return out;
+}
+export class CmuxMultiplexer {
+    name = "cmux";
+    // Track surfaces we created so layout can target them
+    surfaces = [];
+    createSession(_name, cwd) {
+        const initial = process.env.CMUX_SURFACE_ID;
+        log("createSession initial surface:", initial);
+        if (initial) {
+            this.surfaces = [initial];
+            this.sendCommand(initial, `cd "${cwd}"`);
+        }
+        else {
+            log("warning: CMUX_SURFACE_ID not set — are you running inside cmux?");
+        }
+    }
+    killSession(_name) {
+        // No-op — we didn't create a workspace
+    }
+    attach(_name) {
+        // cmux is a native macOS app — already visible
+    }
+    getActivePaneId(_session) {
+        const id = this.surfaces[this.surfaces.length - 1] ?? "";
+        log("getActivePaneId →", id);
+        return id;
+    }
+    listPaneIds(_session) {
+        log("listPaneIds →", this.surfaces);
+        return [...this.surfaces];
+    }
+    splitPane(_target, direction, _sizePercent, cwd) {
+        const cmuxDir = direction === "horizontal" ? "right" : "down";
+        // new-split returns "OK surface:<ref> workspace:<ref>"
+        const output = run(`cmux new-split ${cmuxDir}`);
+        const match = output.match(/surface:(\S+)/);
+        if (match) {
+            const newRef = `surface:${match[1]}`;
+            log("splitPane new surface:", newRef);
+            this.surfaces.push(newRef);
+            // cd into worktree on the new surface
+            this.sendCommand(newRef, `cd "${cwd}"`);
+        }
+        else {
+            log("warning: could not parse surface from new-split output:", output);
+        }
+        log("splitPane surfaces now:", this.surfaces);
+    }
+    focusPane(_paneId) {
+        // no-op — cmux auto-focuses after split
+    }
+    renamePaneTitle(paneId, name) {
+        try {
+            execSync(`cmux rename-tab --surface ${paneId} "${name}"`, { stdio: "ignore" });
+        }
+        catch {
+            // ignore
+        }
+    }
+    sendCommand(target, command) {
+        if (!command || !target) {
+            log("sendCommand skipped — target:", target, "command:", command);
+            return;
+        }
+        log("sendCommand →", target, command);
+        execSync(`cmux send --surface ${target} "${command.replace(/"/g, '\\"')}"`, { stdio: "ignore" });
+        execSync(`cmux send-key --surface ${target} enter`, { stdio: "ignore" });
+    }
+    isInsideSession() {
+        return !!process.env.CMUX_WORKSPACE_ID;
+    }
+    detectFirstPane() {
+        // Return the first surface in the workspace (where the agent typically runs)
+        // NOT the current surface (which is where `orche review` was called)
+        try {
+            const output = run(`cmux tree --json`);
+            const tree = JSON.parse(output);
+            // Walk the tree to find the first terminal surface
+            const first = this.findFirstSurface(tree);
+            if (first)
+                return first;
+        }
+        catch {
+            // fallback
+        }
+        return process.env.CMUX_SURFACE_ID ?? undefined;
+    }
+    findFirstSurface(node) {
+        if (!node || typeof node !== 'object')
+            return null;
+        const obj = node;
+        if (obj.surface_ref && typeof obj.surface_ref === 'string') {
+            // Skip the current surface
+            if (obj.surface_ref !== `surface:${process.env.CMUX_SURFACE_ID}`) {
+                return obj.surface_ref;
+            }
+        }
+        // Recurse into arrays and objects
+        for (const val of Object.values(obj)) {
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    const found = this.findFirstSurface(item);
+                    if (found)
+                        return found;
+                }
+            }
+            else if (val && typeof val === 'object') {
+                const found = this.findFirstSurface(val);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+}

package/dist/multiplexers/tmux.d.ts

@@ -0,0 +1,15 @@
+import type { Multiplexer } from "../multiplexer.js";
+export declare class TmuxMultiplexer implements Multiplexer {
+    readonly name = "tmux";
+    createSession(name: string, cwd: string): void;
+    killSession(name: string): void;
+    attach(name: string): void;
+    getActivePaneId(session: string): string;
+    listPaneIds(session: string): string[];
+    splitPane(target: string, direction: "horizontal" | "vertical", sizePercent: number, cwd: string): void;
+    focusPane(paneId: string): void;
+    renamePaneTitle(paneId: string, name: string): void;
+    sendCommand(target: string, command: string): void;
+    isInsideSession(): boolean;
+    detectFirstPane(): string | undefined;
+}

package/dist/multiplexers/tmux.js

@@ -0,0 +1,77 @@
+import { execSync } from "node:child_process";
+function esc(str) {
+    return `"${str.replace(/"/g, '\\"')}"`;
+}
+export class TmuxMultiplexer {
+    name = "tmux";
+    createSession(name, cwd) {
+        // Kill existing session with same name
+        try {
+            execSync(`tmux kill-session -t "${name}"`, { stdio: "ignore" });
+        }
+        catch {
+            // no existing session
+        }
+        execSync(`tmux new-session -d -s "${name}" -c "${cwd}"`, { stdio: "ignore" });
+        execSync(`tmux set-option -t "${name}" mouse on`, { stdio: "ignore" });
+    }
+    killSession(name) {
+        try {
+            execSync(`tmux kill-session -t "${name}"`, { stdio: "ignore" });
+        }
+        catch {
+            // ignore
+        }
+    }
+    attach(name) {
+        if (process.env.TMUX) {
+            execSync(`tmux switch-client -t "${name}"`, { stdio: "inherit" });
+        }
+        else {
+            execSync(`tmux attach-session -t "${name}"`, { stdio: "inherit" });
+        }
+    }
+    getActivePaneId(session) {
+        return execSync(`tmux display-message -t ${session} -p "#{pane_id}"`)
+            .toString()
+            .trim();
+    }
+    listPaneIds(session) {
+        return execSync(`tmux list-panes -t ${session} -F "#{pane_id}"`)
+            .toString()
+            .trim()
+            .split("\n");
+    }
+    splitPane(target, direction, sizePercent, cwd) {
+        const flag = direction === "horizontal" ? "-h" : "-v";
+        execSync(`tmux split-window ${flag} -t ${target} -p ${sizePercent} -c "${cwd}"`, { stdio: "ignore" });
+    }
+    focusPane(paneId) {
+        execSync(`tmux select-pane -t ${paneId}`, { stdio: "ignore" });
+    }
+    renamePaneTitle(paneId, name) {
+        execSync(`tmux select-pane -t ${paneId} -T ${esc(name)}`, { stdio: "ignore" });
+    }
+    sendCommand(target, command) {
+        execSync(`tmux send-keys -t ${target} ${esc(command)} Enter`);
+    }
+    isInsideSession() {
+        return !!process.env.TMUX;
+    }
+    detectFirstPane() {
+        if (!process.env.TMUX)
+            return undefined;
+        try {
+            const sessionName = execSync("tmux display-message -p '#S'")
+                .toString()
+                .trim();
+            const paneId = execSync(`tmux list-panes -t "${sessionName}" -F "#{pane_id}" | head -1`)
+                .toString()
+                .trim();
+            return paneId || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/review-manager.d.ts

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