@taranek/orche 0.0.32 → 0.0.34

package/dist/cli.js

@@ -48,16 +48,20 @@ function deliverReview(pendingPath) {
     }
 }
 async function runReview(worktreePath) {
-    const resolvedPath = path.resolve(worktreePath);
+    const inputPath = path.resolve(worktreePath);
     // Refuse to run unless the target is inside a git worktree — otherwise the
     // review app may try to recursively watch enormous trees (e.g. $HOME).
+    // Anchor at the worktree root: `git diff --name-status` emits root-relative
+    // paths, so the review app must run from the top-level or file reads (which
+    // join cwd + path) break when invoked from a subdirectory.
+    let resolvedPath;
     try {
-        execFileSync("git", ["-C", resolvedPath, "rev-parse", "--show-toplevel"], {
-            stdio: ["ignore", "pipe", "ignore"],
-        });
+        resolvedPath = execFileSync("git", ["-C", inputPath, "rev-parse", "--show-toplevel"], { stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
     }
     catch {
-        die(`not a git worktree: ${resolvedPath}`);
+        die(`not a git worktree: ${inputPath}`);
     }
     const args = ["--worktree=" + resolvedPath];
     console.log(`opening review for ${worktreePath}...`);

package/dist/layout.js

@@ -19,7 +19,9 @@ export function buildLayout(mux, session, node, worktreePath) {
     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);
+        // Chain off the previous sibling (like collectPaneMap) so flat columns keep
+        // left-to-right order once splitPane honors its target surface.
+        mux.splitPane(paneIds[i - 1], node.direction, sizePercent, worktreePath);
         paneIds.push(mux.getActivePaneId(session));
     }
     const allPaneIds = mux.listPaneIds(session);

package/dist/layout.test.d.ts

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

package/dist/layout.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { buildLayout } from "./layout.js";
+/**
+ * A fake multiplexer that mimics cmux: each split creates a fresh surface that
+ * becomes the active pane (cmux auto-focuses the new split). It records every
+ * splitPane target so tests can assert which surface each split was anchored to.
+ */
+class FakeMux {
+    name = "fake";
+    panes = ["p0"];
+    splitCalls = [];
+    commands = [];
+    createSession() { }
+    killSession() { }
+    attach() { }
+    getActivePaneId() {
+        return this.panes[this.panes.length - 1];
+    }
+    listPaneIds() {
+        return [...this.panes];
+    }
+    splitPane(target, direction) {
+        this.splitCalls.push({ target, direction });
+        this.panes.push(`p${this.panes.length}`);
+    }
+    focusPane() { }
+    renamePaneTitle() { }
+    sendCommand(target, command) {
+        this.commands.push({ target, command });
+    }
+    isInsideSession() {
+        return false;
+    }
+    detectFirstPane() {
+        return undefined;
+    }
+}
+describe("buildLayout", () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = mkdtempSync(path.join(os.tmpdir(), "orche-layout-"));
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true, force: true });
+    });
+    it("chains flat sibling splits off the previous sibling (left-to-right order)", () => {
+        const mux = new FakeMux();
+        const layout = {
+            direction: "horizontal",
+            panes: [
+                { name: "a", command: "cmd-a" },
+                { name: "b", command: "cmd-b" },
+                { name: "c", command: "cmd-c" },
+            ],
+        };
+        buildLayout(mux, "sess", layout, tmp);
+        // Two splits to produce three columns, each anchored to the prior sibling
+        // (NOT all anchored to the first pane) so they render a|b|c in order.
+        expect(mux.splitCalls).toEqual([
+            { target: "p0", direction: "horizontal" },
+            { target: "p1", direction: "horizontal" },
+        ]);
+    });
+    it("anchors a nested split's children to that branch's surface", () => {
+        const mux = new FakeMux();
+        // vertical[ agent, horizontal[db, be, fe] ]
+        const layout = {
+            direction: "vertical",
+            panes: [
+                { name: "agent", command: "claude" },
+                {
+                    direction: "horizontal",
+                    panes: [
+                        { name: "db", command: "db-up" },
+                        { name: "be", command: "be-up" },
+                        { name: "fe", command: "fe-up" },
+                    ],
+                },
+            ],
+        };
+        buildLayout(mux, "sess", layout, tmp);
+        // 1 vertical split (agent | branch) + 2 horizontal splits for the columns.
+        expect(mux.splitCalls).toEqual([
+            { target: "p0", direction: "vertical" },
+            { target: "p1", direction: "horizontal" },
+            { target: "p2", direction: "horizontal" },
+        ]);
+        const session = JSON.parse(readFileSync(path.join(tmp, ".orche", "session.json"), "utf8"));
+        expect(session.panes).toEqual({
+            agent: "p0",
+            db: "p1",
+            be: "p2",
+            fe: "p3",
+        });
+    });
+    it("records a single pane with no splits", () => {
+        const mux = new FakeMux();
+        const layout = { name: "solo", command: "echo hi" };
+        buildLayout(mux, "sess", layout, tmp);
+        expect(mux.splitCalls).toEqual([]);
+        const session = JSON.parse(readFileSync(path.join(tmp, ".orche", "session.json"), "utf8"));
+        expect(session.panes).toEqual({ solo: "p0" });
+    });
+});

