docugate 0.2.0 → 0.2.2

package/dist/init.js

@@ -1,9 +1,9 @@
 import { createInterface } from 'node:readline';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { CONFIG_FILE, loadConfig } from './config.js';
-import { tourInit, BobMissingError, BobKeyMissingError } from './tour-init.js';
+import { tourInit, BobMissingError, BobKeyMissingError, readBobKey, saveBobKey } from './tour-init.js';
 import { tourInstall, pillSnippetLine, DEFAULT_PORT } from './tour-install.js';
 import { login, loadCredentials } from './auth.js';
 /**
@@ -57,6 +57,80 @@ function makeDefaultIO() {
         },
     };
 }
+/**
+ * The nearest folder above `root`, inside the same Git repository, that has
+ * DocuGate set up already (a docugate.json), if any.
+ */
+export function setUpAbove(root) {
+    if (existsSync(join(root, '.git')))
+        return undefined;
+    let dir = dirname(root);
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, CONFIG_FILE)))
+            return dir;
+        if (existsSync(join(dir, '.git')))
+            return undefined;
+        dir = dirname(dir);
+    }
+    return undefined;
+}
+/** Sets one key in docugate.json, keeping everything else as it was. */
+function saveSetting(root, key, value) {
+    const path = join(root, CONFIG_FILE);
+    let existing = {};
+    if (existsSync(path)) {
+        try {
+            existing = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            // unreadable: start again with this key
+        }
+    }
+    existing[key] = value;
+    writeFileSync(path, JSON.stringify(existing, null, 2) + '\n');
+}
+const BOB_KEYS_URL = 'https://bob.ibm.com/docs/ide/account/api-keys';
+/**
+ * Bob Shell runs on its own with an API key, not the IDE sign-in. Setup gets
+ * one without anyone editing environment variables: open the page that makes
+ * it, paste it, and it is kept in ~/.docugate/bob.json, outside the repository.
+ */
+async function askForBobKey(io, openUrl) {
+    const pick = await choose(io, 'IBM Bob needs an API key to write the tour. Get one now?', [
+        'Yes, open the page to create an Inference key, then paste it here',
+        'Skip the tour for now',
+    ]);
+    if (pick !== 1)
+        return false;
+    io.print(`  In your Bob instance: API keys, then create an Inference key.`);
+    io.print(`  ${BOB_KEYS_URL}`);
+    (openUrl ?? openInBrowser)(BOB_KEYS_URL);
+    const key = (await io.ask('  Paste the key and press Enter (it stays on this computer)', '')).trim();
+    if (!key) {
+        io.print('  No key pasted. Skipped the tour: run docugate tour init when you have one.');
+        return false;
+    }
+    saveBobKey(key);
+    io.print('  Key saved in ~/.docugate/bob.json. It is never written into the repository.');
+    return true;
+}
+function openInBrowser(url) {
+    const [cmd, args] = process.platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+        : process.platform === 'darwin' ? ['open', [url]]
+            : ['xdg-open', [url]];
+    try {
+        spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        // the URL is printed above
+    }
+}
+export const FRESHNESS = [
+    { value: 'push', label: 'On every push' },
+    { value: 'daily', label: 'Once a day (recommended: fewer AI runs)' },
+    { value: 'weekly', label: 'Once a week' },
+    { value: 'off', label: 'Never, I will ask for it' },
+];
 function saveRole(root, role) {
     const path = join(root, CONFIG_FILE);
     let existing = {};
@@ -71,7 +145,43 @@ function saveRole(root, role) {
     existing.role = role;
     writeFileSync(path, JSON.stringify(existing, null, 2) + '\n');
 }
-const VALID_ROLES = new Set(['frontend', 'backend', 'both']);
+const ROLE_CHOICES = [{ role: 'frontend' }, { role: 'backend' }, { role: 'both' }];
+const FRONTEND_DIRS = ['frontend', 'client', 'web'];
+const BACKEND_DIRS = ['backend', 'server', 'api'];
+const FRONTEND_MARKERS = ['index.html', 'vite.config.ts', 'vite.config.js', 'next.config.js', 'next.config.mjs', 'next.config.ts', 'angular.json', 'svelte.config.js'];
+const BACKEND_MARKERS = ['go.mod', 'requirements.txt', 'pyproject.toml', 'manage.py', 'pom.xml', 'build.gradle', 'Gemfile', 'composer.json'];
+/**
+ * What the repository probably is, from its folders and files, so the question
+ * can suggest an answer. Only a suggestion: the person always confirms it.
+ */
+export function guessRole(root) {
+    const has = (name) => existsSync(join(root, name));
+    const front = FRONTEND_DIRS.some(has);
+    const back = BACKEND_DIRS.some(has);
+    if (front && back)
+        return 'both';
+    if (FRONTEND_MARKERS.some(has) || front)
+        return 'frontend';
+    if (BACKEND_MARKERS.some(has) || back)
+        return 'backend';
+    return undefined;
+}
+/**
+ * A numbered choice: prints the options, and takes only a number. Enter picks
+ * the default. Nobody types a word during setup.
+ */
+export async function choose(io, question, options, fallback = 1) {
+    io.print('');
+    io.print(`  ${question}`);
+    options.forEach((option, i) => io.print(`    ${i + 1}  ${option}`));
+    for (;;) {
+        const answer = (await io.ask(`  Choose 1-${options.length} [${fallback}]`, String(fallback))).trim();
+        const n = Number(answer);
+        if (Number.isInteger(n) && n >= 1 && n <= options.length)
+            return n;
+        io.print(`  Type a number from 1 to ${options.length}.`);
+    }
+}
 function defaultGetRemote(root) {
     try {
         const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
@@ -97,6 +207,16 @@ export async function initFlow(root, options = {}) {
     const io = options.io ?? makeDefaultIO();
     const yes = options.yes ?? false;
     const port = options.port ?? DEFAULT_PORT;
+    // One project gets one setup and one tour. Run inside frontend/ of a
+    // project already set up at its root, and init points there instead of
+    // starting a second one.
+    const parent = setUpAbove(root);
+    if (parent) {
+        io.print(`  This project is already set up in ${parent}.`);
+        io.print(`  One project has one tour: run docugate commands from that folder.`);
+        const above = loadConfig(parent);
+        return { created: [], kept: [], docsDir: above.docsDir, role: above.config.role, alreadySetUp: parent };
+    }
     // ── Step 1: base repo setup (docugate.json + docs/) ──────────────────────
     const base = init(root, { dir: options.dir, title: options.title });
     // ── Step 2: determine role ────────────────────────────────────────────────
@@ -116,15 +236,19 @@ export async function initFlow(root, options = {}) {
             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;
+            // Interactive: a numbered choice with examples, the likely answer
+            // suggested from the folders in the repository.
+            const guess = guessRole(root);
+            const guessNumber = String(ROLE_CHOICES.findIndex((c) => c.role === guess) + 1);
+            const n = await choose(io, `What is in this repository?${guess ? ` (it looks like ${guess})` : ''}`, [
+                'Frontend   the app people see: React, Vue, Svelte, Next.js, plain HTML',
+                'Backend    the API or server: Node, Python, Go, Java, ...',
+                'Both       frontend and backend in one repository, for example:\n' +
+                    '                 my-app/\n' +
+                    '                 ├─ frontend/   (or client/, web/)\n' +
+                    '                 └─ backend/    (or server/, api/)',
+            ], guessNumber === '0' ? 3 : Number(guessNumber));
+            role = ROLE_CHOICES[n - 1].role;
         }
     }
     if (!savedRole) {
@@ -174,8 +298,11 @@ export async function initFlow(root, options = {}) {
         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);
+                doLogin =
+                    (await choose(io, 'Sign in to DocuGate, so this repository can feed a space?', [
+                        'Yes, open the browser to sign in',
+                        'Skip for now (docugate login does it later)',
+                    ])) === 1;
             }
             if (doLogin) {
                 try {
@@ -207,55 +334,84 @@ export async function initFlow(root, options = {}) {
                     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`);
+                const { docsDir: repoDocsDir } = loadConfig(root);
+                const hasRepo = (sp) => (sp.sources ?? []).some((src) => src.repo.toLowerCase() === repoSlug.toLowerCase());
+                const already = spaces.find(hasRepo);
+                if (connectError) {
+                    // the warning is printed already; carry on with the rest of setup
                 }
-                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 if (yes) {
+                    // --yes: connect only when there is no doubt which space is meant.
+                    if (already) {
+                        io.print(`  ${repoSlug} is already in space "${already.name}".`);
+                    }
+                    else if (spaces.length === 1) {
+                        try {
+                            await connectFn(spaces[0].id, repoSlug, repoDocsDir);
+                            io.print(`  Connected ${repoSlug} to space "${spaces[0].name}".`);
                         }
-                        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}`);
+                        catch (err) {
+                            connectError = err.message;
+                            io.print(`  warning  ${connectError}`);
                         }
                     }
-                    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})`);
+                    else if (spaces.length > 1) {
+                        io.print(`  Several spaces found: run docugate init again without --yes to choose.`);
+                    }
+                }
+                else {
+                    // Interactive: create a space, or pick one, or skip. Numbers only.
+                    const choices = [
+                        `Create a new space for ${repoSlug}`,
+                        ...spaces.map((sp) => `${sp.name}  (${sp.owner}/${sp.slug})${hasRepo(sp) ? '  already reads this repository' : ''}`),
+                        'Skip for now',
+                    ];
+                    const pick = await choose(io, `Which DocuGate space should document ${repoSlug}?`, choices, already ? spaces.indexOf(already) + 2 : 1);
+                    if (pick === 1) {
+                        try {
+                            const createFn = options.createSpaceFn ?? (async (repo, name, dir) => {
+                                const { createSpace } = await import('./api.js');
+                                return createSpace(repo, name, dir);
+                            });
+                            const created = await createFn(repoSlug, loadConfig(root).config.title ?? repoSlug.split('/')[1], repoDocsDir);
+                            io.print(`  Created space "${created.name}": ${BASE_URL}/${created.owner}/${created.slug}`);
+                        }
+                        catch (err) {
+                            connectError = err.message;
+                            io.print(`  warning  ${connectError}`);
+                        }
+                    }
+                    else if (pick <= spaces.length + 1) {
+                        const sp = spaces[pick - 2];
+                        if (hasRepo(sp)) {
+                            io.print(`  ${repoSlug} is already in space "${sp.name}". Nothing to change.`);
                         }
-                        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) {
+                        else {
                             try {
-                                await connectFn(spaces[idx].id, repoSlug, repoDocsDir);
-                                io.print(`  Connected ${repoSlug} to space "${spaces[idx].name}".`);
+                                await connectFn(sp.id, repoSlug, repoDocsDir);
+                                io.print(`  Connected ${repoSlug} to space "${sp.name}".`);
                             }
                             catch (err) {
                                 connectError = err.message;
                                 io.print(`  warning  ${connectError}`);
                             }
                         }
-                        else {
-                            io.print(`  Skipped connecting to a space.`);
-                        }
+                    }
+                    else {
+                        io.print(`  Skipped. docugate init connects it any time.`);
                     }
                 }
             }
         }
     }
+    // ── Step 3c: how often the docs are checked against the code ─────────────
+    if (io.isTTY && !loaded.config.freshness) {
+        const n = yes
+            ? 2
+            : await choose(io, 'How often should DocuGate check that your docs still match the code?', FRESHNESS.map((f) => f.label), 2);
+        saveSetting(root, 'freshness', FRESHNESS[n - 1].value);
+        io.print(`  Saved: ${FRESHNESS[n - 1].label.split(' (')[0].toLowerCase()}. Change "freshness" in docugate.json any time.`);
+    }
     // ── Step 4: tour steps (frontend / both only) ─────────────────────────────
     let tourResult;
     let tourError;
@@ -264,8 +420,16 @@ export async function initFlow(root, options = {}) {
         // 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);
+            const pick = await choose(io, 'Set up the tour: which AI should read your code and write it?', [
+                'IBM Bob (uses Bobcoins)',
+                'IBM watsonx (coming soon)',
+                'Skip, I will write it in the browser',
+            ], 3);
+            if (pick === 2)
+                io.print('  IBM watsonx is coming soon. Skipped for now: run docugate tour init when you are ready.');
+            runTour = pick === 1;
+            if (runTour && !readBobKey() && !options.runBob)
+                runTour = await askForBobKey(io, options.openUrl);
         }
         if (runTour) {
             try {
@@ -290,8 +454,11 @@ export async function initFlow(root, options = {}) {
         // 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);
+            runInstall =
+                (await choose(io, 'Add the DocuGate pill to your app? (development only)', [
+                    'Yes, add it',
+                    'Skip, I will run docugate tour install later',
+                ])) === 1;
         }
         if (runInstall) {
             installResult = tourInstall(root, { port });

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', 'role', 'sidebar', 'api']);
+export const KNOWN_KEYS = new Set(['$schema', 'docsDir', 'title', 'role', 'freshness', 'sidebar', 'api']);

package/dist/tour-init.js

@@ -1,7 +1,8 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import { isMap, isSeq, parseDocument } from 'yaml';
 // `docugate tour init` writes the first tour of an app by asking IBM Bob
 // (through Bob Shell) to read the code. Bob does the reading; this file makes
@@ -75,9 +76,30 @@ export class BobMissingError extends Error {
 /** Bob Shell's headless mode signs in with an API key, not the IDE's IBMid session. */
 export class BobKeyMissingError extends Error {
 }
+/** Where `docugate init` keeps the Bob API key: the home folder, never the repository. */
+export function bobKeyPath() {
+    return join(homedir(), '.docugate', 'bob.json');
+}
+/** The Bob API key: BOB_API_KEY if set, else the one saved during setup. */
+export function readBobKey() {
+    if (process.env.BOB_API_KEY)
+        return process.env.BOB_API_KEY;
+    try {
+        return JSON.parse(readFileSync(bobKeyPath(), 'utf8')).key || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveBobKey(key) {
+    mkdirSync(dirname(bobKeyPath()), { recursive: true });
+    writeFileSync(bobKeyPath(), JSON.stringify({ key }) + '\n', { mode: 0o600 });
+}
 const defaultRunBob = (args, cwd) => {
+    const key = readBobKey();
     const result = spawnSync('bob', args, {
         cwd,
+        env: key ? { ...process.env, BOB_API_KEY: key } : process.env,
         encoding: 'utf8',
         // `bob` is a .cmd shim on Windows, which only runs through a shell.
         shell: process.platform === 'win32',

package/dist/tour-server.js

@@ -1,6 +1,7 @@
+import { spawn } from 'node:child_process';
 import { createServer } from 'node:http';
 import { existsSync, mkdirSync, readFileSync, realpathSync, watch, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative, resolve, isAbsolute } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadTours, matchRoute, parseTourFile, routeToFilename, serializeTourFile } from './tour.js';
 // ---------------------------------------------------------------------------
@@ -94,7 +95,7 @@ function handleGetTour(req, res, root) {
         sendJson(res, 404, { error: 'not found' });
         return;
     }
-    sendJson(res, 200, { route: match.route, title: match.title, stops: match.stops });
+    sendJson(res, 200, { route: match.route, title: match.title, file: match.file, stops: match.stops });
 }
 function handleGetEvents(req, res, root) {
     const tourDir = join(root, '.docugate', 'tour');
@@ -134,7 +135,7 @@ async function handlePutStop(req, res, root) {
         sendJson(res, 400, { error: 'invalid JSON body' });
         return;
     }
-    const { route, title: bodyTitle, stop } = body;
+    const { route, title: bodyTitle, stop, previousTarget } = body;
     if (!route || !stop) {
         sendJson(res, 400, { error: 'body must have route and stop' });
         return;
@@ -161,8 +162,9 @@ async function handlePutStop(req, res, root) {
             stops: [],
         };
     }
-    // Upsert: find by target and update, or append.
-    const idx = tour.stops.findIndex((s) => s.target === stop.target);
+    // Upsert: find the stop being edited (by its old target when the edit
+    // changed it) and update it in place, or append a new one.
+    const idx = tour.stops.findIndex((s) => s.target === (previousTarget ?? stop.target));
     if (idx >= 0) {
         tour.stops[idx] = stop;
     }
@@ -172,6 +174,91 @@ async function handlePutStop(req, res, root) {
     writeFileSync(filepath, serializeTourFile(tour));
     sendJson(res, 200, { ok: true });
 }
+/** DELETE /stop { route, target }: removes one stop, leaving the rest of the file as it was. */
+async function handleDeleteStop(req, res, root) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendJson(res, 400, { error: 'invalid JSON body' });
+        return;
+    }
+    const existing = loadTours(root).find((t) => t.route === body.route);
+    if (!existing?.file || !body.target) {
+        sendJson(res, 404, { error: 'no such stop' });
+        return;
+    }
+    const filepath = join(root, existing.file);
+    const tour = parseTourFile(readFileSync(filepath, 'utf8'), existing.file);
+    const before = tour.stops.length;
+    tour.stops = tour.stops.filter((s) => s.target !== body.target);
+    if (tour.stops.length === before) {
+        sendJson(res, 404, { error: 'no such stop' });
+        return;
+    }
+    writeFileSync(filepath, serializeTourFile(tour));
+    sendJson(res, 200, { ok: true });
+}
+/**
+ * The editor `docugate tour serve` was started from, as the command that opens
+ * a file at a line. DOCUGATE_EDITOR wins; otherwise the integrated terminal's
+ * environment says which VS Code family editor it is.
+ */
+export function editorCommand(env = process.env) {
+    if (env.DOCUGATE_EDITOR)
+        return env.DOCUGATE_EDITOR;
+    const hint = `${env.VSCODE_GIT_ASKPASS_NODE ?? ''} ${env.VSCODE_CWD ?? ''} ${env.CURSOR_TRACE_ID ? 'cursor' : ''}`.toLowerCase();
+    if (hint.includes('cursor'))
+        return 'cursor';
+    if (hint.includes('windsurf'))
+        return 'windsurf';
+    if (hint.includes('insiders'))
+        return 'code-insiders';
+    return 'code';
+}
+/** The 1-based line of the first occurrence of `find` in `text`, or 1. */
+export function lineOf(text, find) {
+    if (!find)
+        return 1;
+    const index = text.split(/\r?\n/).findIndex((line) => line.includes(find));
+    return index >= 0 ? index + 1 : 1;
+}
+/**
+ * POST /open { path, find? }: opens a file of this repository in the editor,
+ * at the line that contains `find` (the element's data-tour value), so "Code"
+ * in the pill jumps straight to the element. Only files inside the repository.
+ */
+async function handleOpen(req, res, root) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendJson(res, 400, { error: 'invalid JSON body' });
+        return;
+    }
+    const abs = resolve(root, body.path ?? '');
+    const rel = relative(root, abs);
+    if (!body.path || rel.startsWith('..') || isAbsolute(rel) || !existsSync(abs) || /["%^&|<>`$]/.test(abs)) {
+        sendJson(res, 404, { error: 'no such file in this repository' });
+        return;
+    }
+    const line = lineOf(readFileSync(abs, 'utf8'), body.find);
+    const command = editorCommand();
+    // One command string, the path quoted: editor launchers are .cmd files on
+    // Windows, which only run through a shell.
+    const child = spawn(`${command} -g "${abs}:${line}"`, { shell: true, stdio: 'ignore' });
+    child.on('error', () => sendJson(res, 501, { error: `could not run ${command}` }));
+    child.on('exit', (code) => {
+        if (res.headersSent)
+            return;
+        if (code === 0)
+            sendJson(res, 200, { ok: true, line });
+        else
+            sendJson(res, 501, { error: `could not run ${command}`, line });
+    });
+}
 function handleGetPill(res) {
     // pill/dist/pill.js is resolved relative to this package's root directory.
     // import.meta.url points at dist/tour-server.js at runtime, so go up one level.
@@ -194,6 +281,18 @@ export function startTourServer(root, port) {
             }
             const url = new URL(req.url ?? '/', 'http://localhost');
             const path = url.pathname;
+            // The pill runs on the app's own port, so a JSON PUT from it is a
+            // cross-origin request: the browser asks first, and must get a yes.
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, PUT, POST, DELETE',
+                    'Access-Control-Allow-Headers': 'Content-Type',
+                    'Access-Control-Max-Age': '600',
+                });
+                res.end();
+                return;
+            }
             if (req.method === 'GET' && path === '/tour') {
                 handleGetTour(req, res, root);
             }
@@ -205,6 +304,16 @@ export function startTourServer(root, port) {
                     sendJson(res, 500, { error: err.message });
                 });
             }
+            else if (req.method === 'DELETE' && path === '/stop') {
+                handleDeleteStop(req, res, root).catch((err) => {
+                    sendJson(res, 500, { error: err.message });
+                });
+            }
+            else if (req.method === 'POST' && path === '/open') {
+                handleOpen(req, res, root).catch((err) => {
+                    sendJson(res, 500, { error: err.message });
+                });
+            }
             else if (req.method === 'GET' && path === '/pill.js') {
                 handleGetPill(res);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docugate",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Command-line tools for DocuGate: set up, check and prepare the documentation DocuGate reads straight from your repository.",
   "type": "module",
   "bin": {