@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/host.js

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// The meta layer's one door into the rest of the CLI
+//
+// Everything under `src/meta/` imports the runtime through this file and no
+// other, so the layer can leave for a package of its own by turning this into
+// a dependency. `test/meta-boundary.test.ts` holds the line.
+// ---------------------------------------------------------------------------
+export { invokedAs, parse } from "../args.js";
+export { paths, readJson, writeJson } from "../home.js";
+export { envOf } from "../keys.js";
+export { PROVIDER_NAMES, splitRef } from "../modelref.js";
+export { duration } from "../narrate.js";
+export { copyTree, SHARED_RULES, TEMPLATES } from "../scaffold.js";
+export { bold, CliError, confirm, credentialError, cut, cyan, dim, EXIT, green, invalidError, json, note, pad, plain, red, styled, table, usageError, write, writeAll, yellow, } from "../term.js";
+export { safe } from "../trace.js";
+export { formatInline, formatMarkdown } from "../tui/markdown.js";
+export { resolveTheme } from "../tui/theme.js";
+export { boxWidth } from "../tui/wrap.js";
+export { META_PROMPT_ENV, META_SESSION_ENV } from "../usage.js";
+export { validateProject } from "../validate.js";
+//# sourceMappingURL=host.js.map

package/dist/meta/index.d.ts

@@ -0,0 +1,11 @@
+export * from './editor.ts';
+export * from './finetune/dataset/index.ts';
+export * from './finetune/index.ts';
+export * from './launch.ts';
+export * from './model.ts';
+export * from './prompts.ts';
+export * from './relay.ts';
+export * from './tokens.ts';
+export * from './window.ts';
+export * from './wire.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/meta/index.js

@@ -0,0 +1,11 @@
+export * from "./editor.js";
+export * from "./finetune/dataset/index.js";
+export * from "./finetune/index.js";
+export * from "./launch.js";
+export * from "./model.js";
+export * from "./prompts.js";
+export * from "./relay.js";
+export * from "./tokens.js";
+export * from "./window.js";
+export * from "./wire.js";
+//# sourceMappingURL=index.js.map

package/dist/meta/launch.d.ts

