@ericrisco/rsc 0.1.5 → 0.1.7

package/README.md

@@ -80,13 +80,15 @@ assistant proposes new skills on its own from then on.
 
 ```
 $ rsc
-👋 rsc — the skill catalog for your assistant.
+ ██████╗ ███████╗ ██████╗     ← animated gradient wordmark
+ ██╔══██╗██╔════╝██╔════╝
+ ██████╔╝███████╗██║
+  231 skills · one CLI · zero bloat
 
 What do you want to do?          ↑↓ move · enter select
 ❯ Base install — the essentials (orient + suggest + harness + init)
   Base + Spec-Driven Development — specify → plan → implement → ship
   Pick skills by hand, by area
-  Describe my project and let rsc choose
 ```
 
 Pick **by area** and you get a checkbox list — **↑↓ to move, space to toggle,

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.5",
+  "version": "0.1.7",
   "counts": {
     "skills": 231
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {

package/scripts/lib/ui.js

@@ -1,6 +1,9 @@
-import { createInterface, emitKeypressEvents } from 'node:readline';
+import { createInterface } from 'node:readline/promises';
+import { emitKeypressEvents } from 'node:readline';
 import { stdin, stdout } from 'node:process';
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
 export async function ask(question) {
   const rl = createInterface({ input: stdin, output: stdout });
   const a = await rl.question(question);
@@ -33,20 +36,52 @@ const C = {
   green: (s) => `\x1b[32m${s}\x1b[39m`,
 };
 
-// ASCII wordmark shown at the top of the wizard.
-export function banner() {
-  const tty = Boolean(stdout.isTTY);
-  const art = [
-    '',
-    ' ██████╗ ███████╗ ██████╗',
-    ' ██╔══██╗██╔════╝██╔════╝',
-    ' ██████╔╝███████╗██║     ',
-    ' ██╔══██╗╚════██║██║     ',
-    ' ██║  ██║███████║╚██████╗',
-    ' ╚═╝  ╚═╝╚══════╝ ╚═════╝',
-  ];
-  for (const l of art) say(tty ? C.cyan(l) : l);
-  say((tty ? C.dim('  231 skills · one CLI · zero bloat') : '  231 skills · one CLI · zero bloat'));
+const ART = [
+  ' ██████╗ ███████╗ ██████╗',
+  ' ██╔══██╗██╔════╝██╔════╝',
+  ' ██████╔╝███████╗██║     ',
+  ' ██╔══██╗╚════██║██║     ',
+  ' ██║  ██║███████║╚██████╗',
+  ' ╚═╝  ╚═╝╚══════╝ ╚═════╝',
+];
+
+// Vertical truecolor gradient (sky → violet), phase-shiftable for the wave.
+function gradientLine(text, row, phase) {
+  const a = [56, 189, 248]; const b = [167, 139, 250];
+  const t = ((row + phase) % ART.length) / (ART.length - 1);
+  const r = Math.round(a[0] + (b[0] - a[0]) * t);
+  const g = Math.round(a[1] + (b[1] - a[1]) * t);
+  const bl = Math.round(a[2] + (b[2] - a[2]) * t);
+  return `\x1b[38;2;${r};${g};${bl}m${text}\x1b[39m`;
+}
+
+// Animated ASCII wordmark — the "wooow". Static plain text when not a TTY.
+export async function banner() {
+  if (!stdout.isTTY) {
+    say('');
+    for (const l of ART) say(l);
+    say('  231 skills · one CLI · zero bloat');
+    return;
+  }
+  const W = Math.max(...ART.map((l) => l.length));
+  stdout.write('\x1b[?25l'); // hide cursor
+  say('');
+  // 1) letters slide in left → right, column by column
+  let first = true;
+  for (let w = 1; w <= W; w++) {
+    if (!first) stdout.write(`\x1b[${ART.length}A`);
+    first = false;
+    stdout.write(ART.map((l, i) => `\x1b[2K${gradientLine(l.slice(0, w), i, 0)}`).join('\n') + '\n');
+    await sleep(20);
+  }
+  // 2) one flowing color wave to settle
+  for (let phase = 1; phase <= ART.length; phase++) {
+    stdout.write(`\x1b[${ART.length}A`);
+    stdout.write(ART.map((l, i) => `\x1b[2K${gradientLine(l, i, phase)}`).join('\n') + '\n');
+    await sleep(45);
+  }
+  say(C.dim('  231 skills · one CLI · zero bloat'));
+  stdout.write('\x1b[?25h'); // show cursor
 }
 
 // Repaint a fixed block of lines in place (cursor ends just below the block).
@@ -142,6 +177,18 @@ export async function select(question, options) {
   return byKey ? byKey.key : null;
 }
 
+// Public: yes/no confirmation. Arrow TUI when interactive, typed prompt otherwise.
+export async function confirm(question) {
+  if (interactive()) {
+    const k = await tuiSelect(question, [
+      { key: 'yes', label: 'Yes, install it' },
+      { key: 'no', label: 'No, cancel' },
+    ]);
+    return k === 'yes';
+  }
+  return yes(await ask(`${question} (yes / no) > `));
+}
+
 // Public: multi-select. items: array of strings or { id, label }. Returns ids.
 export async function pickFrom(title, items) {
   const norm = items.map((it) => (typeof it === 'string' ? { id: it, label: it } : it));

package/scripts/rsc.js

@@ -6,7 +6,7 @@ import { rank } from './consult.js';
 import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
 import { applyInstall, listInstalled, uninstall } from './install-apply.js';
 import { doctor } from './doctor.js';
-import { ask, say, yes, select, pickFrom, banner } from './lib/ui.js';
+import { say, select, pickFrom, banner, confirm } from './lib/ui.js';
 import { refreshRegistry, registryStatus } from './lib/registry.js';
 import { DOMAINS } from './lib/domains.js';
 
@@ -45,19 +45,6 @@ async function manualSelect() {
   return [...chosen];
 }
 
-// Describe-your-project flow: rsc reads repo + words and proposes skills.
-async function describeFlow() {
-  const goal = await ask('\nTell me in one sentence what you want to build or run:\n> ');
-  const ids = await recommendIds(goal, { labeledOnly: true });
-  if (!ids.length) {
-    say("I'm not sure. Try describing it in more detail, or pick by hand (option 3).");
-    return [];
-  }
-  say('\nI recommend installing:');
-  for (const o of toOutcomes(ids)) say(`   • ${o.label}`);
-  return ids;
-}
-
 // After installing, remind the user how to actually start — per IDE — and that
 // rsc keeps recommending skills as they work. The harness/SDD *init* runs INSIDE
 // the assistant (with the user present), never blindly from this CLI.
@@ -94,20 +81,18 @@ function printNextSteps(target, ids) {
 
 async function wizard() {
   const m = loadManifest();
-  banner();
+  await banner();
   say('  the skill catalog for your assistant (Claude Code · Cursor · Codex · Gemini)\n');
   const choice = await select('What do you want to do?', [
     { key: 'base', label: 'Base install — the essentials (orient + suggest + harness + init)' },
     { key: 'sdd', label: 'Base + Spec-Driven Development — the specify → plan → implement → ship flow' },
     { key: 'manual', label: 'Pick skills by hand, by area' },
-    { key: 'describe', label: 'Describe my project and let rsc choose' },
   ]);
 
   let ids = [];
   if (choice === 'base') ids = skillsForProfile(m, 'minimal');
   else if (choice === 'sdd') ids = skillsForProfile(m, 'core');
   else if (choice === 'manual') ids = await manualSelect();
-  else if (choice === 'describe') ids = await describeFlow();
   else { say("Didn't catch that. Run again: npx @ericrisco/rsc"); return; }
 
   // The floor is always installed: the compass + the detector.
@@ -120,7 +105,7 @@ async function wizard() {
   const target = detectTarget();
   say(`\nI'll install ${ids.length} skills into ${target}:`);
   say('   ' + ids.join(', '));
-  if (!yes(await ask('\nInstall it? (yes / no) > '))) {
+  if (!(await confirm('Install it?'))) {
     say('No problem. Anytime: npx @ericrisco/rsc');
     return;
   }

package/skills/implement/SKILL.md

@@ -23,12 +23,18 @@ into them rather than reinventing them.
 ## Before you write a line of code
 
 Run this short gate. Skipping it is the most common way an implement session goes sideways.
-
-1. **Read the inputs.** Open the spec (`02-DOCS/wiki/sdd/specs/<slug>.md`), the plan
-   (`02-DOCS/wiki/sdd/plans/<slug>.md`, which holds the task list), and the constitution
-   (`02-DOCS/wiki/sdd/constitution.md`). If any is missing, you are not ready to implement — route
-   back: no plan → `plan`; no task list inside the plan → `tasks`; unresolved `analyze` findings →
-   resolve them first. Do not start coding to "discover the plan as you go".
+**This gate is a hard refuse, not a checklist to feel good about:** if it fails you stop and route
+back — you do not write feature code anyway.
+
+1. **The spec + plan must exist AND be approved.** Open the spec (`02-DOCS/wiki/sdd/specs/<slug>.md`),
+   the plan (`02-DOCS/wiki/sdd/plans/<slug>.md`, which holds the task list), and the constitution
+   (`02-DOCS/wiki/sdd/constitution.md`). If any is missing, **you are not allowed to implement** —
+   route back: no spec → `specify`; no plan → `plan`; no task list inside the plan → `tasks`;
+   unresolved `analyze` findings → resolve them first. If a spec/plan exists but the user has not
+   actually seen and **approved** it, get that approval first. Never "start coding to discover the
+   plan as you go", and never accept "just build it, skip the spec" on a non-trivial feature — name
+   the gate in one friendly line and route to `specify`. (Only a true one-line, low-risk change
+   earns a skip, and you say so.)
 2. **Read the SDD runtime config.** Open `02-DOCS/wiki/sdd/config.yaml`. If it is missing on
    non-trivial work, stop and route to `sdd-init`. Use `testing.strict_tdd`,
    `testing.commands.apply`, `testing.commands.verify`, `sdd.review_budget` and

package/skills/sdd/SKILL.md

@@ -70,6 +70,8 @@ constitution ─(once per project)─┐
 
 When a request lands, do not start typing code. Place it on the map first, then invoke the phase skill that owns it.
 
+> **The new-feature gate (hard).** The moment the user is thinking about a new feature or change — "add…", "build…", "it should also…", "quiero añadir…" — it goes to `specify` first, *even if a stack skill (nextjs/fastapi/flutter/react…) also fired and could just build it*. **No feature code is written — by any skill — until a spec AND a plan exist and the user has approved them.** A stack skill about to build an unspec'd, non-trivial feature must stop and route here. The only exception is a genuinely one-line, low-risk change; name it and skip.
+
 1. **No `02-DOCS/wiki/sdd/config.yaml` and this is non-trivial?** → `sdd-init`.
 2. **No constitution yet AND this project will grow?** → `constitution` once, then come back to the chain.
 3. **Ambiguous / architectural / risky change before spec?** → optional proposal artifact via `specify`.

package/skills/specify/SKILL.md

@@ -13,6 +13,15 @@ This is the **specify** phase of the rsc-sdd chain: `constitution` → **`specif
 
 A spec is a contract about behaviour and outcomes, readable by a non-technical stakeholder and precise enough that a `plan` can be derived from it. The output is one file: `02-DOCS/wiki/sdd/specs/<slug>.md`, indexed in the root `CLAUDE.md` Knowledge map.
 
+## Detect the moment — and hold the gate
+
+The instant the user is **thinking about a new feature or change** — "I want to add…", "can we build…", "it should also…", "wouldn't it be nice if…", "necesito que haga…", "quiero añadir…" — this phase owns it, *even if a stack skill (nextjs/fastapi/flutter…) also fired and is itching to build it*. Catch it here first.
+
+**The hard gate (non-negotiable for any non-trivial feature):**
+> No feature code gets written until (1) this spec exists and the user has **approved** it, and (2) `plan` has produced a technical plan + task list. If the user tries to jump straight to "just build it", do not. Name the gate in one friendly line, capture the spec, and walk the chain. The only bypass is a genuinely one-line, low-risk change (typo/copy/config) — say so out loud and skip.
+
+You are not slowing them down; you are making the intent reviewable *before* code exists, which is cheaper than discovering the misunderstanding in a PR. End every spec by handing to `clarify`/`plan` — never to `implement`.
+
 ## The one rule that defines this skill
 
 **No implementation leaks.** The moment the spec names a framework, a table schema, a library, an endpoint shape, a file path, or an algorithm, it has stopped being a spec. Those decisions belong to `plan` and the stack skills. Specify describes the *observable behaviour and the reason for it*; the system that delivers it is deliberately left open.