@manix-cli/manix 0.1.2

package/dist/tools/search.js

@@ -0,0 +1,106 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import fg from "fast-glob";
+const IGNORE = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"];
+const globTool = {
+  name: "glob_files",
+  safe: true,
+  description: 'Find files by glob pattern, e.g. "src/**/*.js" or "**/*.test.*".',
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string" },
+      path: { type: "string", description: "Base directory (defaults to cwd)" }
+    },
+    required: ["pattern"]
+  },
+  describe: (a) => `Glob(${a.pattern})`,
+  async run(a, ctx) {
+    const files = await fg(a.pattern, {
+      cwd: path.resolve(ctx.cwd, a.path || "."),
+      ignore: IGNORE,
+      onlyFiles: true,
+      dot: false,
+      suppressErrors: true
+    });
+    if (!files.length) return "No files matched.";
+    const shown = files.slice(0, 200);
+    return shown.join("\n") + (files.length > 200 ? `
+\u2026 +${files.length - 200} more` : "");
+  }
+};
+const grepTool = {
+  name: "grep_search",
+  safe: true,
+  description: "Search file contents with a regex. Returns file:line:text matches.",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regular expression" },
+      path: { type: "string", description: "Directory or file to search (defaults to cwd)" },
+      include: { type: "string", description: 'Only search files matching this glob, e.g. "*.js"' }
+    },
+    required: ["pattern"]
+  },
+  describe: (a) => `Grep(${a.pattern})`,
+  async run(a, ctx) {
+    const base = path.resolve(ctx.cwd, a.path || ".");
+    try {
+      return await rgSearch(a, base);
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+      return jsSearch(a, base);
+    }
+  }
+};
+function rgSearch(a, base) {
+  return new Promise((resolve, reject) => {
+    const args = ["-n", "--no-heading", "-S", "-m", "50", "--max-columns", "300"];
+    if (a.include) args.push("-g", a.include);
+    args.push("--", a.pattern, base);
+    execFile("rg", args, { maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+      if (err && err.code === 1) return resolve("No matches.");
+      if (err && typeof err.code !== "number") return reject(err);
+      if (err && err.code > 1) return reject(new Error(err.message));
+      const lines = stdout.trim().split("\n").slice(0, 200);
+      resolve(lines.map((l) => l.replace(base + path.sep, "")).join("\n"));
+    });
+  });
+}
+async function jsSearch(a, base) {
+  const re = new RegExp(a.pattern);
+  const files = await fg(a.include || "**/*", {
+    cwd: base,
+    ignore: IGNORE,
+    onlyFiles: true,
+    dot: false,
+    suppressErrors: true
+  });
+  const out = [];
+  for (const f of files.slice(0, 3e3)) {
+    const p = path.join(base, f);
+    let src;
+    try {
+      if (fs.statSync(p).size > 512 * 1024) continue;
+      src = fs.readFileSync(p, "utf8");
+    } catch {
+      continue;
+    }
+    if (src.includes("\0")) continue;
+    const lines = src.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        out.push(`${f}:${i + 1}:${lines[i].trim().slice(0, 300)}`);
+        if (out.length >= 200) return out.join("\n");
+      }
+    }
+  }
+  return out.length ? out.join("\n") : "No matches.";
+}
+const searchTools = [globTool, grepTool];
+export {
+  globTool,
+  grepTool,
+  searchTools
+};

package/dist/ui/App.js

