@zenera/rag 1.1.24 → 1.1.26

package/dist/docs/tools.js

@@ -1,8 +1,7 @@
-import { tool } from '@zenera/neo';
-import { PatternError } from "../common/match.js";
+import { PatternError, tool } from '@zenera/neo';
 import { assemble } from "./assemble.js";
 import { CHUNK_KINDS } from "./chunk.js";
-import { grepLines, listFiles, listSections, listTables, readRange, readSection, } from "./lookup.js";
+import { grepLines, isFailure, listFiles, listSections, listTables, readMany, readRange, readSection, } from "./lookup.js";
 import { renderAssembly } from "./render.js";
 import { SEARCH_MODES } from "./search.js";
 // ---------------------------------------------------------------------------
@@ -248,7 +247,8 @@ export function docsTools(index, options = {}) {
         group: GROUP,
         description: 'Reads a document verbatim: a whole named section, or a line range as printed by ' +
             'search_docs or grep_docs. Use it when a passage was found and the lines around ' +
-            'it are needed in full, with nothing omitted and nothing summarised.',
+            'it are needed in full, with nothing omitted and nothing summarised. To read ' +
+            'several passages, name them all in `reads` in one call instead of calling again.',
         parameters: {
             type: 'object',
             properties: {
@@ -262,11 +262,38 @@ export function docsTools(index, options = {}) {
                 },
                 from: { type: 'integer', description: 'First line, 1-based. Default 1.' },
                 to: { type: 'integer', description: 'Last line. Default the end of the document.' },
+                reads: {
+                    type: 'array',
+                    description: 'Instead of file: every passage to read, each as {file, section} or ' +
+                        `{file, from, to}. They share a ceiling of ${MAX_LINES} lines.`,
+                    items: {
+                        type: 'object',
+                        properties: {
+                            file: { type: 'string' },
+                            section: { type: 'string' },
+                            from: { type: 'integer' },
+                            to: { type: 'integer' },
+                        },
+                        required: ['file'],
+                        additionalProperties: false,
+                    },
+                },
             },
-            required: ['file'],
             additionalProperties: false,
         },
         execute: async (args) => {
+            if (args.reads !== undefined) {
+                if (args.file !== undefined || args.reads.length === 0) {
+                    return {
+                        error: args.file ? 'send `file` or `reads`, not both' : '`reads` is empty',
+                        hint: 'put every passage in `reads`, one {file, section} or {file, from, to} each',
+                    };
+                }
+                return await readSeveral(args.reads);
+            }
+            if (!args.file) {
+                return { error: 'nothing to read', hint: 'send `file`, or `reads` for several' };
+            }
             const file = index.resolveFiles([args.file])[0];
             if (!file) {
                 return {
@@ -293,6 +320,43 @@ export function docsTools(index, options = {}) {
         },
     });
     return [searchDocs, listDocs, grepDocs, readDocs];
+    async function readSeveral(reads) {
+        const names = new Set(index.manifest.sources.map((s) => s.name));
+        const resolved = await guard(() => reads.map((r) => ({
+            target: r.file,
+            file: names.has(r.file) ? r.file : (index.resolveFiles([r.file])[0] ?? r.file),
+            section: r.section,
+            from: r.from,
+            to: r.to,
+        })));
+        if ('error' in resolved) {
+            return resolved;
+        }
+        const read = await readMany(index, resolved, {
+            maxLines: MAX_LINES,
+            hints: {
+                document: () => 'call list_docs for the names',
+                section: () => 'call list_docs with what "sections" for its headings',
+                range: (_, total) => `it has ${total} lines`,
+            },
+        });
+        return {
+            printed: read.printed,
+            failed: read.failed,
+            results: read.results.map((r) => isFailure(r)
+                ? { file: r.file, error: r.error, hint: r.hint }
+                : {
+                    file: r.file,
+                    ...(r.section ? { section: r.section } : {}),
+                    start: r.from,
+                    end: r.to,
+                    total: r.total,
+                    truncated: r.truncated,
+                    ...(r.continue ? { continue: r.continue } : {}),
+                    text: r.lines.map((line, at) => `${r.from + at} | ${line}`).join('\n'),
+                }),
+        };
+    }
 }
 // ---------------------------------------------------------------------------
 const strings = (description) => ({

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+export { anyOf, isGlob, loose, matcher, MAX_PATTERN, PatternError, wildcard, type Matcher, type MatchOptions, } from '@zenera/neo';
 export * from './common/locate.ts';
 export * from './common/manifest.ts';
-export * from './common/match.ts';
 export * as docs from './docs/index.ts';
 export * from './schema/build.ts';
 export * from './schema/entities.ts';

package/dist/index.js

@@ -1,6 +1,6 @@
+export { anyOf, isGlob, loose, matcher, MAX_PATTERN, PatternError, wildcard, } from '@zenera/neo';
 export * from "./common/locate.js";
 export * from "./common/manifest.js";
-export * from "./common/match.js";
 // A namespace rather than a re-export: both subjects have a `Manifest`, a
 // `writeIndex` and a `search`, and flattening them would collide on every one.
 export * as docs from "./docs/index.js";

package/dist/present.d.ts

@@ -0,0 +1,17 @@
+import { type HydrateOptions } from './schema/hydrate.ts';
+import { type RenderOptions } from './schema/render.ts';
+import type { Schema } from './schema/schema.ts';
+import type { Operation } from './schema/spec.ts';
+import type { Subgraph } from './schema/subgraph.ts';
+export declare const FORMATS: readonly ["text", "mermaid", "mermaid-flowchart", "ts", "openapi"];
+export type Format = (typeof FORMATS)[number];
+export declare function isFormat(value: string): value is Format;
+export interface OutputOptions extends RenderOptions, HydrateOptions {
+}
+/** Two of the four formats need what is on disk; an open index is enough. */
+export interface SchemaSource {
+    schemas(): Promise<Record<string, Schema>>;
+    operations(): Promise<Operation[]>;
+}
+export declare function present(index: SchemaSource, subgraphs: readonly Subgraph[], format: Format, options?: OutputOptions): Promise<string>;
+//# sourceMappingURL=present.d.ts.map

package/dist/present.js

@@ -0,0 +1,40 @@
+import { toOpenApi, toTypeScript } from "./schema/hydrate.js";
+import { render } from "./schema/render.js";
+// ---------------------------------------------------------------------------
+// One subgraph, in whichever of the four shapes was asked for
+//
+// The command, the prompt loop and the agent tool all print through here, so
+// `--format ts` from a shell and `format: "ts"` from a model are the same
+// bytes. Two of the four need the schemas off disk and two do not, which is
+// the only reason this is async.
+// ---------------------------------------------------------------------------
+export const FORMATS = ['text', 'mermaid', 'mermaid-flowchart', 'ts', 'openapi'];
+export function isFormat(value) {
+    return FORMATS.includes(value);
+}
+export async function present(index, subgraphs, format, options = {}) {
+    if (subgraphs.length === 0) {
+        return format === 'openapi' ? '{}' : '';
+    }
+    if (format === 'ts') {
+        const schemas = await index.schemas();
+        return subgraphs.map((s) => toTypeScript(s, schemas, options)).join('\n');
+    }
+    if (format === 'openapi') {
+        const [schemas, operations] = await Promise.all([index.schemas(), index.operations()]);
+        // One document for the whole answer: several would each have to repeat
+        // the components the others also touched.
+        const merged = subgraphs.reduce((all, one) => ({
+            nodes: [...all.nodes, ...one.nodes],
+            edges: [...all.edges, ...one.edges],
+            hits: [...all.hits, ...one.hits],
+            score: all.score + one.score,
+            truncated: all.truncated || one.truncated,
+        }), { nodes: [], edges: [], hits: [], score: 0, truncated: false });
+        return JSON.stringify(toOpenApi(merged, schemas, operations), null, 2);
+    }
+    return subgraphs
+        .map((s, at) => `${subgraphs.length > 1 ? `# result ${at + 1}\n` : ''}${render(s, format, options)}`)
+        .join('\n\n');
+}
+//# sourceMappingURL=present.js.map

package/dist/query.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaQuery } from './schema/search.ts';
+export declare class QueryError extends Error {
+}
+export declare function parseQuery(value: unknown): SchemaQuery;
+/** Whether anything was actually asked, as opposed to only filtered. */
+export declare function isEmpty(query: SchemaQuery): boolean;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -0,0 +1,88 @@
+// ---------------------------------------------------------------------------
+// A query, from somewhere untrusted
+//
+// `--query` and the tool both hand over a whole object, which means the shape
+// has to be checked rather than assumed. The rule is the same either way: a
+// key that is not known is an error, because a silently ignored
+// `output_propertys` looks exactly like a search that found nothing.
+// ---------------------------------------------------------------------------
+const LISTS = [
+    'all',
+    'methods',
+    'types',
+    'input_types',
+    'output_types',
+    'properties',
+    'input_properties',
+    'output_properties',
+    'exclude_ids',
+    'exclude_methods',
+    'exclude_types',
+    'exclude_properties',
+];
+const NUMBERS = ['limit', 'max_hops', 'max_nodes'];
+const DIRECTIONS = ['input', 'output', 'any'];
+const METHOD_TYPES = ['read_only', 'read_write', 'any'];
+const KNOWN = new Set([...LISTS, ...NUMBERS, 'direction', 'method_type']);
+export class QueryError extends Error {
+}
+export function parseQuery(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new QueryError('a query must be an object');
+    }
+    const input = value;
+    for (const key of Object.keys(input)) {
+        if (!KNOWN.has(key)) {
+            throw new QueryError(`unknown query field "${key}" — expected ${[...KNOWN].join(', ')}`);
+        }
+    }
+    const out = {};
+    for (const key of LISTS) {
+        const list = input[key];
+        if (list === undefined) {
+            continue;
+        }
+        if (!Array.isArray(list) || list.some((v) => typeof v !== 'string')) {
+            throw new QueryError(`${key} must be an array of strings`);
+        }
+        out[key] = list;
+    }
+    for (const key of NUMBERS) {
+        const number = input[key];
+        if (number === undefined) {
+            continue;
+        }
+        if (typeof number !== 'number' || !Number.isInteger(number) || number < 1) {
+            throw new QueryError(`${key} must be a whole number of at least 1`);
+        }
+        out[key] = number;
+    }
+    if (input.direction !== undefined) {
+        out.direction = oneOf('direction', input.direction, DIRECTIONS);
+    }
+    if (input.method_type !== undefined) {
+        out.method_type = oneOf('method_type', input.method_type, METHOD_TYPES);
+    }
+    return out;
+}
+/** Whether anything was actually asked, as opposed to only filtered. */
+export function isEmpty(query) {
+    const terms = [
+        query.all,
+        query.methods,
+        query.types,
+        query.input_types,
+        query.output_types,
+        query.properties,
+        query.input_properties,
+        query.output_properties,
+    ];
+    return terms.every((list) => !list || list.length === 0);
+}
+function oneOf(key, value, allowed) {
+    if (typeof value !== 'string' || !allowed.includes(value)) {
+        throw new QueryError(`${key} must be one of ${allowed.join(', ')}`);
+    }
+    return value;
+}
+//# sourceMappingURL=query.js.map

package/dist/repl.d.ts

@@ -0,0 +1,8 @@
+import { type Format, type OutputOptions } from './present.ts';
+import type { SchemaIndex, SchemaQuery } from './schema/search.ts';
+interface Settings extends OutputOptions {
+    format: Format;
+}
+export declare function repl(index: SchemaIndex, initial: SchemaQuery, settings: Settings): Promise<void>;
+export {};
+//# sourceMappingURL=repl.d.ts.map

package/dist/repl.js

@@ -0,0 +1,119 @@
+import { createInterface } from 'node:readline/promises';
+import { bold, cyan, dim, note, write } from '@zenera/cli/lib';
+import { isFormat, present } from "./present.js";
+import { isEmpty, parseQuery, QueryError } from "./query.js";
+const FIELDS = {
+    all: 'all',
+    method: 'methods',
+    type: 'types',
+    'input-type': 'input_types',
+    'output-type': 'output_types',
+    property: 'properties',
+    'input-property': 'input_properties',
+    'output-property': 'output_properties',
+};
+export async function repl(index, initial, settings) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    let query = { ...initial };
+    let format = settings.format;
+    const options = { docs: settings.docs, onlyHits: settings.onlyHits };
+    note(bold(`${index.manifest.sources.map((s) => s.title).join(', ')}`));
+    note(dim('  a bare line searches every kind; `help` lists the rest.'));
+    try {
+        if (!isEmpty(query)) {
+            query = await run(index, query, format, options);
+        }
+        for (;;) {
+            const line = (await rl.question(cyan('rag> '))).trim();
+            if (line === '') {
+                continue;
+            }
+            if (line === 'quit' || line === 'exit') {
+                return;
+            }
+            if (line === 'help') {
+                help();
+                continue;
+            }
+            if (line === 'reset') {
+                query = {};
+                note(dim('  cleared, exclusions and all'));
+                continue;
+            }
+            if (line === 'show') {
+                note(dim(`  ${JSON.stringify(query)}`));
+                continue;
+            }
+            const [head, ...rest] = line.split(' ');
+            const tail = rest.join(' ').trim();
+            if (head === 'format') {
+                if (isFormat(tail)) {
+                    format = tail;
+                    note(dim(`  format is ${tail}`));
+                }
+                else {
+                    note(dim('  expected text, mermaid, mermaid-flowchart, ts or openapi'));
+                }
+                continue;
+            }
+            if (head === 'direction' || head === 'method-type') {
+                query = patch(query, head === 'direction' ? 'direction' : 'method_type', tail);
+                continue;
+            }
+            if (head && head in FIELDS && tail) {
+                query = { ...query, [FIELDS[head]]: [tail] };
+                query = await run(index, query, format, options);
+                continue;
+            }
+            query = await run(index, { ...query, all: [line] }, format, options);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Runs the search, prints it, and hands back the query with everything just
+ * shown added to the exclusions — so asking the same thing twice moves on
+ * instead of repeating itself.
+ */
+async function run(index, query, format, options) {
+    const result = await index.search(query);
+    const text = await present(index, result.subgraphs, format, options);
+    if (text) {
+        write(text);
+    }
+    note(dim(`  ${result.seeds.length} seed(s) · ${result.subgraphs.length} result(s)` +
+        (result.empty.length > 0 ? ` · nothing for: ${result.empty.join(', ')}` : '')));
+    if (result.seeds.length === 0) {
+        return query;
+    }
+    const seen = new Set([...(query.exclude_ids ?? []), ...result.seeds.map((s) => s.id)]);
+    note(dim(`  ${seen.size} node(s) now excluded — \`reset\` to see them again`));
+    return { ...query, exclude_ids: [...seen] };
+}
+function patch(query, key, value) {
+    try {
+        return { ...query, ...parseQuery({ [key]: value }) };
+    }
+    catch (err) {
+        note(dim(`  ${err instanceof QueryError ? err.message : String(err)}`));
+        return query;
+    }
+}
+function help() {
+    for (const line of [
+        '  <text>                  search everything',
+        '  all|method|type <text>  search one field',
+        '  input-property <text>   also: output-property, property, input-type, output-type',
+        '  direction <d>           input | output | any',
+        '  method-type <t>         read_only | read_write | any',
+        '  format <f>              text | mermaid | mermaid-flowchart | ts | openapi',
+        '  show                    the query as it stands',
+        '  reset                   forget it, exclusions included',
+        '  quit',
+    ]) {
+        note(dim(line));
+    }
+}
+//# sourceMappingURL=repl.js.map

package/dist/schema/command.js

@@ -1,10 +1,10 @@
 import { bold, CliError, cyan, dim, EXIT, isInteractive, json, note, parse, paths, table, usageError, write, } from '@zenera/cli/lib';
+import { isGlob, loose, matcher, PatternError, wildcard } from '@zenera/neo';
 import { existsSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
 import { resolveEmbedder } from "../common/embedder.js";
 import { locateIndex, outputDir } from "../common/locate.js";
 import { assertSameEmbedding, inspectIndex } from "../common/manifest.js";
-import { isGlob, loose, matcher, PatternError, wildcard } from "../common/match.js";
 import { breakdown, indexing } from "../common/prose.js";
 import { announce, reportReady, stagingFor, swapIn } from "../common/restore.js";
 import { buildIndex } from "./build.js";

package/dist/schema/locate.d.ts

@@ -0,0 +1,20 @@
+/** The name a new index is given. Nothing searches for it; only `index --out` writes it. */
+export declare const DEFAULT_DIR = "./schema-db";
+export declare const DIR_ENV = "ZEN_SCHEMA_DB";
+/** How the directory was arrived at, which is what decides whether to say so. */
+export type DirSource = 'flag' | 'env' | 'found' | 'default';
+export interface Located {
+    dir: string;
+    from: DirSource;
+}
+export interface LocateOptions {
+    env?: NodeJS.ProcessEnv;
+    /** do not climb above this; the home directory, or the root, by default */
+    ceiling?: string;
+}
+export declare function locateIndex(cwd: string, flag?: string, options?: LocateOptions): Located;
+/** Where a new index goes: the same environment variable, minus the search. */
+export declare function outputDir(cwd: string, flag?: string, env?: NodeJS.ProcessEnv): string;
+/** An index is a directory with a manifest in it; nothing else is asserted here. */
+export declare function isIndex(dir: string): boolean;
+//# sourceMappingURL=locate.d.ts.map

package/dist/schema/locate.js

@@ -0,0 +1,141 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, parse, relative, resolve } from 'node:path';
+import { MANIFEST_FILE } from "./files.js";
+// ---------------------------------------------------------------------------
+// Which index, when nobody said
+//
+// `--dir` and `$ZEN_SCHEMA_DB` are taken as written, missing or not: naming a
+// directory that turns out not to hold an index has to fail saying so, because
+// quietly using a different one would be a worse answer than an error.
+//
+// With neither, the directory is looked for. There is no list of blessed names
+// here and there should not be — an index is self-describing, so what is being
+// looked for is a `manifest.json`, not a directory called `schema-db`.
+// `schema-db` is only the name a *new* index is given, and nothing reads it
+// back. The search is nearest-first: this directory, then what is under it,
+// then up a level and again, so `/assets/…/whatever` is reachable from
+// `/workspace` because the two meet at a shared root on the way up.
+//
+// Three things bound it, and each is bounding a different kind of mistake.
+// Depth and a visit budget bound the cost. The ceiling — the home directory,
+// or the filesystem root when the search began outside it — bounds the
+// blast radius, because an index in someone else's tree is not yours. And two
+// indexes at the same distance is an ambiguity rather than a tie to break:
+// choosing one silently is the one failure worth ruling out entirely, since
+// the wrong index does not error, it answers confidently about another API.
+// ---------------------------------------------------------------------------
+/** The name a new index is given. Nothing searches for it; only `index --out` writes it. */
+export const DEFAULT_DIR = './schema-db';
+export const DIR_ENV = 'ZEN_SCHEMA_DB';
+/** Far enough to climb out of a package into its workspace, not far enough to roam. */
+const MAX_LEVELS = 6;
+/** How far below a directory an index may sit and still count as being in it. */
+const MAX_DEPTH = 3;
+/** A directory with more entries than this is a data store, not a place to keep an index. */
+const MAX_ENTRIES = 128;
+/** Directories the whole search may read, however it is shaped. */
+const MAX_VISITS = 400;
+export function locateIndex(cwd, flag, options = {}) {
+    const env = options.env ?? process.env;
+    if (flag) {
+        return { dir: resolve(cwd, flag), from: 'flag' };
+    }
+    const named = env[DIR_ENV]?.trim();
+    if (named) {
+        return { dir: resolve(cwd, named), from: 'env' };
+    }
+    const found = search(resolve(cwd), options.ceiling ?? ceilingFor(cwd));
+    // Nothing found still answers with the default, so the error names the
+    // directory everyone expects rather than the last place that was searched.
+    return found
+        ? { dir: found, from: 'found' }
+        : { dir: resolve(cwd, DEFAULT_DIR), from: 'default' };
+}
+/** Where a new index goes: the same environment variable, minus the search. */
+export function outputDir(cwd, flag, env = process.env) {
+    return resolve(cwd, flag ?? env[DIR_ENV]?.trim() ?? DEFAULT_DIR);
+}
+/** An index is a directory with a manifest in it; nothing else is asserted here. */
+export function isIndex(dir) {
+    try {
+        return statSync(join(dir, MANIFEST_FILE)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function search(cwd, ceiling) {
+    const budget = { left: MAX_VISITS, seen: new Set() };
+    let dir = cwd;
+    for (let level = 0; level < MAX_LEVELS; level++) {
+        const found = nearest(dir, budget);
+        if (found.length === 1) {
+            return found[0];
+        }
+        if (found.length > 1) {
+            throw new CliError(`more than one index is equally close to here: ${found.join(', ')}`, EXIT.usage, `say which with --dir, or set ${DIR_ENV}`);
+        }
+        budget.seen.add(dir);
+        const up = dirname(dir);
+        if (up === dir || dir === ceiling) {
+            break;
+        }
+        dir = up;
+    }
+    return undefined;
+}
+/** Every index at the shallowest depth that has any, so a tie can be reported as one. */
+function nearest(root, budget) {
+    let frontier = [root];
+    for (let depth = 0; depth <= MAX_DEPTH && frontier.length > 0; depth++) {
+        const found = frontier.filter(isIndex);
+        if (found.length > 0) {
+            return found;
+        }
+        const next = [];
+        for (const dir of frontier) {
+            if (budget.left <= 0) {
+                return [];
+            }
+            budget.left--;
+            next.push(...children(dir).filter((child) => !budget.seen.has(child)));
+        }
+        frontier = next;
+    }
+    return [];
+}
+/**
+ * The subdirectories of one directory. Hidden directories and `node_modules`
+ * are skipped: an index kept out of sight is not one anybody meant to be found
+ * by looking.
+ */
+function children(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    if (entries.length > MAX_ENTRIES) {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .map((e) => join(dir, e.name));
+}
+/**
+ * Home is the ceiling for anyone working inside it. Starting outside it —
+ * a container whose workspace is `/workspace`, a CI checkout — there is no
+ * home to stay within, so the root is the only stop.
+ */
+function ceilingFor(cwd) {
+    const home = homedir();
+    const below = relative(home, resolve(cwd));
+    return below === '' || (!below.startsWith('..') && !isAbsolute(below))
+        ? home
+        : parse(resolve(cwd)).root;
+}
+//# sourceMappingURL=locate.js.map

package/dist/schema/lookup.d.ts

@@ -1,4 +1,4 @@
-import { type Matcher } from '../common/match.ts';
+import { type Matcher } from '@zenera/neo';
 import { type ApiGraph, type NodeAttrs, type NodeKind } from './graph.ts';
 export interface Row extends NodeAttrs {
     id: string;

package/dist/schema/lookup.js

@@ -1,4 +1,4 @@
-import { PatternError } from "../common/match.js";
+import { PatternError } from '@zenera/neo';
 import { textOf } from "./entities.js";
 import { methodId } from "./graph.js";
 /** A scan is bounded, because a pattern may have come from a model. */

package/dist/schema/match.d.ts

@@ -0,0 +1,40 @@
+/** Long enough for any honest pattern, short enough to bound a bad one. */
+export declare const MAX_PATTERN = 200;
+export declare class PatternError extends Error {
+}
+export interface MatchOptions {
+    /** read the pattern as a regular expression rather than as a literal */
+    regex?: boolean;
+    caseSensitive?: boolean;
+}
+export type Matcher = (text: string) => boolean;
+/**
+ * A predicate over a string. Literal by default: someone typing `user.id` means
+ * those seven characters, and a dot that quietly matched anything would be a
+ * worse answer than no answer.
+ */
+export declare function matcher(pattern: string, options?: MatchOptions): Matcher;
+/**
+ * A glob, matched against the whole string. Globs rather than regexes because
+ * these are for naming things — a path, a schema — and a star is what everyone
+ * reaches for first.
+ */
+export declare function wildcard(pattern: string, options?: {
+    caseSensitive?: boolean;
+}): Matcher;
+/** Whether a pattern is asking to be read as a glob at all. */
+export declare const isGlob: (pattern: string) => boolean;
+/**
+ * What someone means when they type a name into a filter. With a star in it,
+ * a glob; without one, a substring — because `password` typed into `--name` is
+ * a search for the word, and a whole-string match would answer nothing and
+ * look like the field does not exist.
+ *
+ * `regex` settles it outright, and has to: a star is punctuation in both
+ * languages, so `^/(users|teams)/.*` read as a glob would match nothing and
+ * never say why.
+ */
+export declare function loose(pattern: string, options?: MatchOptions): Matcher;
+/** True when any of the patterns matches; no patterns means no opinion. */
+export declare function anyOf(matchers: readonly Matcher[]): Matcher | undefined;
+//# sourceMappingURL=match.d.ts.map