claude-code-station 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.3] — 2026-10-14
+
+### Added
+- **Nested repos are grouped in the list** — a repo whose `path` sits inside another listed repo's `path` now comes right after that repo, indented (`  └ 📁 child  ‹parent›`), instead of wherever its name sorts. The nearest enclosing path wins (the same deepest-path rule that maps sessions to repos), deeper nesting indents further, and siblings stay name-sorted. The dim `‹parent›` suffix keeps the relation readable when a fzf query hides the parent row, and a query for the parent's name matches its children too. Derived from `path` at list time — no `repos.yml` key and no cache migration. A disabled parent is not listed, so its children stay top-level.
+
 ## [0.2.2] — 2026-06-21
 
 ### Fixed

package/README.md

@@ -202,6 +202,14 @@ Notion:   ✅ abc123
 **Visual cues / 見た目のガイド:**
 - NEW rows and RESUME rows are separated by a dim `── Past Sessions ──` divider. Selecting the divider is a no-op.
 - RESUME sessions mapped to a registered repo show that repo's icon (e.g., `🔄 📁 ClaudeCode`). Unmapped sessions (cwd that isn't in `repos.yml`) show `❓` — a visual cue that the session was either a one-off or that the repo isn't registered yet.
+- A repo whose `path` sits inside another registered repo's `path` is listed right under that repo, indented, with the parent's name dimmed at the end. Nothing to configure — the nesting follows from `path`. The dim `‹parent›` keeps the relation visible when a search hides the parent row, and searching for the parent's name lists its children too. / `path` が別の登録リポの `path` の中にあるリポは、そのリポのすぐ下に字下げして並び、行の末尾に親の名前が薄く出る。設定は要らない（`path` から決まる）。絞り込みで親の行が隠れても `‹親›` で親子がわかり、親の名前で絞り込むと子も一緒に出る。
+
+  ```
+  📁 my-company
+    └ 📁 web-app  ‹my-company›
+    └ 📁 mobile-app  ‹my-company›
+  📁 side-project
+  ```
 
 ### Workflows / 主な使い方
 

package/bin/ccs-init.ts

@@ -276,7 +276,12 @@ async function main(): Promise<number> {
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   main().then(
-    (code) => process.exit(code),
+    // exitCode, not process.exit(): bin/ccs captures discover's candidates
+    // with $(...), a pipe, and exiting right after the writes dropped every
+    // candidate past the pipe buffer (same bug as ccs-list, 2026-10-07).
+    (code) => {
+      process.exitCode = code;
+    },
     (err) => {
       process.stderr.write(
         `[ccs-init] fatal: ${err instanceof Error ? err.message : String(err)}\n`,

package/bin/ccs-list.ts

@@ -9,7 +9,8 @@
  *   --current-only    sessions whose cwd matches process.cwd()
  *   --repos-only      only NEW repo rows
  *   --sessions-only   only RESUME session rows
- *   (default)         NEW first (alpha), then RESUME (last_activity_at DESC)
+ *   (default)         NEW first (alpha, nested repos under their parent),
+ *                     then RESUME (last_activity_at DESC)
  */
 
 import { homedir } from "node:os";
@@ -175,8 +176,51 @@ function buildRepoBadges(r: RepoRowFull): string {
 // invoked with --ansi so these codes render as styling.
 const LABEL_SEP = " \x1b[2m│\x1b[0m";
 
-function repoToRow(r: RepoRowFull): string {
-  const label = `${r.icon || "📁"} ${r.name}${LABEL_SEP}`;
+interface GroupedRepo {
+  repo: RepoRowFull;
+  parentName: string | null;
+  depth: number;
+}
+
+function isUnder(child: string, parent: string): boolean {
+  return child.startsWith(parent.endsWith("/") ? parent : parent + "/");
+}
+
+// Nest each repo under the listed repo whose path most deeply contains its
+// own — the same deepest-path-wins rule buildRepoResolver uses for sessions,
+// so no repos.yml key is needed. Children follow their parent, siblings keep
+// the incoming (SQL, name-sorted) order. A disabled parent is not in the
+// list, so its children fall back to the top level.
+function groupRepos(repos: RepoRowFull[]): GroupedRepo[] {
+  const children = new Map<RepoRowFull | null, RepoRowFull[]>();
+  for (const r of repos) {
+    let parent: RepoRowFull | null = null;
+    for (const p of repos) {
+      if (p === r || !isUnder(r.path, p.path)) continue;
+      if (!parent || p.path.length > parent.path.length) parent = p;
+    }
+    const siblings = children.get(parent) ?? [];
+    siblings.push(r);
+    children.set(parent, siblings);
+  }
+  const out: GroupedRepo[] = [];
+  const walk = (parent: RepoRowFull | null, depth: number): void => {
+    for (const r of children.get(parent) ?? []) {
+      out.push({ repo: r, parentName: parent?.name ?? null, depth });
+      walk(r, depth + 1);
+    }
+  };
+  walk(null, 0);
+  return out;
+}
+
+function repoToRow({ repo: r, parentName, depth }: GroupedRepo): string {
+  // Children are indented under their parent. The dim ‹parent› suffix keeps
+  // the relation readable when a fzf query hides the parent row, and lets a
+  // query for the parent's name match its children too.
+  const indent = depth > 0 ? `${"  ".repeat(depth)}└ ` : "";
+  const parentHint = parentName ? `  \x1b[2m‹${parentName}›\x1b[0m` : "";
+  const label = `${indent}${r.icon || "📁"} ${r.name}${parentHint}${LABEL_SEP}`;
   const desc = truncate(r.description || "", DESC_MAX);
   const badges = buildRepoBadges(r);
   const cwd = r.cwd && r.cwd.length > 0 ? r.cwd : r.path;
@@ -271,8 +315,8 @@ function main(): number {
             ORDER BY r.name COLLATE NOCASE ASC`,
         )
         .all() as RepoRowFull[];
-      for (const r of repos) {
-        lines.push(repoToRow(r));
+      for (const g of groupRepos(repos)) {
+        lines.push(repoToRow(g));
       }
     }
 
@@ -359,5 +403,18 @@ function main(): number {
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  process.exit(main());
+  // exitCode, not process.exit(): stdout is a pipe into fzf, and pipe writes
+  // are async on macOS. Exiting right after the write dropped everything past
+  // the pipe buffer — as little as 512 bytes, so the list ended after 3 repos
+  // (2026-10-07). Returning lets Node flush the whole list first.
+  //
+  // The flip side: fzf may exit (pick / Esc) before reading every row, and
+  // the pending write then fails with EPIPE. Those rows have no reader, so
+  // end quietly with main()'s status — an unhandled EPIPE would print a stack
+  // trace and exit 1, which pipefail in bin/ccs turns into a dropped launch.
+  process.stdout.on("error", (err: NodeJS.ErrnoException) => {
+    if (err.code === "EPIPE") process.exit(process.exitCode ?? 0);
+    throw err;
+  });
+  process.exitCode = main();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-station",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Claude Code Station — fzf-powered launcher and session picker for Claude Code with multi-repo support and SQLite-backed state cache",
   "type": "module",
   "bin": {