@@ -0,0 +1,345 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput } from "ink";
+import { Agent } from "../agent.js";
+import { Permissions } from "../permissions.js";
+import { fetchModels, getCredits } from "../openrouter.js";
+import { saveConfig } from "../config.js";
+import { listSessions, loadSession } from "../sessions.js";
+import { slashCommands, helpText } from "../slash.js";
+import { INIT_PROMPT } from "../prompts.js";
+import { color, GLYPH, randomTip, shortenPath } from "../theme.js";
+import { renderMarkdown } from "../markdown.js";
+import LogItem from "./LogItem.js";
+import InputBox from "./InputBox.js";
+import PermissionPrompt from "./PermissionPrompt.js";
+import Picker from "./Picker.js";
+import SpinnerLine from "./SpinnerLine.js";
+import Footer from "./Footer.js";
+import Onboarding from "./Onboarding.js";
+function App({
+  config,
+  cwd,
+  version,
+  mcp,
+  skills,
+  contextFiles,
+  initialPrompt,
+  resumeTarget,
+  yolo
+}) {
+  const { exit } = useApp();
+  const [ready, setReady] = useState(!!config.apiKey);
+  const [items, setItems] = useState([]);
+  const [busy, setBusy] = useState(false);
+  const [streamText, setStreamText] = useState("");
+  const [activity, setActivity] = useState(null);
+  const [permission, setPermission] = useState(null);
+  const [overlay, setOverlay] = useState(null);
+  const [stats, setStats] = useState({
+    tokens: 0,
+    contextLength: 128e3,
+    cost: 0,
+    prompt: 0,
+    completion: 0,
+    requests: 0
+  });
+  const [model, setModelState] = useState(config.model);
+  const [yoloOn, setYoloOn] = useState(!!yolo);
+  const [exitHint, setExitHint] = useState(false);
+  const keyRef = useRef(0);
+  const agentRef = useRef(null);
+  const permsRef = useRef(null);
+  const streamRef = useRef("");
+  const flushTimer = useRef(null);
+  const historyRef = useRef([]);
+  const push = useCallback((item) => {
+    setItems((prev) => [...prev, { ...item, key: keyRef.current++ }]);
+  }, []);
+  const commands = slashCommands(skills);
+  function doResume(fileOrId) {
+    const loaded = loadSession(fileOrId);
+    if (!loaded) return push({ kind: "error", text: "Could not load session." });
+    agentRef.current.resumeFrom(loaded);
+    push({
+      kind: "info",
+      text: `Resumed session ${loaded.meta.id} (${loaded.messages.length} messages).`
+    });
+    const lastAssistant = [...loaded.messages].reverse().find((m) => m.role === "assistant" && m.content);
+    if (lastAssistant) push({ kind: "assistant", text: lastAssistant.content });
+    setStats(agentRef.current.stats());
+  }
+  function runPrompt(text, displayText = text) {
+    push({ kind: "user", text: displayText });
+    setBusy(true);
+    agentRef.current.send(text).finally(() => {
+      setBusy(false);
+      setActivity(null);
+    });
+  }
+  function applyModel(id) {
+    setModelState(id);
+    agentRef.current.setModel(id);
+    saveConfig({ model: id });
+    push({ kind: "info", text: `Model \u2192 ${id}` });
+  }
+  async function cleanup() {
+    try {
+      await mcp.closeAll();
+    } catch {
+    }
+  }
+  async function handleSlash(raw) {
+    const [cmdName, ...rest] = raw.slice(1).split(" ");
+    const args = rest.join(" ").trim();
+    const cmd = commands.find((c) => c.name === cmdName.toLowerCase());
+    if (!cmd) return push({ kind: "error", text: `Unknown command /${cmdName} \u2014 try /help` });
+    if (cmd.skill) {
+      return runPrompt(
+        `Use the "${cmd.skill.name}" skill below to handle this request.
+
+${cmd.skill.body}
+
+---
+User input: ${args || "(none)"}`,
+        `/${cmd.name} ${args}`.trim()
+      );
+    }
+    switch (cmd.name) {
+      case "help":
+        return push({ kind: "info", text: helpText(commands) });
+      case "clear":
+        agentRef.current.reset();
+        setStats(agentRef.current.stats());
+        return push({ kind: "info", text: "Started a fresh conversation (history cleared)." });
+      case "exit":
+        await cleanup();
+        return exit();
+      case "yolo": {
+        const p = permsRef.current;
+        p.yolo = !p.yolo;
+        setYoloOn(p.yolo);
+        return push({
+          kind: "info",
+          text: p.yolo ? "YOLO on \u2014 all tools auto-approved. Careful." : "YOLO off \u2014 permissions restored."
+        });
+      }
+      case "cost": {
+        const s = agentRef.current.stats();
+        const credits = await getCredits(config.apiKey);
+        const creditLine = credits ? `
+OpenRouter credits: $${(credits.total_credits - credits.total_usage).toFixed(2)} remaining` : "";
+        return push({
+          kind: "info",
+          text: `Session: ${s.requests} requests \xB7 ${s.prompt + s.completion} tokens (${s.prompt} in / ${s.completion} out) \xB7 $${s.cost.toFixed(4)}${creditLine}`
+        });
+      }
+      case "mcp": {
+        const st = mcp.status();
+        return push({
+          kind: "info",
+          text: st.length ? st.map(
+            (x) => `${x.name}: ${x.status}${x.status === "ready" ? ` (${x.tools} tools)` : ""}${x.error ? " \u2014 " + x.error : ""}`
+          ).join("\n") : "No MCP servers configured. Add them to ~/.manix/mcp.json or .manix/mcp.json."
+        });
+      }
+      case "skills":
+        return push({
+          kind: "info",
+          text: skills.length ? skills.map((s) => `${s.name}: ${s.description}`).join("\n") : "No skills found. Add SKILL.md folders under ~/.manix/skills/ or .manix/skills/."
+        });
+      case "init":
+        return runPrompt(INIT_PROMPT, "/init");
+      case "compact": {
+        setBusy(true);
+        push({ kind: "info", text: "Compacting conversation\u2026" });
+        try {
+          await agentRef.current.compact();
+          push({ kind: "info", text: "Compacted \u2014 context freed." });
+        } catch (e) {
+          push({ kind: "error", text: "Compact failed: " + e.message });
+        } finally {
+          setBusy(false);
+        }
+        return;
+      }
+      case "model":
+        if (args) return applyModel(args);
+        return setOverlay({ type: "models" });
+      case "resume":
+        return setOverlay({ type: "sessions" });
+      default:
+        return;
+    }
+  }
+  function handleSubmit(raw) {
+    historyRef.current.push(raw);
+    if (raw.startsWith("/")) return handleSlash(raw);
+    runPrompt(raw);
+  }
+  useEffect(() => {
+    if (!ready || agentRef.current) return;
+    const permissions = new Permissions({ yolo: yoloOn });
+    permsRef.current = permissions;
+    agentRef.current = new Agent({
+      config: { ...config, model },
+      cwd,
+      permissions,
+      mcp,
+      skills,
+      contextFiles,
+      handlers: {
+        onTextDelta: (d) => {
+          streamRef.current += d;
+          if (!flushTimer.current) {
+            flushTimer.current = setTimeout(() => {
+              flushTimer.current = null;
+              setStreamText(streamRef.current);
+            }, 60);
+          }
+        },
+        onAssistantDone: (text) => {
+          if (flushTimer.current) {
+            clearTimeout(flushTimer.current);
+            flushTimer.current = null;
+          }
+          streamRef.current = "";
+          setStreamText("");
+          if (text?.trim()) push({ kind: "assistant", text });
+        },
+        onToolStart: ({ display }) => setActivity(display),
+        onToolEnd: ({ display, ok, summary }) => {
+          setActivity(null);
+          push({ kind: "tool", display, ok, summary });
+        },
+        onInfo: (text) => push({ kind: "info", text }),
+        onError: (text) => push({ kind: "error", text }),
+        onStats: (s) => setStats(s),
+        requestPermission: (req) => new Promise((resolve) => setPermission({ ...req, resolve }))
+      }
+    });
+    push({
+      kind: "banner",
+      version,
+      model,
+      cwd: shortenPath(cwd),
+      hasManixmd: contextFiles.some((f) => f.path.startsWith(cwd)),
+      tip: randomTip()
+    });
+    if (resumeTarget === "last" || resumeTarget === "pick") {
+      const sessions = listSessions(cwd);
+      if (!sessions.length) push({ kind: "info", text: "No previous sessions found." });
+      else if (resumeTarget === "last") doResume(sessions[0].file);
+      else setOverlay({ type: "sessions" });
+    } else if (resumeTarget) {
+      doResume(resumeTarget);
+    }
+    if (initialPrompt) runPrompt(initialPrompt);
+  }, [ready]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (permission) {
+        permission.resolve("no");
+        setPermission(null);
+      }
+      if (busy) return agentRef.current?.abort();
+      if (exitHint) return void cleanup().finally(() => exit());
+      setExitHint(true);
+      setTimeout(() => setExitHint(false), 1500);
+      return;
+    }
+    if (key.escape && busy && !permission) agentRef.current?.abort();
+  });
+  if (!ready) {
+    return /* @__PURE__ */ jsx(
+      Onboarding,
+      {
+        onDone: (key) => {
+          config.apiKey = key;
+          setReady(true);
+        }
+      }
+    );
+  }
+  const overlayEl = overlay?.type === "models" ? /* @__PURE__ */ jsx(
+    Picker,
+    {
+      title: "Select model",
+      load: async () => {
+        const models = await fetchModels(config.apiKey);
+        return models.slice().sort((a, b) => a.id.localeCompare(b.id)).map((m) => ({
+          id: m.id,
+          label: m.id,
+          extra: `${Math.round((m.context_length || 0) / 1e3)}k ctx \xB7 $${perM(m.pricing?.prompt)}/${perM(m.pricing?.completion)} per M`
+        }));
+      },
+      onSelect: (it) => {
+        setOverlay(null);
+        applyModel(it.id);
+      },
+      onCancel: () => setOverlay(null)
+    }
+  ) : overlay?.type === "sessions" ? /* @__PURE__ */ jsx(
+    Picker,
+    {
+      title: "Resume session",
+      load: () => listSessions(cwd).map((s) => ({
+        id: s.file,
+        label: s.title,
+        extra: `${timeAgo(s.mtime)} \xB7 ${s.count} msgs`
+      })),
+      onSelect: (it) => {
+        setOverlay(null);
+        doResume(it.id);
+      },
+      onCancel: () => setOverlay(null)
+    }
+  ) : null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Static, { items, children: (item) => /* @__PURE__ */ jsx(LogItem, { item }, item.key) }),
+    streamText ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: color.accent, children: [
+        GLYPH.assistant,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { children: renderMarkdown(streamText) }) })
+    ] }) : null,
+    busy && !permission ? /* @__PURE__ */ jsx(SpinnerLine, { label: activity, cost: stats.cost }) : null,
+    permission ? /* @__PURE__ */ jsx(
+      PermissionPrompt,
+      {
+        request: permission,
+        onAnswer: (v) => {
+          const { resolve } = permission;
+          setPermission(null);
+          resolve(v);
+        }
+      }
+    ) : overlayEl || /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(
+        InputBox,
+        {
+          onSubmit: handleSubmit,
+          commands,
+          active: !busy,
+          history: historyRef.current
+        }
+      ),
+      /* @__PURE__ */ jsx(Footer, { model, stats, yolo: yoloOn, cwd, exitHint })
+    ] })
+  ] });
+}
+function perM(p) {
+  const n = parseFloat(p || 0) * 1e6;
+  return n ? n < 10 ? n.toFixed(2) : Math.round(n) : "0";
+}
+function timeAgo(ms) {
+  const s = Math.floor((Date.now() - ms) / 1e3);
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+export {
+  App as default
+};

package/dist/ui/Footer.js

@@ -0,0 +1,38 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import path from "node:path";
+import { Box, Text } from "ink";
+import { color } from "../theme.js";
+const SEP = "  \xB7  ";
+function Footer({ model, stats, yolo, cwd, exitHint }) {
+  if (exitHint) {
+    return /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: color.warn, children: "press ctrl+c again to exit" }) });
+  }
+  const pct = stats.contextLength ? Math.min(99, Math.round(stats.tokens / stats.contextLength * 100)) : 0;
+  const pctColor = pct < 50 ? color.dim : pct < 80 ? color.warn : color.err;
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: color.faint, children: model }),
+    /* @__PURE__ */ jsx(Text, { color: color.faint, children: SEP }),
+    /* @__PURE__ */ jsxs(Text, { color: pctColor, children: [
+      "ctx ",
+      pct,
+      "%"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: color.faint, children: SEP }),
+    /* @__PURE__ */ jsxs(Text, { color: color.accent, children: [
+      "$",
+      stats.cost.toFixed(4)
+    ] }),
+    yolo ? /* @__PURE__ */ jsxs(Text, { color: color.warn, children: [
+      SEP,
+      "YOLO"
+    ] }) : null,
+    /* @__PURE__ */ jsxs(Text, { color: color.faint, children: [
+      SEP,
+      path.basename(cwd)
+    ] })
+  ] });
+}
+export {
+  Footer as default
+};

