@dastyaresocial/ds-cs 0.2.0 → 0.2.1

package/README.md

@@ -23,20 +23,24 @@ Run it with no flags and `ds-cs` asks, in this order:
   Global (every project)           your user directory — OpenCode, Claude Code
 
 ? Which agents should read these skills?
-  type to filter · space to toggle · enter to confirm
+  type to filter · space toggle · a all · enter confirm
+  ❯ ◉ Select all
     ◉ OpenCode          .agents/skills
     ◉ Cursor            .agents/skills
     ◉ Codex             .agents/skills
     ◉ Claude Code       .claude/skills
     ○ Windsurf          .windsurf/skills
-  …
+  … 8 more
+
+(15 selected: opencode, claude-code, cursor, codex, …)
 
 ? How should the files be shared between agents?
 ❯ Symlink                          one copy, updates land everywhere
   Copy                              independent files per agent
 
 ? Which skills would you like to install?
-  type to filter · space to toggle · enter to install
+  type to filter · space toggle · a all · enter install
+  ❯ ◉ Select all
     ○ add-component     skills/dev/add-component/
     ○ add-orpc-endpoint skills/dev/add-orpc-endpoint/
   …
@@ -45,6 +49,10 @@ Run it with no flags and `ds-cs` asks, in this order:
 Scope first, because it decides which directories exist; then which agents read
 the skills; then how those agents share one copy; then what to install.
 
+Both multi-selects open on a **Select all** row — space on it, or `a` anywhere,
+takes everything; pressing it again clears the selection. That is what you want
+on a first run and never again.
+
 **Your last choices are remembered** in `~/.config/ds-cs/preferences.json`, so
 the next run preselects them and you can just hit enter three times. Delete the
 file to reset. It lives in your user directory, not the repo — scope and agent
@@ -183,10 +191,15 @@ npm run dev -- --help
 The prompts are hand-rolled keypress handling, which cannot be exercised without
 a terminal — every automated check would otherwise stop at `isInteractive()` and
 test the non-interactive path instead. `test/pty_harness.py` runs the real