@@ -0,0 +1,81 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { type Sink } from './window.ts';
+export interface Binary {
+    command: string;
+    args: string[];
+    from: 'path' | 'npx';
+}
+/**
+ * A `copilot` already installed is used as it is; otherwise `npx` fetches one.
+ * Note that finding the name on `PATH` is not the same as finding the CLI —
+ * an editor may have put a shim there that installs it on first run — so this
+ * only decides how to launch, never whether it will work.
+ */
+export declare function locate(has?: (cmd: string) => boolean): Binary;
+interface Event {
+    type: string;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface Outcome {
+    /** the last thing the agent said that was not a preamble to a tool call */
+    answer: string;
+    exitCode: number;
+    sessionId?: string;
+    usage?: Record<string, unknown>;
+    events: Event[];
+}
+export interface Log {
+    readonly path: string;
+    /** Where the answer alone goes, beside the log and openable on its own. */
+    readonly answerPath: string;
+    line(text: string): void;
+    saveAnswer(text: string): void;
+    close(): void;
+}
+/**
+ * `<project>/.tmp/logs/meta.<when>[-<session>].log`, opened for append. The
+ * session keeps runs started in the same second - a tuning loop's - apart.
+ */
+export declare function openLog(dir: string, now?: Date, session?: string): Log;
+export declare function recordSession(dir: string, id: string): void;
+export declare function lastSession(dir: string): string | undefined;
+/**
+ * Folds one event into the outcome and says what, if anything, to show for it.
+ *
+ * `assistant.message` carries both the running commentary and the final word;
+ * what separates them is `toolRequests`, so the last message that asked for no
+ * tool is the answer and the rest are narration.
+ */
+export declare function absorb(event: Event, out: Outcome, sink: Sink, width: number): void;
+export interface Launch {
+    binary: Binary;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+    sink?: Sink;
+    log?: Log;
+    width?: number;
+    /** said after the elapsed time on the status row, e.g. the tokens so far */
+    status?: () => string;
+    /** every event copilot prints, before it is folded */
+    onEvent?: (event: Event) => void;
+    /** injected by the tests, which have no copilot and want none */
+    spawn?: typeof nodeSpawn;
+}
+export declare function launch(opts: Launch): Promise<Outcome>;
+/** Resumes after copilot's own retries run out; `--retries` overrides. */
+export declare const DEFAULT_RESUMES = 5;
+/** What the resumed session is told, since `-p` has to say something. */
+export declare const RESUME_PROMPT = "The previous model call failed. Continue the task from where you stopped.";
+export declare function resumeDelayMs(attempt: number): number;
+/**
+ * Why the run is worth resuming, or undefined when waiting cannot help.
+ *
+ * Only a refusal that time can cure counts: a rate limit, the provider's own
+ * failure, a connection that timed out. A 400 or a bad key fails the same way
+ * however often it is sent - except the one below.
+ */
+export declare function transient(out: Outcome): string | undefined;
+export {};
+//# sourceMappingURL=launch.d.ts.map

package/dist/meta/launch.js

@@ -0,0 +1,286 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { cut, dim, duration, formatInline, plain } from "./host.js";
+import { FRAME_MS, windowSink } from "./window.js";
+/**
+ * A `copilot` already installed is used as it is; otherwise `npx` fetches one.
+ * Note that finding the name on `PATH` is not the same as finding the CLI —
+ * an editor may have put a shim there that installs it on first run — so this
+ * only decides how to launch, never whether it will work.
+ */
+export function locate(has = (cmd) => onPath(cmd)) {
+    return has('copilot')
+        ? { command: 'copilot', args: [], from: 'path' }
+        : { command: 'npx', args: ['--yes', '@github/copilot'], from: 'npx' };
+}
+function onPath(cmd) {
+    const dirs = (process.env.PATH ?? '').split(':').filter(Boolean);
+    return dirs.some((d) => existsSync(`${d}/${cmd}`));
+}
+/**
+ * `<project>/.tmp/logs/meta.<when>[-<session>].log`, opened for append. The
+ * session keeps runs started in the same second - a tuning loop's - apart.
+ */
+export function openLog(dir, now = new Date(), session) {
+    const two = (n) => String(n).padStart(2, '0');
+    const stamp = `${now.getFullYear()}${two(now.getMonth() + 1)}${two(now.getDate())}` +
+        `${two(now.getHours())}${two(now.getMinutes())}${two(now.getSeconds())}` +
+        (session ? `-${session.slice(0, 8)}` : '');
+    const folder = `${dir}/.tmp/logs`;
+    mkdirSync(folder, { recursive: true });
+    const path = `${folder}/meta.${stamp}.log`;
+    const answerPath = `${folder}/meta.${stamp}.md`;
+    const file = createWriteStream(path, { flags: 'a' });
+    return {
+        path,
+        answerPath,
+        line: (text) => {
+            file.write(`${plain(text)}\n`);
+        },
+        saveAnswer: (text) => {
+            writeFileSync(answerPath, text.endsWith('\n') ? text : `${text}\n`);
+        },
+        close: () => {
+            file.end();
+        },
+    };
+}
+/** The project's last meta session, so `zen meta resume` needs no id. */
+function sessionFile(dir) {
+    return `${dir}/.tmp/logs/meta.session`;
+}
+export function recordSession(dir, id) {
+    mkdirSync(`${dir}/.tmp/logs`, { recursive: true });
+    writeFileSync(sessionFile(dir), `${id}\n`);
+}
+export function lastSession(dir) {
+    try {
+        return readFileSync(sessionFile(dir), 'utf8').trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Everything the sink is told, kept by the log too — and the detail only there. */
+function tee(sink, log) {
+    return {
+        answer: (text) => sink.answer(text),
+        narrate: (line) => {
+            log.line(line);
+            sink.narrate(line);
+        },
+        detail: (line) => log.line(line),
+        warn: (line) => {
+            log.line(line);
+            sink.warn(line);
+        },
+        status: (line) => sink.status?.(line),
+        close: () => sink.close?.(),
+    };
+}
+/**
+ * Folds one event into the outcome and says what, if anything, to show for it.
+ *
+ * `assistant.message` carries both the running commentary and the final word;
+ * what separates them is `toolRequests`, so the last message that asked for no
+ * tool is the answer and the rest are narration.
+ */
+export function absorb(event, out, sink, width) {
+    const data = (event.data ?? {});
+    switch (event.type) {
+        case 'assistant.message': {
+            const content = String(data.content ?? '').trim();
+            const requests = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+            if (requests.length === 0) {
+                out.answer = content;
+            }
+            else if (content) {
+                sink.narrate(cut(formatInline(content.replace(/\s+/g, ' ')), width));
+            }
+            break;
+        }
+        case 'tool.execution_start': {
+            const args = (data.arguments ?? {});
+            const what = String(args.command ?? args.description ?? data.toolName ?? '').trim();
+            // Step-by-step belongs in the log: on screen it is a wall of `$`
+            // saying less than the one line of commentary above it.
+            sink.detail?.(`$ ${what.replace(/\s+/g, ' ')}`);
+            break;
+        }
+        case 'tool.execution_complete': {
+            if (data.success === false) {
+                sink.detail?.(`  ${String(data.toolName ?? 'the tool')} failed`);
+            }
+            break;
+        }
+        case 'session.tools_updated': {
+            if (data.model) {
+                sink.detail?.(`model ${String(data.model)}`);
+            }
+            break;
+        }
+        case 'session.error': {
+            sink.warn(String(data.message ?? 'the session failed'));
+            break;
+        }
+        case 'model.call_failure': {
+            const status = data.statusCode ? ` (${String(data.statusCode)})` : '';
+            sink.warn(`${cut(String(data.errorMessage ?? 'the model call failed'), width)}${status}`);
+            break;
+        }
+        case 'result': {
+            out.exitCode = Number(event.exitCode ?? 0);
+            out.sessionId = event.sessionId;
+            out.usage = event.usage;
+            break;
+        }
+        default:
+            break;
+    }
+    out.events.push(event);
+}
+export async function launch(opts) {
+    const shown = opts.sink ?? windowSink();
+    const sink = opts.log ? tee(shown, opts.log) : shown;
+    const width = opts.width ?? Math.max(40, (process.stderr.columns ?? 100) - 4);
+    const start = opts.spawn ?? nodeSpawn;
+    const out = { answer: '', exitCode: 0, events: [] };
+    const child = start(opts.binary.command, [...opts.binary.args, ...opts.args], {
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: false,
+    });
+    const stop = (signal) => () => {
+        child.kill(signal);
+    };
+    const onInt = stop('SIGINT');
+    const onTerm = stop('SIGTERM');
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
+    // The first model call says nothing for as long as it takes, and silence
+    // after the model line is indistinguishable from a hang.
+    const began = Date.now();
+    const beat = setInterval(() => {
+        const extra = opts.status?.();
+        sink.status?.(`working: ${duration(Date.now() - began)}${extra ? ` · ${extra}` : ''}`);
+    }, FRAME_MS);
+    beat.unref();
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString().trimEnd();
+        if (text) {
+            sink.narrate(dim(text));
+        }
+    });
+    try {
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        for await (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                // Not ours to interpret, but losing it is worse than showing it.
+                sink.narrate(line);
+                continue;
+            }
+            opts.onEvent?.(event);
+            absorb(event, out, sink, width);
+        }
+        const code = await new Promise((resolve) => {
+            child.on('close', (value, signal) => resolve(value ?? (signal ? 1 : 0)));
+        });
+        if (out.exitCode === 0 && code !== 0) {
+            out.exitCode = code;
+        }
+    }
+    finally {
+        clearInterval(beat);
+        process.off('SIGINT', onInt);
+        process.off('SIGTERM', onTerm);
+        // The answer is written by the caller, so the window has to be gone first.
+        sink.close?.();
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Resuming
+//
+// Copilot retries a failed model call itself, five times over about a minute,
+// and has no setting to change that. A run that outlasts it is still a session
+// on disk, so the retry happens one level up: wait, then resume that session.
+// ---------------------------------------------------------------------------
+/** Resumes after copilot's own retries run out; `--retries` overrides. */
+export const DEFAULT_RESUMES = 5;
+/** The first wait; it doubles per resume, up to `RESUME_MAX_MS`. */
+const RESUME_INITIAL_MS = 30_000;
+const RESUME_MAX_MS = 300_000;
+/** What the resumed session is told, since `-p` has to say something. */
+export const RESUME_PROMPT = 'The previous model call failed. Continue the task from where you stopped.';
+export function resumeDelayMs(attempt) {
+    return Math.min(RESUME_INITIAL_MS * 2 ** attempt, RESUME_MAX_MS);
+}
+/**
+ * Why the run is worth resuming, or undefined when waiting cannot help.
+ *
+ * Only a refusal that time can cure counts: a rate limit, the provider's own
+ * failure, a connection that timed out. A 400 or a bad key fails the same way
+ * however often it is sent - except the one below.
+ */
+export function transient(out) {
+    if (out.exitCode === 0 || !out.sessionId) {
+        return undefined;
+    }
+    const at = out.events.findLastIndex((e) => e.type === 'session.error');
+    const data = out.events[at]?.data;
+    if (!data) {
+        return undefined;
+    }
+    const status = Number(data.statusCode ?? 0);
+    if (data.errorType === 'rate_limit' || status === 429) {
+        return 'rate-limited (429)';
+    }
+    if (status === 408 || status >= 500) {
+        return `the provider failed (${status})`;
+    }
+    if (/timed out|ECONNRESET|socket hang up/i.test(String(data.message ?? ''))) {
+        return 'the connection failed';
+    }
+    if (status === 400 && injected(out.events.slice(0, at))) {
+        return 'refused a tool call copilot made itself (400)';
+    }
+    return undefined;
+}
+/**
+ * Whether the turn that failed began with a tool call copilot wrote, not the
+ * model. When a background command finishes, copilot adds a `read_bash` of its
+ * own; Gemini 3 rejects any tool call in the current turn that lacks its thought
+ * signature, so that request is a 400 every time. A new user message - the
+ * resume - starts a turn that no longer holds it.
+ */
+function injected(before) {
+    for (let i = before.length - 1; i >= 0; i--) {
+        const event = before[i];
+        if (event.type === 'system.notification') {
+            return true;
+        }
+        if (event.type === 'user.message') {
+            return false;
+        }
+        if (event.type === 'assistant.message') {
+            if (event.data?.model) {
+                return false;
+            }
+            const requests = event.data?.toolRequests;
+            if (Array.isArray(requests) && requests.length > 0) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=launch.js.map

package/dist/meta/model.d.ts

@@ -0,0 +1,44 @@
+import { type KeyStore, type Provider } from './host.ts';
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export declare const MODEL_ENV = "ZENERA_META_MODEL";
+export type ModelSource = 'flag' | 'shell' | 'env' | 'store' | 'project' | 'default';
+export interface ModelChoice {
+    /** a zen ref: `vertex/gemini-3.8-flash`, or a bare id for the default provider */
+    ref: string;
+    from: ModelSource;
+}
+export interface ModelSources {
+    flag?: string;
+    /** `ZENERA_META_MODEL` as it stood before the project's `.env` was folded in */
+    shell?: string;
+    /** the same variable after it was, which is the `.env` answer when they differ */
+    env?: string;
+    stored?: string;
+    /** the project's `agents.yaml` `model:` */
+    project?: string;
+    /** what a held key recommends, when nothing above answered */
+    fallback?: string;
+}
+/** Where the answer is looked for, best first. */
+export declare const ORDER: readonly ModelSource[];
+export declare function chooseModel(sources: ModelSources): ModelChoice | undefined;
+export declare const SOURCE_LABELS: Record<ModelSource, string>;
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export declare const RECOMMENDED: Partial<Record<Provider, readonly string[]>>;
+/** The recommended ref for the first provider with a key, or for `only`. */
+export declare function defaultRef(store: KeyStore, only?: Provider): string | undefined;
+export interface MetaFile {
+    version: 1;
+    model?: string;
+}
+export declare const readMeta: () => Promise<MetaFile>;
+export declare function writeMeta(file: MetaFile): void;
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export declare function misspelledProvider(ref: string): Provider | undefined;
+//# sourceMappingURL=model.d.ts.map

package/dist/meta/model.js

@@ -0,0 +1,119 @@
+import { paths, PROVIDER_NAMES, readJson, writeJson, } from "./host.js";
+// ---------------------------------------------------------------------------
+// The model
+// ---------------------------------------------------------------------------
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export const MODEL_ENV = 'ZENERA_META_MODEL';
+/** Where the answer is looked for, best first. */
+export const ORDER = [
+    'flag',
+    'shell',
+    'env',
+    'store',
+    'project',
+    'default',
+];
+export function chooseModel(sources) {
+    const at = {
+        flag: sources.flag,
+        // `.env` only fills gaps, so an answer that survived it came from the shell
+        shell: sources.shell,
+        env: sources.shell ? undefined : sources.env,
+        store: sources.stored,
+        project: sources.project,
+        default: sources.fallback,
+    };
+    for (const from of ORDER) {
+        const ref = at[from]?.trim();
+        if (ref) {
+            return { ref, from };
+        }
+    }
+    return undefined;
+}
+export const SOURCE_LABELS = {
+    flag: '--model',
+    shell: `${MODEL_ENV} (shell)`,
+    env: `${MODEL_ENV} (.env)`,
+    store: 'zen meta model',
+    project: 'agents.yaml model:',
+    default: 'recommended',
+};
+// ---------------------------------------------------------------------------
+// What to run when nobody said
+//
+// A first `zen meta` should work on a machine that has a key and nothing else,
+// so the last resort is the best model the keys on hand can buy rather than an
+// error. Deep tier deliberately: this agent is pointed at the project itself,
+// and a cheap model reading a specification is a false economy.
+// ---------------------------------------------------------------------------
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export const RECOMMENDED = {
+    openai: ['gpt-5.6-sol', 'gpt-5.6-terra'],
+    anthropic: ['claude-opus-5', 'claude-sonnet-5'],
+    vertex: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    google: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    openrouter: ['anthropic/claude-opus-5', 'openai/gpt-5.6-sol'],
+};
+/** Which provider is tried first when several are held. */
+const PREFERENCE = ['anthropic', 'openai', 'vertex', 'google', 'openrouter'];
+/** The recommended ref for the first provider with a key, or for `only`. */
+export function defaultRef(store, only) {
+    for (const provider of only ? [only] : PREFERENCE) {
+        const id = RECOMMENDED[provider]?.[0];
+        if (id && store.active(provider)) {
+            return `${provider}/${id}`;
+        }
+    }
+    return undefined;
+}
+const EMPTY = { version: 1 };
+export const readMeta = () => readJson(paths.meta(), EMPTY);
+export function writeMeta(file) {
+    writeJson(paths.meta(), file);
+}
+// ---------------------------------------------------------------------------
+// Refs
+// ---------------------------------------------------------------------------
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export function misspelledProvider(ref) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0) {
+        return undefined;
+    }
+    const head = ref.slice(0, slash).toLowerCase();
+    if (PROVIDER_NAMES.has(head)) {
+        return undefined;
+    }
+    for (const name of PROVIDER_NAMES) {
+        // Two, so that a transposition — which Levenshtein counts twice — reads
+        // as the typo it is. No provider name is short enough for that to be loose.
+        if (distance(head, name) <= 2) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/** Levenshtein, one row at a time. Both operands are a word long. */
+function distance(a, b) {
+    if (Math.abs(a.length - b.length) > 2) {
+        return 3;
+    }
+    let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const next = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            next[j] = Math.min(next[j - 1] + 1, row[j] + 1, row[j - 1] + cost);
+        }
+        row = next;
+    }
+    return row[b.length];
+}
+//# sourceMappingURL=model.js.map

package/dist/meta/prompts.d.ts

@@ -0,0 +1,18 @@
+export declare const PROMPT_DIR = ".github/prompts";
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export declare function promptPath(dir: string, name: string): string;
+export interface StoredPrompt {
+    name: string;
+    path: string;
+    description?: string;
+    body: string;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export declare function readPrompt(path: string, name: string, text: string): StoredPrompt;
+export declare function loadPrompt(dir: string, name: string): Promise<StoredPrompt>;
+export declare function listPrompts(dir: string): Promise<string[]>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/meta/prompts.js

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { usageError } from "./host.js";
+// ---------------------------------------------------------------------------
+// Stored prompts
+//
+// Copilot reads `AGENTS.md`, `.github/skills/` and `.github/agents/`, but it
+// has no notion of `.github/prompts/*.prompt.md` — the files an editor offers
+// as slash commands. Reading one and handing over its body is the whole of
+// `zen meta run`, and it is why that subcommand exists.
+// ---------------------------------------------------------------------------
+export const PROMPT_DIR = '.github/prompts';
+const PROMPT_SUFFIX = '.prompt.md';
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export function promptPath(dir, name) {
+    const bare = name.replace(/^\//, '');
+    if (bare.includes('/') || bare.endsWith('.md')) {
+        return `${dir}/${bare}`;
+    }
+    return `${dir}/${PROMPT_DIR}/${bare}${PROMPT_SUFFIX}`;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export function readPrompt(path, name, text) {
+    let body = text;
+    let description;
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (match) {
+        body = text.slice(match[0].length);
+        const found = /^description:\s*(.+)$/m.exec(match[1]);
+        description = found?.[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { name, path, description, body: body.trim() };
+}
+export async function loadPrompt(dir, name) {
+    const path = promptPath(dir, name);
+    if (!existsSync(path)) {
+        const known = await listPrompts(dir);
+        throw usageError(`no prompt named ${name.replace(/^\//, '')}`, known.length > 0
+            ? `try: ${known.map((p) => `/${p}`).join(', ')}`
+            : `put one in ${PROMPT_DIR}/`);
+    }
+    return readPrompt(path, name.replace(/^\//, ''), await readFile(path, 'utf8'));
+}
+export async function listPrompts(dir) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        const names = await readdir(`${dir}/${PROMPT_DIR}`);
+        return names
+            .filter((n) => n.endsWith(PROMPT_SUFFIX))
+            .map((n) => n.slice(0, -PROMPT_SUFFIX.length))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=prompts.js.map

package/dist/meta/relay.d.ts

@@ -0,0 +1,20 @@
+export interface Relay {
+    url: string;
+    close(): Promise<void>;
+}
+export interface RelaySpec {
+    /** the per-session secret copilot must present; anything else on the machine is refused */
+    key: string;
+    /** `https://…/v1/projects/<project>/locations/<location>` */
+    base: string;
+    token: () => Promise<string>;
+}
+export interface VertexRelaySpec {
+    key: string;
+    project: string;
+    location: string;
+    keyFile: string;
+}
+export declare function startVertexRelay(spec: VertexRelaySpec): Promise<Relay>;
+export declare function startRelay(spec: RelaySpec): Promise<Relay>;
+//# sourceMappingURL=relay.d.ts.map