docugate 0.1.3 → 0.2.0

package/dist/cli.js

@@ -1,38 +1,67 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { check } from './check.js';
 import { loadConfig } from './config.js';
-import { init } from './init.js';
+import { initFlow } from './init.js';
 import { buildOpenApi, isCurrent, writeOpenApi } from './openapi.js';
+import { BobKeyMissingError, BobMissingError, tourInit } from './tour-init.js';
+import { tourInstall, hasPillSnippet, pillSnippetLine, DEFAULT_PORT } from './tour-install.js';
+import { loadTours } from './tour.js';
+import { startTourServer } from './tour-server.js';
+import { login, clearCredentials, loadCredentials } from './auth.js';
+import { BASE_URL, getSession } from './api.js';
 const SITE = 'https://www.trydocugate.site';
-const HELP = `docugate: set up and check the docs DocuGate reads from your repository
-
-Usage
-  docugate <command> [options]
-
-Commands
-  init        Set up this repository for DocuGate
-  check       Check the docs the way DocuGate will read them
-  openapi     Prepare an OpenAPI spec for DocuGate's API reference
-
-init
-  --dir <folder>       Docs folder (default: docs)
-  --title <text>       Space title (default: this folder's name)
-
-check
-  --dir <folder>       Check this folder instead of docugate.json's docsDir
-  --strict             Treat warnings as errors
-
-openapi
-  --from <file|url>    The spec to read (or api.generate.from in docugate.json)
-  --out <file>         Where to write it (default: openapi.json)
-  --include <glob>     Keep only paths that match; repeatable
-  --exclude <glob>     Drop paths that match; repeatable
-  --redact <name>      Remove a property from every schema and example; repeatable
-  --check              Fail if the file is out of date, instead of writing it
-
-Run it from the root of your repository.
-${SITE}
+const HELP = `docugate: set up and check the docs DocuGate reads from your repository
+
+Usage
+  docugate <command> [options]
+
+Commands
+  init              Set up this repository for DocuGate (interactive)
+  login             Sign in to DocuGate with GitHub
+  logout            Sign out and delete saved credentials
+  whoami            Print the currently signed-in user
+  check             Check the docs the way DocuGate will read them
+  openapi           Prepare an OpenAPI spec for DocuGate's API reference
+  tour init         Write the first tour of this app with IBM Bob
+  tour install      Add the pill loader to your app
+  tour serve        Start a local server that serves tour data for the pill
+  tour export       Write every tour screen to a single JSON file
+
+init
+  --dir <folder>       Docs folder (default: docs)
+  --title <text>       Space title (default: this folder's name)
+  --role <role>        Repository role: frontend, backend, or both
+  --yes                Accept every default without asking
+
+check
+  --dir <folder>       Check this folder instead of docugate.json's docsDir
+  --strict             Treat warnings as errors
+
+openapi
+  --from <file|url>    The spec to read (or api.generate.from in docugate.json)
+  --out <file>         Where to write it (default: openapi.json)
+  --include <glob>     Keep only paths that match; repeatable
+  --exclude <glob>     Drop paths that match; repeatable
+  --redact <name>      Remove a property from every schema and example; repeatable
+  --check              Fail if the file is out of date, instead of writing it
+
+tour init
+  --max-cost <n>       Most Bobcoins the run may spend (default: 3)
+  --team-id <id>       Bob team to run under, for API keys that need one
+
+tour install
+  --port <n>           Port the pill server listens on (default: 4178)
+  --remove             Remove the pill snippet instead of adding it
+
+tour serve
+  --port <n>           Port to listen on (default: 4178)
+
+tour export <file>
+  Write all tour screens to <file> as JSON.
+
+Run it from the root of your repository.
+${SITE}
 `;
 const color = process.stdout.isTTY && !process.env.NO_COLOR;
 const paint = (code, text) => (color ? `\x1b[${code}m${text}\x1b[0m` : text);
@@ -40,11 +69,13 @@ const red = (t) => paint(31, t);
 const yellow = (t) => paint(33, t);
 const green = (t) => paint(32, t);
 const dim = (t) => paint(2, t);
-const VALUE_FLAGS = new Set(['dir', 'title', 'from', 'out', 'include', 'exclude', 'redact']);
+const VALUE_FLAGS = new Set(['dir', 'title', 'role', 'from', 'out', 'include', 'exclude', 'redact', 'max-cost', 'team-id', 'port']);
 function parse(argv) {
     const flags = new Map();
     const bools = new Set();
     let command;
+    let sub;
+    let sub2;
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         if (arg === '-h')
@@ -64,10 +95,14 @@ function parse(argv) {
         }
         else if (!command)
             command = arg;
+        else if (command === 'tour' && !sub)
+            sub = arg;
+        else if (command === 'tour' && sub === 'export' && !sub2)
+            sub2 = arg;
         else
             fail(`Unexpected argument "${arg}".`);
     }
-    return { command, flags, bools };
+    return { command, sub, sub2, flags, bools };
 }
 function fail(message) {
     // Phrased without a command name on purpose: this is the message somebody
@@ -97,14 +132,78 @@ async function main() {
     if (args.bools.has('help') || !args.command)
         return console.log(HELP);
     switch (args.command) {
+        case 'login': {
+            const creds = loadCredentials();
+            if (creds) {
+                // Already signed in — confirm with the server.
+                try {
+                    const { user } = await getSession();
+                    if (user) {
+                        console.log(`Already signed in as @${user.githubLogin}`);
+                        return;
+                    }
+                }
+                catch {
+                    // server unreachable; proceed to sign in again
+                }
+            }
+            const { token } = await login(BASE_URL, args.bools.has('yes') ? {} : {});
+            try {
+                const { user } = await getSession();
+                if (user) {
+                    console.log(`Signed in as @${user.githubLogin}`);
+                }
+                else {
+                    console.log('Signed in.');
+                }
+            }
+            catch {
+                // token saved; just confirm
+                console.log('Signed in.');
+            }
+            void token;
+            return;
+        }
+        case 'logout': {
+            clearCredentials();
+            console.log('Signed out.');
+            return;
+        }
+        case 'whoami': {
+            const creds = loadCredentials();
+            if (!creds) {
+                console.log('Not signed in. Run docugate login.');
+                return;
+            }
+            let session;
+            try {
+                session = await getSession();
+            }
+            catch (err) {
+                console.error(`Signed in, but couldn't reach DocuGate to confirm who you are: ${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (session.user) {
+                console.log(`@${session.user.githubLogin}`);
+            }
+            else {
+                console.log('Not signed in. Run docugate login.');
+            }
+            return;
+        }
         case 'init': {
-            const result = init(root, { dir: one('dir'), title: one('title') });
-            for (const f of result.created)
-                console.log(`  ${green('created')}  ${f}`);
-            for (const f of result.kept)
-                console.log(`  ${dim('kept')}     ${f}`);
-            console.log(`\nNext: commit and push, then publish the space at ${SITE}/dashboard/new` +
-                `\nand pick "${result.docsDir}" as the docs folder.`);
+            const roleFlag = one('role');
+            if (roleFlag && !['frontend', 'backend', 'both'].includes(roleFlag)) {
+                fail(`--role must be frontend, backend, or both.`);
+            }
+            await initFlow(root, {
+                dir: one('dir'),
+                title: one('title'),
+                role: roleFlag,
+                yes: args.bools.has('yes'),
+                port: one('port') !== undefined ? parseInt(one('port'), 10) : undefined,
+            });
             return;
         }
         case 'check': {
@@ -153,6 +252,117 @@ async function main() {
             console.log(`${green('wrote')}  ${output} ${dim(`(${summary})`)}`);
             return;
         }
+        case 'tour': {
+            switch (args.sub) {
+                case 'install': {
+                    const port = parseInt(one('port') ?? String(DEFAULT_PORT), 10);
+                    const remove = args.bools.has('remove');
+                    const result = tourInstall(root, { port, remove });
+                    if (result.target === null) {
+                        console.log(`  ${yellow('not found')}  No supported HTML or layout file found.`);
+                        console.log(`  Paste this into your app's HTML during development:`);
+                        console.log(`    ${pillSnippetLine(port)}`);
+                    }
+                    else if (result.action === 'inserted') {
+                        console.log(`  ${green('installed')}  ${result.target}`);
+                    }
+                    else if (result.action === 'removed') {
+                        console.log(`  ${green('removed')}   ${result.target}`);
+                    }
+                    else {
+                        // already / no-op
+                        console.log(`  ${dim('unchanged')}  ${result.target}`);
+                    }
+                    return;
+                }
+                case 'init': {
+                    console.log(`${dim('Bob is reading your code and writing the tour. This takes a minute or two.')}`);
+                    let result;
+                    try {
+                        result = tourInit(root, { maxCost: one('max-cost'), teamId: one('team-id') });
+                    }
+                    catch (error) {
+                        if (error instanceof BobKeyMissingError) {
+                            console.error(`${red('error')} Bob Shell needs an API key to run on its own (your IDE sign-in is not used here).
+` +
+                                `1. At https://bob.ibm.com, open your instance, then API keys, and create an Inference key.
+` +
+                                `2. Save it as the BOB_API_KEY environment variable, then open a new terminal:
+` +
+                                `     PowerShell   [Environment]::SetEnvironmentVariable("BOB_API_KEY", "<key>", "User")
+` +
+                                `     macOS/Linux  export BOB_API_KEY=<key>   (add it to your shell profile)
+` +
+                                dim('Keep the key out of your repository. https://bob.ibm.com/docs/ide/account/api-keys'));
+                            process.exit(2);
+                        }
+                        if (!(error instanceof BobMissingError))
+                            throw error;
+                        console.error(`${red('error')} Bob Shell is not installed, and tours are written by IBM Bob.
+` +
+                            `Install it (Node 24 or later), sign in, then run this again:
+` +
+                            `  Windows      powershell -c "irm -Uri https://bob.ibm.com/download/bobshell.ps1 | iex"
+` +
+                            `  macOS/Linux  curl -fsSL https://bob.ibm.com/download/bobshell.sh | bash
+` +
+                            dim('https://bob.ibm.com/docs/shell/getting-started/install-and-setup'));
+                        process.exit(2);
+                    }
+                    for (const f of result.setup)
+                        console.log(`  ${green('created')}  ${f}`);
+                    for (const f of result.added)
+                        console.log(`  ${green('added')}    ${f}`);
+                    for (const f of result.restored)
+                        console.log(`  ${yellow('kept')}     ${f} ${dim('(Bob changed it; your version was put back)')}`);
+                    if (!result.added.length)
+                        console.log(`  ${dim('No new screens: every screen Bob found already has a tour file.')}`);
+                    const stats = result.stats;
+                    const parts = [
+                        result.mode === 'agent' ? 'agent mode' : 'Tour Writer mode',
+                        stats?.durationMs !== undefined ? `${Math.round(stats.durationMs / 1000)}s` : '',
+                        stats?.cost !== undefined ? `${stats.cost} Bobcoins` : '',
+                    ].filter(Boolean);
+                    console.log(`
+${dim(`Bob: ${parts.join(', ')}`)}`);
+                    console.log('Next: read the new files, fix anything Bob got wrong, and commit them. They are yours now.');
+                    return;
+                }
+                case 'serve': {
+                    const tourDir = `${root}/.docugate/tour`;
+                    if (!existsSync(tourDir)) {
+                        console.error(`${red('error')} .docugate/tour/ not found. Run ${green('docugate tour init')} first.`);
+                        process.exit(2);
+                    }
+                    const port = parseInt(one('port') ?? '4178', 10);
+                    const server = await startTourServer(root, port);
+                    const url = `http://localhost:${server.port}`;
+                    const screens = loadTours(root);
+                    console.log(`${green('Tour server')}  ${url}`);
+                    console.log(`${plural(screens.length, 'screen')} loaded from .docugate/tour/`);
+                    if (!hasPillSnippet(root)) {
+                        console.log(`${dim('Hint: run')} ${green('docugate tour install')} ${dim('to add the pill to your app automatically.')}`);
+                    }
+                    // Keep the process alive; Ctrl-C will stop it.
+                    process.on('SIGINT', () => { server.close(); process.exit(0); });
+                    process.on('SIGTERM', () => { server.close(); process.exit(0); });
+                    await new Promise(() => { });
+                    return;
+                }
+                case 'export': {
+                    const outFile = args.sub2;
+                    if (!outFile)
+                        fail('Say where to write: docugate tour export <file>.');
+                    const screens = loadTours(root);
+                    const json = JSON.stringify(screens.map(({ route, title, stops }) => ({ route, title, stops })), null, 2);
+                    writeFileSync(outFile, json);
+                    console.log(`${green('wrote')}  ${outFile} ${dim(`(${plural(screens.length, 'screen')})`)}`);
+                    return;
+                }
+                default:
+                    fail(args.sub ? `Unknown tour command "${args.sub}".` : 'Say which: docugate tour init, tour install, or tour serve.');
+            }
+        }
         default:
             fail(`Unknown command "${args.command}".`);
     }

package/dist/init.js

@@ -1,6 +1,11 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { CONFIG_FILE, loadConfig } from './config.js';
+import { tourInit, BobMissingError, BobKeyMissingError } from './tour-init.js';
+import { tourInstall, pillSnippetLine, DEFAULT_PORT } from './tour-install.js';
+import { login, loadCredentials } from './auth.js';
 /**
  * Sets a repository up for DocuGate: a docugate.json, and a first page if the
  * docs folder has none. Never overwrites — running it twice is harmless, and
@@ -34,3 +39,293 @@ export function init(root, opts = {}) {
     }
     return { created, kept, docsDir };
 }
+function makeDefaultIO() {
+    const isTTY = Boolean(process.stdin.isTTY);
+    return {
+        isTTY,
+        ask(question, defaultAnswer) {
+            return new Promise((resolve) => {
+                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                rl.question(`${question} `, (answer) => {
+                    rl.close();
+                    resolve(answer.trim() || defaultAnswer);
+                });
+            });
+        },
+        print(line) {
+            console.log(line);
+        },
+    };
+}
+function saveRole(root, role) {
+    const path = join(root, CONFIG_FILE);
+    let existing = {};
+    if (existsSync(path)) {
+        try {
+            existing = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            // leave as empty object; will be overwritten with role added
+        }
+    }
+    existing.role = role;
+    writeFileSync(path, JSON.stringify(existing, null, 2) + '\n');
+}
+const VALID_ROLES = new Set(['frontend', 'backend', 'both']);
+function defaultGetRemote(root) {
+    try {
+        const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            encoding: 'utf8',
+            cwd: root,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        // Match HTTPS: https://github.com/owner/repo(.git)
+        // Match SSH:   git@github.com:owner/repo(.git)
+        const m = remote.match(/github\.com[:/]([^/]+\/[^/\s]+?)(?:\.git)?$/);
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Runs the full interactive DocuGate setup wizard. Asks one short question,
+ * saves the result in docugate.json, conditionally runs tour init and tour
+ * install, and prints a summary.
+ */
+export async function initFlow(root, options = {}) {
+    const io = options.io ?? makeDefaultIO();
+    const yes = options.yes ?? false;
+    const port = options.port ?? DEFAULT_PORT;
+    // ── Step 1: base repo setup (docugate.json + docs/) ──────────────────────
+    const base = init(root, { dir: options.dir, title: options.title });
+    // ── Step 2: determine role ────────────────────────────────────────────────
+    const loaded = loadConfig(root);
+    const savedRole = loaded.config.role;
+    let role = savedRole ?? options.role;
+    if (!role) {
+        if (!io.isTTY) {
+            // CI / no terminal: write config without role and explain.
+            io.print(`  docugate.json written. Set the repository role with --role frontend|backend|both.`);
+            io.print(`  Run docugate login to connect this repository to a DocuGate space.`);
+            // Return early — no tour steps without a known role.
+            return { ...base, role: undefined };
+        }
+        if (yes) {
+            // --yes with no --role: default to "both"
+            role = 'both';
+        }
+        else {
+            // Interactive: ask once; re-prompt on invalid answer.
+            let answer = '';
+            while (!VALID_ROLES.has(answer)) {
+                answer = await io.ask('Is this repository the frontend, the backend, or both? [frontend/backend/both]', 'both');
+                if (!VALID_ROLES.has(answer)) {
+                    io.print(`  Please answer frontend, backend, or both.`);
+                }
+            }
+            role = answer;
+        }
+    }
+    if (!savedRole) {
+        saveRole(root, role);
+    }
+    // ── Step 3: sign in and connect this repository ───────────────────────────
+    const BASE_URL = options.baseUrl ?? process.env.DOCUGATE_URL ?? 'https://www.trydocugate.site';
+    let connectError;
+    // In CI (no TTY) skip sign-in entirely (hint already printed in the early-return branch above).
+    if (!io.isTTY) {
+        // nothing more — hint was already printed
+    }
+    else {
+        // Lazily import real API functions only when not overridden by tests.
+        const realGetSession = async () => {
+            const { getSession } = await import('./api.js');
+            return getSession();
+        };
+        const realGetSpaces = async () => {
+            const { getSpaces } = await import('./api.js');
+            return getSpaces();
+        };
+        const realConnectRepo = async (id, repo, dir) => {
+            const { connectRepo } = await import('./api.js');
+            return connectRepo(id, repo, dir);
+        };
+        const realLogin = login;
+        const getSessionFn = options.getSessionFn ?? realGetSession;
+        const getSpacesFn = options.getSpacesFn ?? realGetSpaces;
+        const connectFn = options.connectFn ?? realConnectRepo;
+        const loginFn = options.loginFn ?? realLogin;
+        const getRemoteFn = options.getRemoteFn ?? defaultGetRemote;
+        // ── 3a: ensure the user is signed in ─────────────────────────────────────
+        let signedIn = false;
+        try {
+            // When getSessionFn is injected (tests), trust it directly.
+            // In production, only call it if there are saved credentials.
+            const creds = options.getSessionFn ? true : loadCredentials();
+            if (creds) {
+                const sess = await getSessionFn();
+                signedIn = sess.user !== null;
+            }
+        }
+        catch {
+            // can't reach server; treat as not signed in
+        }
+        if (!signedIn) {
+            let doLogin = yes;
+            if (!yes) {
+                const answer = await io.ask('Sign in to DocuGate now? [Y/n]', 'y');
+                doLogin = !/^n(o)?$/i.test(answer);
+            }
+            if (doLogin) {
+                try {
+                    await loginFn(BASE_URL);
+                    signedIn = true;
+                    io.print(`  Signed in to DocuGate.`);
+                }
+                catch (err) {
+                    connectError = `Sign-in failed: ${err.message}`;
+                    io.print(`  warning  ${connectError}`);
+                }
+            }
+        }
+        // ── 3b: connect this repository to a space ────────────────────────────────
+        if (signedIn) {
+            // Read git remote.
+            const repoSlug = getRemoteFn(root);
+            if (!repoSlug) {
+                io.print(`  This repository has no GitHub remote yet, so it can't be connected to a space.`);
+            }
+            else {
+                // List spaces.
+                let spaces = [];
+                try {
+                    const res = await getSpacesFn();
+                    spaces = res.spaces;
+                }
+                catch (err) {
+                    connectError = `Couldn't load spaces: ${err.message}`;
+                    io.print(`  warning  ${connectError}`);
+                }
+                if (spaces.length === 0 && !connectError) {
+                    io.print(`  No spaces found. Create one first: ${BASE_URL}/dashboard/new`);
+                }
+                else if (spaces.length > 0) {
+                    const { docsDir: repoDocsDir } = loadConfig(root);
+                    if (yes) {
+                        // --yes: auto-connect only when there is exactly one space.
+                        if (spaces.length === 1) {
+                            try {
+                                await connectFn(spaces[0].id, repoSlug, repoDocsDir);
+                                io.print(`  Connected ${repoSlug} to space "${spaces[0].name}".`);
+                            }
+                            catch (err) {
+                                connectError = err.message;
+                                io.print(`  warning  ${connectError}`);
+                            }
+                        }
+                        else {
+                            io.print(`  Multiple spaces found — run docugate init again without --yes to choose:`);
+                            for (const s of spaces)
+                                io.print(`    ${s.owner}/${s.slug}  ${s.name}`);
+                        }
+                    }
+                    else {
+                        // Interactive: list spaces and ask.
+                        io.print(`  Your spaces:`);
+                        for (let i = 0; i < spaces.length; i++) {
+                            io.print(`    ${i + 1}. ${spaces[i].name}  (${spaces[i].owner}/${spaces[i].slug})`);
+                        }
+                        const answer = await io.ask(`Connect ${repoSlug} to which space? [1-${spaces.length}/skip]`, 'skip');
+                        const idx = parseInt(answer, 10) - 1;
+                        if (!isNaN(idx) && idx >= 0 && idx < spaces.length) {
+                            try {
+                                await connectFn(spaces[idx].id, repoSlug, repoDocsDir);
+                                io.print(`  Connected ${repoSlug} to space "${spaces[idx].name}".`);
+                            }
+                            catch (err) {
+                                connectError = err.message;
+                                io.print(`  warning  ${connectError}`);
+                            }
+                        }
+                        else {
+                            io.print(`  Skipped connecting to a space.`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // ── Step 4: tour steps (frontend / both only) ─────────────────────────────
+    let tourResult;
+    let tourError;
+    let installResult;
+    if (role === 'frontend' || role === 'both') {
+        // Decide whether to run tour init.
+        let runTour = yes;
+        if (!yes && io.isTTY) {
+            const answer = await io.ask('Write the tour with IBM Bob? (costs Bobcoins) [y/N]', 'n');
+            runTour = /^y(es)?$/i.test(answer);
+        }
+        if (runTour) {
+            try {
+                tourResult = tourInit(root, { runBob: options.runBob });
+            }
+            catch (error) {
+                // Bob missing or failed — describe what went wrong, then continue.
+                if (error instanceof BobKeyMissingError) {
+                    tourError =
+                        `Bob Shell needs an API key. Set BOB_API_KEY, then run docugate tour init.`;
+                }
+                else if (error instanceof BobMissingError) {
+                    tourError =
+                        `Bob Shell is not installed. Install it, sign in, then run docugate tour init.`;
+                }
+                else {
+                    tourError = `Tour init failed: ${error.message}. Run docugate tour init to retry.`;
+                }
+                io.print(`  warning  ${tourError}`);
+            }
+        }
+        // tour install: ask in TTY unless --yes.
+        let runInstall = yes;
+        if (!yes && io.isTTY) {
+            const answer = await io.ask('Add the pill loader to your app? [Y/n]', 'y');
+            runInstall = !/^n(o)?$/i.test(answer);
+        }
+        if (runInstall) {
+            installResult = tourInstall(root, { port });
+            if (installResult.target === null) {
+                io.print(`  Paste this into your app's HTML during development:`);
+                io.print(`    ${pillSnippetLine(port)}`);
+            }
+        }
+    }
+    else {
+        // backend
+        io.print(`  backend role: skipping tour. The frontend repository's tour can point into this one.`);
+    }
+    // ── Step 5: summary ───────────────────────────────────────────────────────
+    io.print(``);
+    for (const f of base.created)
+        io.print(`  created  ${f}`);
+    for (const f of base.kept)
+        io.print(`  kept     ${f}`);
+    if (!savedRole && role)
+        io.print(`  saved    role: ${role} in ${CONFIG_FILE}`);
+    if (tourResult) {
+        for (const f of tourResult.setup)
+            io.print(`  created  ${f}`);
+        for (const f of tourResult.added)
+            io.print(`  added    ${f}`);
+        for (const f of tourResult.restored)
+            io.print(`  kept     ${f} (Bob changed it; your version was put back)`);
+    }
+    if (installResult?.action === 'inserted')
+        io.print(`  installed pill in ${installResult.target}`);
+    if (installResult?.action === 'already')
+        io.print(`  pill already in ${installResult.target}`);
+    io.print(``);
+    io.print(`Next: docugate tour serve`);
+    return { ...base, role, tourResult, tourError, installResult, connectError };
+}

package/dist/rules.js

@@ -58,4 +58,4 @@ export function firstHeading(content) {
     const heading = content.match(/^#\s+(.+)$/m);
     return heading ? heading[1].trim() : null;
 }
-export const KNOWN_KEYS = new Set(['$schema', 'docsDir', 'title', 'sidebar', 'api']);
+export const KNOWN_KEYS = new Set(['$schema', 'docsDir', 'title', 'role', 'sidebar', 'api']);