@zenera/cli 1.1.21 → 1.1.23

package/dist/tui/markdown.js

@@ -0,0 +1,259 @@
+// ---------------------------------------------------------------------------
+// Terminal Markdown Formatter
+//
+// Formats markdown text into styled ANSI terminal lines wrapped to a width.
+//
+// Consumes the block and span AST from `wrap.ts` and applies terminal styling
+// from `term.ts` (bold, italic, green for code, underline for links, dimmed
+// borders and markers). Line wrapping measures plain characters, so ANSI
+// escape codes never cause lines to wrap early or misalign borders.
+// ---------------------------------------------------------------------------
+import { bold, cut, dim, green, italic, plain, styled, underline } from "../term.js";
+import { blocksOf, gridOf, inlineOf } from "./wrap.js";
+function renderPiece(piece) {
+    if (!styled()) {
+        return piece.text;
+    }
+    let t = piece.text;
+    if (piece.code) {
+        t = green(t);
+    }
+    if (piece.italic) {
+        t = italic(t);
+    }
+    if (piece.bold) {
+        t = bold(t);
+    }
+    if (piece.href) {
+        t = underline(t);
+    }
+    return t;
+}
+function sameStyle(a, b) {
+    return (!!a.bold === !!b.bold &&
+        !!a.italic === !!b.italic &&
+        !!a.code === !!b.code &&
+        a.href === b.href);
+}
+function mergePieces(pieces) {
+    const out = [];
+    for (const p of pieces) {
+        if (!p.text)
+            continue;
+        const last = out[out.length - 1];
+        if (last && sameStyle(last, p)) {
+            last.text += p.text;
+        }
+        else {
+            out.push({ ...p });
+        }
+    }
+    return out;
+}
+function wordsOf(spans) {
+    const words = [];
+    let currentPieces = [];
+    let currentLen = 0;
+    for (const span of spans) {
+        const style = {
+            ...(span.bold ? { bold: true } : {}),
+            ...(span.italic ? { italic: true } : {}),
+            ...(span.code ? { code: true } : {}),
+            ...(span.href ? { href: span.href } : {}),
+        };
+        const parts = span.text.split(/(\s+)/);
+        for (const part of parts) {
+            if (!part)
+                continue;
+            if (/^\s+$/.test(part)) {
+                if (currentPieces.length > 0) {
+                    words.push({ pieces: currentPieces, length: currentLen });
+                    currentPieces = [];
+                    currentLen = 0;
+                }
+            }
+            else {
+                currentPieces.push({ text: part, ...style });
+                currentLen += part.length;
+            }
+        }
+    }
+    if (currentPieces.length > 0) {
+        words.push({ pieces: currentPieces, length: currentLen });
+    }
+    return words;
+}
+function sliceWord(word, at) {
+    const leftPieces = [];
+    const rightPieces = [];
+    let taken = 0;
+    for (const p of word.pieces) {
+        if (taken + p.text.length <= at) {
+            leftPieces.push(p);
+            taken += p.text.length;
+        }
+        else if (taken < at) {
+            const cutIndex = at - taken;
+            leftPieces.push({ ...p, text: p.text.slice(0, cutIndex) });
+            rightPieces.push({ ...p, text: p.text.slice(cutIndex) });
+            taken = at;
+        }
+        else {
+            rightPieces.push(p);
+        }
+    }
+    return [
+        { pieces: leftPieces, length: at },
+        { pieces: rightPieces, length: word.length - at },
+    ];
+}
+export function wrapSpans(spans, width, prefix = '', subsequentPrefix = '') {
+    const w = Math.max(1, width);
+    const words = wordsOf(spans);
+    if (words.length === 0) {
+        return prefix ? [prefix] : [''];
+    }
+    const lines = [];
+    let currentWords = [];
+    const prefixLen = plain(prefix).length;
+    const subLen = plain(subsequentPrefix).length;
+    let currentLen = prefixLen;
+    const flush = () => {
+        if (currentWords.length === 0)
+            return;
+        const linePieces = [];
+        for (let i = 0; i < currentWords.length; i++) {
+            const word = currentWords[i];
+            if (i > 0) {
+                const prev = currentWords[i - 1];
+                const prevPiece = prev.pieces[prev.pieces.length - 1];
+                const nextPiece = word.pieces[0];
+                const sharedStyle = prevPiece && nextPiece && sameStyle(prevPiece, nextPiece)
+                    ? { ...prevPiece, text: ' ' }
+                    : { text: ' ' };
+                linePieces.push(sharedStyle);
+            }
+            linePieces.push(...word.pieces);
+        }
+        const p = lines.length === 0 ? prefix : subsequentPrefix;
+        lines.push(p + mergePieces(linePieces).map(renderPiece).join(''));
+        currentWords = [];
+        currentLen = subLen;
+    };
+    for (let word of words) {
+        const available = lines.length === 0 ? w - prefixLen : w - subLen;
+        while (word.length > available && available > 0) {
+            if (currentWords.length > 0) {
+                flush();
+            }
+            const [head, tail] = sliceWord(word, available);
+            const p = lines.length === 0 ? prefix : subsequentPrefix;
+            lines.push(p + mergePieces(head.pieces).map(renderPiece).join(''));
+            word = tail;
+            currentLen = subLen;
+        }
+        const spaceNeeded = currentWords.length > 0 ? 1 : 0;
+        if (currentLen + spaceNeeded + word.length <= w) {
+            currentWords.push(word);
+            currentLen += spaceNeeded + word.length;
+        }
+        else {
+            flush();
+            currentWords.push(word);
+            const p = lines.length === 0 ? prefix : subsequentPrefix;
+            currentLen = plain(p).length + word.length;
+        }
+    }
+    flush();
+    return lines;
+}
+/**
+ * Render a sequence of AST `Block`s into styled terminal lines wrapped to `width`.
+ */
+export function formatBlocks(blocks, width = 80) {
+    const lines = [];
+    let previous;
+    for (const block of blocks) {
+        if (previous && !(block.kind === 'item' && previous.kind === 'item')) {
+            lines.push('');
+        }
+        previous = block;
+        if (block.kind === 'code') {
+            lines.push(dim(`\u250c\u2500${block.title ? ` ${block.title}` : ''}`));
+            lines.push(...(block.lines ?? []).map((l) => `${dim('\u2502')} ${cut(l, Math.max(0, width - 2))}`));
+            lines.push(dim('\u2514\u2500'));
+        }
+        else if (block.kind === 'table') {
+            for (const [j, row] of gridOf(block).entries()) {
+                let formatted;
+                if (block.align !== undefined && j === 0) {
+                    formatted = row
+                        .map((s) => s.text === '| ' || s.text === ' | ' || s.text === ' |'
+                        ? dim(s.text)
+                        : renderPiece({ ...s, bold: true }))
+                        .join('');
+                }
+                else if (block.align !== undefined && j === 1) {
+                    formatted = dim(row.map((s) => s.text).join(''));
+                }
+                else {
+                    formatted = row
+                        .map((s) => s.text === '| ' || s.text === ' | ' || s.text === ' |'
+                        ? dim(s.text)
+                        : renderPiece(s))
+                        .join('');
+                }
+                lines.push(cut(formatted, width));
+            }
+        }
+        else if (block.kind === 'heading') {
+            const headingSpans = (block.spans ?? []).map((s) => ({ ...s, bold: true }));
+            lines.push(...wrapSpans(headingSpans, width));
+        }
+        else if (block.kind === 'item') {
+            const indentLevel = block.level ?? 0;
+            const marker = block.marker ?? '\u2022';
+            const leadSpaces = '  '.repeat(indentLevel);
+            const prefix = `${leadSpaces}${dim(marker)} `;
+            const subPrefix = `${leadSpaces}${' '.repeat(marker.length + 1)}`;
+            lines.push(...wrapSpans(block.spans ?? [], width, prefix, subPrefix));
+        }
+        else if (block.kind === 'quote') {
+            const quoteSpans = (block.spans ?? []).map((s) => ({ ...s, italic: true }));
+            lines.push(...wrapSpans(quoteSpans, width, `${dim('\u2502')} `, `${dim('\u2502')} `));
+        }
+        else if (block.kind === 'rule') {
+            lines.push(dim('\u2500'.repeat(width)));
+        }
+        else if (block.lines) {
+            lines.push(...block.lines.map((l) => cut(l, width)));
+        }
+        else {
+            lines.push(...wrapSpans(block.spans ?? [], width));
+        }
+    }
+    return lines;
+}
+/**
+ * Format markdown text into styled ANSI terminal lines wrapped to `width`.
+ */
+export function formatMarkdown(text, width = 80) {
+    return formatBlocks(blocksOf(text), width);
+}
+/**
+ * Format inline markdown text (bold, italic, code, links) into a styled ANSI string.
+ * Markers like backticks and asterisks are resolved and removed.
+ */
+export function formatInline(text) {
+    const spans = inlineOf(text);
+    return mergePieces(spans.map((s) => ({
+        text: s.text,
+        ...(s.bold ? { bold: true } : {}),
+        ...(s.italic ? { italic: true } : {}),
+        ...(s.code ? { code: true } : {}),
+        ...(s.href ? { href: s.href } : {}),
+    })))
+        .map(renderPiece)
+        .join('');
+}
+//# sourceMappingURL=markdown.js.map

