@wacht/bench 0.1.3 → 0.1.4

package/dist/commands.js

@@ -16,6 +16,7 @@ import { completionScript } from './completion.js';
 import { configApply, configDiff, configPull, configSchemaCommand, printConfigTemplate, } from './config-workflow.js';
 import { clearDeployment, createDeploymentCommand, createProjectCommand, currentDeployment, selectDeployment, } from './deployment-context.js';
 import { initProject, initStarter } from './init.js';
+import { docsSearch } from './docs-search.js';
 import { envPull } from './env-pull.js';
 import { apiCommand, listProjects } from './machine-api.js';
 import { openApiCall, openApiDescribe, openApiList, openApiRefresh } from './openapi.js';
@@ -219,6 +220,21 @@ export async function runCli(args) {
         .action((options) => {
         printMcpConfig(options.client);
     });
+    const docs = program.command('docs').description('search and explore Wacht docs');
+    docs
+        .command('search <query...>')
+        .description('full-text search Wacht docs and print matching pages')
+        .option('--limit <n>', 'max number of pages to print', (v) => Number.parseInt(v, 10))
+        .option('--base-url <url>', 'docs base URL (default: https://wacht.dev/docs, or $WACHT_DOCS_URL)')
+        .option('--json', 'emit JSON instead of human-readable output')
+        .action(async (queryParts, options) => {
+        await docsSearch(context(program), {
+            query: queryParts.join(' '),
+            limit: options.limit,
+            baseUrl: options.baseUrl,
+            json: options.json,
+        });
+    });
     const env = program.command('env').description('manage deployment credentials and environment files');
     env
         .command('pull')

package/dist/docs-search.js

@@ -0,0 +1,81 @@
+import { field, log, printBannerFor, printError, printJson, section } from './ui.js';
+const DEFAULT_DOCS_URL = 'https://wacht.dev/docs';
+export async function docsSearch(ctx, options) {
+    const baseUrl = (options.baseUrl ?? process.env.WACHT_DOCS_URL ?? DEFAULT_DOCS_URL).replace(/\/+$/, '');
+    const endpoint = `${baseUrl}/api/search?query=${encodeURIComponent(options.query)}`;
+    let response;
+    try {
+        response = await fetch(endpoint, { headers: { Accept: 'application/json' } });
+    }
+    catch (error) {
+        printError(error);
+        process.exitCode = 1;
+        return;
+    }
+    if (!response.ok) {
+        printError(new Error(`docs search failed: ${response.status} ${response.statusText} (${endpoint})`));
+        process.exitCode = 1;
+        return;
+    }
+    const raw = (await response.json());
+    if (!Array.isArray(raw)) {
+        printError(new Error('unexpected docs search response shape'));
+        process.exitCode = 1;
+        return;
+    }
+    const pages = new Map();
+    const snippets = new Map();
+    for (const hit of raw) {
+        const pageUrl = hit.url.split('#')[0];
+        if (hit.type === 'page') {
+            pages.set(pageUrl, hit);
+        }
+        else {
+            if (!snippets.has(pageUrl))
+                snippets.set(pageUrl, []);
+            snippets.get(pageUrl).push(hit);
+        }
+    }
+    const orderedPages = Array.from(pages.values());
+    const sliced = options.limit ? orderedPages.slice(0, options.limit) : orderedPages;
+    if (options.json) {
+        printJson({
+            ok: true,
+            query: options.query,
+            baseUrl,
+            results: sliced.map((page) => ({
+                title: page.content,
+                url: `${baseUrl}${page.url}`,
+                breadcrumbs: page.breadcrumbs ?? [],
+                snippets: (snippets.get(page.url) ?? []).map((s) => ({
+                    text: s.content,
+                    url: `${baseUrl}${s.url}`,
+                })),
+            })),
+        });
+        return;
+    }
+    printBannerFor(ctx);
+    log(ctx, section('Docs Search'));
+    log(ctx, field('Query', options.query));
+    log(ctx, field('Source', baseUrl));
+    log(ctx, field('Results', String(sliced.length)));
+    log(ctx, '');
+    if (sliced.length === 0) {
+        log(ctx, 'No matches.');
+        return;
+    }
+    for (const page of sliced) {
+        const breadcrumbs = page.breadcrumbs?.length ? page.breadcrumbs.join(' › ') : '';
+        log(ctx, `• ${page.content}`);
+        if (breadcrumbs)
+            log(ctx, `    ${breadcrumbs}`);
+        log(ctx, `    ${baseUrl}${page.url}`);
+        const pageSnippets = snippets.get(page.url) ?? [];
+        for (const s of pageSnippets.slice(0, 3)) {
+            const trimmed = s.content.length > 140 ? `${s.content.slice(0, 137).trimEnd()}…` : s.content;
+            log(ctx, `      – ${trimmed}`);
+        }
+        log(ctx, '');
+    }
+}

package/dist/openapi-validate.js

@@ -20,22 +20,8 @@ export function validateBody(spec, schema, body) {
         return null;
     return summariseErrors(compiled.errors ?? [], body);
 }
-/**
- * The raw ajv error stream is noisy:
- *   - `anyOf` / `oneOf` umbrellas restate "doesn't match" without specifics.
- *   - The `type: null` branches our `nullable` rewrite introduces are never what
- *     the user is trying to send.
- *   - oneOf-with-discriminator emits per-variant required errors from every
- *     non-matching branch, drowning out the actual problem.
- *
- * Strategy:
- *   1. Drop nullable + anyOf/oneOf umbrellas.
- *   2. When an `oneOf` umbrella was present at a path, collapse all required/const
- *      errors under that path into a single "doesn't match any variant" line with
- *      the discriminator value found in the body (if any). Tell the user to run
- *      `wacht api describe` for the variant payload — avoids guessing wrong.
- *   3. Pass everything else through unchanged.
- */
+// Collapse `oneOf` failures into one line per union and drop the noisy umbrella
+// + `type: null` errors our `nullable` rewrite introduces.
 function summariseErrors(rawErrors, body) {
     // Discover oneOf failure points by looking for the `oneOf` umbrella error.
     const oneOfPaths = new Set();
@@ -72,13 +58,6 @@ function summariseErrors(rawErrors, body) {
     // Dedupe identical lines (e.g. two variants both miss the same field).
     return [...new Set(out)];
 }
-/**
- * When a `oneOf` discriminated union mismatches, ajv emits a "must be equal to constant"
- * error for every variant whose const failed, plus the required-field errors from each
- * variant's payload schema. That's overwhelming. If the input has a discriminator value
- * that matches *no* variant, surface a single "X must be one of [...]"; if it matches
- * exactly one, drop the per-variant required errors from the other variants.
- */
 function readJsonPointer(value, pointer) {
     if (!pointer || pointer === '/')
         return value;

package/dist/openapi.js

@@ -119,6 +119,8 @@ function schemaType(schema) {
         return schema.anyOf.map((item) => isRecord(item) ? schemaType(item) : 'unknown').join(' | ');
     if (Array.isArray(schema.oneOf))
         return schema.oneOf.map((item) => isRecord(item) ? schemaType(item) : 'unknown').join(' | ');
+    if (schema.const !== undefined)
+        return `const ${JSON.stringify(schema.const)}`;
     return 'object';
 }
 const REF_PREFIX = '#/components/schemas/';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wacht/bench",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "CLI for Wacht Bench, the AI development workbench for Wacht.",
   "type": "module",
   "bin": {