package/dist/ui/InputBox.js

@@ -0,0 +1,123 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import chalk from "chalk";
+import { color, hr } from "../theme.js";
+function InputBox({ onSubmit, commands, active, history }) {
+  const [value, setValue] = useState("");
+  const [pos, setPos] = useState(0);
+  const [histIdx, setHistIdx] = useState(-1);
+  const [menuIdx, setMenuIdx] = useState(0);
+  const menuOpen = active && value.startsWith("/") && !value.includes(" ");
+  const matches = menuOpen ? commands.filter((c) => ("/" + c.name).startsWith(value.toLowerCase())) : [];
+  const sel = matches.length ? Math.min(menuIdx, matches.length - 1) : 0;
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        if (menuOpen && matches.length) {
+          setValue("");
+          setPos(0);
+          setMenuIdx(0);
+          setHistIdx(-1);
+          onSubmit("/" + matches[sel].name);
+          return;
+        }
+        const text = value.trim();
+        if (!text) return;
+        setValue("");
+        setPos(0);
+        setHistIdx(-1);
+        onSubmit(text);
+        return;
+      }
+      if (key.tab) {
+        if (menuOpen && matches.length) {
+          const cmd = "/" + matches[sel].name + " ";
+          setValue(cmd);
+          setPos(cmd.length);
+        }
+        return;
+      }
+      if (key.upArrow) {
+        if (menuOpen && matches.length) return setMenuIdx((i) => (i + matches.length - 1) % matches.length);
+        if (history.length) {
+          const next = histIdx === -1 ? history.length - 1 : Math.max(0, histIdx - 1);
+          setHistIdx(next);
+          setValue(history[next]);
+          setPos(history[next].length);
+        }
+        return;
+      }
+      if (key.downArrow) {
+        if (menuOpen && matches.length) return setMenuIdx((i) => (i + 1) % matches.length);
+        if (histIdx !== -1) {
+          const next = histIdx + 1;
+          if (next >= history.length) {
+            setHistIdx(-1);
+            setValue("");
+            setPos(0);
+          } else {
+            setHistIdx(next);
+            setValue(history[next]);
+            setPos(history[next].length);
+          }
+        }
+        return;
+      }
+      if (key.leftArrow) return setPos((p) => Math.max(0, p - 1));
+      if (key.rightArrow) return setPos((p) => Math.min(value.length, p + 1));
+      if (key.escape) {
+        setValue("");
+        setPos(0);
+        setHistIdx(-1);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (pos > 0) {
+          setValue(value.slice(0, pos - 1) + value.slice(pos));
+          setPos(pos - 1);
+        }
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        setValue("");
+        setPos(0);
+        return;
+      }
+      if (key.ctrl && input === "a") return setPos(0);
+      if (key.ctrl && input === "e") return setPos(value.length);
+      if (key.ctrl || key.meta) return;
+      if (input) {
+        const clean = input.replace(/\r/g, "\n");
+        setValue(value.slice(0, pos) + clean + value.slice(pos));
+        setPos(pos + clean.length);
+        setMenuIdx(0);
+      }
+    },
+    { isActive: active }
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    menuOpen && matches.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: matches.slice(0, 6).map((c, i) => /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: i === sel ? color.accent : color.dim, children: [
+        i === sel ? "\u276F " : "  ",
+        "/",
+        c.name.padEnd(14)
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: color.faint, children: c.desc })
+    ] }, c.name)) }),
+    /* @__PURE__ */ jsx(Text, { color: color.faint, children: hr(2) }),
+    /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: color.accent, children: "\u276F " }),
+      /* @__PURE__ */ jsx(Text, { children: renderValue(value, pos, active) })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: color.faint, children: hr(2) })
+  ] });
+}
+function renderValue(value, pos, active) {
+  if (!active) return chalk.hex(color.faint)(value || "working\u2026 (esc to interrupt)");
+  if (!value) return chalk.inverse(" ") + chalk.hex(color.faint)('ask anything \xB7 "/" for commands');
+  return value.slice(0, pos) + chalk.inverse(value[pos] || " ") + value.slice(pos + 1);
+}
+export {
+  InputBox as default
+};

