@ryuxdsgn/design-intelligence 0.0.0-stage → 2.6.1

package/dist/cli/index.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { AGENT_TARGETS, AGENTS_MD_INLINE, LEGACY_CURSOR_RULES_DIR, LEGACY_SKILL_DIRS, } from "../adapters.js";
+import { ALL_INSTALLABLE_IDS } from "../intelligence/content.js";
+import { CLI_CMD, CONTEXT_END, CONTEXT_FILE, CONTEXT_START, MARK_START, MCP_LOCAL_ADD_CMD, MCP_STATUS, VERSION } from "../product.js";
+import { validateBundle } from "../validate.js";
+import { renderAgentsBlock, renderBundle, renderPointerBlock, SKILL_NAME } from "../render.js";
+import { hasBlock, readIfExists, rel, removeBlock, removePath, upsertBlock, writeFileEnsured } from "./fsutil.js";
+import { readFile, readdir } from "node:fs/promises";
+const AGENT_IDS = [...AGENT_TARGETS.map((a) => a.id), AGENTS_MD_INLINE.id];
+const targetDir = (a, scope) => join(scope.root, scope.global ? a.globalDir : a.dir);
+/** Unique skill folders for the chosen agents (agents that share a folder are written once). */
+function dirsFor(agentIds, scope) {
+    const dirs = AGENT_TARGETS.filter((a) => agentIds.includes(a.id)).map((a) => targetDir(a, scope));
+    return [...new Set(dirs)];
+}
+function pointersFor(agentIds) {
+    const files = AGENT_TARGETS.filter((a) => agentIds.includes(a.id)).map((a) => a.pointer);
+    return [...new Set(files)];
+}
+async function removeLegacy(dir, root) {
+    const done = [];
+    for (const c of LEGACY_SKILL_DIRS) {
+        const target = join(dir, `ryux-${c}`);
+        if (await removePath(target))
+            done.push(`${rel(target)} (legacy)`);
+    }
+    const cursorRules = join(root, LEGACY_CURSOR_RULES_DIR);
+    if (existsSync(cursorRules)) {
+        for (const f of readdirSync(cursorRules)) {
+            if (f.startsWith("ryux-") && f.endsWith(".mdc") && (await removePath(join(cursorRules, f)))) {
+                done.push(`${rel(join(cursorRules, f))} (legacy)`);
+            }
+        }
+    }
+    return done;
+}
+/** Former per-skill folders (RYUX 1.x), removed when the single `ryux` skill is written. */
+const OLD_SKILL_DIRS = ["core", ...ALL_INSTALLABLE_IDS].map((id) => `ryux-${id}`);
+async function writeSkills(dir, root) {
+    const done = await removeLegacy(dir, root);
+    for (const name of OLD_SKILL_DIRS)
+        if (await removePath(join(dir, name)))
+            done.push(`${rel(join(dir, name))} (replaced)`);
+    const skillDir = join(dir, SKILL_NAME);
+    await removePath(skillDir);
+    const files = renderBundle();
+    for (const [path, content] of Object.entries(files))
+        await writeFileEnsured(join(skillDir, path), content);
+    done.push(`${rel(skillDir)}/ (${Object.keys(files).length} files)`);
+    return done;
+}
+async function install(agentIds, scope) {
+    const done = [];
+    for (const dir of dirsFor(agentIds, scope))
+        done.push(...(await writeSkills(dir, scope.root)));
+    if (scope.global)
+        return done;
+    const inline = agentIds.includes(AGENTS_MD_INLINE.id);
+    for (const file of pointersFor(agentIds)) {
+        if (file === "AGENTS.md" && inline)
+            continue;
+        await upsertBlock(join(scope.root, file), renderPointerBlock());
+        done.push(`${file} (block)`);
+    }
+    if (inline) {
+        await upsertBlock(join(scope.root, "AGENTS.md"), renderAgentsBlock());
+        done.push("AGENTS.md (rules inline)");
+    }
+    return done;
+}
+const hasInstall = (dir) => existsSync(join(dir, SKILL_NAME, "SKILL.md")) || existsSync(join(dir, "ryux-core")) || existsSync(join(dir, "ryux-rules"));
+/** Skill folders that already hold a RYUX install (the single skill, or the RYUX 1.x folders). */
+function detectInstalled(scope) {
+    return [...new Set(AGENT_TARGETS.map((a) => targetDir(a, scope)))].filter(hasInstall);
+}
+/** Agent ids whose folders hold a RYUX install (or, for preselection, whose folders exist). */
+function agentsAt(scope, requireInstall) {
+    return AGENT_TARGETS.filter((a) => {
+        const dir = targetDir(a, scope);
+        return requireInstall ? hasInstall(dir) : existsSync(join(dir, ".."));
+    }).map((a) => a.id);
+}
+function parseFlags(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith("--"))
+            continue;
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags[key] = next;
+            i++;
+        }
+        else {
+            flags[key] = true;
+        }
+    }
+    return flags;
+}
+const list = (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : null;
+const scopeOf = (flags) => ({ global: Boolean(flags.global), root: flags.global ? homedir() : process.cwd() });
+function cancel() {
+    p.cancel("Cancelled.");
+}
+async function runInstall(flags) {
+    const scope = scopeOf(flags);
+    const flagAgents = list(flags.agent);
+    const nonInteractive = Boolean(flagAgents);
+    if (flags.for || flags.groups || flags.concerns) {
+        console.log(pc.yellow("RYUX 2 installs one skill that picks the knowledge each task needs; --for, --groups, and --concerns are no longer needed."));
+    }
+    let agents;
+    let showMcp;
+    if (flagAgents) {
+        agents = flagAgents.includes("all") ? AGENT_TARGETS.map((a) => a.id) : flagAgents.filter((a) => AGENT_IDS.includes(a));
+        showMcp = Boolean(flags.mcp);
+        if (!agents.length) {
+            console.error(`Invalid agent.\nAgents: ${AGENT_IDS.join(",")},all`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        if (!process.stdin.isTTY) {
+            console.error(`Interactive mode needs a terminal. Use flags, e.g.: ${CLI_CMD} install --agent claude,cursor`);
+            process.exitCode = 1;
+            return;
+        }
+        p.intro(pc.bgCyan(pc.black(" RYUX ")));
+        const detected = agentsAt(scope, false);
+        const a = await p.multiselect({
+            message: `Which agents do you use?${keys("↑/↓ move", "Space select", "a all", "Enter continue", "Ctrl+C cancel")}`,
+            options: [
+                ...AGENT_TARGETS.map((x) => ({ value: x.id, label: x.label, hint: scope.global ? `~/${x.globalDir}` : x.dir })),
+                { value: AGENTS_MD_INLINE.id, label: AGENTS_MD_INLINE.label, hint: "AGENTS.md" },
+            ],
+            initialValues: detected.length ? detected : ["claude"],
+            required: true,
+        });
+        if (p.isCancel(a))
+            return cancel();
+        const m = await p.confirm({ message: `Show how to connect the ryux MCP?${keys(YES_NO, "Enter continue")}`, initialValue: false });
+        if (p.isCancel(m))
+            return cancel();
+        agents = a;
+        showMcp = Boolean(m);
+    }
+    if (scope.global && agents.includes(AGENTS_MD_INLINE.id)) {
+        console.log(pc.yellow("agents-md is project-only; skipped for --global."));
+        agents = agents.filter((x) => x !== AGENTS_MD_INLINE.id);
+    }
+    const written = await install(agents, scope);
+    const summary = written.map((w) => pc.green("✓ ") + w).join("\n");
+    if (nonInteractive)
+        console.log(summary);
+    else
+        p.note(summary, "Installed");
+    if (showMcp) {
+        if (nonInteractive)
+            console.log(`\nMCP: ${MCP_STATUS}`);
+        else
+            p.note(MCP_STATUS, "ryux MCP");
+    }
+    if (nonInteractive)
+        return;
+    if (!scope.global) {
+        const s = await p.confirm({ message: `Set up project context now? Every question can be skipped.${keys(YES_NO, "Enter continue")}`, initialValue: true });
+        if (p.isCancel(s))
+            return cancel();
+        if (s && !(await setupInteractive(scope.root)))
+            return cancel();
+        if (!s)
+            p.log.info(`Set it up later with: ${CLI_CMD} setup`);
+    }
+    p.outro(`RYUX is ready. Try: ${pc.cyan('"Design a transaction detail page for our app."')}`);
+}
+async function runUpdate(flags) {
+    const scope = scopeOf(flags);
+    const dirs = detectInstalled(scope);
+    const agentsFile = scope.global ? null : await readIfExists(join(scope.root, "AGENTS.md"));
+    const inline = Boolean(agentsFile?.includes(MARK_START) && (agentsFile.includes("# RYUX\n") || agentsFile.includes("# ryux-core")));
+    if (!dirs.length && !inline) {
+        console.log(`No RYUX install found. Run: ${CLI_CMD} install`);
+        return;
+    }
+    const done = [];
+    for (const dir of dirs)
+        done.push(...(await writeSkills(dir, scope.root)));
+    if (!scope.global) {
+        for (const file of ["CLAUDE.md", "GEMINI.md", "AGENTS.md"]) {
+            const path = join(scope.root, file);
+            const content = await readIfExists(path);
+            if (!content?.includes(MARK_START))
+                continue;
+            await upsertBlock(path, file === "AGENTS.md" && inline ? renderAgentsBlock() : renderPointerBlock());
+            done.push(`${file} (block)`);
+        }
+    }
+    console.log(`${pc.green("✓ ")}Updated to v${VERSION}:\n${done.map((d) => `  ${d}`).join("\n")}`);
+}
+async function runRemove(flags) {
+    const scope = scopeOf(flags);
+    const dirs = [...new Set(AGENT_TARGETS.map((a) => targetDir(a, scope)))];
+    const hasSkills = dirs.some(hasInstall);
+    const pointerFiles = scope.global ? [] : ["CLAUDE.md", "GEMINI.md", "AGENTS.md"];
+    const hasBlocks = (await Promise.all(pointerFiles.map(async (f) => (await readIfExists(join(scope.root, f)))?.includes(MARK_START)))).some(Boolean);
+    const hasLegacyCursor = existsSync(join(scope.root, LEGACY_CURSOR_RULES_DIR));
+    if (!hasSkills && !hasBlocks && !hasLegacyCursor) {
+        console.log("No RYUX install found.");
+        return;
+    }
+    if (!flags.yes) {
+        const ok = await p.confirm({ message: `Remove RYUX from ${scope.global ? "your home directory" : "this project"}?${keys(YES_NO, "Enter confirm")}` });
+        if (p.isCancel(ok) || !ok) {
+            console.log("Cancelled.");
+            return;
+        }
+    }
+    const removed = [];
+    for (const dir of dirs) {
+        for (const name of [SKILL_NAME, ...OLD_SKILL_DIRS]) {
+            const target = join(dir, name);
+            if (await removePath(target))
+                removed.push(rel(target));
+        }
+        removed.push(...(await removeLegacy(dir, scope.root)));
+    }
+    for (const f of pointerFiles)
+        if (await removeBlock(join(scope.root, f)))
+            removed.push(`${f} (block)`);
+    console.log(removed.length ? removed.map((r) => pc.red("− ") + r).join("\n") : "No files removed.");
+}
+/** Read every file of an installed skill folder, keyed by its path inside the folder. */
+async function readBundle(skillDir) {
+    const files = {};
+    for (const entry of await readdir(skillDir, { recursive: true, withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        const full = join(entry.parentPath, entry.name);
+        files[full.slice(skillDir.length + 1)] = await readFile(full, "utf8");
+    }
+    return files;
+}
+async function runCheck(flags) {
+    const scope = scopeOf(flags);
+    const ok = (m) => console.log(`${pc.green("✓")} ${m}`);
+    const warn = (m) => console.log(`${pc.yellow("!")} ${m}`);
+    const fail = (m) => {
+        console.log(`${pc.red("✗")} ${m}`);
+        process.exitCode = 1;
+    };
+    const dirs = detectInstalled(scope);
+    if (!dirs.length) {
+        fail(`RYUX is not installed ${scope.global ? "in your home directory" : "in this project"}. Run: ${CLI_CMD} init`);
+        return;
+    }
+    for (const dir of dirs) {
+        const where = rel(dir);
+        const skillDir = join(dir, SKILL_NAME);
+        const leftovers = OLD_SKILL_DIRS.filter((n) => existsSync(join(dir, n)));
+        if (leftovers.length)
+            fail(`${where}: RYUX 1.x folders remain (${leftovers.length}). Run: ${CLI_CMD} update`);
+        if (!existsSync(join(skillDir, "SKILL.md"))) {
+            fail(`${where}: no ${SKILL_NAME}/ skill. Run: ${CLI_CMD} update`);
+            continue;
+        }
+        const report = validateBundle(await readBundle(skillDir));
+        for (const e of report.errors)
+            fail(`${where}/${SKILL_NAME}: ${e}`);
+        for (const w of report.warnings)
+            warn(`${where}/${SKILL_NAME}: ${w}`);
+        if (report.version && report.version !== VERSION)
+            warn(`${where}: installed RYUX ${report.version}, this CLI is ${VERSION}. Run: ${CLI_CMD} update`);
+        if (!report.errors.length)
+            ok(`${where}/${SKILL_NAME}: complete, RYUX ${report.version}`);
+    }
+    if (!scope.global) {
+        const agentsHere = agentsAt(scope, true);
+        for (const file of pointersFor(agentsHere)) {
+            if (hasBlock(await readIfExists(join(scope.root, file))))
+                ok(`${file}: RYUX pointer block present`);
+            else
+                warn(`${file}: no RYUX pointer block. Run: ${CLI_CMD} update`);
+        }
+        const context = contextBody(await readIfExists(join(scope.root, CONTEXT_FILE)));
+        if (context !== null) {
+            ok(`${CONTEXT_FILE}: project context present, ${filledCount(context)} of ${ASKED_FIELDS.length} setup fields filled (blanks are treated as unknown)`);
+        }
+        else
+            warn(`${CONTEXT_FILE}: no RYUX project context. Run: ${CLI_CMD} setup`);
+    }
+    if (!process.exitCode)
+        console.log(pc.green("\nRYUX is ready."));
+}
+/** Facts init can detect without guessing: the project name and where design tokens live. */
+function detectContext(root) {
+    let name = null;
+    try {
+        name = JSON.parse(readFileSync(join(root, "package.json"), "utf8")).name ?? null;
+    }
+    catch {
+        name = null;
+    }
+    const candidates = [
+        "tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs", "tokens.json", "design-tokens.json",
+        "src/components", "components", "app/components", "src/styles", "styles",
+    ];
+    return { name, system: candidates.filter((c) => existsSync(join(root, c))) };
+}
+/** A choice whose value is empty means "not decided": the field stays unknown. */
+const CONTEXT_FIELDS = [
+    {
+        label: "Product", hint: "(what it does, in one sentence:)",
+        ask: { flag: "product", group: "Project", question: "What kind of product is it?", options: [
+                { value: "Online store", label: "Online store" },
+                { value: "Payments or finance", label: "Payments or finance" },
+                { value: "Marketplace", label: "Marketplace" },
+                { value: "Booking or scheduling", label: "Booking or scheduling" },
+                { value: "SaaS or dashboard", label: "SaaS or dashboard", hint: "a tool people use for work" },
+                { value: "Content or media", label: "Content or media" },
+                { value: "Internal tool", label: "Internal tool", hint: "used by your own team" },
+            ] },
+    },
+    {
+        label: "Current work", hint: "",
+        ask: { flag: "work", group: "Project", question: "What are you building right now?", options: [
+                { value: "A new product", label: "A new product" },
+                { value: "A new feature", label: "A new feature" },
+                { value: "A new screen", label: "A new screen" },
+                { value: "An existing flow", label: "An existing flow", hint: "changing something that already exists" },
+                { value: "A redesign", label: "A redesign" },
+                { value: "", label: "Not decided yet", hint: "stays unknown" },
+            ] },
+    },
+    {
+        label: "Audience", hint: "",
+        ask: { flag: "audience", group: "Project", question: "Who is it for?", options: [
+                { value: "Consumers", label: "Consumers", hint: "people using it for themselves" },
+                { value: "Small business owners", label: "Small business owners" },
+                { value: "Professionals at work", label: "Professionals at work" },
+                { value: "An internal team", label: "An internal team" },
+                { value: "Developers", label: "Developers" },
+            ] },
+    },
+    {
+        label: "Market and locale", hint: "(for example Indonesia, id-ID, Rupiah; or global, en-US, USD)",
+        ask: { flag: "market", group: "Project", question: "Where is it used? This sets language and currency.", options: [
+                { value: "Global, several markets", label: "Global, several markets" },
+                { value: "Indonesia (id-ID, IDR)", label: "Indonesia", hint: "id-ID, Rupiah" },
+                { value: "United States (en-US, USD)", label: "United States", hint: "en-US, US dollar" },
+                { value: "", label: "Not decided yet", hint: "stays unknown" },
+            ] },
+    },
+    { label: "Brand and design system", hint: "" },
+    { label: "Evidence sources", hint: `RYUX MCP (hosted server not live yet; local: ${MCP_LOCAL_ADD_CMD}), Figma files, reference URLs:` },
+    {
+        label: "Constraints", hint: "platforms, accessibility target (for example WCAG 2.2 AA), what must not change:",
+        ask: { flag: "constraints", group: "Project", question: "What must RYUX keep or support?", multi: true, options: [
+                { value: "Mobile app", label: "Mobile app" },
+                { value: "Web", label: "Web" },
+                { value: "Responsive web", label: "Responsive web", hint: "one site for phone and desktop" },
+                { value: "Web and mobile app", label: "Web and mobile app" },
+                { value: "Existing design system", label: "Existing design system" },
+                { value: "Existing brand identity", label: "Existing brand identity" },
+                { value: "Accessibility, WCAG 2.2 AA", label: "Accessibility", hint: "WCAG 2.2 AA" },
+            ] },
+    },
+    {
+        label: "Design intent", hint: "(what users should understand, feel, and do)",
+        ask: { flag: "intent", group: "Design", question: "What should people get from it?", options: [
+                { value: "Understand their status at a glance", label: "Understand their status at a glance" },
+                { value: "Finish a task quickly", label: "Finish a task quickly" },
+                { value: "Feel safe and in control", label: "Feel safe and in control" },
+                { value: "Learn the product step by step", label: "Learn the product step by step" },
+            ] },
+    },
+    {
+        label: "UX direction", hint: "",
+        ask: { flag: "ux", group: "Design", question: "How should the experience help users?", options: [
+                { value: "Fast for people who use it often", label: "Fast for people who use it often" },
+                { value: "Clear for people using it for the first time", label: "Clear for people using it for the first time" },
+                { value: "Easy to scan and understand", label: "Easy to scan and understand" },
+                { value: "Guided through a complex task", label: "Guided through a complex task" },
+            ] },
+    },
+    {
+        label: "UI direction", hint: "(character, for example calm, trustworthy, restrained)",
+        ask: { flag: "ui", group: "Design", question: "What character should it have? A character, not colors or fonts. Pick up to 3.", multi: true, max: 3, options: [
+                { value: "Calm", label: "Calm" },
+                { value: "Trustworthy", label: "Trustworthy" },
+                { value: "Friendly", label: "Friendly" },
+                { value: "Playful", label: "Playful" },
+                { value: "Bold", label: "Bold" },
+                { value: "Minimal", label: "Minimal" },
+                { value: "Information-rich", label: "Information-rich" },
+                { value: "Premium", label: "Premium" },
+            ] },
+    },
+    {
+        label: "Motion direction", hint: "(feel, what motion communicates, what to avoid)",
+        ask: { flag: "motion", group: "Design", question: "How much motion?", options: [
+                { value: "No motion unless necessary", label: "No motion unless necessary" },
+                { value: "Subtle, only to show change", label: "Subtle, only to show change" },
+                { value: "Expressive, part of the brand", label: "Expressive, part of the brand" },
+            ] },
+    },
+];
+const ASKED_FIELDS = CONTEXT_FIELDS.filter((f) => f.ask);
+const CONTEXT_MARKS = [CONTEXT_START, CONTEXT_END];
+const fieldLine = (label, text) => `- **${label}**:${text ? ` ${text}` : ""}`;
+const fieldRe = (label) => new RegExp(`^- \\*\\*${label}\\*\\*:.*$`, "m");
+function contextBlock(root) {
+    const { name, system } = detectContext(root);
+    const initial = {
+        Product: `${name ?? ""} ${CONTEXT_FIELDS[0].hint}`,
+        "Brand and design system": system.map((x) => `\`${x}\``).join(", "),
+    };
+    return `## RYUX project context
+
+RYUX reads this block before any design task. These answers are the team's context and direction,
+not evidence or verified facts: RYUX follows them and still backs its decisions with evidence.
+Blanks stay unknown. UI direction describes character, not colors, fonts, or spacing.
+
+${CONTEXT_FIELDS.map((f) => fieldLine(f.label, initial[f.label] ?? f.hint)).join("\n")}`;
+}
+/** The body between the context markers, or null when there is no block. */
+function contextBody(content) {
+    if (!content)
+        return null;
+    const start = content.indexOf(CONTEXT_START);
+    const end = content.indexOf(CONTEXT_END, start);
+    return start === -1 || end === -1 ? null : content.slice(start + CONTEXT_START.length, end).trim();
+}
+/** What the user (or detection) wrote for a field; template hints count as blank. */
+function fieldValue(body, f) {
+    const line = body.match(fieldRe(f.label))?.[0];
+    if (!line)
+        return "";
+    const value = line.slice(line.indexOf(":") + 1).trim();
+    if (!f.hint)
+        return value;
+    if (value === f.hint)
+        return "";
+    return value.endsWith(` ${f.hint}`) ? value.slice(0, -f.hint.length).trim() : value;
+}
+const filledCount = (body) => ASKED_FIELDS.filter((f) => fieldValue(body, f)).length;
+/** Replace only the answered field lines; every other line of the block stays as the user left it. */
+async function writeContext(root, answers) {
+    const path = join(root, CONTEXT_FILE);
+    let body = contextBody(await readIfExists(path)) ?? contextBlock(root);
+    for (const f of ASKED_FIELDS) {
+        const value = answers[f.label]?.trim();
+        if (!value)
+            continue;
+        const line = fieldLine(f.label, value);
+        if (fieldRe(f.label).test(body)) {
+            body = body.replace(fieldRe(f.label), () => line);
+            continue;
+        }
+        // A field added in a later version (e.g. Current work): place it after the field before it.
+        const prev = CONTEXT_FIELDS[CONTEXT_FIELDS.indexOf(f) - 1];
+        const anchor = prev && body.match(fieldRe(prev.label));
+        body = anchor ? body.replace(fieldRe(prev.label), (m) => `${m}\n${line}`) : `${body}\n${line}`;
+    }
+    await upsertBlock(path, body, CONTEXT_MARKS);
+    return body;
+}
+/** A dim second line under a prompt's question: which keys move, select, and what Enter does here. */
+function keys(...parts) {
+    return `\n${pc.gray("│")}  ${pc.dim(parts.join(" · "))}`;
+}
+const YES_NO = "←/→ or y/n choose";
+const TEXT_KEYS = "Type, then Enter save (empty skips)";
+const OWN = "\u0000own";
+const KEEP = "\u0000keep";
+const SKIP = "\u0000skip";
+/** One select: Keep (when set), the choices, Write my own, Skip. Returns "" for skip, null on cancel. */
+async function askOne(question, options, current) {
+    const v = await p.select({
+        message: `${question}${keys("↑/↓ move", "Enter choose and go on")}`,
+        options: [
+            ...(current ? [{ value: KEEP, label: `Keep: ${current}` }] : []),
+            ...options.map((o) => ({ value: o.value || SKIP, label: o.label, hint: o.hint })),
+            { value: OWN, label: "Write my own…" },
+            { value: SKIP, label: "Skip, leave unknown" },
+        ],
+        initialValue: current ? KEEP : SKIP,
+    });
+    if (p.isCancel(v))
+        return null;
+    if (v === KEEP || v === SKIP)
+        return "";
+    if (v === OWN) {
+        const t = await p.text({ message: `${question}${keys(TEXT_KEYS)}`, placeholder: "Enter to skip" });
+        return p.isCancel(t) ? null : (t ?? "").trim();
+    }
+    return v;
+}
+/** A multiselect: pick any, or none to skip. Returns "" for skip, null on cancel. */
+async function askMany(question, options, current, max) {
+    const parts = current ? current.split(",").map((x) => x.trim()).filter(Boolean) : [];
+    const known = options.map((o) => o.value);
+    const custom = parts.filter((x) => !known.includes(x)).join(", ");
+    for (;;) {
+        const v = await p.multiselect({
+            message: `${question}${keys("↑/↓ move", "Space select", "Enter go on (nothing selected skips)")}`,
+            options: [
+                ...(custom ? [{ value: KEEP, label: `Keep: ${custom}` }] : []),
+                ...options.map((o) => ({ value: o.value, label: o.label, hint: o.hint })),
+                { value: OWN, label: "Write my own…" },
+            ],
+            initialValues: [...(custom ? [KEEP] : []), ...parts.filter((x) => known.includes(x))],
+            required: false,
+        });
+        if (p.isCancel(v))
+            return null;
+        const picked = v;
+        const values = picked.filter((x) => x !== KEEP && x !== OWN);
+        if (picked.includes(KEEP))
+            values.push(custom);
+        if (picked.includes(OWN)) {
+            const t = await p.text({ message: `${question}${keys(TEXT_KEYS)}`, placeholder: "Enter to skip" });
+            if (p.isCancel(t))
+                return null;
+            if (t?.trim())
+                values.push(t.trim());
+        }
+        if (max && values.length > max) {
+            p.log.warn(`Pick up to ${max}.`);
+            continue;
+        }
+        return values.join(", ");
+    }
+}
+/** Ask the setup questions as choices; every answer can be skipped. Returns null when cancelled. */
+async function askContext(root) {
+    const body = contextBody(await readIfExists(join(root, CONTEXT_FILE))) ?? contextBlock(root);
+    const answers = {};
+    let group = "";
+    for (const f of ASKED_FIELDS) {
+        const ask = f.ask;
+        if (ask.group !== group) {
+            group = ask.group;
+            p.log.step(group === "Project" ? "Project setup" : "Design setup");
+        }
+        const current = fieldValue(body, f);
+        const v = ask.multi ? await askMany(ask.question, ask.options, current, ask.max) : await askOne(ask.question, ask.options, current);
+        if (v === null)
+            return null;
+        answers[f.label] = v;
+        if (f.label === "Product" && v) {
+            const t = await p.text({ message: `In one sentence, what does it do?${keys(TEXT_KEYS)}`, placeholder: "Enter to skip" });
+            if (p.isCancel(t))
+                return null;
+            if (t?.trim())
+                answers[f.label] = `${v}: ${t.trim()}`;
+        }
+    }
+    return answers;
+}
+async function setupInteractive(root) {
+    p.log.info("Teach RYUX about this project. Every question can be skipped: blanks stay unknown, and RYUX asks when they matter.");
+    const answers = await askContext(root);
+    if (!answers)
+        return false;
+    const body = await writeContext(root, answers);
+    p.log.success(`${CONTEXT_FILE} updated · ${filledCount(body)} of ${ASKED_FIELDS.length} setup fields filled`);
+    return true;
+}
+async function runSetup(flags) {
+    if (flags.global) {
+        console.error(`setup is per project. Run it inside the project folder: ${CLI_CMD} setup`);
+        process.exitCode = 1;
+        return;
+    }
+    const root = scopeOf(flags).root;
+    const fromFlags = {};
+    for (const f of ASKED_FIELDS) {
+        const v = flags[f.ask.flag];
+        if (typeof v === "string")
+            fromFlags[f.label] = v;
+    }
+    if (Object.keys(fromFlags).length) {
+        const body = await writeContext(root, fromFlags);
+        console.log(`${pc.green("✓ ")}${CONTEXT_FILE} updated · ${filledCount(body)} of ${ASKED_FIELDS.length} setup fields filled`);
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        const names = ASKED_FIELDS.map((f) => `--${f.ask.flag}`).join(" ");
+        console.error(`setup asks questions and needs a terminal. Without one, pass fields as flags (${names}) or edit ${CONTEXT_FILE}.`);
+        process.exitCode = 1;
+        return;
+    }
+    p.intro(pc.bgCyan(pc.black(" RYUX setup ")));
+    if (!(await setupInteractive(root)))
+        return cancel();
+    p.outro(`RYUX is ready. Next: ${CLI_CMD} check`);
+}
+async function runInit(flags) {
+    if (flags.global) {
+        console.error(`init sets up a project. For a global install, use: ${CLI_CMD} install --global`);
+        process.exitCode = 1;
+        return;
+    }
+    const scope = scopeOf(flags);
+    const path = join(scope.root, CONTEXT_FILE);
+    const had = hasBlock(await readIfExists(path), CONTEXT_MARKS);
+    await runInstall(flags);
+    if (process.exitCode)
+        return;
+    if (had) {
+        console.log(`${pc.green("✓ ")}${CONTEXT_FILE}: project context already present (left as you wrote it). Edit it with: ${CLI_CMD} setup`);
+    }
+    else if (!hasBlock(await readIfExists(path), CONTEXT_MARKS)) {
+        await upsertBlock(path, contextBlock(scope.root), CONTEXT_MARKS);
+        console.log(`${pc.green("✓ ")}${CONTEXT_FILE}: project context added. Fill it in with: ${CLI_CMD} setup`);
+    }
+    console.log(`\nNext: ${CLI_CMD} check`);
+}
+function help() {
+    const agents = AGENT_TARGETS.map((a) => `  ${a.id.padEnd(12)} ${a.label.padEnd(15)} ${a.dir}  (global ~/${a.globalDir})`).join("\n");
+    console.log(`ryux v${VERSION}: install RYUX, design intelligence for AI agents and designers, into your agents.
+One skill, five entry points: Analyze, Design, Build, Critique, QA. RYUX picks the knowledge each task needs.
+
+Usage:
+  ${CLI_CMD} [command] [options]
+
+Commands:
+  install     Install RYUX (interactive, or with flags). Interactive also offers setup. Default. Start here.
+  setup       Teach RYUX about this project: a few skippable questions, saved to DESIGN.md.
+  init        Install RYUX and add the DESIGN.md project context block.
+  check       Check the install: files, version, references, pointers, project context.
+  update      Update an install to this version (also migrates RYUX 1.x folders).
+  remove      Remove RYUX and the marked blocks.
+  help        Show this help.
+
+Agents:
+${agents}
+  ${AGENTS_MD_INLINE.id.padEnd(12)} any other agent: RYUX inline in AGENTS.md (project only)
+
+Options:
+  --agent <list|all>   agents to install for (non-interactive)
+  --global             install into your home directory instead of this project
+  --mcp                print the ryux MCP connect command
+  --yes                skip the confirmation (remove)
+  --product, --work, --audience, --market, --constraints, --intent, --ux, --ui, --motion <text>
+                       set project context fields without questions (setup)
+
+Examples:
+  ${CLI_CMD}
+  ${CLI_CMD} setup
+  ${CLI_CMD} setup --audience "small business owners" --market "Indonesia, id-ID, IDR"
+  ${CLI_CMD} init --agent claude
+  ${CLI_CMD} check
+  ${CLI_CMD} install --agent claude,cursor,codex
+  ${CLI_CMD} install --agent all
+  ${CLI_CMD} install --agent claude --global
+  ${CLI_CMD} update
+  ${CLI_CMD} remove --yes`);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const first = argv[0];
+    if (argv.includes("--help") || argv.includes("-h") || first === "help")
+        return help();
+    if (argv.includes("--version") || argv.includes("-v") || first === "version") {
+        console.log(VERSION);
+        return;
+    }
+    const cmd = first && !first.startsWith("--") ? first : "install";
+    const flags = parseFlags(first && first.startsWith("--") ? argv : argv.slice(1));
+    switch (cmd) {
+        case "update":
+            return runUpdate(flags);
+        case "check":
+        case "doctor":
+            return runCheck(flags);
+        case "init":
+            return runInit(flags);
+        case "setup":
+            return runSetup(flags);
+        case "remove":
+            return runRemove(flags);
+        case "install":
+            return runInstall(flags);
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            help();
+            process.exitCode = 1;
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exitCode = 1;
+});