@zenera/cli 1.1.27 → 1.1.29

package/dist/catalog.js

@@ -16,7 +16,7 @@
 // `source` for exactly that reason: a curated guess must never be mistaken for
 // the vendor's own word.
 // ---------------------------------------------------------------------------
-import { ModelRegistry, vertexEndpoint } from '@zenera/neo';
+import { GATEWAY_KEY_HEADER, GATEWAY_NAME, GATEWAY_UPSTREAMS, gatewayOf, ModelRegistry, vertexEndpoint, } from '@zenera/neo';
 import { Cache, cacheKey } from "./cache.js";
 import { PROVIDERS } from "./keys.js";
 import { classify } from "./liveness.js";
@@ -72,11 +72,8 @@ export const CURATED = {
     ],
 };
 /**
- * The order `zen models pick` walks, per provider and per role.
- *
- * Cheap and fast first. `pick` exists to answer "give me something that works"
- * in one round trip where it can, and the small models answer soonest and cost
- * least when the answer is thrown away — which it always is.
+ * The cheap, fast models per provider and role, best first. `zen init` takes
+ * its default embedder from here.
  */
 export const PREFERRED = {
     openai: {
@@ -369,6 +366,65 @@ export async function fetchCatalog(provider, client = new ModelRegistry().client
             return enrich(provider, await fromRouter(client, provider));
     }
 }
+const UPSTREAM_OF = new Map(PROVIDERS.map((p) => [GATEWAY_UPSTREAMS[p], p]));
+/** One request per gateway per process, however many providers ask. */
+const listings = new Map();
+function gatewayListing(at) {
+    const key = `${at.baseURL}\0${at.apiKey ?? ''}`;
+    let listing = listings.get(key);
+    if (!listing) {
+        listing = fetchGatewayListing(at);
+        listings.set(key, listing);
+        listing.catch(() => listings.delete(key));
+    }
+    return listing;
+}
+async function fetchGatewayListing(at) {
+    const res = await fetch(`${at.baseURL}/v1/models`, {
+        headers: at.apiKey
+            ? { authorization: `Bearer ${at.apiKey}`, [GATEWAY_KEY_HEADER]: at.apiKey }
+            : {},
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw Object.assign(new Error(`${GATEWAY_NAME} answered ${res.status}: ${body}`), {
+            status: res.status,
+        });
+    }
+    const { data } = (await res.json());
+    const by = new Map();
+    for (const model of data ?? []) {
+        if (typeof model.id !== 'string') {
+            continue;
+        }
+        const slash = model.id.indexOf('/');
+        const provider = slash > 0 ? UPSTREAM_OF.get(model.id.slice(0, slash)) : undefined;
+        const id = model.id.slice(slash + 1);
+        const role = openaiRole(id);
+        if (!provider || !id || !role) {
+            continue;
+        }
+        const rows = by.get(provider) ?? [];
+        rows.push(entry(provider, {
+            id,
+            roles: [role],
+            name: typeof model.name === 'string' ? model.name : undefined,
+            contextLength: typeof model.context_length === 'number' ? model.context_length : undefined,
+            created: iso(typeof model.created === 'number' ? model.created : undefined),
+            publisher: provider === 'vertex' ? publisherOf(id) : undefined,
+        }));
+        by.set(provider, rows);
+    }
+    return by;
+}
+function publisherOf(id) {
+    return /^claude-/.test(id) ? 'anthropic' : id.includes('/') ? id.split('/')[0] : 'google';
+}
+/** What the gateway serves under one provider's name, enriched like a vendor listing. */
+export async function fetchGatewayCatalog(provider, at) {
+    return enrich(provider, (await gatewayListing(at)).get(provider) ?? []);
+}
 // ---------------------------------------------------------------------------
 // Enrichment and cache
 // ---------------------------------------------------------------------------
@@ -407,6 +463,10 @@ const store = () => new Cache(CATALOG_KIND, { mode: 0o644 });
  * to both. A project left to the service-account file is not seen here.
  */
 function scope(provider) {
+    const at = gatewayOf();
+    if (at) {
+        return cacheKey(GATEWAY_NAME, at.baseURL);
+    }
     if (provider !== 'vertex') {
         return undefined;
     }
@@ -433,19 +493,31 @@ function readCache(provider) {
  * model list to four rows.
  */
 export async function loadCatalog(provider, opts = {}) {
+    const at = gatewayOf();
+    const via = at ? { via: { name: GATEWAY_NAME, url: at.baseURL } } : {};
+    // The built-in list names vendor models the gateway may not serve at all.
+    const fallback = () => (at ? [] : curated(provider));
     const cached = readCache(provider);
     const fresh = cached && Date.now() - new Date(cached.fetchedAt).getTime() < CATALOG_TTL_MS
         ? cached
         : undefined;
     if (fresh && !opts.refresh) {
-        return { provider, entries: fresh.entries, origin: 'cache', fetchedAt: fresh.fetchedAt };
+        return {
+            provider,
+            entries: fresh.entries,
+            origin: 'cache',
+            fetchedAt: fresh.fetchedAt,
+            ...via,
+        };
     }
     if (!opts.offline) {
         try {
-            const entries = await fetchCatalog(provider);
+            const entries = at
+                ? await fetchGatewayCatalog(provider, at)
+                : await fetchCatalog(provider);
             const fetchedAt = new Date().toISOString();
             store().put(catalogKey(provider), { provider, fetchedAt, entries });
-            return { provider, entries, origin: 'live', fetchedAt };
+            return { provider, entries, origin: 'live', fetchedAt, ...via };
         }
         catch (err) {
             const problem = classify(err);
@@ -456,25 +528,34 @@ export async function loadCatalog(provider, opts = {}) {
                     origin: 'stale',
                     fetchedAt: cached.fetchedAt,
                     problem,
+                    ...via,
                 };
             }
             return {
                 provider,
-                entries: curated(provider),
+                entries: fallback(),
                 origin: 'curated',
                 fetchedAt: new Date(0).toISOString(),
                 problem,
+                ...via,
             };
         }
     }
     if (cached) {
-        return { provider, entries: cached.entries, origin: 'stale', fetchedAt: cached.fetchedAt };
+        return {
+            provider,
+            entries: cached.entries,
+            origin: 'stale',
+            fetchedAt: cached.fetchedAt,
+            ...via,
+        };
     }
     return {
         provider,
-        entries: curated(provider),
+        entries: fallback(),
         origin: 'curated',
         fetchedAt: new Date(0).toISOString(),
+        ...via,
     };
 }
 // ---------------------------------------------------------------------------

package/dist/commands/completion.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../command.ts';
+export { install, installed, loader, rcFile } from '../completion-install.ts';
+/**
+ * Prints the shell's side of tab completion. The script is a few lines that
+ * call back into `zen __complete`, so the project names and stored prompts it
+ * offers are always read from the machine it runs on, never baked in.
+ */
+export declare const completion: Command;
+//# sourceMappingURL=completion.d.ts.map

package/dist/commands/completion.js

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { one, parse } from "../args.js";
+import { install, installed, loader, rcFiles, shellOf } from "../completion-install.js";
+import { TEMPLATES } from "../scaffold.js";
+import { bold, confirm, usageError, write } from "../term.js";
+export { install, installed, loader, rcFile } from "../completion-install.js";
+const USAGE = 'zen completion [<zsh|bash|fish>] [--install [--yes]]';
+/**
+ * Prints the shell's side of tab completion. The script is a few lines that
+ * call back into `zen __complete`, so the project names and stored prompts it
+ * offers are always read from the machine it runs on, never baked in.
+ */
+export const completion = {
+    summary: 'Print the tab-completion script for your shell.',
+    usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Completion', subtitle: 'Shell Integration', hue: 'magenta' },
+    quiet: () => true,
+    details: [
+        'Global npm installs set this up automatically. Open a new shell afterward.',
+        '',
+        'Add one line to your shell’s startup file:',
+        '  zsh    eval "$(zen completion zsh)"      in ~/.zshrc',
+        '  bash   eval "$(zen completion bash)"     in ~/.bashrc',
+        '  fish   zen completion fish | source      in ~/.config/fish/config.fish',
+        '',
+        'Or let zen do it — it appends that line to the file, once, after asking:',
+        '  zen completion --install                 for the shell you are in',
+        '  zen completion zsh --install --yes       without asking',
+        '',
+        'Then, in a new shell:',
+        '  zen meta run my-project /<Tab>           the project’s stored prompts',
+        '  zen meta <Tab>                           run, prompts, resume, model …',
+        '  zen run <Tab>                            your projects',
+        '',
+        'The prompts are the files in .github/prompts/ — the same ones an editor',
+        'offers as slash commands. Where there is nothing to offer, file names are.',
+    ],
+    run: async (ctx) => {
+        const { values, positionals } = parse(ctx.args, { install: { type: 'boolean' }, yes: { type: 'boolean' } }, USAGE);
+        const name = one(positionals, 'shell', USAGE) ?? basename(process.env.SHELL ?? '');
+        const shell = shellOf(name);
+        if (!shell) {
+            throw usageError(name ? `no completion for "${name}"` : 'which shell?', 'try: zen completion zsh|bash|fish');
+        }
+        if (values.yes && !values.install) {
+            throw usageError('--yes only goes with --install', USAGE);
+        }
+        if (values.install) {
+            const files = rcFiles(shell).filter((file) => !installed(shell, file));
+            if (files.length === 0) {
+                write(`Already set up in ${rcFiles(shell).join(', ')}.`);
+                return;
+            }
+            const line = bold(loader(shell));
+            if (!values.yes && !(await confirm(`Add ${line} to ${files.join(', ')}?`, true))) {
+                write('Nothing changed.');
+                return;
+            }
+            for (const file of files) {
+                install(shell, file);
+                write(`Added to ${file}.`);
+            }
+            write('Open a new shell to use tab completion.');
+            return;
+        }
+        process.stdout.write(readFileSync(`${TEMPLATES}/completions/zen.${shell}`, 'utf8'));
+    },
+};
+//# sourceMappingURL=completion.js.map

package/dist/commands/index.js

@@ -1,5 +1,6 @@
 import { cache } from "./cache.js";
 import { check } from "./check.js";
+import { completion } from "./completion.js";
 import { pack } from "./export.js";
 import { unpack } from "./import.js";
 import { init } from "./init.js";
@@ -39,6 +40,7 @@ export const COMMANDS = {
     memory,
     sandbox,
     cache,
+    completion,
     version,
 };
 /** Names that are not listed in help but still work. */

package/dist/commands/init.js

@@ -47,7 +47,7 @@ const DEFAULT_MODEL = {
 /**
  * What vectorises the project's memory, given the provider it ends up on.
  *
- * Taken from the same table `zen models pick` ranks by rather than written out
+ * Taken from the catalogue's `PREFERRED` table rather than written out
  * again here, so the scaffold cannot drift from what the catalogue calls
  * current. Anthropic publishes no embeddings API, and a `--model` naming a
  * provider we do not ship gives nothing to guess from; both scaffold without

package/dist/commands/key.js

@@ -1,10 +1,11 @@
+import { GATEWAY_URL_ENV } from '@zenera/neo';
 import { existsSync } from 'node:fs';
 import { parse } from "../args.js";
 import { ensureHome } from "../home.js";
-import { ambient, ambientId, assertNotEmpty, checkRegion, describe, envNames, envOf, formOf, keyId, KeyStore, mask, OWNERS, parseRef, SHAPES, } from "../keys.js";
+import { ambient, ambientId, assertNotEmpty, checkRegion, describe, envNames, envOf, formOf, GATEWAYS, isGateway, keyId, KeyStore, mask, MODES, OWNERS, parseRef, SHAPES, } from "../keys.js";
 import { probe, probeAll } from "../liveness.js";
-import { ago, ask, askSecret, bold, confirm, credentialError, cyan, dim, green, isInteractive, json, note, progress, readStdin, red, table, usageError, write, writeAll, yellow, } from "../term.js";
-const USAGE = 'zen key <ls|add|use|check|rm|show|env> [ref] [options]';
+import { ago, ask, askSecret, badge, bold, confirm, credentialError, cyan, dim, green, isInteractive, json, note, progress, readStdin, red, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen key <ls|add|use|mode|check|rm|show|env> [ref] [options]';
 // ---------------------------------------------------------------------------
 // Display
 // ---------------------------------------------------------------------------
@@ -32,6 +33,9 @@ const ORIGIN = {
  * the environment supplied either, because then the stored one is not in play.
  */
 function placed(store, entry) {
+    if (entry.url) {
+        return dim(entry.url);
+    }
     if (entry.provider !== 'vertex' || entry.holds !== 'file') {
         return '';
     }
@@ -61,14 +65,28 @@ function asEntry(cred) {
 }
 function rows(store, borrowed) {
     const out = [
-        [bold(''), bold('KEY'), bold('VALUE'), bold('GCP'), bold('STATE'), bold('CHECKED')],
+        [bold(''), bold('KEY'), bold('VALUE'), bold('WHERE'), bold('STATE'), bold('CHECKED')],
     ];
     for (const provider of OWNERS) {
+        // Held but not in play under the current mode: drawn grey, so the live set stands out.
+        const idle = unused(store, provider);
         for (const entry of store.for(provider)) {
             const shadow = envNames(provider).find((name) => process.env[name]);
+            if (idle) {
+                out.push([
+                    dim('-'),
+                    dim(keyId(entry)),
+                    dim(describe(store, entry)),
+                    dim(entry.url ?? ''),
+                    dim(entry.check?.state ?? 'unchecked'),
+                    dim(`not used in ${store.mode} mode`),
+                ]);
+                continue;
+            }
+            const gateway = isGateway(provider);
             out.push([
                 store.isActive(entry) ? green('*') : ' ',
-                keyId(entry),
+                gateway && store.isActive(entry) ? bold(cyan(keyId(entry))) : keyId(entry),
                 dim(describe(store, entry)),
                 placed(store, entry),
                 state(entry),
@@ -78,17 +96,47 @@ function rows(store, borrowed) {
         }
         for (const [cred, entry] of borrowed.filter(([c]) => c.provider === provider)) {
             out.push([
-                dim('~'),
+                dim(idle ? '-' : '~'),
                 dim(ambientId(cred)),
                 dim(describe(store, entry)),
-                placed(store, entry),
-                state(entry),
-                dim(cred.env ? 'from the environment' : 'from gcloud'),
+                idle ? '' : placed(store, entry),
+                idle ? dim(entry.check?.state ?? 'unchecked') : state(entry),
+                dim(idle
+                    ? `not used in ${store.mode} mode`
+                    : cred.env
+                        ? 'from the environment'
+                        : 'from gcloud'),
             ]);
         }
     }
     return table(out);
 }
+/** A vendor key under a gateway mode, or a gateway key under any other. */
+function unused(store, provider) {
+    if (isGateway(provider)) {
+        return store.mode !== provider;
+    }
+    return SHAPES[provider].kind === 'model' && store.mode !== 'direct';
+}
+/**
+ * Above the table, because it decides which half of the table matters. Said
+ * only once a gateway key exists: before that there is no choice to report.
+ */
+function modeLine(store) {
+    const mode = store.mode;
+    if (mode === 'direct') {
+        if (GATEWAYS.some((g) => store.active(g))) {
+            note(`${bold('mode')} ${cyan('direct')} ${dim('— each provider with its own key; zen key mode bifrost to send every model through the gateway')}`);
+            note('');
+        }
+        return;
+    }
+    const gateway = store.active(mode);
+    note(`${cyan(badge(`⇄ ${mode.toUpperCase()} MODE`))} ${bold(gateway?.url ?? 'no url stored')}`);
+    note(dim(`every model goes through the gateway with ${gateway ? keyId(gateway) : 'no key'}; ` +
+        'vendor keys are not used — zen key mode direct to stop'));
+    note('');
+}
 /**
  * Checking is a network round trip per key, so it says which ones have come
  * back. Silence for ten seconds is indistinguishable from a hang.
@@ -123,6 +171,7 @@ const ls = async (ctx, args) => {
     }
     if (ctx.json) {
         json({
+            mode: store.mode,
             keys: store.entries.map((e) => ({
                 ...e,
                 value: e.holds === 'file' ? store.fileOf(e) : mask(e.value),
@@ -145,8 +194,12 @@ const ls = async (ctx, args) => {
         note(dim('add one: zen key add openai'));
         return;
     }
+    modeLine(store);
     writeAll(rows(store, borrowed));
-    const missing = OWNERS.filter((p) => !store.active(p) && !borrowed.some(([c]) => c.provider === p));
+    const missing = OWNERS.filter((p) => !store.active(p) &&
+        !borrowed.some(([c]) => c.provider === p) &&
+        (!isGateway(p) || store.mode === p) &&
+        (store.mode === 'direct' || SHAPES[p].kind !== 'model'));
     if (missing.length) {
         note('');
         note(dim(`no key for: ${missing.join(', ')}`));
@@ -164,8 +217,9 @@ const add = async (ctx, args) => {
         // Prefixed because every other command's --project is a Zenera one.
         'gcp-project': { type: 'string' },
         'gcp-location': { type: 'string' },
+        url: { type: 'string' },
     }, 'zen key add <provider>[/name] [--name <name>] [--gcp-project <id>] ' +
-        '[--gcp-location <region>] [--no-check]');
+        '[--gcp-location <region>] [--url <gateway url>] [--no-check]');
     const ref = positionals[0];
     if (!ref) {
         throw usageError('which provider?', `one of: ${OWNERS.join(', ')}`);
@@ -177,6 +231,7 @@ const add = async (ctx, args) => {
     if ((values['gcp-project'] || values['gcp-location']) && provider !== 'vertex') {
         throw usageError(`--gcp-project and --gcp-location mean nothing to ${shape.label}`, 'they configure a Vertex service account');
     }
+    const url = gatewayUrl(provider, values.url);
     // Checked before the prompt, so a typo does not cost you pasting the key.
     const region = values['gcp-location'];
     if (region !== undefined && !checkRegion(region)) {
@@ -208,6 +263,7 @@ const add = async (ctx, args) => {
     const entry = store.add(provider, name, raw, {
         project: values['gcp-project'],
         location: values['gcp-location'],
+        url,
     });
     // Verified before it is trusted, but stored either way: a key that cannot
     // be checked right now — offline, behind a proxy — is not a key that is
@@ -249,6 +305,9 @@ const add = async (ctx, args) => {
     if (process.env[envOf(entry)]) {
         note(yellow(`$${envOf(entry)} is set and will win over this`));
     }
+    if (isGateway(provider) && store.mode !== provider) {
+        note(dim(`not in use yet — send every model through it with: zen key mode ${provider}`));
+    }
     if (provider === 'vertex' && entry.holds === 'file' && !entry.project) {
         const found = store.projectOf(entry);
         note(dim(found
@@ -256,6 +315,36 @@ const add = async (ctx, args) => {
             : 'no --gcp-project given, and the key file names no project_id'));
     }
 };
+/**
+ * A gateway is nothing without its address, and nothing else has one. Only
+ * http(s) is taken: the url ends up as an SDK base url, where anything else
+ * fails three frames down.
+ */
+function gatewayUrl(provider, raw) {
+    if (!isGateway(provider)) {
+        if (raw !== undefined) {
+            throw usageError(`--url means nothing to ${SHAPES[provider].label}`, 'it locates a gateway');
+        }
+        return undefined;
+    }
+    if (!raw) {
+        throw usageError(`${SHAPES[provider].label} needs --url`, `e.g. zen key add ${provider} --url https://bifrost.example.com`);
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw usageError(`"${raw}" is not a url`);
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw usageError(`"${raw}" is not an http(s) url`);
+    }
+    if (url.protocol === 'http:' && !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)) {
+        note(yellow('plain http: the virtual key will cross the network unencrypted'));
+    }
+    return url.href.replace(/\/+$/, '');
+}
 /**
  * A provider with two forms cannot ask for one of them. It asks with the echo
  * off, because one of the two answers is a secret and there is no way to know
@@ -294,6 +383,31 @@ const use = async (ctx, args) => {
     }
     note(`${green('using')} ${bold(keyId(entry))} for ${SHAPES[provider].label}`);
 };
+/** Bare, it says which mode a run would use; with a word, it switches. */
+const mode = async (ctx, args) => {
+    const { positionals } = parse(args, {}, `zen key mode [${MODES.join('|')}]`);
+    const wanted = positionals[0];
+    const store = await KeyStore.open();
+    if (wanted !== undefined) {
+        if (!MODES.includes(wanted)) {
+            throw usageError(`unknown mode "${wanted}"`, `one of: ${MODES.join(', ')}`);
+        }
+        store.setMode(wanted);
+        store.save();
+    }
+    const now = store.mode;
+    const gateway = now === 'direct' ? undefined : store.active(now);
+    if (ctx.json) {
+        json({ mode: now, ...(gateway ? { key: keyId(gateway), url: gateway.url } : {}) });
+        return;
+    }
+    if (!gateway) {
+        note(`${cyan('direct')} ${dim('— each provider is called with its own key')}`);
+        return;
+    }
+    note(`${cyan(now)} ${dim('— every model goes through')} ${gateway.url} ` +
+        dim(`with ${keyId(gateway)}`));
+};
 const check = async (ctx, args) => {
     const { positionals } = parse(args, {}, 'zen key check [provider[/name]]');
     const store = await KeyStore.open();
@@ -404,6 +518,7 @@ const show = async (ctx, args) => {
             ? [[dim('gcp project'), `${project.id} ${dim(ORIGIN[project.from])}`]]
             : []),
         ...(entry.location ? [[dim('gcp location'), entry.location]] : []),
+        ...(entry.url ? [[dim('url'), entry.url]] : []),
         [dim('state'), state(entry)],
         ...(entry.check?.fix ? [[dim('fix'), entry.check.fix]] : []),
         [dim('added'), ago(entry.addedAt)],
@@ -424,11 +539,18 @@ const env = async (ctx, args) => {
     // Ignore what is already exported: the point is to produce the exports.
     const vars = {};
     for (const provider of only ?? OWNERS) {
+        // Unasked-for, a gateway is exported only in its own mode, where it is the switch.
+        if (!only && isGateway(provider) && store.mode !== provider) {
+            continue;
+        }
         const entry = store.active(provider);
         if (!entry) {
             continue;
         }
         vars[envOf(entry)] = store.reveal(entry);
+        if (entry.url) {
+            vars[GATEWAY_URL_ENV] = entry.url;
+        }
         // A service account says which project it belongs to but not which
         // region to call, and a shell that has the file and not the region is
         // still a shell that cannot reach a model.
@@ -498,6 +620,7 @@ const SUBS = {
     list: ls,
     add,
     use,
+    mode,
     check,
     rm,
     remove: rm,
@@ -516,14 +639,22 @@ export const key = {
         '',
         'Model providers: openai, anthropic, google, vertex, openrouter.',
         'Services the tools call: exa.',
+        `Gateways every model can go through: ${GATEWAYS.join(', ')}.`,
         '',
         'Vertex takes either shape: a service-account JSON file, which wants',
         '--gcp-project and --gcp-location too, or an express-mode API key, which',
         'wants neither. Which one you gave is read off the value.',
         '',
+        'A gateway holds one virtual key and its --url. In its mode every model',
+        'goes through it, each in its own vendor protocol, and agents.yaml does',
+        'not change: vertex:gemini-3.5-flash reaches <url>/genai as',
+        'vertex/gemini-3.5-flash. Vendor keys are withheld from runs meanwhile.',
+        '',
         '  zen key ls [--check]              Everything stored, and its state.',
         '  zen key add <provider>[/name]     Read a key from stdin, or ask for it.',
+        '  zen key add bifrost --url <url>   A gateway key, and where the gateway is.',
         '  zen key use <provider>/<name>     Choose which one a run uses.',
+        '  zen key mode [direct|bifrost]     Call vendors directly, or via the gateway.',
         '  zen key check [provider[/name]]   Ask the provider whether it still works.',
         '  zen key rm <provider>/<name>      Forget one.',
         '  zen key show <ref> [--reveal]     Masked by default.',

package/dist/commands/meta.d.ts

@@ -1,3 +1,6 @@
+import { type Candidate } from '../candidates.ts';
 import type { Command } from '../command.ts';
 export declare const meta: Command;
+/** `args` is what came after `meta`, without the word being completed. */
+export declare function completeMeta(args: readonly string[], cur: string, cwd: string): Promise<Candidate[]>;
 //# sourceMappingURL=meta.d.ts.map