package/dist/ui/LogItem.js

@@ -0,0 +1,82 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import { color, GLYPH } from "../theme.js";
+import { renderMarkdown } from "../markdown.js";
+import Mascot from "./Mascot.js";
+function LogItem({ item }) {
+  switch (item.kind) {
+    case "banner":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsx(Mascot, {}),
+          /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { bold: true, color: color.user, children: "Manix" }),
+              /* @__PURE__ */ jsxs(Text, { color: color.faint, children: [
+                "  v",
+                item.version
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: color.dim, children: item.model }),
+            /* @__PURE__ */ jsx(Text, { color: color.faint, children: item.cwd })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+          !item.hasManixmd && /* @__PURE__ */ jsxs(Text, { color: color.faint, children: [
+            GLYPH.info,
+            " MANIX.md not found \u2014 /init to create"
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: color.faint, children: [
+            GLYPH.info,
+            " ",
+            item.tip
+          ] })
+        ] })
+      ] });
+    case "user":
+      return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { color: color.accent, children: [
+          GLYPH.user,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: color.user, children: item.text })
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { color: color.accent, children: [
+          GLYPH.assistant,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { children: renderMarkdown(item.text) }) })
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: item.ok ? color.accent : color.err, children: [
+            GLYPH.tool,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: item.display })
+        ] }),
+        item.summary ? /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: color.dim, children: item.summary }) }) : null
+      ] });
+    case "info":
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: color.dim, children: [
+        GLYPH.info,
+        " ",
+        item.text
+      ] }) });
+    case "error":
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: color.err, children: [
+        GLYPH.error,
+        " ",
+        item.text
+      ] }) });
+    default:
+      return null;
+  }
+}
+export {
+  LogItem as default
+};