package/dist/multiplexers/cmux.d.ts

@@ -7,7 +7,7 @@ export declare class CmuxMultiplexer implements Multiplexer {
     attach(_name: string): void;
     getActivePaneId(_session: string): string;
     listPaneIds(_session: string): string[];
-    splitPane(_target: string, direction: "horizontal" | "vertical", _sizePercent: number, cwd: string): void;
+    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;

package/dist/multiplexers/cmux.js

@@ -40,10 +40,14 @@ export class CmuxMultiplexer {
         log("listPaneIds →", this.surfaces);
         return [...this.surfaces];
     }
-    splitPane(_target, direction, _sizePercent, cwd) {
+    splitPane(target, direction, _sizePercent, cwd) {
         const cmuxDir = direction === "horizontal" ? "right" : "down";
+        // Split the requested surface explicitly. Without --surface, cmux splits
+        // whatever is focused, which lands nested splits on the wrong pane
+        // (focusPane is a no-op and sendCommand refocuses the agent surface).
+        const targetFlag = target ? ` --surface ${target}` : "";
         // new-split returns "OK surface:<ref> workspace:<ref>"
-        const output = run(`cmux new-split ${cmuxDir}`);
+        const output = run(`cmux new-split ${cmuxDir}${targetFlag}`);
         const match = output.match(/surface:(\S+)/);
         if (match) {
             const newRef = `surface:${match[1]}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taranek/orche",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "type": "module",
   "bin": {
     "orche": "./dist/cli.js"

package/src/cli.ts

@@ -48,16 +48,24 @@ function deliverReview(pendingPath: string): void {
 }
 
 async function runReview(worktreePath: string): Promise<void> {
-  const resolvedPath = path.resolve(worktreePath);
+  const inputPath = path.resolve(worktreePath);
 
   // Refuse to run unless the target is inside a git worktree — otherwise the
   // review app may try to recursively watch enormous trees (e.g. $HOME).
+  // Anchor at the worktree root: `git diff --name-status` emits root-relative
+  // paths, so the review app must run from the top-level or file reads (which
+  // join cwd + path) break when invoked from a subdirectory.
+  let resolvedPath: string;
   try {
-    execFileSync("git", ["-C", resolvedPath, "rev-parse", "--show-toplevel"], {
-      stdio: ["ignore", "pipe", "ignore"],
-    });
+    resolvedPath = execFileSync(
+      "git",
+      ["-C", inputPath, "rev-parse", "--show-toplevel"],
+      { stdio: ["ignore", "pipe", "ignore"] },
+    )
+      .toString()
+      .trim();
   } catch {
-    die(`not a git worktree: ${resolvedPath}`);
+    die(`not a git worktree: ${inputPath}`);
   }
 
   const args = ["--worktree=" + resolvedPath];

package/src/layout.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { buildLayout } from "./layout.js";
+import type { Multiplexer } from "./multiplexer.js";
+import type { PaneConfig, SplitConfig } from "./types.js";
+
+interface SplitCall {
+  target: string;
+  direction: "horizontal" | "vertical";
+}
+
+/**
+ * A fake multiplexer that mimics cmux: each split creates a fresh surface that
+ * becomes the active pane (cmux auto-focuses the new split). It records every
+ * splitPane target so tests can assert which surface each split was anchored to.
+ */
+class FakeMux implements Multiplexer {
+  readonly name = "fake";
+  panes: string[] = ["p0"];
+  splitCalls: SplitCall[] = [];
+  commands: { target: string; command: string }[] = [];
+
+  createSession(): void {}
+  killSession(): void {}
+  attach(): void {}
+
+  getActivePaneId(): string {
+    return this.panes[this.panes.length - 1];
+  }
+
+  listPaneIds(): string[] {
+    return [...this.panes];
+  }
+
+  splitPane(target: string, direction: "horizontal" | "vertical"): void {
+    this.splitCalls.push({ target, direction });
+    this.panes.push(`p${this.panes.length}`);
+  }
+
+  focusPane(): void {}
+  renamePaneTitle(): void {}
+  sendCommand(target: string, command: string): void {
+    this.commands.push({ target, command });
+  }
+
+  isInsideSession(): boolean {
+    return false;
+  }
+  detectFirstPane(): string | undefined {
+    return undefined;
+  }
+}
+
+describe("buildLayout", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(path.join(os.tmpdir(), "orche-layout-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("chains flat sibling splits off the previous sibling (left-to-right order)", () => {
+    const mux = new FakeMux();
+    const layout: SplitConfig = {
+      direction: "horizontal",
+      panes: [
+        { name: "a", command: "cmd-a" },
+        { name: "b", command: "cmd-b" },
+        { name: "c", command: "cmd-c" },
+      ],
+    };
+
+    buildLayout(mux, "sess", layout, tmp);
+
+    // Two splits to produce three columns, each anchored to the prior sibling
+    // (NOT all anchored to the first pane) so they render a|b|c in order.
+    expect(mux.splitCalls).toEqual([
+      { target: "p0", direction: "horizontal" },
+      { target: "p1", direction: "horizontal" },
+    ]);
+  });
+
+  it("anchors a nested split's children to that branch's surface", () => {
+    const mux = new FakeMux();
+    // vertical[ agent, horizontal[db, be, fe] ]
+    const layout: SplitConfig = {
+      direction: "vertical",
+      panes: [
+        { name: "agent", command: "claude" },
+        {
+          direction: "horizontal",
+          panes: [
+            { name: "db", command: "db-up" },
+            { name: "be", command: "be-up" },
+            { name: "fe", command: "fe-up" },
+          ],
+        } as SplitConfig,
+      ],
+    };
+
+    buildLayout(mux, "sess", layout, tmp);
+
+    // 1 vertical split (agent | branch) + 2 horizontal splits for the columns.
+    expect(mux.splitCalls).toEqual([
+      { target: "p0", direction: "vertical" },
+      { target: "p1", direction: "horizontal" },
+      { target: "p2", direction: "horizontal" },
+    ]);
+
+    const session = JSON.parse(
+      readFileSync(path.join(tmp, ".orche", "session.json"), "utf8")
+    );
+    expect(session.panes).toEqual({
+      agent: "p0",
+      db: "p1",
+      be: "p2",
+      fe: "p3",
+    });
+  });
+
+  it("records a single pane with no splits", () => {
+    const mux = new FakeMux();
+    const layout: PaneConfig = { name: "solo", command: "echo hi" };
+
+    buildLayout(mux, "sess", layout, tmp);
+
+    expect(mux.splitCalls).toEqual([]);
+    const session = JSON.parse(
+      readFileSync(path.join(tmp, ".orche", "session.json"), "utf8")
+    );
+    expect(session.panes).toEqual({ solo: "p0" });
+  });
+});

package/src/layout.ts

@@ -34,7 +34,9 @@ export function buildLayout(
   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);
+    // Chain off the previous sibling (like collectPaneMap) so flat columns keep
+    // left-to-right order once splitPane honors its target surface.
+    mux.splitPane(paneIds[i - 1], node.direction, sizePercent, worktreePath);
     paneIds.push(mux.getActivePaneId(session));
   }
 

package/src/multiplexers/cmux.ts

@@ -51,14 +51,18 @@ export class CmuxMultiplexer implements Multiplexer {
   }
 
   splitPane(
-    _target: string,
+    target: string,
     direction: "horizontal" | "vertical",
     _sizePercent: number,
     cwd: string
   ): void {
     const cmuxDir = direction === "horizontal" ? "right" : "down";
+    // Split the requested surface explicitly. Without --surface, cmux splits
+    // whatever is focused, which lands nested splits on the wrong pane
+    // (focusPane is a no-op and sendCommand refocuses the agent surface).
+    const targetFlag = target ? ` --surface ${target}` : "";
     // new-split returns "OK surface:<ref> workspace:<ref>"
-    const output = run(`cmux new-split ${cmuxDir}`);
+    const output = run(`cmux new-split ${cmuxDir}${targetFlag}`);
 
     const match = output.match(/surface:(\S+)/);
     if (match) {