@zenera/cli 1.1.21 → 1.1.23

package/dist/commands/memory.js

@@ -1,13 +1,13 @@
-import { ALL_AGENTS, buildMemoryReport, hostPath, memoryDir, MemoryIndex, MemoryStore, readProjectConfig, renderMemoryHtml, } from '@zenera/neo';
+import { ALL_AGENTS, buildMemoryReport, hostPath, memoryDir, MemoryIndex, MemoryStore, MergeConflicts, mergeMemories, readProjectConfig, renderMemoryHtml, } from '@zenera/neo';
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { basename, isAbsolute, join, resolve } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { parse } from "../args.js";
 import { project as resolveProject } from "../resolve.js";
-import { ago, bold, bytes, confirm, count, cyan, dim, green, isInteractive, json, note, table, usageError, write, writeAll, yellow, } from "../term.js";
-const USAGE = 'zen memory [stats|ls|show|export|forget] [args] [options]';
-const SUBCOMMANDS = ['stats', 'ls', 'show', 'export', 'forget'];
+import { ago, bold, bytes, CliError, confirm, count, cyan, dim, EXIT, green, isInteractive, json, note, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen memory [stats|ls|show|export|merge|forget] [args] [options]';
+const SUBCOMMANDS = ['stats', 'ls', 'show', 'export', 'merge', 'forget'];
 /** Enough to see the shape of it; the rest is a number. */
 const LISTED = 30;
 // ---------------------------------------------------------------------------
@@ -31,11 +31,13 @@ const LISTED = 30;
 export const memory = {
     summary: 'What the agents remember, and getting rid of it.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Memory', subtitle: 'Knowledge Graph', hue: 'purple' },
     details: [
         '  stats                  Size, vocabulary, and whether it is embedded.',
         '  ls                     Nodes, newest first. Changes nothing.',
         '  show <id>              One node in full, with what it links to.',
         '  export [file]          The whole graph as one HTML page.',
+        '  merge <dir...>         Fold other memories into this one.',
         '  forget <id...>         Remove nodes, their vectors and their files.',
         '',
         '  --project <name|dir>   Which project. Defaults to the one you are in.',
@@ -47,7 +49,10 @@ export const memory = {
         '  --limit <n>            Rows to list. Default 30.',
         '  --out <file>           Where `export` writes. Default memory.html.',
         '  --open                 Open the exported page.',
-        '  --yes                  Do not ask before removing.',
+        '  --dry-run              Say what `merge` would do, and stop.',
+        '  --no-dedupe            Keep memories `merge` would otherwise fold together.',
+        '  --force                Let `merge` pick a winner where two copies disagree.',
+        '  --yes                  Do not ask before removing or merging.',
         '',
         'Everything here reads the graph *unmasked* — every audience, including',
         'what no agent can see. That is the point: when a mask is the thing',
@@ -56,6 +61,11 @@ export const memory = {
         '`export` is the one to reach for. It writes a single self-contained',
         'page: the node list on the left, the graph in the middle, and whatever',
         'you click on the right, file contents and all.',
+        '',
+        '`merge` is for warming a memory in parallel. The lock is per directory,',
+        'so N runs write N memories; this folds them back into one:',
+        '',
+        '  zen memory merge .tmp/warmup-*/memory',
     ],
     run: async (ctx) => {
         const { values, positionals } = parse(ctx.args, {
@@ -69,13 +79,18 @@ export const memory = {
             out: { type: 'string' },
             open: { type: 'boolean' },
             yes: { type: 'boolean' },
+            force: { type: 'boolean' },
+            'dry-run': { type: 'boolean' },
+            'no-dedupe': { type: 'boolean' },
         }, USAGE);
         const what = positionals[0] ?? 'stats';
         if (!SUBCOMMANDS.includes(what)) {
             throw usageError(`unknown subcommand: ${what}`, USAGE);
         }
         const rest = positionals.slice(1);
-        const opened = await open(ctx.cwd, values.project, values.dir);
+        // `merge` is the one subcommand that may write a memory into existence;
+        // every other one is an inspector and a missing manifest is a mistake.
+        const opened = await open(ctx.cwd, values.project, values.dir, what === 'merge');
         try {
             switch (what) {
                 case 'stats':
@@ -86,6 +101,8 @@ export const memory = {
                     return show(opened, rest, ctx.json);
                 case 'export':
                     return await write_(opened, rest, values, ctx.cwd, ctx.json);
+                case 'merge':
+                    return await merge(opened, rest, values, ctx.cwd, ctx.json);
                 default:
                     return await forget(opened, rest, values, ctx.json);
             }
@@ -104,11 +121,15 @@ export const memory = {
  * A named directory is opened as it stands, project or no project: a graph
  * copied out of a running session is the one most worth looking at, and it
  * should not have to be given an `agents.yaml` first.
+ *
+ * `create` drops the requirement that anything be there yet, for `merge`,
+ * which has somewhere to put what it reads even when the destination is a name
+ * nothing has written to.
  */
-async function open(cwd, want, at) {
+async function open(cwd, want, at, create = false) {
     if (at) {
         const dir = resolve(cwd, at);
-        if (!existsSync(join(dir, 'manifest.json'))) {
+        if (!create && !existsSync(join(dir, 'manifest.json'))) {
             throw usageError(`${dir} is not a memory`, 'no manifest.json in it');
         }
         return { store: await MemoryStore.open(dir), dir, project: basename(dir) };
@@ -119,7 +140,7 @@ async function open(cwd, want, at) {
     if (!dir) {
         throw usageError(`${project.name} has no memory`, 'give an agent `memory: true` in agents.yaml, or add a `memory:` block');
     }
-    if (!existsSync(join(dir, 'manifest.json'))) {
+    if (!create && !existsSync(join(dir, 'manifest.json'))) {
         throw usageError(`${project.name} has a memory configured but nothing in it yet`, 'it is written the first time an agent commits something');
     }
     return { store: await MemoryStore.open(dir), dir, project: project.name };
@@ -335,6 +356,88 @@ function reveal(target) {
     spawn(command, [target], { stdio: 'ignore', detached: true }).unref();
 }
 // ---------------------------------------------------------------------------
+// merge
+// ---------------------------------------------------------------------------
+/**
+ * Warming a memory is parallel work, and the lock is per directory, so N runs
+ * produce N memories rather than one. This is the other half of that: it folds
+ * them back together, offline and without a model.
+ *
+ * Divergence refuses rather than guesses. Two copies of the same memory that
+ * disagree are a question about which piece of work was right, and answering
+ * it silently is how a merge loses the answer.
+ */
+async function merge(o, dirs, flags, cwd, asJson) {
+    if (!dirs.length) {
+        throw usageError('merge takes at least one memory directory', 'zen memory merge <dir...> [--dir <into>]');
+    }
+    const dryRun = flags['dry-run'] === true;
+    const held = o.store.graph.order;
+    if (held && !dryRun && !flags.yes) {
+        if (!isInteractive()) {
+            throw usageError(`${o.project} already remembers ${count(held, 'node')}`, 'pass --yes, or --dry-run to see what would change first');
+        }
+        note(`${count(dirs.length, 'memory', 'memories')} into ${bold(o.dir)} ` +
+            dim(`· ${count(held, 'node')} already there`));
+        if (!(await confirm('Merge?'))) {
+            note('nothing merged');
+            return;
+        }
+    }
+    let report;
+    try {
+        report = await mergeMemories(o.store, dirs.map((d) => resolve(cwd, d)), { dedupe: !flags['no-dedupe'], force: flags.force, dryRun });
+    }
+    catch (err) {
+        if (err instanceof MergeConflicts) {
+            throw diverged(err, cwd, asJson);
+        }
+        throw err;
+    }
+    if (asJson) {
+        json(report);
+        return;
+    }
+    writeAll(table([
+        [dim('memory'), dim('nodes'), dim('new'), dim('shared'), dim('folded'), dim('files')],
+        ...report.sources.map((s) => [
+            near(s.dir, cwd),
+            String(s.nodes),
+            s.added ? green(String(s.added)) : '0',
+            String(s.shared),
+            s.twins ? yellow(String(s.twins)) : '0',
+            String(s.files),
+        ]),
+    ]));
+    write();
+    const summary = [
+        count(report.added, 'node'),
+        `${count(report.edges, 'edge')}`,
+        `${report.twins} folded`,
+    ].join(', ');
+    note(dryRun ? `${yellow('would add')} ${summary}` : `${green('merged')} ${summary}`);
+}
+/**
+ * A refusal with the ids to look at. It is deliberately not a summary: the
+ * point of stopping is that a person decides, and they cannot decide from a
+ * count.
+ */
+function diverged(err, cwd, asJson) {
+    if (asJson) {
+        json({ error: err.message, conflicts: err.conflicts });
+    }
+    else {
+        writeAll(table(err.conflicts.map((c) => [
+            cyan(c.id),
+            dim(`r${c.mine} ↔ r${c.theirs}`),
+            clip(c.text, 48),
+            dim(near(c.dir, cwd)),
+        ])));
+        write();
+    }
+    return new CliError(err.message, EXIT.failed, err.hint);
+}
+// ---------------------------------------------------------------------------
 // forget
 // ---------------------------------------------------------------------------
 /**
@@ -385,4 +488,9 @@ function clip(text, n) {
     const one = text.replace(/\s+/g, ' ').trim();
     return one.length > n ? one.slice(0, n - 1) + '…' : one;
 }
+/** A path as it was probably typed: relative when it is below here, absolute when it is not. */
+function near(dir, cwd) {
+    const rel = relative(cwd, dir);
+    return rel && !rel.startsWith('..') ? rel : dir;
+}
 //# sourceMappingURL=memory.js.map

package/dist/commands/open.js

@@ -16,6 +16,7 @@ const USAGE = 'zen open [project] [--editor <cmd>] [--wait]';
 export const open = {
     summary: 'Open a project in your editor.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Open', subtitle: 'Workspace Studio', hue: 'teal' },
     details: [
         'Editor: --editor, then $ZENERA_EDITOR, then the editor this terminal',
         'belongs to, then $VISUAL or $EDITOR, then a known editor on PATH or',

package/dist/commands/run.js

@@ -12,6 +12,7 @@ const USAGE = 'zen run [project] [prompt] [options]';
 export const run = {
     summary: 'Run the project — the TUI on a terminal, one shot otherwise.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Neo', subtitle: 'Agentic Runtime', hue: 'orange' },
     details: [
         'Arguments:',
         '  [project]   Name of a project. Default: the one you are in.',
@@ -31,6 +32,7 @@ export const run = {
         '  --theme <dark|light>   Colours for the TUI. Default: auto.',
         '  --out <file>           Put the answer in this file instead of on screen.',
         '  --yes                  Answer yes to every question.',
+        '  --json                 Print machine-readable JSON (session, run, mounts, output, etc...).',
         '',
         'The first word is the project when it names one, otherwise the prompt.',
         'The answer goes to stdout and the progress to stderr, so `> out.md` keeps',
@@ -46,6 +48,7 @@ export const run = {
         '  git diff | zen run                    take the prompt from stdin',
         '  zen run "what changed?" > out.md      redirect the answer into a file',
         '  zen run --out out.md "what changed?"  write the answer to out.md only',
+        '  zen run --json "what changed?"        output JSON with workspace, run paths, state, etc...',
         '  zen run --read-only "what changed?"   let it read but not write',
         '  zen run --memory ./mem                remember into ./mem, not the project',
         '  zen run --new                         open the TUI in a new session',

package/dist/commands/sandbox.js

@@ -21,6 +21,7 @@ const INDENT = ' '.repeat(11);
 export const sandbox = {
     summary: 'Check and prepare the container command-line tools run in.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Sandbox', subtitle: 'Container Isolation', hue: 'azure' },
     details: [
         '  status                 What is installed, running and pulled. Changes nothing.',
         '  up                     Install if asked, start the machine, pull or build the image.',

package/dist/commands/version.js

@@ -20,6 +20,7 @@ function libraryManifest() {
 export const version = {
     summary: 'Print the CLI, library and Node versions.',
     usage: 'zen version',
+    banner: { head: 'Zenera', accent: 'Version', subtitle: 'Runtime & Build', hue: 'steel' },
     run: async (ctx) => {
         const versions = {
             cli: await versionOf(cliManifest),

package/dist/lib.d.ts

@@ -7,5 +7,6 @@ export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson
 export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, type CredentialForm, type KeyCheck, type KeyEntry, type KeyOwner, type Liveness, type Provider, type Service, } from './keys.ts';
 export { probe, probeAll } from './liveness.ts';
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, type DiskLine, type EngineDisk, type OwnedContainer, type PodmanOptions, type PodmanStatus, } from './podman.ts';
-export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';
+export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';
+export { formatBlocks, formatInline, formatMarkdown, wrapSpans } from './tui/markdown.ts';
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.js

@@ -29,5 +29,6 @@ export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson
 export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, } from "./keys.js";
 export { probe, probeAll } from "./liveness.js";
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "./podman.js";
-export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, } from "./term.js";
+export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, } from "./term.js";
+export { formatBlocks, formatInline, formatMarkdown, wrapSpans } from "./tui/markdown.js";
 //# sourceMappingURL=lib.js.map

package/dist/meta.d.ts

@@ -179,7 +179,7 @@ export declare function footerCells(label: string, width: number): string[];
 export declare function windowSink(rows?: number): Sink;
 /**
  * The answer in the same box `zen run` draws it in: bounded width, rounded
- * rule, fenced blocks kept as they were written.
+ * rule, formatted with full markdown styling (bold, italics, code, lists, quotes, tables).
  *
  * Redirected output gets the text and nothing else — `zen meta run ... > out.md`
  * is meant to produce a file you can read, not one with a border down its side.

package/dist/meta.js

@@ -6,7 +6,8 @@ import { invokedAs } from "./args.js";
 import { paths, readJson, writeJson } from "./home.js";
 import { envOf } from "./keys.js";
 import { credentialError, cut, cyan, dim, note, pad, plain, red, styled, usageError, write, yellow, } from "./term.js";
-import { blocksOf, boxWidth, textOf, wrap } from "./tui/wrap.js";
+import { formatInline, formatMarkdown } from "./tui/markdown.js";
+import { boxWidth } from "./tui/wrap.js";
 export const PROMPT_DIR = '.github/prompts';
 const PROMPT_SUFFIX = '.prompt.md';
 // ---------------------------------------------------------------------------
@@ -483,7 +484,7 @@ export function windowSink(rows = WINDOW_ROWS) {
 }
 /**
  * The answer in the same box `zen run` draws it in: bounded width, rounded
- * rule, fenced blocks kept as they were written.
+ * rule, formatted with full markdown styling (bold, italics, code, lists, quotes, tables).
  *
  * Redirected output gets the text and nothing else — `zen meta run ... > out.md`
  * is meant to produce a file you can read, not one with a border down its side.
@@ -494,31 +495,7 @@ export function answerBox(text, columns = process.stdout.columns ?? 80) {
     }
     const outer = boxWidth(text, columns);
     const inner = outer - 4;
-    const body = [];
-    let previous;
-    for (const block of blocksOf(text)) {
-        if (previous && !(block.kind === 'item' && previous.kind === 'item')) {
-            body.push('');
-        }
-        previous = block;
-        if (block.kind === 'code') {
-            // Indentation is the meaning of a fenced block, so it is cut rather
-            // than reflowed.
-            body.push(dim(`\u250c\u2500${block.title ? ` ${block.title}` : ''}`));
-            body.push(...(block.lines ?? []).map((l) => `${dim('\u2502')} ${cut(l, inner - 2)}`));
-            body.push(dim('\u2514\u2500'));
-        }
-        else if (block.lines || block.kind === 'table') {
-            body.push(...textOf(block)
-                .split('\n')
-                .map((l) => cut(l, inner)));
-        }
-        else {
-            // Plain, not styled: `wrap` counts characters, and a bold run
-            // measured with its escape codes in it folds the line early.
-            body.push(...wrap(textOf(block, inner), inner));
-        }
-    }
+    const body = formatMarkdown(text, inner);
     const rule = BOX.h.repeat(outer - 2);
     return [
         '',
@@ -586,7 +563,7 @@ export function absorb(event, out, sink, width) {
                 out.answer = content;
             }
             else if (content) {
-                sink.narrate(cut(content.replace(/\s+/g, ' '), width));
+                sink.narrate(cut(formatInline(content.replace(/\s+/g, ' ')), width));
             }
             break;
         }

package/dist/resolve.js

@@ -1,9 +1,10 @@
 import { existsSync } from 'node:fs';
-import { relative, resolve, sep } from 'node:path';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { stamp } from "./ids.js";
 import * as Projects from "./projects.js";
 import { createSession, listSessions, readSessionMeta, requireSession, sessionPaths, } from "./session.js";
-import { ago, bold, choose, confirm, cyan, dim, isInteractive, usageError, warn, yellow, } from "./term.js";
+import * as term from "./term.js";
+import { ago, bold, cyan, dim, usageError, yellow } from "./term.js";
 // ---------------------------------------------------------------------------
 // Project
 // ---------------------------------------------------------------------------
@@ -20,7 +21,7 @@ export async function project(want) {
     if (known.length === 0) {
         throw usageError('not inside a project, and none are registered', 'create one: zen init');
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         throw usageError('not inside a project', 'name one with --project');
     }
     // Most recently worked in first: the answer to "which project" is nearly
@@ -29,7 +30,7 @@ export async function project(want) {
     const ranked = known
         .map((entry) => ({ entry, used: Projects.lastUsedAt(entry.path) ?? '' }))
         .sort((a, b) => b.used.localeCompare(a.used) || a.entry.name.localeCompare(b.entry.name));
-    const chosen = await choose('Which project?', ranked.map(({ entry }) => ({ label: entry.name, detail: entry.path, value: entry })));
+    const chosen = await term.choose('Which project?', ranked.map(({ entry }) => ({ label: entry.name, detail: entry.path, value: entry })));
     return Projects.openDir(chosen.path);
 }
 // ---------------------------------------------------------------------------
@@ -89,11 +90,11 @@ async function pickExisting(projectDir) {
     if (all.length === 0) {
         return undefined;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         return sessionPaths(projectDir, all[0].id);
     }
     const sessions = all.slice(0, MAX_SESSIONS);
-    const choice = await choose('Session', [
+    const choice = await term.choose('Session', [
         {
             key: '0',
             label: bold(cyan('New session…')),
@@ -137,10 +138,10 @@ export async function chooseWorkspace(session, want) {
         await approve(at, session, want);
         return at;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         return own;
     }
-    const chosen = await choose('Workspace — what the agent can read and write', [
+    const chosen = await term.choose('Workspace — what the agent can read and write', [
         { label: 'A fresh, empty directory', detail: own, value: own },
         { label: 'The directory you started in', detail: want.cwd, value: want.cwd },
     ]);
@@ -151,20 +152,26 @@ async function approve(at, session, want) {
     if (contains(session.dir, at)) {
         return;
     }
-    warn(`the agent will be able to read and write ${at}`);
+    if (!want.workspace) {
+        term.warn(`the agent will be able to read and write ${at}`);
+    }
     if (want.yes) {
         return;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         throw usageError('refusing a workspace outside the session without confirmation', 'pass --yes if that is what you meant');
     }
-    if (!(await confirm('Continue?'))) {
+    if (!(await term.confirm('Continue?'))) {
         throw usageError('cancelled');
     }
 }
 function contains(parent, child) {
     const from = resolve(parent);
     const to = resolve(child);
-    return from === to || !relative(from, to).startsWith(`..${sep}`);
+    if (from === to) {
+        return true;
+    }
+    const rel = relative(from, to);
+    return !rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel);
 }
 //# sourceMappingURL=resolve.js.map

package/dist/sandbox.js

@@ -161,6 +161,7 @@ function toSpec(config, extra, secrets) {
         network: config.network,
         workdir: config.workdir,
         timeout: config.timeout,
+        hardening: config.hardening,
         user: config.user,
         persist: config.persist,
         env,

package/dist/scaffold.d.ts

@@ -11,6 +11,14 @@
  * own beside them.
  */
 export declare const SHARED_RULES: readonly string[];
+/**
+ * This `zen`'s own version, which the scaffold pins the sandbox's tools to.
+ * The publishable packages move in lockstep, so one number covers them all.
+ *
+ * Exported so the check that reports a drifted pin reads the same number the
+ * scaffold wrote, rather than a second definition of "this version".
+ */
+export declare function ownVersion(): string;
 /**
  * Writes the editor's files under `dir`, replacing what is there. They are
  * ours: they say how the editor is to treat a directory the agents write into,

package/dist/scaffold.js

@@ -33,6 +33,8 @@ import { fileURLToPath } from 'node:url';
 const TEMPLATES = fileURLToPath(new URL('../templates', import.meta.url));
 /** The suffix on a file with `{{...}}` in it, dropped when the file lands. */
 const TEMPLATE = '.tmpl';
+/** How to use file tools: a house rules file, landing under `agents/`. */
+const FILE_RULES = join('agents', 'files-instructions.md');
 /** How to use the memory graph: a house rules file, landing under `agents/`. */
 const MEMORY_RULES = join('agents', 'memory-instructions.md');
 /** How tools are called: the same, and equally not the project's to maintain. */
@@ -51,14 +53,17 @@ const FORK_RULES = join('agents', 'fork-instructions.md');
  * place: project policy on any of those subjects goes in a topic file of its
  * own beside them.
  */
-export const SHARED_RULES = [FORK_RULES, MEMORY_RULES, TOOL_RULES];
+export const SHARED_RULES = [FILE_RULES, FORK_RULES, MEMORY_RULES, TOOL_RULES];
 /** The same bytes, kept in the `zen-memory` skill to restore or diff against. */
 const MEMORY_REFERENCE = join('.github', 'skills', 'zen-memory', 'references', 'memory-instructions.md');
 /**
  * This `zen`'s own version, which the scaffold pins the sandbox's tools to.
  * The publishable packages move in lockstep, so one number covers them all.
+ *
+ * Exported so the check that reports a drifted pin reads the same number the
+ * scaffold wrote, rather than a second definition of "this version".
  */
-function ownVersion() {
+export function ownVersion() {
     const manifest = fileURLToPath(new URL('../package.json', import.meta.url));
     return JSON.parse(readFileSync(manifest, 'utf8')).version;
 }

package/dist/term.d.ts

@@ -26,6 +26,8 @@ export declare const CHROME: Record<Appearance, number>;
 /** What the terminal looks like, as far as can be known without asking it. */
 export declare function appearance(): Appearance;
 export declare const bold: (s: string) => string;
+export declare const italic: (s: string) => string;
+export declare const underline: (s: string) => string;
 /**
  * One step quieter, which is half of everything this tool prints: paths,
  * counts, hints, the second column of every table.

package/dist/term.js

@@ -88,6 +88,8 @@ function fromAppleTerminal() {
 // Styling
 // ---------------------------------------------------------------------------
 export const bold = (s) => styleText('bold', s);
+export const italic = (s) => styleText('italic', s);
+export const underline = (s) => styleText('underline', s);
 /**
  * One step quieter, which is half of everything this tool prints: paths,
  * counts, hints, the second column of every table.

package/dist/tui/markdown.d.ts

@@ -0,0 +1,16 @@
+import { type Block, type Span } from './wrap.ts';
+export declare function wrapSpans(spans: readonly Span[], width: number, prefix?: string, subsequentPrefix?: string): string[];
+/**
+ * Render a sequence of AST `Block`s into styled terminal lines wrapped to `width`.
+ */
+export declare function formatBlocks(blocks: readonly Block[], width?: number): string[];
+/**
+ * Format markdown text into styled ANSI terminal lines wrapped to `width`.
+ */
+export declare function formatMarkdown(text: string, width?: number): string[];
+/**
+ * Format inline markdown text (bold, italic, code, links) into a styled ANSI string.
+ * Markers like backticks and asterisks are resolved and removed.
+ */
+export declare function formatInline(text: string): string;
+//# sourceMappingURL=markdown.d.ts.map