smol-symphony 0.2.0 → 0.3.0

package/dist/src/core/runner/prompt.js

@@ -0,0 +1,720 @@
+// FCIS rewrite — PURE functional-core prompt construction for the runner.
+//
+// Responsibility (ported from the original src/prompt.ts + the prompt-building
+// helpers inlined in the original src/agent/runner.ts):
+//   - renderPrompt:            strict Liquid render of a state's prompt template
+//                              against the issue scope (initial / first turn).
+//   - continuationPrompt:      the bare follow-up turn prompt (MCP on/off).
+//   - buildSteeringReplyPrompt: the human-in-the-loop reply prompt.
+//   - selectPromptKind:        pick which of the three to use this iteration.
+//   - composePrompt:           one entry the shell calls per turn.
+//   - stageDonePrBodyEnv:      the Done-state PR-body/title staging env-map shape.
+//
+// 100% SYNCHRONOUS, zero IO, zero node: imports. Imports ONLY from src/types.
+//
+// The REF renders with liquidjs in async mode (`ENGINE.render`). liquidjs is a
+// third-party engine and importing it is forbidden here (core may import only
+// src/types). So this module ships a small, SELF-CONTAINED, *synchronous* strict
+// Liquid interpreter covering exactly the constructs the real workflow prompt
+// templates use today: `{{ output | filters }}`, `{% if/unless %}`, `{% for %}`
+// (+ `forloop.last`), `{% case/when/else %}`, dotted/`.size` access, whitespace
+// control (`-%}` / `{%-`), and the strictVariables / strictFilters /
+// ownPropertyOnly semantics (unknown var or unknown filter → PromptError).
+//
+// Note: this is a faithful SUBSET, not the full liquidjs surface. A construct
+// outside the set above (e.g. `assign`, `capture`, `tablerow`, arithmetic
+// filters) hits the unknown-tag path and throws PromptError('template_parse_error',
+// …), so any such gap fails loudly rather than silently mis-rendering — at which
+// point either extend this interpreter or move the render into the shell as an
+// Effect executed via liquidjs.
+import { PromptError } from '../../types/errors.js';
+/** Convert an Issue into the template scope. Preserves nested arrays/maps. */
+export function issueToScope(issue) {
+    return {
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description,
+        priority: issue.priority,
+        state: issue.state,
+        branch_name: issue.branch_name,
+        url: issue.url,
+        labels: issue.labels.slice(),
+        blocked_by: issue.blocked_by.map((b) => ({
+            id: b.id,
+            identifier: b.identifier,
+            state: b.state,
+        })),
+        created_at: issue.created_at,
+        updated_at: issue.updated_at,
+    };
+}
+/** §4.4 fallback when the workflow body is empty. */
+export const FALLBACK_PROMPT = 'You are working on an issue.';
+/**
+ * Strict Liquid render of the initial prompt. Empty body → FALLBACK_PROMPT.
+ * Unknown variable / filter / tag → PromptError (parse vs render code).
+ */
+export function renderPrompt(input) {
+    const tpl = input.template.trim();
+    if (tpl.length === 0)
+        return FALLBACK_PROMPT;
+    const scope = {
+        issue: issueToScope(input.issue),
+        attempt: input.attempt,
+    };
+    return renderLiquid(tpl, scope);
+}
+// ---------------------------------------------------------------------------
+// continuationPrompt (REF runner.ts CONTINUATION_PROMPT_* + continuationPrompt)
+// ---------------------------------------------------------------------------
+export const CONTINUATION_PROMPT_WITH_MCP = 'Continue working on the same issue. Pick up where the prior turn left off and proceed with the next concrete action. If the work is fully complete, summarize what changed and call the symphony.transition tool to hand off to the next state.';
+export const CONTINUATION_PROMPT_NO_MCP = 'Continue working on the same issue. Pick up where the prior turn left off and proceed with the next concrete action. If the work is fully complete, summarize what changed and stop.';
+/** The bare follow-up turn prompt; MCP-on routes the agent to symphony.transition. */
+export function continuationPrompt(mcpEnabled) {
+    return mcpEnabled ? CONTINUATION_PROMPT_WITH_MCP : CONTINUATION_PROMPT_NO_MCP;
+}
+// ---------------------------------------------------------------------------
+// buildSteeringReplyPrompt (REF runner.ts `buildSteeringReplyPrompt`)
+// ---------------------------------------------------------------------------
+/** Compose the human-in-the-loop reply prompt. Collapses 3+ blank lines to 2. */
+export function buildSteeringReplyPrompt(question, context, reply) {
+    const ctxBlock = context && context.length > 0 ? `\n\nContext you provided:\n${context}` : '';
+    return [
+        'The human operator has responded to your steering request.',
+        '',
+        'Your question was:',
+        question,
+        ctxBlock,
+        '',
+        'The human responded:',
+        reply,
+        '',
+        'Continue work on the issue, taking the human response into account. If the work is fully complete, call symphony.transition to hand off to the next state. If you need to ask another question, call symphony.request_human_steering again.',
+    ]
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n');
+}
+// ---------------------------------------------------------------------------
+// selectPromptKind + composePrompt (REF runner.ts selectPromptKind / composeTurnPrompt)
+// ---------------------------------------------------------------------------
+/**
+ * Pick the prompt template for the next iteration. Pending steering trumps
+ * everything (human in the loop); then the first-turn full prompt; then the
+ * bare continuation prompt.
+ */
+export function selectPromptKind(input) {
+    if (input.pendingSteering)
+        return 'steering';
+    if (input.firstTurn)
+        return 'initial';
+    return 'continuation';
+}
+/**
+ * Single pure entry the shell calls per turn (mirrors REF `composeTurnPrompt`).
+ * Throws PromptError for an unknown var/filter/tag in the initial template.
+ */
+export function composePrompt(input) {
+    const kind = selectPromptKind({
+        pendingSteering: input.pendingSteering !== null,
+        firstTurn: input.firstTurn,
+    });
+    if (kind === 'steering') {
+        const ps = input.pendingSteering;
+        return { kind, prompt: buildSteeringReplyPrompt(ps.question, ps.context, ps.reply) };
+    }
+    if (kind === 'initial') {
+        return {
+            kind,
+            prompt: renderPrompt({ template: input.template, issue: input.issue, attempt: input.attempt }),
+        };
+    }
+    return { kind, prompt: continuationPrompt(input.mcpEnabled) };
+}
+/**
+ * The SYMPHONY_* env map the Done-state `actions:` block (push_branch +
+ * create_pr_if_missing) consumes. Pure: no clock, no fs, no randomness.
+ * PR title is `<id>: <title>` when the title is non-empty after trimming,
+ * else just `<id>` (REF parity).
+ */
+export function stageDonePrBodyEnv(input) {
+    const branch = `agent/${input.identifier}`;
+    const title = input.issue_title.trim();
+    return {
+        SYMPHONY_ISSUE_ID: input.issue_id,
+        SYMPHONY_BRANCH: branch,
+        SYMPHONY_BASE_BRANCH: input.base_branch,
+        SYMPHONY_PR_TITLE: title.length > 0 ? `${input.issue_id}: ${title}` : input.issue_id,
+        SYMPHONY_PR_BODY_FILE: input.pr_body_file,
+    };
+}
+const UNDEF = Symbol('undefined-liquid-value');
+function tokenize(src) {
+    const tokens = [];
+    let i = 0;
+    const n = src.length;
+    while (i < n) {
+        const open = src.indexOf('{', i);
+        if (open === -1 || open + 1 >= n) {
+            tokens.push({ type: 'text', value: src.slice(i) });
+            break;
+        }
+        const marker = src[open + 1];
+        if (marker !== '{' && marker !== '%') {
+            // a lone '{' — emit up to and including it as text, keep scanning.
+            tokens.push({ type: 'text', value: src.slice(i, open + 1) });
+            i = open + 1;
+            continue;
+        }
+        if (open > i)
+            tokens.push({ type: 'text', value: src.slice(i, open) });
+        const isOutput = marker === '{';
+        const closeSeq = isOutput ? '}}' : '%}';
+        const close = src.indexOf(closeSeq, open + 2);
+        if (close === -1) {
+            throw new PromptError('template_parse_error', `unterminated ${isOutput ? 'output' : 'tag'}`);
+        }
+        let inner = src.slice(open + 2, close);
+        let trimLeft = false;
+        let trimRight = false;
+        if (inner.startsWith('-')) {
+            trimLeft = true;
+            inner = inner.slice(1);
+        }
+        if (inner.endsWith('-')) {
+            trimRight = true;
+            inner = inner.slice(0, -1);
+        }
+        inner = inner.trim();
+        tokens.push(isOutput
+            ? { type: 'output', value: inner, trimLeft, trimRight }
+            : { type: 'tag', value: inner, trimLeft, trimRight });
+        i = close + 2;
+    }
+    return applyWhitespaceControl(tokens);
+}
+/** Honor `-%}` / `{%-` whitespace stripping on adjacent text tokens. */
+function applyWhitespaceControl(tokens) {
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.type === 'text')
+            continue;
+        if (t.trimLeft) {
+            const prev = tokens[k - 1];
+            if (prev && prev.type === 'text')
+                prev.value = prev.value.replace(/\s+$/, '');
+        }
+        if (t.trimRight) {
+            const next = tokens[k + 1];
+            if (next && next.type === 'text')
+                next.value = next.value.replace(/^\s+/, '');
+        }
+    }
+    return tokens;
+}
+function parse(tokens) {
+    let pos = 0;
+    function parseUntil(stopTags) {
+        const nodes = [];
+        while (pos < tokens.length) {
+            const t = tokens[pos];
+            if (t.type === 'text') {
+                if (t.value.length > 0)
+                    nodes.push({ type: 'text', value: t.value });
+                pos++;
+                continue;
+            }
+            if (t.type === 'output') {
+                nodes.push({ type: 'output', expr: t.value });
+                pos++;
+                continue;
+            }
+            // tag
+            const tagName = t.value.split(/\s+/)[0];
+            if (stopTags.includes(tagName)) {
+                return { nodes, stoppedAt: tagName };
+            }
+            pos++;
+            if (tagName === 'if' || tagName === 'unless') {
+                nodes.push(parseConditional(t.value, tagName));
+            }
+            else if (tagName === 'for') {
+                nodes.push(parseFor(t.value));
+            }
+            else if (tagName === 'case') {
+                nodes.push(parseCase(t.value));
+            }
+            else {
+                throw new PromptError('template_parse_error', `unknown tag "${tagName}"`);
+            }
+        }
+        return { nodes, stoppedAt: null };
+    }
+    function parseConditional(openValue, kind) {
+        const rest = openValue.slice(kind.length).trim();
+        const branches = [];
+        const endTag = kind === 'if' ? 'endif' : 'endunless';
+        // `unless X` is `if not X`; encode by wrapping the condition.
+        const firstCond = kind === 'unless' ? `__unless__ ${rest}` : rest;
+        let curCond = firstCond;
+        for (;;) {
+            const { nodes, stoppedAt } = parseUntil(['elsif', 'else', endTag]);
+            branches.push({ cond: curCond, body: nodes });
+            if (stoppedAt === endTag || stoppedAt === null) {
+                expectClose(endTag);
+                break;
+            }
+            const stopTok = tokens[pos];
+            pos++;
+            if (stoppedAt === 'else') {
+                const elseBlock = parseUntil([endTag]);
+                branches.push({ cond: null, body: elseBlock.nodes });
+                expectClose(endTag);
+                break;
+            }
+            // elsif
+            curCond = stopTok.value.slice('elsif'.length).trim();
+        }
+        return { type: 'if', branches };
+    }
+    function parseFor(openValue) {
+        // `for <var> in <collection>`
+        const m = /^for\s+(\w+)\s+in\s+(.+)$/.exec(openValue);
+        if (!m)
+            throw new PromptError('template_parse_error', `malformed for tag: ${openValue}`);
+        const varName = m[1];
+        const collExpr = m[2].trim();
+        const { nodes, stoppedAt } = parseUntil(['endfor']);
+        if (stoppedAt !== 'endfor')
+            throw new PromptError('template_parse_error', 'unterminated for');
+        expectClose('endfor');
+        return { type: 'for', varName, collExpr, body: nodes };
+    }
+    function parseCase(openValue) {
+        const subject = openValue.slice('case'.length).trim();
+        const whens = [];
+        let elseBody = [];
+        // Skip any text/whitespace before the first when/else/endcase.
+        for (;;) {
+            const { stoppedAt } = parseUntil(['when', 'else', 'endcase']);
+            if (stoppedAt === null)
+                throw new PromptError('template_parse_error', 'unterminated case');
+            const tok = tokens[pos];
+            pos++;
+            if (stoppedAt === 'endcase') {
+                expectClose('endcase');
+                break;
+            }
+            if (stoppedAt === 'else') {
+                const block = parseUntil(['endcase']);
+                elseBody = block.nodes;
+                expectClose('endcase');
+                break;
+            }
+            // when — collect comma/`or` separated literals, then its body.
+            const matchSpec = tok.value.slice('when'.length).trim();
+            const matches = matchSpec.split(/\s*,\s*|\s+or\s+/).map((s) => s.trim());
+            const block = parseUntil(['when', 'else', 'endcase']);
+            whens.push({ matches, body: block.nodes });
+            // Do NOT consume the next when/else/endcase here; loop re-enters parseUntil
+            // which will immediately stop on it. Rewind one parseUntil iteration by
+            // continuing the outer loop (pos already points at the stop tag).
+        }
+        return { type: 'case', subject, whens, elseBody };
+    }
+    function expectClose(endTag) {
+        const t = tokens[pos];
+        if (!t || t.type !== 'tag' || t.value.split(/\s+/)[0] !== endTag) {
+            throw new PromptError('template_parse_error', `expected ${endTag}`);
+        }
+        pos++;
+    }
+    const { nodes, stoppedAt } = parseUntil([]);
+    if (stoppedAt !== null) {
+        throw new PromptError('template_parse_error', `unexpected ${stoppedAt}`);
+    }
+    return nodes;
+}
+// --- Renderer (node tree + scope → string) --------------------------------
+function renderNodes(nodes, scope) {
+    let out = '';
+    for (const node of nodes) {
+        out += renderNode(node, scope);
+    }
+    return out;
+}
+function renderNode(node, scope) {
+    switch (node.type) {
+        case 'text':
+            return node.value;
+        case 'output':
+            return stringify(evalOutput(node.expr, scope));
+        case 'if': {
+            for (const branch of node.branches) {
+                if (branch.cond === null || evalCondition(branch.cond, scope)) {
+                    return renderNodes(branch.body, scope);
+                }
+            }
+            return '';
+        }
+        case 'for': {
+            const coll = evalExpr(node.collExpr, scope);
+            const items = Array.isArray(coll) ? coll : [];
+            let out = '';
+            const len = items.length;
+            for (let idx = 0; idx < len; idx++) {
+                const childScope = {
+                    ...scope,
+                    [node.varName]: items[idx],
+                    forloop: {
+                        index: idx + 1,
+                        index0: idx,
+                        first: idx === 0,
+                        last: idx === len - 1,
+                        length: len,
+                    },
+                };
+                out += renderNodes(node.body, childScope);
+            }
+            return out;
+        }
+        case 'case': {
+            const subject = evalExpr(node.subject, scope);
+            for (const when of node.whens) {
+                for (const m of when.matches) {
+                    if (looseEq(subject, evalLiteralOrVar(m, scope))) {
+                        return renderNodes(when.body, scope);
+                    }
+                }
+            }
+            return renderNodes(node.elseBody, scope);
+        }
+    }
+}
+// --- Expression evaluation -------------------------------------------------
+/** Evaluate an output expression: `value | filter: arg | filter2`. */
+function evalOutput(expr, scope) {
+    const parts = splitPipes(expr);
+    let value = evalExpr(parts[0].trim(), scope);
+    for (let k = 1; k < parts.length; k++) {
+        value = applyFilter(parts[k].trim(), value, scope);
+    }
+    return value;
+}
+/** Split on `|` that are not inside quotes. */
+function splitPipes(expr) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (const ch of expr) {
+        if (quote) {
+            cur += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            cur += ch;
+            continue;
+        }
+        if (ch === '|') {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    out.push(cur);
+    return out;
+}
+/**
+ * Evaluate a primary expression: a literal, or a dotted/bracket variable path.
+ * Strict: an unknown variable throws PromptError('template_render_error').
+ */
+function evalExpr(expr, scope) {
+    const lit = parseLiteral(expr);
+    if (lit !== UNDEF)
+        return lit;
+    const v = resolvePath(expr, scope);
+    if (v === UNDEF) {
+        throw new PromptError('template_render_error', `undefined variable: ${expr}`);
+    }
+    return v;
+}
+/** Like evalExpr but a bare word that is not a known var is treated as a string literal (case/when RHS). */
+function evalLiteralOrVar(expr, scope) {
+    const lit = parseLiteral(expr);
+    if (lit !== UNDEF)
+        return lit;
+    const v = resolvePath(expr, scope);
+    return v === UNDEF ? expr : v;
+}
+function parseLiteral(expr) {
+    const e = expr.trim();
+    if ((e.startsWith('"') && e.endsWith('"') && e.length >= 2) ||
+        (e.startsWith("'") && e.endsWith("'") && e.length >= 2)) {
+        return e.slice(1, -1);
+    }
+    if (e === 'true')
+        return true;
+    if (e === 'false')
+        return false;
+    if (e === 'nil' || e === 'null' || e === 'empty')
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(e))
+        return Number(e);
+    return UNDEF;
+}
+/**
+ * Resolve a dotted / `.size` / bracket path against the scope using
+ * own-property-only semantics. Returns UNDEF when any hop is missing.
+ */
+function resolvePath(path, scope) {
+    const segs = splitPath(path);
+    if (segs.length === 0)
+        return UNDEF;
+    let cur = scope;
+    let first = true;
+    for (const seg of segs) {
+        if (first) {
+            // top-level scope lookup is always own-prop on the scope object
+            if (!hasOwn(scope, seg))
+                return UNDEF;
+            cur = scope[seg];
+            first = false;
+            continue;
+        }
+        if (cur == null)
+            return UNDEF;
+        if (seg === 'size') {
+            if (Array.isArray(cur))
+                cur = cur.length;
+            else if (typeof cur === 'string')
+                cur = cur.length;
+            else
+                return UNDEF;
+            continue;
+        }
+        if (Array.isArray(cur)) {
+            const n = Number(seg);
+            if (!Number.isInteger(n))
+                return UNDEF;
+            cur = cur[n];
+            continue;
+        }
+        if (typeof cur === 'object') {
+            if (!hasOwn(cur, seg))
+                return UNDEF;
+            cur = cur[seg];
+            continue;
+        }
+        return UNDEF;
+    }
+    return cur;
+}
+function splitPath(path) {
+    // Support `a.b.c` and `a[0].b`; brackets become path segments.
+    const normalized = path.replace(/\[\s*['"]?([^'"\]]+)['"]?\s*\]/g, '.$1');
+    return normalized
+        .split('.')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+// --- Conditions ------------------------------------------------------------
+/** Evaluate an `if`/`elsif`/`unless` condition (supports and/or, comparisons). */
+function evalCondition(cond, scope) {
+    let negate = false;
+    let c = cond.trim();
+    if (c.startsWith('__unless__')) {
+        negate = true;
+        c = c.slice('__unless__'.length).trim();
+    }
+    const result = evalBoolExpr(c, scope);
+    return negate ? !result : result;
+}
+function evalBoolExpr(expr, scope) {
+    // `or` binds looser than `and` (Liquid evaluates right-to-left but the
+    // boolean result is the same for our supported operators).
+    const orParts = splitOnKeyword(expr, 'or');
+    if (orParts.length > 1) {
+        return orParts.some((p) => evalBoolExpr(p, scope));
+    }
+    const andParts = splitOnKeyword(expr, 'and');
+    if (andParts.length > 1) {
+        return andParts.every((p) => evalBoolExpr(p, scope));
+    }
+    return evalComparison(expr.trim(), scope);
+}
+/** Split `expr` on a whitespace-delimited `and`/`or` keyword, ignoring quotes. */
+function splitOnKeyword(expr, keyword) {
+    const out = [];
+    let quote = null;
+    let cur = '';
+    for (const t of expr.split(/(\s+)/)) {
+        if (quote) {
+            cur += t;
+            if (t.includes(quote))
+                quote = null;
+        }
+        else if (/^['"]/.test(t) && !t.endsWith(t[0])) {
+            quote = t[0];
+            cur += t;
+        }
+        else if (t === keyword) {
+            out.push(cur);
+            cur = '';
+        }
+        else {
+            cur += t;
+        }
+    }
+    out.push(cur);
+    return out.length === 1 ? [expr] : out.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+const COMPARATORS = [
+    ['==', (a, b) => looseEq(a, b)],
+    ['!=', (a, b) => !looseEq(a, b)],
+    ['>=', (a, b) => Number(a) >= Number(b)],
+    ['<=', (a, b) => Number(a) <= Number(b)],
+    ['>', (a, b) => Number(a) > Number(b)],
+    ['<', (a, b) => Number(a) < Number(b)],
+];
+function evalComparison(expr, scope) {
+    for (const [op, fn] of COMPARATORS) {
+        const idx = findOp(expr, op);
+        if (idx !== -1) {
+            const lhs = expr.slice(0, idx).trim();
+            const rhs = expr.slice(idx + op.length).trim();
+            return fn(evalSoft(lhs, scope), evalSoft(rhs, scope));
+        }
+    }
+    // Bare truthiness test (`{% if attempt %}` / `{% if issue.description %}`).
+    return truthy(evalSoft(expr, scope));
+}
+/** Find a comparison operator outside quotes; returns -1 if absent. */
+function findOp(expr, op) {
+    let quote = null;
+    for (let i = 0; i + op.length <= expr.length; i++) {
+        const ch = expr[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        // Don't match '>'/'<' that are really the start of '>='/'<=' (longer ops
+        // are tried first, so a bare '>' here is genuine only if no '=' follows).
+        if (expr.startsWith(op, i)) {
+            if ((op === '>' || op === '<') && expr[i + 1] === '=')
+                continue;
+            return i;
+        }
+    }
+    return -1;
+}
+/** Soft evaluation: literal, else variable path that yields undefined→null (no throw). */
+function evalSoft(expr, scope) {
+    const lit = parseLiteral(expr);
+    if (lit !== UNDEF)
+        return lit;
+    const v = resolvePath(expr, scope);
+    return v === UNDEF ? null : v;
+}
+function looseEq(a, b) {
+    if (a === b)
+        return true;
+    if (a == null && b == null)
+        return true;
+    // Liquid treats `nil`/`empty` specially; for our use string vs string is enough.
+    if (typeof a === 'string' && typeof b === 'string')
+        return a === b;
+    return false;
+}
+function truthy(v) {
+    // Liquid: only nil and false are falsy; 0 and '' are truthy.
+    return v !== null && v !== undefined && v !== false;
+}
+// --- Filters ---------------------------------------------------------------
+/**
+ * Apply a filter `name: arg1, arg2`. Strict: an unknown filter name throws
+ * PromptError('template_render_error') (REF strictFilters: true).
+ */
+function applyFilter(spec, value, scope) {
+    const colon = spec.indexOf(':');
+    const name = (colon === -1 ? spec : spec.slice(0, colon)).trim();
+    const argStr = colon === -1 ? '' : spec.slice(colon + 1);
+    const args = argStr
+        .split(',')
+        .map((a) => a.trim())
+        .filter((a) => a.length > 0)
+        .map((a) => evalSoft(a, scope));
+    const fn = FILTERS[name];
+    if (!fn) {
+        throw new PromptError('template_render_error', `unknown filter: ${name}`);
+    }
+    return fn(value, args);
+}
+const FILTERS = {
+    upcase: (v) => stringify(v).toUpperCase(),
+    downcase: (v) => stringify(v).toLowerCase(),
+    capitalize: (v) => {
+        const s = stringify(v);
+        return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+    },
+    strip: (v) => stringify(v).trim(),
+    size: (v) => (Array.isArray(v) ? v.length : stringify(v).length),
+    default: (v, args) => (truthy(v) && stringify(v).length > 0 ? v : (args[0] ?? '')),
+    join: (v, args) => (Array.isArray(v) ? v.map(stringify).join(stringify(args[0] ?? ' ')) : stringify(v)),
+    first: (v) => (Array.isArray(v) ? v[0] : stringify(v)[0]),
+    last: (v) => (Array.isArray(v) ? v[v.length - 1] : stringify(v).slice(-1)),
+    append: (v, args) => stringify(v) + stringify(args[0] ?? ''),
+    prepend: (v, args) => stringify(args[0] ?? '') + stringify(v),
+    replace: (v, args) => stringify(v).split(stringify(args[0] ?? '')).join(stringify(args[1] ?? '')),
+    truncate: (v, args) => {
+        const s = stringify(v);
+        const n = typeof args[0] === 'number' ? args[0] : Number(args[0] ?? 50);
+        return s.length <= n ? s : s.slice(0, Math.max(0, n - 3)) + '...';
+    },
+};
+// --- Output stringification ------------------------------------------------
+function stringify(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    if (Array.isArray(v))
+        return v.map(stringify).join('');
+    return String(v);
+}
+// --- Top-level render ------------------------------------------------------
+function renderLiquid(template, scope) {
+    let tokens;
+    let nodes;
+    try {
+        tokens = tokenize(template);
+        nodes = parse(tokens);
+    }
+    catch (err) {
+        if (err instanceof PromptError && err.code === 'template_parse_error')
+            throw err;
+        throw new PromptError('template_parse_error', err.message);
+    }
+    try {
+        return renderNodes(nodes, scope);
+    }
+    catch (err) {
+        if (err instanceof PromptError)
+            throw err;
+        throw new PromptError('template_render_error', err.message);
+    }
+}
+//# sourceMappingURL=prompt.js.map