@bastani/atomic 0.5.0-3 → 0.5.0-4

package/src/commands/cli/init/scm.ts

@@ -2,7 +2,11 @@ import { join } from "path";
 import { readdir } from "fs/promises";
 import { copyFile, pathExists, ensureDir } from "@/services/system/copy.ts";
 import { getOppositeScriptExtension } from "@/services/system/detect.ts";
-import type { AgentKey, SourceControlType } from "@/services/config/index.ts";
+import {
+  SCM_SKILLS_BY_TYPE,
+  type AgentKey,
+  type SourceControlType,
+} from "@/services/config/index.ts";
 
 export const SCM_PREFIX_BY_TYPE: Record<SourceControlType, "gh-" | "sl-"> = {
   github: "gh-",
@@ -127,14 +131,21 @@ export interface InstallLocalScmSkillsOptions {
 
 export interface InstallLocalScmSkillsResult {
   success: boolean;
+  /** The explicit skill names that were requested (e.g. `["gh-commit", "gh-create-pr"]`). */
+  skills: readonly string[];
   /** Non-empty when `success` is false. */
   details: string;
 }
 
 /**
- * Install the SCM skill variants (gh-* or sl-*) locally into the current
- * project via `npx skills add`. The `-g` flag is intentionally omitted so
- * the skills are installed per-project (in the given `cwd`).
+ * Install the SCM skill variants (e.g. `gh-commit`, `gh-create-pr` for
+ * GitHub) locally into the current project via `npx skills add`. The `-g`
+ * flag is intentionally omitted so the skills are installed per-project
+ * (in the given `cwd`).
+ *
+ * Each skill is passed explicitly with `--skill <name>` — the skills CLI
+ * does not support glob patterns like `gh-*`, which would either fail or
+ * fall back to installing the entire skill set.
  *
  * This is best-effort: callers should treat a failed result as a warning,
  * not as a fatal error.
@@ -144,13 +155,15 @@ export async function installLocalScmSkills(
 ): Promise<InstallLocalScmSkillsResult> {
   const { scmType, agentKey, cwd } = options;
 
+  const skills = SCM_SKILLS_BY_TYPE[scmType];
+
   const npxPath = Bun.which("npx");
   if (!npxPath) {
-    return { success: false, details: "npx not found on PATH" };
+    return { success: false, skills, details: "npx not found on PATH" };
   }
 
-  const pattern = `${getScmPrefix(scmType)}*`;
   const agentFlag = SKILLS_AGENT_BY_KEY[agentKey];
+  const skillFlags = skills.flatMap((skill) => ["--skill", skill]);
 
   try {
     const proc = Bun.spawn({
@@ -160,8 +173,7 @@ export async function installLocalScmSkills(
         "skills",
         "add",
         SKILLS_REPO,
-        "--skill",
-        pattern,
+        ...skillFlags,
         "-a",
         agentFlag,
         "-y",
@@ -177,13 +189,18 @@ export async function installLocalScmSkills(
       proc.exited,
     ]);
     if (exitCode === 0) {
-      return { success: true, details: "" };
+      return { success: true, skills, details: "" };
     }
     const details = stderr.trim().length > 0 ? stderr.trim() : stdout.trim();
-    return { success: false, details: details || `exit code ${exitCode}` };
+    return {
+      success: false,
+      skills,
+      details: details || `exit code ${exitCode}`,
+    };
   } catch (error) {
     return {
       success: false,
+      skills,
       details: error instanceof Error ? error.message : String(error),
     };
   }

package/src/sdk/components/connectors.test.ts

@@ -659,3 +659,48 @@ describe("buildMergeConnector", () => {
     expect(barLine[84]).toBe("┤");
   });
 });
+
+// ─── Integration tests: connectors with computeLayout-produced nodes ──────
+
+describe("integration with computeLayout", () => {
+  test("connector from orchestrator to reclassified orphan child", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "orchestrator", status: "running", parents: [], startedAt: null, endedAt: null },
+      { name: "orphan", status: "pending", parents: ["nonexistent"], startedAt: null, endedAt: null },
+    ]);
+    const orch = layout.map["orchestrator"];
+    expect(orch.children).toHaveLength(1);
+    const conn = buildConnector(orch, layout.rowH, mockTheme);
+    expect(conn).not.toBeNull();
+    expect(conn!.height).toBeGreaterThan(0);
+  });
+
+  test("connector from parent to reclassified merge-to-single-parent node", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "orchestrator", status: "running", parents: [], startedAt: null, endedAt: null },
+      { name: "A", status: "pending", parents: ["orchestrator"], startedAt: null, endedAt: null },
+      { name: "M", status: "pending", parents: ["A", "nonexistent"], startedAt: null, endedAt: null },
+    ]);
+    const nodeA = layout.map["A"];
+    expect(nodeA.children).toHaveLength(1);
+    expect(nodeA.children[0].name).toBe("M");
+    const conn = buildConnector(nodeA, layout.rowH, mockTheme);
+    expect(conn).not.toBeNull();
+  });
+
+  test("merge connector still works for valid merge nodes", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "A", status: "pending", parents: [], startedAt: null, endedAt: null },
+      { name: "B", status: "pending", parents: [], startedAt: null, endedAt: null },
+      { name: "M", status: "pending", parents: ["A", "B"], startedAt: null, endedAt: null },
+    ]);
+    const nodeM = layout.map["M"];
+    expect(nodeM.parents).toEqual(["A", "B"]);
+    const mergeConn = buildMergeConnector(nodeM, layout.rowH, layout.map, mockTheme);
+    expect(mergeConn).not.toBeNull();
+    expect(mergeConn!.height).toBeGreaterThan(0);
+  });
+});

package/src/sdk/components/layout.test.ts

@@ -921,4 +921,325 @@ describe("computeLayout", () => {
       });
     }
   });
+
+  // ─── Edge cases: parent normalization ─────────
+
+  describe("missing parent fallback", () => {
+    test("session with missing parent falls back to orchestrator child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // orphan should be a child of orchestrator, not a root
+      expect(r.roots).toHaveLength(1);
+      expect(r.roots[0]!.name).toBe("orchestrator");
+      expect(r.map["orchestrator"]!.children).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children[0]!.name).toBe("orphan");
+      expect(r.map["orphan"]!.depth).toBe(1);
+    });
+
+    test("session with missing parent and no orchestrator becomes root", () => {
+      const r = computeLayout([
+        session("A"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // Without orchestrator, orphan becomes a root alongside A
+      expect(r.roots).toHaveLength(2);
+      expect(r.roots.map((n) => n.name)).toContain("orphan");
+    });
+
+    test("preserves raw parents array on LayoutNode even when normalized", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // raw parents metadata should be unchanged
+      expect(r.map["orphan"]!.parents).toEqual(["nonexistent"]);
+    });
+
+    test("multiple orphans all fall back to orchestrator", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("a", ["ghost-1"]),
+        session("b", ["ghost-2"]),
+      ]);
+      expect(r.roots).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children).toHaveLength(2);
+      expect(r.map["a"]!.depth).toBe(1);
+      expect(r.map["b"]!.depth).toBe(1);
+    });
+
+    test("valid parent takes priority over orchestrator fallback", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("step-1", ["orchestrator"]),
+        session("child", ["step-1"]),
+      ]);
+      // child should be under step-1, not orchestrator
+      expect(r.map["step-1"]!.children).toHaveLength(1);
+      expect(r.map["step-1"]!.children[0]!.name).toBe("child");
+      expect(r.map["child"]!.depth).toBe(2);
+    });
+
+    test("orchestrator itself does not get reparented to itself", () => {
+      const r = computeLayout([session("orchestrator")]);
+      expect(r.roots).toHaveLength(1);
+      expect(r.roots[0]!.name).toBe("orchestrator");
+      expect(r.map["orchestrator"]!.children).toHaveLength(0);
+    });
+  });
+
+  describe("merge node with missing parents", () => {
+    test("merge with one missing parent reclassified as single-parent child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("A", ["orchestrator"]),
+        session("M", ["A", "nonexistent"]),
+      ]);
+      // M should become a single-parent child of A (not a merge node)
+      expect(r.map["A"]!.children).toHaveLength(1);
+      expect(r.map["A"]!.children[0]!.name).toBe("M");
+      expect(r.map["M"]!.depth).toBe(2);
+    });
+
+    test("merge with all missing parents falls back to orchestrator child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("M", ["ghost-1", "ghost-2"]),
+      ]);
+      // All parents missing → falls back to orchestrator
+      expect(r.map["orchestrator"]!.children).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children[0]!.name).toBe("M");
+      expect(r.map["M"]!.depth).toBe(1);
+    });
+
+    test("merge with duplicate parents after filtering is deduplicated", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("A", ["orchestrator"]),
+        session("M", ["A", "A"]),
+      ]);
+      // Duplicate "A" deduplicated → single parent → tree child of A
+      expect(r.map["A"]!.children).toHaveLength(1);
+      expect(r.map["A"]!.children[0]!.name).toBe("M");
+    });
+  });
+
+  describe("chained merge node ordering", () => {
+    test("merge nodes in reverse order get correct depths", () => {
+      // M2 depends on M1, but M2 appears first in the sessions array
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M2", ["M1", "C"]),  // M2 before M1 in array
+        session("M1", ["A", "B"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["M2"]!.depth).toBe(2); // must be deeper than M1
+    });
+
+    test("indirect merge dependency: A,B → M1 → X; C,X → M2", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M1", ["A", "B"]),
+        session("X", ["M1"]),
+        session("M2", ["C", "X"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["X"]!.depth).toBe(2);
+      expect(r.map["M2"]!.depth).toBe(3);
+    });
+
+    test("indirect merge dependency in forward session order", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M1", ["A", "B"]),
+        session("X", ["M1"]),
+        session("M2", ["C", "X"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["X"]!.depth).toBe(2);
+      expect(r.map["M2"]!.depth).toBe(3);
+    });
+  });
+
+  describe("deeply nested tree", () => {
+    test("four levels of nesting with orchestrator", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("step-1", ["orchestrator"]),
+        session("step-2", ["step-1"]),
+        session("step-3", ["step-2"]),
+        session("step-4", ["step-3"]),
+      ]);
+      expect(r.map["orchestrator"]!.depth).toBe(0);
+      expect(r.map["step-1"]!.depth).toBe(1);
+      expect(r.map["step-2"]!.depth).toBe(2);
+      expect(r.map["step-3"]!.depth).toBe(3);
+      expect(r.map["step-4"]!.depth).toBe(4);
+      // All share x (single chain)
+      const x0 = r.map["orchestrator"]!.x;
+      for (const name of ["step-1", "step-2", "step-3", "step-4"]) {
+        expect(r.map[name]!.x).toBe(x0);
+      }
+    });
+  });
+
+  describe("merge node as single parent", () => {
+    test("child of merge node is placed correctly", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("M", ["A", "B"]),
+        session("child", ["M"]),
+      ]);
+      expect(r.map["M"]!.depth).toBe(1);
+      expect(r.map["child"]!.depth).toBe(2);
+      // child should be directly below M
+      expect(r.map["child"]!.x).toBe(r.map["M"]!.x);
+    });
+  });
+
+  describe("wide fan-out from non-root node", () => {
+    test("multiple children of a mid-tree node", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("parent", ["orchestrator"]),
+        session("c1", ["parent"]),
+        session("c2", ["parent"]),
+        session("c3", ["parent"]),
+      ]);
+      expect(r.map["parent"]!.depth).toBe(1);
+      expect(r.map["c1"]!.depth).toBe(2);
+      expect(r.map["c2"]!.depth).toBe(2);
+      expect(r.map["c3"]!.depth).toBe(2);
+      // parent centered over children
+      const parentX = r.map["parent"]!.x;
+      const c1X = r.map["c1"]!.x;
+      const c3X = r.map["c3"]!.x;
+      expect(parentX).toBe(Math.round((c1X + c3X) / 2));
+    });
+  });
+
+  // ─── Extended invariants for new topologies ───
+
+  describe("layout invariants (extended edge cases)", () => {
+    const EDGE_TOPOLOGIES = [
+      {
+        name: "missing parent → orchestrator fallback",
+        sessions: () => [
+          session("orchestrator"),
+          session("orphan", ["nonexistent"]),
+        ],
+      },
+      {
+        name: "merge with missing parent reclassified",
+        sessions: () => [
+          session("orchestrator"),
+          session("A", ["orchestrator"]),
+          session("M", ["A", "nonexistent"]),
+        ],
+      },
+      {
+        name: "chained merges in reverse order",
+        sessions: () => [
+          session("A"),
+          session("B"),
+          session("C"),
+          session("M2", ["M1", "C"]),
+          session("M1", ["A", "B"]),
+        ],
+      },
+      {
+        name: "indirect merge dependency",
+        sessions: () => [
+          session("A"),
+          session("B"),
+          session("C"),
+          session("M1", ["A", "B"]),
+          session("X", ["M1"]),
+          session("M2", ["C", "X"]),
+        ],
+      },
+      {
+        name: "deeply nested (5 levels)",
+        sessions: () => [
+          session("orchestrator"),
+          session("s1", ["orchestrator"]),
+          session("s2", ["s1"]),
+          session("s3", ["s2"]),
+          session("s4", ["s3"]),
+        ],
+      },
+      {
+        name: "wide fan-out from non-root",
+        sessions: () => [
+          session("orchestrator"),
+          session("parent", ["orchestrator"]),
+          session("c1", ["parent"]),
+          session("c2", ["parent"]),
+          session("c3", ["parent"]),
+        ],
+      },
+    ];
+
+    for (const topo of EDGE_TOPOLOGIES) {
+      test(`[${topo.name}] all x values are >= PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        for (const node of Object.values(r.map)) {
+          expect(node.x).toBeGreaterThanOrEqual(PAD);
+        }
+      });
+
+      test(`[${topo.name}] all y values are >= PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        for (const node of Object.values(r.map)) {
+          expect(node.y).toBeGreaterThanOrEqual(PAD);
+        }
+      });
+
+      test(`[${topo.name}] width = max(node.x + NODE_W) + PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        const rightmost = Math.max(...Object.values(r.map).map((n) => n.x + NODE_W));
+        expect(r.width).toBe(rightmost + PAD);
+      });
+
+      test(`[${topo.name}] height = max(node.y + NODE_H) + PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        const bottommost = Math.max(...Object.values(r.map).map((n) => n.y + NODE_H));
+        expect(r.height).toBe(bottommost + PAD);
+      });
+
+      test(`[${topo.name}] nodes at same depth share the same y`, () => {
+        const r = computeLayout(topo.sessions());
+        const byDepth: Record<number, number[]> = {};
+        for (const node of Object.values(r.map)) {
+          (byDepth[node.depth] ??= []).push(node.y);
+        }
+        for (const ys of Object.values(byDepth)) {
+          const first = ys[0]!;
+          for (const y of ys) expect(y).toBe(first);
+        }
+      });
+
+      test(`[${topo.name}] no horizontal overlap between nodes at same depth`, () => {
+        const r = computeLayout(topo.sessions());
+        const byDepth: Record<number, number[]> = {};
+        for (const node of Object.values(r.map)) {
+          (byDepth[node.depth] ??= []).push(node.x);
+        }
+        for (const xs of Object.values(byDepth)) {
+          xs.sort((a, b) => a - b);
+          for (let i = 1; i < xs.length; i++) {
+            expect(xs[i]! - xs[i - 1]!).toBeGreaterThanOrEqual(NODE_W + H_GAP);
+          }
+        }
+      });
+    }
+  });
 });

package/src/sdk/components/layout.ts

@@ -72,6 +72,32 @@ function resolveOverlaps(map: Record<string, LayoutNode>): void {
 
 // ─── Layout Computation ───────────────────────────
 
+/**
+ * Compute effective parents for each session by filtering out references
+ * to sessions that don't exist in the map and deduplicating.  Orphaned
+ * sessions (all parents missing) fall back to the "orchestrator" node
+ * when one is present, instead of becoming disconnected roots.
+ */
+function normalizeParents(
+  sessions: SessionData[],
+  map: Record<string, LayoutNode>,
+): Map<string, string[]> {
+  const hasOrchestrator = "orchestrator" in map;
+  const effective = new Map<string, string[]>();
+
+  for (const s of sessions) {
+    const valid = [...new Set(s.parents)].filter((p) => p in map);
+    if (valid.length > 0) {
+      effective.set(s.name, valid);
+    } else if (hasOrchestrator && s.name !== "orchestrator") {
+      effective.set(s.name, ["orchestrator"]);
+    } else {
+      effective.set(s.name, []);
+    }
+  }
+  return effective;
+}
+
 export function computeLayout(sessions: SessionData[]): LayoutResult {
   const map: Record<string, LayoutNode> = {};
   const roots: LayoutNode[] = [];
@@ -92,27 +118,36 @@ export function computeLayout(sessions: SessionData[]): LayoutResult {
     };
   }
 
-  // Classify: single-parent → tree child, multi-parent → merge node, no parent → root
+  // Normalize parents: filter missing refs, dedupe, orchestrator fallback
+  const effective = normalizeParents(sessions, map);
+
+  // Classify using effective parents (preserves LayoutNode.parents as raw metadata)
   for (const s of sessions) {
-    if (s.parents.length > 1) {
+    const ep = effective.get(s.name) ?? [];
+    if (ep.length > 1) {
       mergeNodes.push(map[s.name]!);
-    } else if (s.parents.length === 1 && map[s.parents[0]!]) {
-      map[s.parents[0]!]!.children.push(map[s.name]!);
+    } else if (ep.length === 1 && map[ep[0]!]) {
+      map[ep[0]!]!.children.push(map[s.name]!);
     } else {
       roots.push(map[s.name]!);
     }
   }
 
-  function setDepth(n: LayoutNode, d: number) {
-    n.depth = d;
-    for (const c of n.children) setDepth(c, d + 1);
+  // Memoized depth resolution — handles tree children, merge nodes,
+  // indirect dependencies, and arbitrary session ordering.
+  const depthCache = new Map<string, number>();
+  function resolveDepth(name: string): number {
+    if (depthCache.has(name)) return depthCache.get(name)!;
+    depthCache.set(name, 0); // guard against cycles
+    const ep = effective.get(name) ?? [];
+    if (ep.length === 0) return 0;
+    const maxParentDepth = Math.max(...ep.map((p) => resolveDepth(p)));
+    const depth = maxParentDepth + 1;
+    depthCache.set(name, depth);
+    return depth;
   }
-  for (const r of roots) setDepth(r, 0);
-
-  // Merge nodes: depth = max(parent depths) + 1, then recurse into children
-  for (const m of mergeNodes) {
-    const maxParentDepth = Math.max(...m.parents.map((p) => map[p]?.depth ?? 0));
-    setDepth(m, maxParentDepth + 1);
+  for (const s of sessions) {
+    map[s.name]!.depth = resolveDepth(s.name);
   }
 
   const rowH: Record<number, number> = {};
@@ -149,9 +184,10 @@ export function computeLayout(sessions: SessionData[]): LayoutResult {
     firstRoot = false;
   }
 
-  // Place merge nodes centered under all parents (and their sub-trees)
+  // Place merge nodes centered under all effective parents (and their sub-trees)
   for (const m of mergeNodes) {
-    const parentCenters = m.parents.map((p) => (map[p]?.x ?? 0) + Math.floor(NODE_W / 2));
+    const ep = effective.get(m.name) ?? [];
+    const parentCenters = ep.map((p) => (map[p]?.x ?? 0) + Math.floor(NODE_W / 2));
     const avgCenter = Math.round(parentCenters.reduce((a, b) => a + b, 0) / parentCenters.length);
 
     if (m.children.length > 0) {