@phren/agent 0.1.2 → 0.1.4

package/dist/providers/anthropic.js

@@ -4,28 +4,15 @@ export class AnthropicProvider {
     maxOutputTokens;
     apiKey;
     model;
-    constructor(apiKey, model, maxOutputTokens) {
+    cacheEnabled;
+    constructor(apiKey, model, maxOutputTokens, cacheEnabled = true) {
         this.apiKey = apiKey;
         this.model = model ?? "claude-sonnet-4-20250514";
         this.maxOutputTokens = maxOutputTokens ?? 8192;
+        this.cacheEnabled = cacheEnabled;
     }
     async chat(system, messages, tools) {
-        const body = {
-            model: this.model,
-            system,
-            messages: messages.map((m) => ({
-                role: m.role,
-                content: m.content,
-            })),
-            max_tokens: this.maxOutputTokens,
-        };
-        if (tools.length > 0) {
-            body.tools = tools.map((t) => ({
-                name: t.name,
-                description: t.description,
-                input_schema: t.input_schema,
-            }));
-        }
+        const body = this.buildRequestBody(system, messages, tools);
         const res = await fetch("https://api.anthropic.com/v1/messages", {
             method: "POST",
             headers: {
@@ -45,6 +32,7 @@ export class AnthropicProvider {
             : data.stop_reason === "max_tokens" ? "max_tokens"
                 : "end_turn";
         const usage = data.usage;
+        logCacheUsage(usage);
         return {
             content,
             stop_reason: stop_reason,
@@ -52,20 +40,8 @@ export class AnthropicProvider {
         };
     }
     async *chatStream(system, messages, tools) {
-        const body = {
-            model: this.model,
-            system,
-            messages: messages.map((m) => ({ role: m.role, content: m.content })),
-            max_tokens: this.maxOutputTokens,
-            stream: true,
-        };
-        if (tools.length > 0) {
-            body.tools = tools.map((t) => ({
-                name: t.name,
-                description: t.description,
-                input_schema: t.input_schema,
-            }));
-        }
+        const body = this.buildRequestBody(system, messages, tools);
+        body.stream = true;
         const res = await fetch("https://api.anthropic.com/v1/messages", {
             method: "POST",
             headers: {
@@ -118,26 +94,89 @@ export class AnthropicProvider {
                     stopReason = "tool_use";
                 else if (delta.stop_reason === "max_tokens")
                     stopReason = "max_tokens";
+                // message_delta carries output_tokens — merge with existing input_tokens from message_start
                 const u = data.usage;
                 if (u) {
                     usage = {
-                        input_tokens: u.input_tokens ?? 0,
+                        input_tokens: usage?.input_tokens ?? 0,
                         output_tokens: u.output_tokens ?? 0,
                     };
                 }
             }
             else if (type === "message_start") {
+                // message_start carries input_tokens — initialize usage
                 const u = data.message?.usage;
                 if (u) {
+                    logCacheUsage(u);
                     usage = {
                         input_tokens: u.input_tokens ?? 0,
-                        output_tokens: u.output_tokens ?? 0,
+                        output_tokens: usage?.output_tokens ?? 0,
                     };
                 }
             }
         }
         yield { type: "done", stop_reason: stopReason, usage };
     }
+    /** Build the request body with optional prompt caching breakpoints. */
+    buildRequestBody(system, messages, tools) {
+        const cache = { cache_control: { type: "ephemeral" } };
+        // System prompt: use content array format with cache_control on the text block
+        const systemValue = this.cacheEnabled
+            ? [{ type: "text", text: system, ...cache }]
+            : system;
+        const mappedMessages = messages.map((m) => ({ role: m.role, content: m.content }));
+        // Mark the last 2 user messages with cache_control for recent-context caching
+        if (this.cacheEnabled) {
+            let marked = 0;
+            for (let i = mappedMessages.length - 1; i >= 0 && marked < 2; i--) {
+                if (mappedMessages[i].role !== "user")
+                    continue;
+                const c = mappedMessages[i].content;
+                if (typeof c === "string") {
+                    mappedMessages[i] = {
+                        role: "user",
+                        content: [{ type: "text", text: c, ...cache }],
+                    };
+                }
+                else if (Array.isArray(c) && c.length > 0) {
+                    // Add cache_control to the last block of the content array
+                    const blocks = [...c];
+                    blocks[blocks.length - 1] = { ...blocks[blocks.length - 1], ...cache };
+                    mappedMessages[i] = { role: "user", content: blocks };
+                }
+                marked++;
+            }
+        }
+        const body = {
+            model: this.model,
+            system: systemValue,
+            messages: mappedMessages,
+            max_tokens: this.maxOutputTokens,
+        };
+        if (tools.length > 0) {
+            const mappedTools = tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.input_schema,
+            }));
+            // Cache the last tool definition — Anthropic uses it as the breakpoint for the entire tools block
+            if (this.cacheEnabled) {
+                mappedTools[mappedTools.length - 1] = { ...mappedTools[mappedTools.length - 1], ...cache };
+            }
+            body.tools = mappedTools;
+        }
+        return body;
+    }
+}
+/** Log cache hit/creation stats to stderr (visible in verbose mode). */
+function logCacheUsage(usage) {
+    if (!usage)
+        return;
+    const created = usage.cache_creation_input_tokens;
+    const read = usage.cache_read_input_tokens;
+    if (created || read) {
+        process.stderr.write(`[cache] created=${created ?? 0} read=${read ?? 0} input=${usage.input_tokens ?? 0}\n`);
+    }
 }
 /** Parse SSE stream from a fetch Response. */
 async function* parseSSE(res) {

package/dist/providers/codex.js

@@ -10,7 +10,7 @@ function toResponsesTools(tools) {
     }));
 }
 /** Convert our messages to Responses API input format. */
-function toResponsesInput(system, messages) {
+function toResponsesInput(messages) {
     const input = [];
     for (const msg of messages) {
         if (msg.role === "user") {
@@ -91,11 +91,16 @@ function parseResponsesOutput(data) {
             }
             else if (item.type === "function_call") {
                 hasToolUse = true;
+                let input = {};
+                try {
+                    input = JSON.parse(item.arguments);
+                }
+                catch { /* malformed arguments */ }
                 content.push({
                     type: "tool_use",
                     id: item.call_id,
                     name: item.name,
-                    input: JSON.parse(item.arguments),
+                    input,
                 });
             }
         }
@@ -125,7 +130,7 @@ export class CodexProvider {
         const body = {
             model: this.model,
             instructions: system,
-            input: toResponsesInput(system, messages),
+            input: toResponsesInput(messages),
             store: false,
             stream: true,
         };
@@ -185,7 +190,7 @@ export class CodexProvider {
         const body = {
             model: this.model,
             instructions: system,
-            input: toResponsesInput(system, messages),
+            input: toResponsesInput(messages),
             store: false,
             stream: true,
             include: ["reasoning.encrypted_content"],
@@ -194,73 +199,129 @@ export class CodexProvider {
             body.tools = toResponsesTools(tools);
             body.tool_choice = "auto";
         }
-        const res = await fetch(CODEX_API, {
-            method: "POST",
+        // Use WebSocket for true token-by-token streaming (matches Codex CLI behavior).
+        // The HTTP SSE endpoint batches the entire response before flushing.
+        yield* this.chatStreamWs(accessToken, body);
+    }
+    /** WebSocket streaming — sends request, yields deltas as they arrive. */
+    async *chatStreamWs(accessToken, body) {
+        const wsUrl = CODEX_API.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+        // Queue for events received from the WebSocket before the consumer pulls them
+        const queue = [];
+        let resolve = null;
+        let done = false;
+        const push = (item) => {
+            queue.push(item);
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        };
+        // Node.js (undici) WebSocket accepts headers in the second argument object,
+        // but the DOM typings only allow string | string[]. Cast to bypass.
+        const ws = new WebSocket(wsUrl, {
             headers: {
-                "Content-Type": "application/json",
                 Authorization: `Bearer ${accessToken}`,
             },
-            body: JSON.stringify(body),
         });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Codex API error ${res.status}: ${text}`);
-        }
-        // Parse SSE stream
-        if (!res.body)
-            throw new Error("Provider returned empty response body");
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
         let activeToolCallId = "";
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop();
-            for (const line of lines) {
-                if (!line.startsWith("data: "))
-                    continue;
-                const data = line.slice(6).trim();
-                if (data === "[DONE]")
-                    return;
-                let event;
+        ws.addEventListener("open", () => {
+            // Wrap the request body in a response.create envelope (Codex WS protocol)
+            const wsRequest = { type: "response.create", ...body };
+            ws.send(JSON.stringify(wsRequest));
+        });
+        ws.addEventListener("message", (evt) => {
+            const data = typeof evt.data === "string" ? evt.data : String(evt.data);
+            let event;
+            try {
+                event = JSON.parse(data);
+            }
+            catch {
+                return;
+            }
+            const type = event.type;
+            // Handle server-side errors
+            if (type === "error") {
+                const err = event.error;
+                const msg = err?.message ?? "Codex WebSocket error";
+                const status = event.status;
+                push(new Error(`Codex WS error${status ? ` ${status}` : ""}: ${msg}`));
+                done = true;
                 try {
-                    event = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const type = event.type;
-                if (type === "response.output_text.delta") {
-                    yield { type: "text_delta", text: event.delta };
+                    ws.close();
                 }
-                else if (type === "response.output_item.added") {
-                    if (event.item?.type === "function_call") {
-                        const item = event.item;
-                        activeToolCallId = item.call_id;
-                        yield { type: "tool_use_start", id: activeToolCallId, name: item.name };
-                    }
+                catch { /* ignore */ }
+                return;
+            }
+            if (type === "response.output_text.delta") {
+                const delta = event.delta;
+                if (delta)
+                    push({ type: "text_delta", text: delta });
+            }
+            else if (type === "response.output_item.added") {
+                if (event.item?.type === "function_call") {
+                    const item = event.item;
+                    activeToolCallId = item.call_id;
+                    push({ type: "tool_use_start", id: activeToolCallId, name: item.name });
                 }
-                else if (type === "response.function_call_arguments.delta") {
-                    yield { type: "tool_use_delta", id: activeToolCallId, json: event.delta };
+            }
+            else if (type === "response.function_call_arguments.delta") {
+                push({ type: "tool_use_delta", id: activeToolCallId, json: event.delta });
+            }
+            else if (type === "response.function_call_arguments.done") {
+                push({ type: "tool_use_end", id: activeToolCallId });
+            }
+            else if (type === "response.completed") {
+                const response = event.response;
+                const usage = response?.usage;
+                const output = response?.output;
+                const hasToolCalls = output?.some((o) => o.type === "function_call");
+                push({
+                    type: "done",
+                    stop_reason: hasToolCalls ? "tool_use" : "end_turn",
+                    usage: usage ? { input_tokens: usage.input_tokens ?? 0, output_tokens: usage.output_tokens ?? 0 } : undefined,
+                });
+                done = true;
+                try {
+                    ws.close();
                 }
-                else if (type === "response.function_call_arguments.done") {
-                    yield { type: "tool_use_end", id: activeToolCallId };
+                catch { /* ignore */ }
+            }
+        });
+        ws.addEventListener("error", () => {
+            if (!done) {
+                push(new Error("Codex WebSocket connection error"));
+                done = true;
+            }
+        });
+        ws.addEventListener("close", () => {
+            if (!done) {
+                push(new Error("Codex WebSocket closed before response.completed"));
+                done = true;
+            }
+        });
+        // Async iteration: drain the queue, wait for new events
+        try {
+            while (true) {
+                while (queue.length > 0) {
+                    const item = queue.shift();
+                    if (item instanceof Error)
+                        throw item;
+                    yield item;
+                    if (item.type === "done")
+                        return;
                 }
-                else if (type === "response.completed") {
-                    const response = event.response;
-                    const usage = response?.usage;
-                    const output = response?.output;
-                    const hasToolCalls = output?.some((o) => o.type === "function_call");
-                    yield {
-                        type: "done",
-                        stop_reason: hasToolCalls ? "tool_use" : "end_turn",
-                        usage: usage ? { input_tokens: usage.input_tokens ?? 0, output_tokens: usage.output_tokens ?? 0 } : undefined,
-                    };
+                if (done)
+                    return;
+                await new Promise((r) => { resolve = r; });
+            }
+        }
+        finally {
+            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                try {
+                    ws.close();
                 }
+                catch { /* ignore */ }
             }
         }
     }

package/dist/providers/openai-compat.js

@@ -58,11 +58,16 @@ export function parseOpenAiResponse(data) {
     if (toolCalls) {
         for (const tc of toolCalls) {
             const fn = tc.function;
+            let input = {};
+            try {
+                input = JSON.parse(fn.arguments);
+            }
+            catch { /* malformed arguments */ }
             content.push({
                 type: "tool_use",
                 id: tc.id,
                 name: fn.name,
-                input: JSON.parse(fn.arguments),
+                input,
             });
         }
     }

package/dist/repl.js

@@ -82,7 +82,7 @@ export async function startRepl(config) {
             rl.prompt();
             continue;
         }
-        if (handleCommand(trimmed, { session, contextLimit, undoStack: [] })) {
+        if (handleCommand(trimmed, { session, contextLimit, undoStack: [], phrenCtx: config.phrenCtx })) {
             rl.prompt();
             continue;
         }
@@ -118,7 +118,7 @@ export async function startRepl(config) {
                     process.stderr.write(`${YELLOW}Input mode: ${inputMode}${RESET}\n`);
                 }
                 else {
-                    handleCommand(queued, { session, contextLimit, undoStack: [] });
+                    handleCommand(queued, { session, contextLimit, undoStack: [], phrenCtx: config.phrenCtx });
                 }
                 break;
             }

package/dist/system-prompt.js

@@ -1,37 +1,35 @@
 export function buildSystemPrompt(phrenContext, priorSummary, providerInfo) {
     const modelNote = providerInfo ? ` You are running on ${providerInfo.name}${providerInfo.model ? ` (model: ${providerInfo.model})` : ""}.` : "";
     const parts = [
-        `You are phren-agent, a coding assistant with persistent memory powered by phren.${modelNote} You retain knowledge across sessions — past decisions, discovered patterns, and project context are all searchable. Use this memory to avoid repeating mistakes and to build on prior work.`,
+        `You are phren-agent, an autonomous coding agent with persistent memory.${modelNote}`,
         "",
-        "## Workflow",
-        "1. **Orient** — Before starting, search phren for relevant findings (`phren_search`) and check active tasks (`phren_get_tasks`). Past sessions may have context that saves time.",
-        "2. **Read** — Read the relevant code before modifying it. Use `glob` to find files, `grep` to locate symbols, `read_file` to understand context.",
-        "3. **Change** — Make targeted edits. Use `edit_file` for surgical changes; reserve `write_file` for new files. Don't refactor code you weren't asked to touch.",
-        "4. **Verify** — Run tests and linters via `shell` after edits. Check `git_diff` to review your changes.",
-        "5. **Remember** — Save non-obvious discoveries with `phren_add_finding`: tricky bugs, architecture decisions, gotchas, workarounds. Skip obvious things — only save what would help a future session.",
-        "6. **Report** — Explain what you did concisely. Mention files changed and why.",
+        "## Core Behavior",
+        "ACT IMMEDIATELY. When the user asks you to do something, DO IT. Don't describe what you're going to do — just do it. Use your tools without asking permission. Read files, search code, make edits, run commands. Only ask clarifying questions when the request is genuinely ambiguous.",
+        "",
+        "You have persistent memory via phren. Past decisions, discovered patterns, and project context are searchable across sessions. Use this to avoid repeating mistakes.",
         "",
-        "## Memory",
-        "- `phren_search` finds past findings, reference docs, and project context. Search before asking the user for context they may have already provided.",
-        "- `phren_add_finding` saves insights for future sessions. Good findings: non-obvious patterns, decisions with rationale, error resolutions, architecture constraints. Bad findings: narration of what you did, obvious facts, secrets.",
-        "- `phren_get_tasks` shows tracked work items. Complete tasks with `phren_complete_task` when done.",
+        "## Workflow",
+        "1. **Search memory first** — `phren_search` for relevant past findings before starting work.",
+        "2. **Read before writing** — `glob` to find files, `grep` to locate symbols, `read_file` to understand code.",
+        "3. **Make changes** — `edit_file` for surgical edits, `write_file` for new files only.",
+        "4. **Verify** — `shell` to run tests/linters, `git_diff` to review changes.",
+        "5. **Save learnings** — `phren_add_finding` for non-obvious discoveries (bugs, architecture decisions, gotchas). Skip obvious stuff.",
+        "6. **Report concisely** — what changed and why. No fluff.",
         "",
-        "## Self-configuration",
-        "You ARE phren-agent. You can configure phren itself via shell commands:",
-        "- `phren init` — set up phren (MCP server, hooks, profiles)",
-        "- `phren add <path>` — register a project directory",
-        "- `phren config proactivity <level>` — set proactivity (high/medium/low)",
-        "- `phren config policy set <key> <value>` — configure retention, TTL, decay",
-        "- `phren hooks enable <tool>` — enable hooks for claude/copilot/cursor/codex",
-        "- `phren doctor --fix` — diagnose and self-heal",
-        "- `phren status` — check health",
-        "If the user asks you to configure phren, set up a project, or fix their install, use the shell tool to run these commands.",
+        "## Tools You Have",
+        "- File I/O: `read_file`, `write_file`, `edit_file`",
+        "- Search: `glob`, `grep`, `web_search`, `web_fetch`",
+        "- System: `shell` (run commands, cd, build, test)",
+        "- Git: `git_status`, `git_diff`, `git_commit`",
+        "- Memory: `phren_search`, `phren_add_finding`, `phren_get_tasks`, `phren_complete_task`, `phren_add_task`",
         "",
-        "## Rules",
+        "## Important",
+        "- Be direct and concise. Lead with the answer, not the reasoning.",
+        "- Call multiple tools in parallel when they're independent.",
+        "- NEVER ask 'should I read the file?' or 'would you like me to...' — just call the tool. If permission is needed, the system will prompt the user automatically. You don't handle permissions.",
+        "- Don't describe your plan unless asked. Execute immediately.",
         "- Never write secrets, API keys, or PII to files or findings.",
-        "- Prefer `edit_file` over `write_file` for existing files.",
-        "- Keep shell commands safe. No `rm -rf`, no `sudo`, no destructive operations.",
-        "- If unsure, say so. Don't guess at behavior you can verify by reading code or running tests.",
+        "- You ARE phren-agent. You can run `phren` CLI commands via shell to configure yourself.",
     ];
     if (priorSummary) {
         parts.push("", `## Last session\n${priorSummary}`);

package/dist/tools/glob.js

@@ -3,12 +3,36 @@ import * as path from "path";
 import { validatePath } from "../permissions/sandbox.js";
 /** Simple glob matching without external dependencies. Supports * and ** patterns. */
 function matchGlob(pattern, filePath) {
-    const regex = pattern
-        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-        .replace(/\*\*/g, "{{GLOBSTAR}}")
-        .replace(/\*/g, "[^/]*")
-        .replace(/{{GLOBSTAR}}/g, ".*");
-    return new RegExp(`^${regex}$`).test(filePath);
+    // Normalize path separators
+    const p = pattern.replace(/\\/g, "/");
+    const f = filePath.replace(/\\/g, "/");
+    // Build regex: escape special chars, then convert glob tokens
+    let regex = "";
+    let i = 0;
+    while (i < p.length) {
+        if (p[i] === "*" && p[i + 1] === "*") {
+            // ** matches any depth of directories
+            regex += ".*";
+            i += 2;
+            if (p[i] === "/")
+                i++; // skip trailing /
+        }
+        else if (p[i] === "*") {
+            // * matches anything except /
+            regex += "[^/]*";
+            i++;
+        }
+        else if (p[i] === "?") {
+            regex += "[^/]";
+            i++;
+        }
+        else {
+            // Escape regex special chars
+            regex += p[i].replace(/[.+^${}()|[\]\\]/g, "\\$&");
+            i++;
+        }
+    }
+    return new RegExp(`^${regex}$`).test(f);
 }
 function walkDir(dir, base, results, maxResults) {
     if (results.length >= maxResults)

package/dist/tools/shell.js

@@ -5,7 +5,7 @@ const MAX_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_BYTES = 100_000;
 export const shellTool = {
     name: "shell",
-    description: "Run a shell command via bash -c and return stdout + stderr. Use for: running tests, linters, build commands, git operations, and exploring the environment. Prefer specific tools (read_file, glob, grep) over shell equivalents when available.",
+    description: "Run a shell command and return stdout + stderr. Uses bash on Unix, cmd.exe on Windows. Use for: running tests, linters, build commands, git operations, and exploring the environment. Prefer specific tools (read_file, glob, grep) over shell equivalents when available.",
     input_schema: {
         type: "object",
         properties: {
@@ -24,8 +24,11 @@ export const shellTool = {
         if (!safety.safe && safety.severity === "block") {
             return { output: `Blocked: ${safety.reason}`, is_error: true };
         }
+        const isWindows = process.platform === "win32";
+        const shell = isWindows ? "cmd" : "bash";
+        const shellArgs = isWindows ? ["/c", command] : ["-c", command];
         try {
-            const output = execFileSync("bash", ["-c", command], {
+            const output = execFileSync(shell, shellArgs, {
                 cwd,
                 encoding: "utf-8",
                 timeout,

package/dist/tui/ansi.js

@@ -0,0 +1,48 @@
+// ── ANSI helpers ─────────────────────────────────────────────────────────────
+export const ESC = "\x1b[";
+export const s = {
+    reset: `${ESC}0m`,
+    bold: (t) => `${ESC}1m${t}${ESC}0m`,
+    dim: (t) => `${ESC}2m${t}${ESC}0m`,
+    italic: (t) => `${ESC}3m${t}${ESC}0m`,
+    cyan: (t) => `${ESC}36m${t}${ESC}0m`,
+    green: (t) => `${ESC}32m${t}${ESC}0m`,
+    yellow: (t) => `${ESC}33m${t}${ESC}0m`,
+    red: (t) => `${ESC}31m${t}${ESC}0m`,
+    blue: (t) => `${ESC}34m${t}${ESC}0m`,
+    magenta: (t) => `${ESC}35m${t}${ESC}0m`,
+    gray: (t) => `${ESC}90m${t}${ESC}0m`,
+    invert: (t) => `${ESC}7m${t}${ESC}0m`,
+    // Gradient-style brand text
+    brand: (t) => `${ESC}1;35m${t}${ESC}0m`,
+};
+export function cols() {
+    return process.stdout.columns || 80;
+}
+export function stripAnsi(t) {
+    return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+// ── Permission mode helpers ─────────────────────────────────────────────────
+export const PERMISSION_MODES = ["suggest", "auto-confirm", "full-auto"];
+export function nextPermissionMode(current) {
+    const idx = PERMISSION_MODES.indexOf(current);
+    return PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length];
+}
+export const PERMISSION_LABELS = {
+    "suggest": "suggest",
+    "auto-confirm": "auto",
+    "full-auto": "full-auto",
+};
+export const PERMISSION_ICONS = {
+    "suggest": "○",
+    "auto-confirm": "◐",
+    "full-auto": "●",
+};
+export const PERMISSION_COLORS = {
+    "suggest": s.cyan,
+    "auto-confirm": s.green,
+    "full-auto": s.yellow,
+};
+export function permTag(mode) {
+    return PERMISSION_COLORS[mode](`${PERMISSION_ICONS[mode]} ${mode}`);
+}

package/dist/tui/components/AgentMessage.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function AgentMessage({ text }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "magenta", children: ["◆", " ", _jsx(Text, { children: text })] }), _jsx(Text, { children: "" })] }));
+}