@indigo-gr/claude-code-station 0.4.1 → 0.5.0

package/bin/ccs-init.ts

@@ -14,13 +14,15 @@
  */
 
 import { readdir } from "node:fs/promises";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, relative } from "node:path";
 import { parseDocument, isSeq } from "yaml";
 
 import { ensureConfigDir, getPaths, loadConfig } from "./ccs-config.ts";
+import { EditStop, runEditSync } from "./ccs-config-edit.ts";
 import { hasShellMetachars } from "./ccs-sanitize.ts";
+import { pathToFileURL } from "node:url";
 
 // ---------------------------------------------------------------------------
 // Discovery
@@ -143,6 +145,27 @@ export function buildCandidates(
 // YAML append (comment/format-preserving)
 // ---------------------------------------------------------------------------
 
+/**
+ * `repos: [{name: a, path: ~/a}]` (one line, YAML flow style) is valid, but
+ * appending to it keeps it on one line, and tools that read repos.yml line by
+ * line (`name:` and `path:` under each `- ` item) see none of it. ccs init
+ * only writes the block form, so it refuses here and leaves the file as is.
+ * `flow_style_repos` is the reason word for scripts to match on.
+ */
+export function rejectFlowStyleRepos(repos: unknown): void {
+  if (isSeq(repos) && repos.flow) {
+    throw new Error(
+      "flow_style_repos: repos.yml lists `repos:` on one line ([...]); ccs init only adds to a block list. " +
+        "Rewrite it with one `- name: ...` / `path: ...` item per entry, then run ccs init --auto-discover again. repos.yml unchanged",
+    );
+  }
+}
+
+/** The repos.yml source's `repos:` node, for the checks before any scan. */
+function reposNodeOf(source: string): unknown {
+  return parseDocument(source).get("repos", true);
+}
+
 /**
  * Append candidates to the `repos:` sequence of a repos.yml source string.
  * parseDocument round-trips comments and the user's existing formatting —
@@ -157,6 +180,7 @@ export function appendReposToYaml(
   if (!isSeq(repos)) {
     throw new Error("repos.yml: top-level `repos` sequence not found");
   }
+  rejectFlowStyleRepos(repos);
   for (const c of candidates) {
     repos.add(doc.createNode({ name: c.name, path: c.path }));
   }
@@ -168,25 +192,41 @@ export function appendReposToYaml(
 }
 
 /**
- * Write candidates into repos.yml with a `.bak` backup, then re-run the full
- * loadConfig() validation. On any validation failure the original file is
- * restored — `ccs init` must never leave a config the launcher cannot load.
+ * Write candidates into repos.yml through the common write path
+ * (ccs-config-edit: lock, check, `.bak`, write in place, check again, put the
+ * old text back on failure) — `ccs init` must never leave a config the
+ * launcher cannot load. A one-line `repos:` is refused before anything else,
+ * even when the file fails the other checks.
  */
 export function appendAndValidate(
   reposYmlPath: string,
   candidates: Candidate[],
 ): void {
-  const source = readFileSync(reposYmlPath, "utf-8");
-  const updated = appendReposToYaml(source, candidates);
-  writeFileSync(reposYmlPath + ".bak", source, { mode: 0o600 });
-  writeFileSync(reposYmlPath, updated, { mode: 0o600 });
+  rejectFlowStyleRepos(reposNodeOf(readFileSync(reposYmlPath, "utf-8")));
   try {
-    loadConfig();
+    runEditSync({
+      reposYml: reposYmlPath,
+      transform: ({ doc }) => {
+        const repos = doc.get("repos", true);
+        if (!isSeq(repos)) {
+          throw new Error("repos.yml: top-level `repos` sequence not found");
+        }
+        rejectFlowStyleRepos(repos);
+        for (const c of candidates) {
+          repos.add(doc.createNode({ name: c.name, path: c.path }));
+        }
+      },
+    });
   } catch (err) {
-    writeFileSync(reposYmlPath, source, { mode: 0o600 });
-    throw new Error(
-      `[ccs-init] validation failed after append — repos.yml restored (backup kept at .bak): ${err instanceof Error ? err.message : String(err)}`,
-    );
+    if (err instanceof EditStop && err.code === "validation_after_write_failed") {
+      throw new Error(
+        `[ccs-init] validation failed after append — repos.yml restored (backup kept at .bak): ${err.message}`,
+      );
+    }
+    if (err instanceof EditStop) {
+      throw new Error(`${err.code}: ${err.message}`);
+    }
+    throw err;
   }
 }
 
@@ -208,6 +248,8 @@ async function cliDiscover(argv: string[]): Promise<number> {
   const maxDepth = parseDepth(argv);
   ensureConfigDir();
   const config = loadConfig(); // throws ConfigError on a broken repos.yml
+  // Refuse before the $HOME scan and the picker, not after the user chose.
+  rejectFlowStyleRepos(reposNodeOf(readFileSync(getPaths().reposYml, "utf-8")));
   const existing: ExistingConfig = {
     names: new Set(config.repos.map((r) => r.name)),
     paths: new Set(config.repos.map((r) => r.path)),
@@ -274,7 +316,9 @@ async function main(): Promise<number> {
   }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+// pathToFileURL, not `file://${argv[1]}`: a folder with a space (or any
+// character a URL escapes) in its name would never match.
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
   main().then(
     // exitCode, not process.exit(): bin/ccs captures discover's candidates
     // with $(...), a pipe, and exiting right after the writes dropped every

package/bin/ccs-list-json.ts

@@ -0,0 +1,124 @@
+/**
+ * ccs-list-json.ts — `ccs list --json [--with-paths]`.
+ *
+ * repos.yml after ccs's checks, read directly (not the cache: no wait for a
+ * scan, nothing stale after --no-scan). Names, labels and descriptions are
+ * printed — that is what this command is for — but paths only with
+ * --with-paths, and never `command`, `cwd`, `custom` or `scan`.
+ * Contract: docs/design/machine-interface.md 2.2.
+ *
+ * Creates nothing: a missing repos.yml is exit 4 (config_missing), not a
+ * template.
+ */
+
+import { statSync } from "node:fs";
+
+import { readConfig, type RepoEntry } from "./ccs-config.ts";
+import {
+  cliOutcome,
+  configFailure,
+  emit,
+  okOutcome,
+  onInterrupt,
+  parseFlags,
+  wantsJson,
+  type Outcome,
+} from "./ccs-machine.ts";
+import { readLogicalGroups } from "./ccs-groups.ts";
+import { findParentRepo } from "./ccs-utils.ts";
+
+const COMMAND = "list";
+
+function isDirectory(p: string): boolean {
+  if (!p) return false;
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** One repos[] item of the output, in the documented key order. */
+export function listItem(
+  repo: RepoEntry,
+  parent: RepoEntry | null,
+  withPaths: boolean,
+): Record<string, unknown> {
+  const item: Record<string, unknown> = {
+    name: repo.name,
+    label: repo.label,
+    description: repo.description,
+    icon: repo.icon,
+    kind: repo.launch ? "repo" : "group",
+    launch: repo.launch,
+    lead: repo.lead,
+    disabled: repo.disabled,
+    parent: parent ? parent.name : null,
+    tags: [...repo.tags],
+    exists: isDirectory(repo.path),
+  };
+  if (withPaths) item.path = repo.path || null;
+  return item;
+}
+
+/**
+ * `groups[]`: the logical groups in defaults.groups_dir, read now (not from
+ * the cache), with their members' repos.yml names in the file's order.
+ */
+function logicalGroupsJson(dir: string, repos: RepoEntry[]): Record<string, unknown>[] {
+  return readLogicalGroups(dir, repos).groups.map((g) => ({
+    id: g.id,
+    label: g.label,
+    kind: "logical",
+    members: g.members,
+    unregistered_members: g.unregistered,
+  }));
+}
+
+/** The outcome of `ccs list` for these arguments (no printing). */
+export function listOutcome(args: readonly string[]): Outcome {
+  const flags = parseFlags(args, { booleans: ["--json", "--with-paths"] });
+  if (!flags.ok) return cliOutcome(flags.code);
+  if (flags.positionals.length > 0 || flags.rest.length > 0) {
+    return cliOutcome("extra_argument");
+  }
+  if (!flags.booleans.has("--json")) {
+    return cliOutcome(
+      "json_required",
+      {},
+      "`ccs list` needs --json (to pick a repo by hand, run ccs)",
+    );
+  }
+  const withPaths = flags.booleans.has("--with-paths");
+
+  let repos: RepoEntry[];
+  let groupsDir: string | null = null;
+  try {
+    const result = readConfig();
+    if (!result.found) {
+      return cliOutcome(
+        "config_missing",
+        {},
+        "no repos.yml yet (config_missing); `ccs init` creates one",
+      );
+    }
+    repos = result.config.repos;
+    groupsDir = result.config.settings.groupsDir;
+  } catch (err) {
+    return configFailure(err);
+  }
+
+  // The list tree's rule (ccs-list): the deepest enabled entry whose path
+  // holds this one; a disabled entry is never anyone's parent.
+  const enabled = repos.filter((r) => !r.disabled);
+  return okOutcome({
+    repos: repos.map((r) => listItem(r, findParentRepo(r, enabled), withPaths)),
+    groups: groupsDir ? logicalGroupsJson(groupsDir, repos) : [],
+  });
+}
+
+export function runList(args: readonly string[]): number {
+  const json = wantsJson(args);
+  onInterrupt(COMMAND, json);
+  return emit(COMMAND, listOutcome(args), json);
+}

package/bin/ccs-list.ts

@@ -9,7 +9,7 @@
  * `launch: false`), `resume` (past session) or `separator`.
  *
  * Modes:
- *   --current-only    sessions whose cwd matches process.cwd()
+ *   --current-only    sessions whose cwd matches CCS_CWD (else process.cwd())
  *   --repos-only      only NEW repo rows (and group headers)
  *   --sessions-only   only RESUME session rows
  *   (default)         NEW first (alpha, nested repos in a tree under their
@@ -23,10 +23,13 @@
  *                     row; no badge column, no tree glyphs, plain-word times
  *
  *   --print-ui        print the `defaults.ui` the last scan stored, then exit
+ *   --print-settings  print `ui=<mode>` and `update_check=<on|off>` as the
+ *                     last scan stored them, then exit
  */
 
 import { homedir } from "node:os";
 import { openDb, getMeta, reposV3Columns } from "./ccs-db.ts";
+import { groupsFromMeta } from "./ccs-groups.ts";
 import { getPaths } from "./ccs-config.ts";
 import { SHELL_METACHARS } from "./ccs-sanitize.ts";
 import {
@@ -44,6 +47,7 @@ import {
   uiFromArgv,
   type UiMode,
 } from "./ccs-utils.ts";
+import { pathToFileURL } from "node:url";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -71,6 +75,7 @@ interface Flags {
   sessionsOnly: boolean;
   ui: UiMode;
   printUi: boolean;
+  printSettings: boolean;
 }
 
 function parseArgs(argv: string[]): Flags {
@@ -80,6 +85,7 @@ function parseArgs(argv: string[]): Flags {
     sessionsOnly: argv.includes("--sessions-only"),
     ui: uiFromArgv(argv),
     printUi: argv.includes("--print-ui"),
+    printSettings: argv.includes("--print-settings"),
   };
 }
 
@@ -452,17 +458,77 @@ function simpleRepoRow(n: SimpleNode, nameCol: number): string {
   return [label, desc, "", `new:${r.name}`, cwd, r.command || "claude"].join("\t");
 }
 
-function simpleRepoRows(repos: RepoRowFull[]): string[] {
+/** A logical group (defaults.groups_dir) with the listed repos it holds. */
+interface LogicalView {
+  id: string;
+  label: string;
+  members: RepoRowFull[];
+}
+
+/** Match the stored groups to the listed (enabled) repos; empty groups go. */
+function logicalGroupsOf(
+  groups: { id: string; label: string; members: string[] }[],
+  repos: RepoRowFull[],
+): LogicalView[] {
+  const byName = new Map(repos.map((r) => [r.name, r]));
+  return groups
+    .map((g) => ({
+      id: g.id,
+      label: g.label,
+      members: g.members.map((n) => byName.get(n)).filter((r): r is RepoRowFull => r !== undefined),
+    }))
+    .filter((g) => g.members.length > 0);
+}
+
+/** The icon of a logical group's header (not a repos.yml entry, so no icon of its own). */
+const LOGICAL_ICON = "🗂";
+
+/**
+ * Classic rows of the logical groups: a display-only header (KIND=group, key
+ * `@<id>`, so the preview looks in the logical groups first) and the members
+ * under it, drawn as a tree.
+ */
+function logicalGroupRows(groups: LogicalView[]): string[] {
+  const lines: string[] = [];
+  for (const g of groups) {
+    const label = `${displayIcon(LOGICAL_ICON)} ${truncate(g.label, 40)}${LABEL_SEP}`;
+    lines.push([label, "", "", `group:@${g.id}`, "", ""].join("\t"));
+    g.members.forEach((r, i) => {
+      const last = i === g.members.length - 1;
+      lines.push(repoToRow({ repo: r, parent: null, prefix: `  ${last ? "└ " : "├ "}` }));
+    });
+  }
+  return lines;
+}
+
+/** Simple rows of a logical group: the bold header, then its members one level in. */
+function simpleLogicalRows(g: LogicalView, nameCol: number): string[] {
+  const head = `${padDisplay(LOGICAL_ICON, 2)} ${truncate(g.label, 40)}`;
+  const gap = " ".repeat(Math.max(0, nameCol - displayWidth(head)));
+  const styled = `${padDisplay(LOGICAL_ICON, 2)} ${BOLD}${truncate(g.label, 40)}${RESET}${gap}`;
+  return [
+    [`${styled}  `, "", "", `group:@${g.id}`, "", ""].join("\t"),
+    ...g.members.map((r) => simpleRepoRow({ repo: r, parent: null, depth: 1 }, nameCol)),
+  ];
+}
+
+function simpleRepoRows(repos: RepoRowFull[], logical: LogicalView[] = []): string[] {
   const { groups, projects } = simpleSections(repos);
   const all = [...groups, ...projects];
+  const logicalHeads = logical.flatMap((g) => [
+    `${padDisplay(LOGICAL_ICON, 2)} ${truncate(g.label, 40)}`,
+    ...g.members.map((r) => simpleHead({ repo: r, parent: null, depth: 1 })),
+  ]);
   const nameCol = Math.min(
     SIMPLE_NAME_COL_MAX,
-    Math.max(0, ...all.map((n) => displayWidth(simpleHead(n)))),
+    Math.max(0, ...all.map((n) => displayWidth(simpleHead(n))), ...logicalHeads.map(displayWidth)),
   );
   const lines: string[] = [];
-  if (groups.length > 0) {
+  if (groups.length > 0 || logical.length > 0) {
     lines.push(simpleHeading("グループ"));
     for (const n of groups) lines.push(simpleRepoRow(n, nameCol));
+    // After the launch: false headers.
+    for (const g of logical) lines.push(...simpleLogicalRows(g, nameCol));
   }
   if (projects.length > 0) {
     lines.push(simpleHeading("プロジェクト"));
@@ -554,10 +620,35 @@ function printUi(stateDb: string): number {
   return 0;
 }
 
+/**
+ * `--print-settings`: what the last scan stored, as the pre-scan prints it
+ * (`ui=<mode>` and `update_check=<on|off>`). Any failure prints the defaults
+ * (classic, on): the launcher must always get an answer it can use.
+ */
+function printSettings(stateDb: string): number {
+  let ui: UiMode = "classic";
+  let updateCheck = "on";
+  try {
+    const handle = openDb(stateDb, { readonly: true, skipMigrate: true });
+    try {
+      const v = getMeta(handle.db, "defaults_ui");
+      if (isUiMode(v)) ui = v;
+      if (getMeta(handle.db, "defaults_update_check") === "off") updateCheck = "off";
+    } finally {
+      handle.close();
+    }
+  } catch {
+    // keep the defaults
+  }
+  process.stdout.write(`ui=${ui}\nupdate_check=${updateCheck}\n`);
+  return 0;
+}
+
 function main(): number {
   const flags = parseArgs(process.argv.slice(2));
   const paths = getPaths();
   if (flags.printUi) return printUi(paths.stateDb);
+  if (flags.printSettings) return printSettings(paths.stateDb);
   const simple = flags.ui === "simple";
   // openDb() is called INSIDE the try so that a cold-start failure (state.db
   // missing before first scan) is caught and rendered as a friendly hint
@@ -589,12 +680,17 @@ function main(): number {
             ORDER BY r.name COLLATE NOCASE ASC`,
         )
         .all() as RepoRowFull[];
+      // defaults.groups_dir: logical groups the last scan matched to these
+      // repos (none when the setting is off).
+      const logical = logicalGroupsOf(groupsFromMeta(getMeta(db, "logical_groups")), repos);
       if (simple) {
-        lines.push(...simpleRepoRows(repos));
+        lines.push(...simpleRepoRows(repos, logical));
       } else {
         for (const g of groupRepos(repos)) {
           lines.push(repoToRow(g));
         }
+        // After every project row, before the conversations.
+        lines.push(...logicalGroupRows(logical));
       }
     }
 
@@ -610,7 +706,9 @@ function main(): number {
           ? metaCommand
           : "claude";
 
-      const filterCwd = flags.currentOnly ? process.cwd() : null;
+      // CCS_CWD: the folder ccs was run in (bin/ccs starts this module from
+      // its own folder; see ccs-tsx.sh).
+      const filterCwd = flags.currentOnly ? process.env.CCS_CWD || process.cwd() : null;
       const baseSelect = `SELECT s.uuid, s.repo_name, s.cwd, s.last_activity_at, s.topic,
                   r.name AS repo_display, r.icon AS repo_icon, r.command AS repo_command
              FROM sessions s
@@ -701,7 +799,9 @@ function main(): number {
   }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+// pathToFileURL, not `file://${argv[1]}`: a folder with a space (or any
+// character a URL escapes) in its name would never match.
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
   // 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