-binary under a pty, sends keystrokes, and prints the transcript:
+binary under a pty, sends keystrokes, and prints the final screen.
+
+It splits the raw stream into repaint frames rather than counting occurrences of
+a menu in it. A prompt redraws by emitting cursor-up and erase sequences, so the
+byte stream contains every frame ever drawn; counting them there would report a
+correctly-repainting prompt as one that duplicates its menu:
 
 ```bash
-python3 test/pty_harness.py "ENTER,ENTER,ENTER,s,t,o,SPACE,ENTER" \
+python3 test/pty_harness.py "ENTER,SPACE,ENTER,ENTER,s,t,o,SPACE,ENTER" \
   node bin/ds-cs.mjs add
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dastyaresocial/ds-cs",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CLI for Dastyare Social — CS. Install DS-CS skills and third-party agent skills, wire up MCP, and authenticate to a channel.",
   "license": "MIT",
   "type": "module",

package/src/setup.mjs

@@ -106,7 +106,7 @@ export async function resolveInstallTarget(flags, { projectRoot }) {
       message: "Which agents should read these skills?",
       choices: agentChoices(detected),
       initialSelected: seed,
-      hint: "type to filter · space to toggle · enter to confirm",
+      hint: "type to filter · space toggle · a all · enter confirm",
       required: true,
     });
     agents = picked.map((choice) => choice.value);
@@ -175,7 +175,7 @@ export async function pickSkills(skills) {
       description: skill.skillPath.replace(/SKILL\.md$/, ""),
       keywords: `${skill.name} ${skill.skillPath} ${skill.description ?? ""}`,
     })),
-    hint: "type to filter · space to toggle · enter to install",
+    hint: "type to filter · space toggle · a all · enter install",
     required: true,
   });
   return picked.map((choice) => choice.value);

package/src/utils/prompt.mjs

@@ -8,22 +8,47 @@ import { bold, cyan, dim, yellow } from "./log.mjs";
  * Interactive prompts.
  *
  * Hand-rolled rather than pulled from a prompt library, because the CLI ships
- * with zero runtime dependencies. That means implementing the parts that matter
- * for an installer: search/filter over a list, multi-select with pre-selection,
- * and keyboard navigation — plus the guarantee that a non-interactive shell
- * never blocks on a keypress.
+ * with zero runtime dependencies.
  */
 
 const KEY = {
   up: "up",
   down: "down",
   space: "space",
-  enter: "return",
+  enter: "enter",
   escape: "escape",
   ctrlC: "c",
   backspace: "backspace",
 };
 
+/**
+ * A repainting region of the terminal.
+ *
+ * The previous implementation moved the cursor up, cleared a single line, and
+ * wrote the menu again — which appended a fresh copy on every keypress and
+ * scrolled the real menu off screen. Repainting has to be stateless: each frame
+ * is measured, the last one is fully erased, and the new one is written at a
+ * known position.
+ */
+function createScreen(write) {
+  let lastHeight = 0;
+
+  return {
+    paint(lines) {
+      if (lastHeight > 0) write(`\x1B[${lastHeight}A`);
+      write("\x1B[0J"); // erase from the cursor to the end of the screen
+      for (const line of lines) write(`${line}\n`);
+      lastHeight = lines.length;
+    },
+    erase() {
+      if (lastHeight === 0) return;
+      write(`\x1B[${lastHeight}A`);
+      write("\x1B[0J");
+      lastHeight = 0;
+    },
+  };
+}
+
 function readKeys() {
   readline.emitKeypressEvents(stdin);
   if (stdin.isTTY) stdin.setRawMode(true);
@@ -37,9 +62,11 @@ function keyOf(key) {
   if (!key) return null;
   switch (key.name) {
     case "up":
+      return KEY.up;
     case "k":
       return KEY.up;
     case "down":
+      return KEY.down;
     case "j":
       return KEY.down;
     case "space":
@@ -68,34 +95,36 @@ export function isInteractive() {
   return Boolean(stdin.isTTY && stdout.isTTY) && process.env.CI !== "true";
 }
 
-function visibleWidth(text) {
-  return stripAnsi(text).length;
-}
-
 function stripAnsi(text) {
   return text.replace(/\u001B\[[0-9;]*m/g, "");
 }
 
+function visibleWidth(text) {
+  return stripAnsi(text).length;
+}
+
 function pad(text, width) {
   const gap = width - visibleWidth(text);
   return gap > 0 ? text + " ".repeat(gap) : text;
 }
 
+function termWidth() {
+  return stdout.columns || 80;
+}
+
+function termRows() {
+  return stdout.rows || 24;
+}
+
 /**
  * Search-and-multi-select over a list of choices.
  *
- * This is the prompt an installer lives or dies by: typing filters, space
- * toggles, enter confirms, and the current selection is always visible. Keys
- * that are not commands are treated as filter input, so the user never has to
- * think about which mode they are in.
+ * The prompt an installer lives or dies by: typing filters, space toggles,
+ * enter confirms. A leading "Select all" row — and the `a` shortcut — make the
+ * whole registry selectable without fifteen space presses, which is what you
+ * want on a first run and never again.
  */
-export function multiselect({
-  message,
-  choices,
-  initialSelected = [],
-  hint,
-  required = false,
-}) {
+export function multiselect({ message, choices, initialSelected = [], hint, required = false }) {
   if (!isInteractive()) {
     throw new CliError(`"${message}" needs an interactive terminal`, {
       hint: "Pass the choice explicitly instead, e.g. --skill <name> or --agent <name>.",
@@ -103,136 +132,179 @@ export function multiselect({
   }
   if (choices.length === 0) return [];
 
-  const selected = new Set(initialSelected.filter((value) => choices.some((c) => c.value === value)));
+  const ALL = Symbol("select-all");
+  const selected = new Set(
+    initialSelected.filter((value) => choices.some((choice) => choice.value === value))
+  );
+
   let cursor = 0;
   let filter = "";
   let offset = 0;
+  let status = "";
 
-  const stop = readKeys();
   const write = (line) => stdout.write(line);
-  const pageSize = Math.min(10, Math.max(3, stdout.rows ? stdout.rows - 8 : 10));
+  const screen = createScreen(write);
+  const stop = readKeys();
+  const pageSize = Math.min(8, Math.max(3, termRows() - 9));
 
-  const visible = () =>
+  const visibleChoices = () =>
     filter === ""
       ? choices
       : choices.filter((choice) =>
-          // `keywords` lets a choice carry extra searchable text — a skill's
-          // full description, say — without widening what the list shows.
+          // `keywords` carries extra searchable text — a skill's full
+          // description, say — without widening what the list displays.
           (choice.keywords ?? `${choice.label} ${choice.description ?? ""}`)
             .toLowerCase()
             .includes(filter.toLowerCase())
         );
 
-  const render = (bottomLine) => {
-    const rows = visible();
-    if (cursor >= rows.length) cursor = Math.max(0, rows.length - 1);
+  const rows = () => [
+    { value: ALL, label: "Select all" },
+    ...visibleChoices().map((choice) => ({ value: choice.value, label: choice.label, choice })),
+  ];
+
+  const paint = () => {
+    const all = rows();
+    if (cursor >= all.length) cursor = all.length - 1;
+    if (cursor < 0) cursor = 0;
     if (cursor < offset) offset = cursor;
     if (cursor >= offset + pageSize) offset = cursor - pageSize + 1;
 
-    write("\x1B[2K\r");
-    write(`${bold("?")} ${bold(message)}\n`);
-
-    if (hint) write(`  ${dim(hint)}\n`);
-    if (filter) write(`  ${dim("filter:")} ${filter}${cyan("▌")}\n`);
-    write("\x1B[1A".repeat(filter ? 2 : hint ? 2 : 1));
-
-    const window = rows.slice(offset, offset + pageSize);
-    const labelWidth = Math.max(
+    const window = all.slice(offset, offset + pageSize);
+    const labelWidth = Math.min(
+      28,
+      Math.max(0, ...all.map((row) => visibleWidth(row.label)))
+    );
+    const pathWidth = Math.max(
       0,
-      ...choices.map((choice) => visibleWidth(choice.label))
+      ...all.map((row) => visibleWidth(row.choice?.description ?? ""))
     );
-
-    for (const choice of window) {
-      const index = rows.indexOf(choice);
+    const lines = [];
+    lines.push(`${bold("?")} ${bold(message)}`);
+    if (hint) lines.push(`  ${dim(hint)}`);
+    lines.push(filter === "" ? "" : `  ${dim("filter:")} ${filter}${cyan("▌")}`);
+    if (lines[lines.length - 1] === "") lines.pop();
+
+    for (const row of window) {
+      const index = offset + window.indexOf(row);
       const isCursor = index === cursor;
-      const isSelected = selected.has(choice.value);
+
+      if (row.value === ALL) {
+        const every = visibleChoices().length > 0 && visibleChoices().every((c) => selected.has(c.value));
+        const marker = every ? cyan("◉") : dim("○");
+        lines.push(
+          `  ${isCursor ? cyan("❯") : " "} ${marker} ${isCursor ? bold("Select all") : "Select all"}`
+        );
+        continue;
+      }
+
+      const isSelected = selected.has(row.value);
       const marker = isSelected ? cyan("◉") : dim("○");
-      const pointer = isCursor ? cyan("❯") : " ";
-      const label = isCursor ? bold(pad(choice.label, labelWidth)) : pad(choice.label, labelWidth);
-      const description = choice.description ? dim(`  ${choice.description}`) : "";
-      write(`  ${pointer} ${marker} ${label}${description}\n`);
+      const label = isCursor ? bold(pad(row.label, labelWidth)) : pad(row.label, labelWidth);
+      const path = row.choice?.description ? dim(`  ${row.choice.description}`) : "";
+      lines.push(
+        `  ${isCursor ? cyan("❯") : " "} ${marker} ${label}${path}`.slice(0, termWidth()).padEnd(
+          Math.min(termWidth(), labelWidth + pathWidth + 6)
+        )
+      );
     }
 
-    write("\x1B[1A".repeat(window.length));
-    write("\x1B[2K\r");
-    write(`${bottomLine}\n`);
+    if (all.length > window.length) {
+      lines.push(dim(`  … ${all.length - window.length} more`));
+    }
+    lines.push("");
+    lines.push(
+      status ||
+        dim(
+          selected.size === 0
+            ? "(none selected)"
+            : `(${selected.size} selected: ${[...selected].slice(0, 4).join(", ")}${selected.size > 4 ? ", …" : ""})`
+        )
+    );
+    screen.paint(lines);
   };
 
-  const cleanup = (message) => {
+  const finish = (error) => {
     stop();
-    write("\x1B[?25h"); // show cursor
-    if (message) write(`${message}\n`);
+    screen.erase();
+    stdout.write("\x1B[?25h");
+    if (error) throw error;
   };
 
-  stdout.write("\x1B[?25l"); // hide cursor for the duration of the prompt
+  stdout.write("\x1B[?25l"); // hide the cursor while navigating
+  paint();
 
-  return new Promise((resolve, reject) => {
-    const summary = () =>
-      selected.size === 0
-        ? `${dim("(none selected)")}`
-        : dim(`(${selected.size} selected: ${[...selected].join(", ")})`);
-
-    render(summary());
+  return new Promise((resolve) => {
+    const toggleAll = () => {
+      const shown = visibleChoices();
+      const everySelected = shown.every((choice) => selected.has(choice.value));
+      if (everySelected) for (const choice of shown) selected.delete(choice.value);
+      else for (const choice of shown) selected.add(choice.value);
+    };
 
     const onKeypress = (str, key) => {
       const name = keyOf(key);
+      const all = rows();
 
       if (name === KEY.ctrlC) {
-        write("\x1B[1A".repeat(1)); // clear summary row
-        cleanup();
+        finish();
         process.exit(130);
       }
-
       if (name === KEY.escape) {
-        cleanup();
-        reject(new CliError("Aborted."));
+        finish(new CliError("Aborted."));
         return;
       }
-
       if (name === KEY.enter) {
         if (required && selected.size === 0) {
-          render(`${yellow("!")} select at least one (enter to confirm)`);
+          status = yellow("! select at least one (enter to confirm)");
+          paint();
           return;
         }
-        cleanup();
+        finish();
         resolve(choices.filter((choice) => selected.has(choice.value)));
         return;
       }
-
       if (name === KEY.up || name === KEY.down) {
-        const rows = visible();
-        if (rows.length === 0) return;
         cursor = name === KEY.up ? cursor - 1 : cursor + 1;
-        if (cursor < 0) cursor = rows.length - 1;
-        if (cursor >= rows.length) cursor = 0;
-        render(summary());
+        if (cursor < 0) cursor = all.length - 1;
+        if (cursor >= all.length) cursor = 0;
+        status = "";
+        paint();
         return;
       }
-
       if (name === KEY.space) {
-        const rows = visible();
-        const choice = rows[cursor];
-        if (!choice) return;
-        if (selected.has(choice.value)) selected.delete(choice.value);
-        else selected.add(choice.value);
-        render(summary());
+        const row = all[cursor];
+        if (row) {
+          if (row.value === ALL) toggleAll();
+          else if (selected.has(row.value)) selected.delete(row.value);
+          else selected.add(row.value);
+        }
+        status = "";
+        paint();
         return;
       }
-
       if (name === KEY.backspace) {
         filter = filter.slice(0, -1);
         cursor = 0;
         offset = 0;
-        render(summary());
+        status = "";
+        paint();
         return;
       }
 
-      // Anything else is filter input.
+      // `a` toggles everything; anything else is filter input.
+      if (str === "a" && !key.ctrl && !key.meta) {
+        toggleAll();
+        status = "";
+        paint();
+        return;
+      }
       if (str && !key.ctrl && !key.meta && visibleWidth(str) > 0) {
         filter += str;
         cursor = 0;
         offset = 0;
-        render(summary());
+        status = "";
+        paint();
       }
     };
 
@@ -241,8 +313,8 @@ export function multiselect({
   });
 }
 
-/** Single-select, same interaction model with `enter` selecting the cursor. */
-export function select({ message, choices, initialIndex = 0 }) {
+/** Single-select, same repaint model with enter choosing the cursor row. */
+export function select({ message, choices, initialIndex = 0, hint }) {
   if (choices.length === 0) return [];
 
   if (!isInteractive()) {
@@ -251,60 +323,67 @@ export function select({ message, choices, initialIndex = 0 }) {
     });
   }
 
-  let cursor = Math.min(initialIndex, choices.length - 1);
+  let cursor = Math.min(Math.max(0, initialIndex), choices.length - 1);
   let offset = 0;
-  const stop = readKeys();
+
   const write = (line) => stdout.write(line);
-  const pageSize = Math.min(10, Math.max(3, stdout.rows ? stdout.rows - 8 : 10));
+  const screen = createScreen(write);
+  const stop = readKeys();
+  const pageSize = Math.min(8, Math.max(3, termRows() - 8));
 
-  const render = () => {
+  const paint = () => {
     if (cursor >= choices.length) cursor = choices.length - 1;
     if (cursor < offset) offset = cursor;
     if (cursor >= offset + pageSize) offset = cursor - pageSize + 1;
 
-    write("\x1B[2K\r");
-    write(`${bold("?")} ${bold(message)}\n`);
-
     const window = choices.slice(offset, offset + pageSize);
-    const labelWidth = Math.max(0, ...choices.map((choice) => visibleWidth(choice.label)));
+    const labelWidth = Math.min(28, Math.max(0, ...choices.map((choice) => visibleWidth(choice.label))));
+
+    const lines = [`${bold("?")} ${bold(message)}`];
+    if (hint) lines.push(`  ${dim(hint)}`);
 
     for (const choice of window) {
       const index = offset + window.indexOf(choice);
-      const pointer = index === cursor ? cyan("❯") : " ";
-      const label = index === cursor ? bold(pad(choice.label, labelWidth)) : pad(choice.label, labelWidth);
+      const isCursor = index === cursor;
+      const label = isCursor ? bold(pad(choice.label, labelWidth)) : pad(choice.label, labelWidth);
       const description = choice.description ? dim(`  ${choice.description}`) : "";
-      write(`  ${pointer} ${label}${description}\n`);
+      lines.push(`  ${isCursor ? cyan("❯") : " "} ${label}${description}`);
     }
 
-    write("\x1B[1A".repeat(window.length));
-    write("\x1B[2K\r");
-    write(dim("  ↑/↓ move · enter select\n"));
-  };
+    if (choices.length > window.length) {
+      lines.push(dim(`  … ${choices.length - window.length} more`));
+    }
+    lines.push("");
+    lines.push(dim(hint ? "" : "↑/↓ move · enter select"));
+    if (lines[lines.length - 1] === "") lines.pop();
 
-  const cleanup = () => {
-    stop();
-    write("\x1B[?25h");
+    screen.paint(lines);
   };
 
-  stdout.write("\x1B[?25l"); // hide cursor for the duration of the prompt
+  stdout.write("\x1B[?25l");
+  paint();
 
   return new Promise((resolve, reject) => {
-    render();
-
     const onKeypress = (str, key) => {
       const name = keyOf(key);
 
       if (name === KEY.ctrlC) {
-        cleanup();
+        stop();
+        screen.erase();
+        stdout.write("\x1B[?25h");
         process.exit(130);
       }
       if (name === KEY.escape) {
-        cleanup();
+        stop();
+        screen.erase();
+        stdout.write("\x1B[?25h");
         reject(new CliError("Aborted."));
         return;
       }
       if (name === KEY.enter) {
-        cleanup();
+        stop();
+        screen.erase();
+        stdout.write("\x1B[?25h");
         resolve([choices[cursor]]);
         return;
       }
@@ -312,7 +391,7 @@ export function select({ message, choices, initialIndex = 0 }) {
         cursor = name === KEY.up ? cursor - 1 : cursor + 1;
         if (cursor < 0) cursor = choices.length - 1;
         if (cursor >= choices.length) cursor = 0;
-        render();
+        paint();
       }
     };
 
@@ -328,8 +407,7 @@ export function select({ message, choices, initialIndex = 0 }) {
 export async function confirm(message, { defaultYes = true } = {}) {
   if (!isInteractive()) return defaultYes;
 
-  const { createInterface } = readline;
-  const rl = createInterface({ input: stdin, output: stdout });
+  const rl = readline.createInterface({ input: stdin, output: stdout });
   try {
     const suffix = defaultYes ? "[Y/n]" : "[y/N]";
     const answer = (await rl.question(`${bold("?")} ${message} ${dim(suffix)} `)).trim().toLowerCase();
@@ -342,8 +420,7 @@ export async function confirm(message, { defaultYes = true } = {}) {
 
 export async function promptText(message, fallback = "") {
   if (!isInteractive()) return fallback;
-  const { createInterface } = readline;
-  const rl = createInterface({ input: stdin, output: stdout });
+  const rl = readline.createInterface({ input: stdin, output: stdout });
   try {
     const suffix = fallback ? dim(` (${fallback})`) : "";
     const answer = (await rl.question(`${bold("?")} ${message}${suffix} `)).trim();
@@ -353,4 +430,4 @@ export async function promptText(message, fallback = "") {
   }
 }
 
-export { select as selectOne, multiselect as selectMany };
+export { select as selectOne, multiselect as selectMany };