package/dist/tui/theme.js

@@ -168,7 +168,7 @@ async function queryBackground(timeoutMs = 300) {
         stdout.write(QUERY);
     });
 }
-/** Components come back as 1–4 hex digits, so each is scaled by its own width. */
+/** Components come back as 1-4 hex digits, so each is scaled by its own width. */
 function appearanceOf(r, g, b) {
     const channel = (hex) => parseInt(hex, 16) / (16 ** hex.length - 1);
     const luminance = 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);

package/dist/tui/wrap.d.ts

@@ -154,7 +154,7 @@ export type Align = 'left' | 'right' | 'center';
  */
 export interface Block {
     kind: BlockKind;
-    /** `heading`: its depth, 1–6. `item`: how deep it is nested. */
+    /** `heading`: its depth, 1-6. `item`: how deep it is nested. */
     level?: number;
     /** the fence's info string, when it had one */
     title?: string;

package/dist/validate.js

@@ -7,7 +7,7 @@ import { resolveBuild } from "./image.js";
 import { SHAPES, envNames, form } from "./keys.js";
 import { probeModels } from "./liveness.js";
 import { BuildError, ensurePodmanReady } from "./podman.js";
-import { staleShared } from "./scaffold.js";
+import { ownVersion, staleShared } from "./scaffold.js";
 // Mirrors the loader's own constants (`packages/neo/src/project/load.ts`).
 // Duplicated rather than exported, because a check that agreed with the loader
 // by construction could not report that the two had diverged.
@@ -15,24 +15,87 @@ const CONFIG_NAMES = ['agents.yaml', 'agents.yml', 'agents/agents.yaml', 'agents
 const AGENTS_DIR = 'agents';
 const HOUSE_RULES = 'agents/instructions.md';
 const INSTRUCTIONS_SUFFIX = '-instructions.md';
+/** How file tools are used; without it the model has schemas only. */
+const FILE_RULES = 'agents/files-instructions.md';
 /** The only place memory is explained to a model; the runtime composes none of it. */
 const MEMORY_RULES = 'agents/memory-instructions.md';
 /** The only place forking is explained to a model; the same holds. */
 const FORK_RULES = 'agents/fork-instructions.md';
 /** The conditioned documents `zen` ships, which land whether or not they apply. */
-const OURS = new Set([MEMORY_RULES, FORK_RULES]);
+const OURS = new Set([FILE_RULES, MEMORY_RULES, FORK_RULES]);
 const PROMPTS_DIR = 'agents/prompts';
 const SKILLS_DIR = 'agents/skills';
 const SKILL_FILE = 'SKILL.md';
 const ASSETS_DIR = 'assets';
 /** What `allow:` and `preload:` accept, so a skill outside it cannot be named. */
 const REFERABLE = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/;
+const FILE_TOOLS = [
+    'read_file',
+    'list_dir',
+    'find_files',
+    'write_file',
+    'apply_patch',
+    'move_file',
+    'delete_file',
+];
+const FILE_WRITE_TOOLS = new Set(['write_file', 'apply_patch', 'move_file', 'delete_file']);
+function activeFileTools(selectors) {
+    const active = new Set();
+    if (!selectors?.length) {
+        return active;
+    }
+    for (const raw of selectors) {
+        const drop = raw.startsWith('-');
+        const selector = (drop ? raw.slice(1) : raw).trim();
+        if (selector === '*' || selector === 'files:*' || selector === 'workspace:*') {
+            for (const t of FILE_TOOLS) {
+                if (drop) {
+                    active.delete(t);
+                }
+                else {
+                    active.add(t);
+                }
+            }
+            continue;
+        }
+        const colon = selector.lastIndexOf(':');
+        const name = colon >= 0 ? selector.slice(colon + 1) : selector;
+        const group = colon >= 0 ? selector.slice(0, colon) : undefined;
+        if (FILE_TOOLS.includes(name)) {
+            if (!group || group === 'files' || group === 'workspace') {
+                if (drop) {
+                    active.delete(name);
+                }
+                else {
+                    active.add(name);
+                }
+            }
+        }
+    }
+    return active;
+}
+function hasFileTools(spec) {
+    return activeFileTools(spec.tools).size > 0;
+}
+function hasFileWriteTools(spec) {
+    const active = activeFileTools(spec.tools);
+    for (const t of FILE_WRITE_TOOLS) {
+        if (active.has(t)) {
+            return true;
+        }
+    }
+    return false;
+}
 /** What `requires:` may name. Mirrors `CAPABILITIES` in the loader. */
 const CAPABILITIES = {
     fork: (spec) => Boolean(spec.fork),
     memory: (spec) => Boolean(spec.memory),
     'memory-write': (spec) => spec.memory?.access === 'read-write' || spec.memory?.access === 'full',
     'memory-forget': (spec) => spec.memory?.access === 'full',
+    files: (spec) => hasFileTools(spec),
+    'files-write': (spec) => hasFileWriteTools(spec),
+    workspace: (spec) => hasFileTools(spec),
+    'workspace-write': (spec) => hasFileWriteTools(spec),
 };
 /**
  * Mirrors `readHouseRules` in the loader, in the same order:
@@ -276,7 +339,23 @@ export async function validateProject(opts) {
             });
         }
     }
-    // Present is not the same as current. These three files are copies of ours
+    // The same again for file operations: the file tools need instructions on
+    // discovery, safe reading, and patching. Without them the tools are granted
+    // with only their schemas to explain them.
+    if (config.agents.some((a) => hasFileTools(a))) {
+        const path = join(root, FILE_RULES);
+        if (!existsSync(path) || empty(path)) {
+            add({
+                severity: 'error',
+                code: 'files.uninstructed',
+                where: FILE_RULES,
+                message: 'an agent has file tools, but nothing tells it how to use them — ' +
+                    'the tools are granted with only their schemas to explain them',
+                fix: 'zen check --fix, which writes the current rules back',
+            });
+        }
+    }
+    // Present is not the same as current. These files are copies of ours
     // and nobody is meant to be maintaining them, so bytes that differ are an
     // older `zen`'s — prose about a runtime that has since moved, which reads
     // exactly as authoritative as the version that is true. The frontmatter
@@ -605,7 +684,7 @@ function checkAgent(root, config, spec, entry, available, rules, record, add) {
         try {
             tools = selectTools(available, [...selectors], {
                 where: `${where}.tools`,
-                hint: 'this CLI provides the workspace and sandbox groups',
+                hint: 'this CLI provides the files and sandbox groups',
             }).map((t) => t.name);
         }
         catch (err) {
@@ -1173,6 +1252,7 @@ function checkSandbox(root, config, record, add) {
     if (!ok) {
         return undefined;
     }
+    checkPin(join(root, file), file, add);
     try {
         return resolveBuild(root, config.sandbox);
     }
@@ -1186,6 +1266,72 @@ function checkSandbox(root, config, record, add) {
         return undefined;
     }
 }
+/** `@zenera/cli`, and the version after it when the line pins one. */
+const ZENERA_INSTALL = /@zenera\/([a-z0-9-]+)(?:@([^\s\\'"]+))?/g;
+/**
+ * Whether the Dockerfile's `@zenera/*` installs name this `zen`.
+ *
+ * `zen init` writes the version it was run by and never rewrites the file
+ * again — the scaffold keeps what the project already has — so the pin is fixed
+ * at creation and falls behind the host on the next upgrade. Nothing else
+ * notices: the file parses, the image builds, and the container simply holds a
+ * different `zen` than the session outside it, which is a mismatch that shows
+ * up as a tool behaving unlike its documentation.
+ *
+ * Read rather than run, so it is true on the laptop with no container engine —
+ * the one `--no-sandbox` leaves with no other word on the subject.
+ */
+function checkPin(path, rel, add) {
+    let text;
+    try {
+        // Existence is already a finding; an unreadable file is not worth a
+        // second one, and a throw here would cost every check after it.
+        text = readFileSync(path, 'utf8');
+    }
+    catch {
+        return;
+    }
+    const mine = ownVersion();
+    const stale = new Set();
+    const loose = new Set();
+    for (const line of text.split('\n')) {
+        // A comment naming the package is prose about the pin, not the pin.
+        if (/^\s*#/.test(line)) {
+            continue;
+        }
+        for (const match of line.matchAll(ZENERA_INSTALL)) {
+            const name = `@zenera/${match[1]}`;
+            const pinned = match[2];
+            if (pinned === undefined) {
+                loose.add(name);
+            }
+            else if (pinned !== mine) {
+                stale.add(`${name}@${pinned}`);
+            }
+        }
+    }
+    const fix = `pin them to ${mine}, the version \`zen --version\` reports`;
+    if (stale.size > 0) {
+        add({
+            severity: 'warning',
+            code: 'sandbox.pin.stale',
+            where: rel,
+            message: `installs ${[...stale].join(', ')}, but this \`zen\` is ${mine} — the CLI an ` +
+                'agent runs inside the container is not the one that built the session',
+            fix,
+        });
+    }
+    if (loose.size > 0) {
+        add({
+            severity: 'warning',
+            code: 'sandbox.pin.absent',
+            where: rel,
+            message: `installs ${[...loose].join(', ')} unpinned, so the next image build takes ` +
+                'whatever is current and drifts away from the host without saying so',
+            fix,
+        });
+    }
+}
 /** Written by the smoke test and read back, to prove the mount is real. */
 const SMOKE = 'zen-check';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/cli",
-    "version": "1.1.21",
+    "version": "1.1.23",
     "description": "Command-line front end for @zenera/neo: agentic projects you can run, share and commit.",
     "keywords": [
         "agents",
@@ -48,14 +48,20 @@
         "prepack": "tsc -b"
     },
     "dependencies": {
-        "@inkjs/ui": "^2.0.0",
-        "ink": "^7.1.1",
-        "react": "^19.2.8",
-        "@zenera/neo": "^1.1.21",
         "@anthropic-ai/sdk": "^0.120.0",
         "@google/genai": "^2.18.0",
+        "@inkjs/ui": "^2.0.0",
         "@openrouter/sdk": "^1.2.80",
+        "@zenera/neo": "^1.1.23",
         "google-auth-library": "^10.0.0",
-        "openai": "^6.0.0"
+        "ink": "^7.1.1",
+        "openai": "^6.0.0",
+        "react": "^19.2.8",
+        "yauzl": "^3.4.0",
+        "yazl": "^3.3.1"
+    },
+    "devDependencies": {
+        "@types/yauzl": "^3.4.0",
+        "@types/yazl": "^3.3.1"
     }
 }