@qxbyte/muse 0.1.0

package/dist/cli.js

@@ -0,0 +1,3015 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { Command } from "commander";
+import { render } from "ink";
+
+// src/app.tsx
+import { useCallback, useEffect, useMemo as useMemo2, useReducer, useRef, useState as useState2 } from "react";
+import { Box as Box9, Text as Text9, useApp, useInput as useInput3, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import { mkdir as mkdir2, readFile as readFile4, writeFile } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+
+// src/components/StartupBanner.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var LETTERS = {
+  M: ["\u2588   \u2588", "\u2588\u2588 \u2588\u2588", "\u2588 \u2588 \u2588", "\u2588   \u2588", "\u2588   \u2588"],
+  U: ["\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", " \u2588\u2588\u2588 "],
+  S: ["\u2588\u2588\u2588\u2588\u2588", "\u2588    ", " \u2588\u2588\u2588 ", "    \u2588", "\u2588\u2588\u2588\u2588\u2588"],
+  E: ["\u2588\u2588\u2588\u2588\u2588", "\u2588    ", "\u2588\u2588\u2588\u2588 ", "\u2588    ", "\u2588\u2588\u2588\u2588\u2588"]
+};
+var COLORS = {
+  M: "#EF4444",
+  U: "#F97316",
+  S: "#EAB308",
+  E: "#22C55E",
+  asterisk: "#06B6D4",
+  text: "white",
+  versionAccent: "#FDE047"
+};
+var LETTER_GAP = 3;
+var LOGO_WIDTH = 5 * 4 + LETTER_GAP * 3;
+var GAP_WIDTH = 6;
+function LogoLine({ row }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: COLORS.M, children: LETTERS.M[row] }) }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.U, children: LETTERS.U[row] }) }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.S, children: LETTERS.S[row] }) }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.E, children: LETTERS.E[row] }) })
+  ] });
+}
+function BannerLine({ row, children }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx(Box, { minWidth: LOGO_WIDTH, children: /* @__PURE__ */ jsx(LogoLine, { row }) }),
+    /* @__PURE__ */ jsx(Box, { width: GAP_WIDTH }),
+    children ?? null
+  ] });
+}
+function StartupBanner({ version, model, cwd }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 0, children: [
+    /* @__PURE__ */ jsx(BannerLine, { row: 0 }),
+    /* @__PURE__ */ jsx(BannerLine, { row: 1, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Text, { color: COLORS.asterisk, children: "\u273B" }),
+      /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: " Welcome to Muse " }),
+      /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+        "v",
+        version
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx(BannerLine, { row: 2, children: /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+      "model: ",
+      model
+    ] }) }),
+    /* @__PURE__ */ jsx(BannerLine, { row: 3, children: /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+      "cwd:   ",
+      cwd
+    ] }) }),
+    /* @__PURE__ */ jsx(BannerLine, { row: 4 })
+  ] });
+}
+function CompactBanner({ version, model, cwd }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 0, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Text, { color: COLORS.asterisk, children: "\u273B" }),
+      /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: " Welcome to Muse " }),
+      /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+        "v",
+        version
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+      "model: ",
+      model
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+      "cwd:   ",
+      cwd
+    ] })
+  ] });
+}
+function SingleLineBanner({ version, model }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: "Muse " }),
+    /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+      "v",
+      version
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+      " \xB7 ",
+      model
+    ] })
+  ] });
+}
+function pickBanner(width, props) {
+  if (width >= 60) return /* @__PURE__ */ jsx(StartupBanner, { ...props });
+  if (width >= 40) return /* @__PURE__ */ jsx(CompactBanner, { ...props });
+  return /* @__PURE__ */ jsx(SingleLineBanner, { version: props.version, model: props.model });
+}
+
+// src/components/MessageView.tsx
+import { useMemo } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+marked.use(markedTerminal());
+function renderMarkdown(text) {
+  try {
+    const out = marked.parse(text);
+    return out.replace(/\n+$/, "");
+  } catch {
+    return text;
+  }
+}
+function MessageView({ message }) {
+  switch (message.role) {
+    case "user":
+      return /* @__PURE__ */ jsx2(UserMessage, { content: typeof message.content === "string" ? message.content : flattenText(message.content) });
+    case "assistant":
+      return /* @__PURE__ */ jsx2(AssistantMessage, { content: message.content });
+    case "tool":
+      return /* @__PURE__ */ jsx2(ToolResultLine, { isError: message.isError ?? false, content: message.content });
+    case "system":
+      return null;
+  }
+}
+function flattenText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function UserMessage({ content }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginTop: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "> " }),
+    /* @__PURE__ */ jsx2(Text2, { children: content })
+  ] });
+}
+function AssistantMessage({ content }) {
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: content.map((part, i) => {
+    if (part.type === "text") {
+      return /* @__PURE__ */ jsx2(AssistantTextPart, { text: part.text }, i);
+    }
+    if (part.type === "tool_use") {
+      return /* @__PURE__ */ jsx2(ToolCallLine, { name: part.name, args: part.args }, i);
+    }
+    return null;
+  }) });
+}
+function AssistantTextPart({ text }) {
+  const rendered = useMemo(() => renderMarkdown(text), [text]);
+  return /* @__PURE__ */ jsx2(Text2, { children: rendered });
+}
+function ToolCallLine({ name, args }) {
+  const argSummary = formatArgs(args);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginTop: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u2192 " }),
+    /* @__PURE__ */ jsx2(Text2, { color: "yellow", bold: true, children: name }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "(",
+      argSummary,
+      ")"
+    ] })
+  ] });
+}
+function ToolResultLine({ isError, content }) {
+  const preview = content.length > 200 ? content.slice(0, 200) + "..." : content;
+  const oneLine = preview.split("\n")[0];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginLeft: 2, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: isError ? "red" : "green", children: isError ? "\u2717 " : "\u2713 " }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: oneLine })
+  ] });
+}
+function formatArgs(args) {
+  if (typeof args !== "object" || args === null) return String(args);
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const [k, v] of entries) {
+    if (typeof v === "string") {
+      const truncated = v.length > 40 ? v.slice(0, 40) + "..." : v;
+      parts.push(`${k}="${truncated}"`);
+    } else {
+      parts.push(`${k}=${JSON.stringify(v).slice(0, 40)}`);
+    }
+  }
+  return parts.join(", ");
+}
+
+// src/components/PermissionPrompt.tsx
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function PermissionPrompt({ request }) {
+  useInput((input, key) => {
+    if (input === "y" || key.return) {
+      request.resolve(true);
+    } else if (input === "n" || key.escape) {
+      request.resolve(false);
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginY: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { color: "yellow", bold: true, children: [
+      "\u23F5 Approve ",
+      request.toolName,
+      "?"
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: request.summary }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { children: "(y)es / (n)o / Enter=allow / Esc=reject" }) })
+  ] });
+}
+
+// src/components/ModelSelector.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+
+// src/components/Selector.tsx
+import { useState } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var POINTER_COLOR = "#A855F7";
+function Selector({
+  items,
+  initialIndex = 0,
+  title,
+  hint,
+  maxVisible,
+  renderRow,
+  onSubmit,
+  onCancel
+}) {
+  const safeInitial = Math.max(0, Math.min(initialIndex, items.length - 1));
+  const [index, setIndex] = useState(safeInitial);
+  useInput2((_, key) => {
+    if (key.upArrow) {
+      setIndex((i) => Math.max(0, i - 1));
+    } else if (key.downArrow) {
+      setIndex((i) => Math.min(items.length - 1, i + 1));
+    } else if (key.return) {
+      onSubmit(items[index]);
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+  const len = items.length;
+  const window = maxVisible && maxVisible < len ? maxVisible : len;
+  const start = Math.max(0, Math.min(index - Math.floor(window / 2), len - window));
+  const end = Math.min(len, start + window);
+  const visible = items.slice(start, end);
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      marginTop: 1,
+      paddingX: 1,
+      borderStyle: "round",
+      borderColor: "cyan",
+      children: [
+        (title || hint) && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
+          title && /* @__PURE__ */ jsx4(Text4, { bold: true, children: title }),
+          title && hint && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  " }),
+          hint && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: hint })
+        ] }),
+        visible.map((item, i) => {
+          const realIndex = start + i;
+          const focused = realIndex === index;
+          return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "row", children: [
+            /* @__PURE__ */ jsx4(Text4, { color: POINTER_COLOR, bold: true, children: focused ? "\u203A " : "  " }),
+            renderRow(item, focused)
+          ] }, realIndex);
+        }),
+        window < len && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "(",
+          start + 1,
+          "-",
+          end,
+          " / ",
+          len,
+          ")"
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/components/ModelSelector.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ModelSelector({ request }) {
+  const { items, currentId, resolve: resolve5 } = request;
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((m) => m.id === currentId)
+  );
+  const labelWidth = Math.max(...items.map((m) => (m.name ?? m.id).length));
+  return /* @__PURE__ */ jsx5(
+    Selector,
+    {
+      items,
+      initialIndex,
+      title: "Select model",
+      hint: "\u2191\u2193 navigate \xB7 Enter confirm \xB7 Esc cancel",
+      onSubmit: (m) => resolve5(m),
+      onCancel: () => resolve5(null),
+      renderRow: (m, _focused) => /* @__PURE__ */ jsx5(ModelRow, { model: m, active: m.id === currentId, labelWidth })
+    }
+  );
+}
+function ModelRow({
+  model,
+  active,
+  labelWidth
+}) {
+  const dot = active ? "\u25CF" : " ";
+  const label = (model.name ?? model.id).padEnd(labelWidth);
+  const vendor = model.vendor ? `[${model.vendor}]` : "";
+  const caps = formatCaps(model);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs5(Text5, { color: active ? "green" : void 0, children: [
+      dot,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { children: label }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "  ",
+      vendor
+    ] }),
+    caps && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "  ",
+      caps
+    ] })
+  ] });
+}
+function formatCaps(m) {
+  const flags = [];
+  if (m.supportsToolCall === false) flags.push("no-tools");
+  if (m.supportsImages) flags.push("vision");
+  return flags.length ? flags.join(" \xB7 ") : "";
+}
+
+// src/components/SessionSelector.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function SessionSelector({ request }) {
+  const { items, currentId, resolve: resolve5 } = request;
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((s) => s.id === currentId)
+  );
+  return /* @__PURE__ */ jsx6(
+    Selector,
+    {
+      items,
+      initialIndex,
+      maxVisible: 12,
+      title: "Resume session",
+      hint: "\u2191\u2193 navigate \xB7 Enter load \xB7 Esc cancel",
+      onSubmit: (s) => resolve5(s),
+      onCancel: () => resolve5(null),
+      renderRow: (s) => /* @__PURE__ */ jsx6(SessionRow, { session: s, active: s.id === currentId })
+    }
+  );
+}
+function SessionRow({ session, active }) {
+  const id8 = session.id.slice(0, 8);
+  const time = formatTime(session.createdAt);
+  const count = `[${String(session.messageCount).padStart(2)} msgs]`;
+  const preview = session.preview ?? "(empty)";
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx6(Text6, { color: active ? "green" : void 0, children: active ? "\u25CF " : "  " }),
+    /* @__PURE__ */ jsx6(Text6, { children: id8 }),
+    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+      "  ",
+      time
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+      "  ",
+      count
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      "  ",
+      preview
+    ] })
+  ] });
+}
+function formatTime(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return iso;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+// src/components/SlashAutocomplete.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var DEFAULT_MAX = 10;
+var SLASH_COLOR = "#A855F7";
+function SlashAutocomplete({ matches, index, maxVisible = DEFAULT_MAX }) {
+  if (matches.length === 0) return null;
+  const start = Math.max(0, Math.min(index - Math.floor(maxVisible / 2), matches.length - maxVisible));
+  const end = Math.min(matches.length, start + maxVisible);
+  const visible = matches.slice(start, end);
+  const nameWidth = Math.max(...matches.map((c) => c.name.length + (c.argsHint ? c.argsHint.length + 1 : 0)));
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+    visible.map((cmd, i) => {
+      const realIndex = start + i;
+      return /* @__PURE__ */ jsx7(Row, { cmd, focused: realIndex === index, nameWidth }, cmd.name);
+    }),
+    matches.length > visible.length && /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "\u2191\u2193 select \xB7 Tab/Enter accept \xB7 Esc cancel  (",
+      matches.length - visible.length,
+      " more)"
+    ] }) }),
+    matches.length <= visible.length && /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2191\u2193 select \xB7 Tab/Enter accept \xB7 Esc cancel" }) })
+  ] });
+}
+function Row({ cmd, focused, nameWidth }) {
+  const head = cmd.argsHint ? `${cmd.name} ${cmd.argsHint}` : cmd.name;
+  const padded = head.padEnd(nameWidth);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs7(Text7, { color: focused ? SLASH_COLOR : void 0, bold: focused, children: [
+      "/",
+      padded
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { children: "   " }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: cmd.description })
+  ] });
+}
+
+// src/components/PermissionModeBar.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+
+// src/permission/index.ts
+var MODE_CYCLE = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions"
+];
+var MODE_LABEL = {
+  default: "default permissions on",
+  acceptEdits: "accept edits on",
+  plan: "plan mode on",
+  bypassPermissions: "bypass permissions on"
+};
+var MODE_COLOR = {
+  default: "gray",
+  acceptEdits: "#EAB308",
+  plan: "#06B6D4",
+  bypassPermissions: "#EF4444"
+};
+var PermissionGate = class {
+  rules;
+  mode = "default";
+  constructor(rules = {}) {
+    this.rules = {
+      allow: rules.allow ?? [],
+      ask: rules.ask ?? [],
+      deny: rules.deny ?? [],
+      defaultMode: rules.defaultMode ?? "ask"
+    };
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
+  getMode() {
+    return this.mode;
+  }
+  cycleMode() {
+    const i = MODE_CYCLE.indexOf(this.mode);
+    this.mode = MODE_CYCLE[(i + 1) % MODE_CYCLE.length];
+    return this.mode;
+  }
+  decide(input) {
+    if (this.matches(this.rules.deny, input)) return "deny";
+    switch (this.mode) {
+      case "bypassPermissions":
+        return "allow";
+      case "plan":
+        return input.permission === "read" ? "allow" : "deny";
+      case "acceptEdits":
+        if (input.toolName === "Edit" || input.toolName === "Write") return "allow";
+        return this.defaultDecide(input);
+      case "default":
+      default:
+        return this.defaultDecide(input);
+    }
+  }
+  defaultDecide(input) {
+    if (this.matches(this.rules.allow, input)) return "allow";
+    if (this.matches(this.rules.ask, input)) return "ask";
+    switch (this.rules.defaultMode) {
+      case "strict":
+        return "ask";
+      case "relaxed":
+        return "allow";
+      case "ask":
+      default:
+        return "ask";
+    }
+  }
+  matches(patterns, input) {
+    for (const pattern of patterns) {
+      if (this.matchOne(pattern, input)) return true;
+    }
+    return false;
+  }
+  matchOne(pattern, input) {
+    if (!pattern.includes("(")) {
+      return pattern === input.toolName;
+    }
+    const m = pattern.match(/^([A-Za-z_][A-Za-z0-9_]*)\(([^)]*)\)$/);
+    if (!m) return false;
+    const [, toolName, sub] = m;
+    if (toolName !== input.toolName) return false;
+    if (input.toolName === "Bash" && typeof input.args === "object" && input.args !== null) {
+      const cmd = input.args.command ?? "";
+      if (sub.endsWith(":*")) {
+        const prefix = sub.slice(0, -2);
+        return cmd.startsWith(prefix);
+      }
+      return cmd === sub || cmd.startsWith(sub + " ");
+    }
+    return false;
+  }
+};
+
+// src/components/PermissionModeBar.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function PermissionModeBar({ mode, compact }) {
+  const color = MODE_COLOR[mode];
+  const label = MODE_LABEL[mode];
+  const isBypass = mode === "bypassPermissions";
+  if (compact) {
+    const short = {
+      default: "[default]",
+      acceptEdits: "[edits]",
+      plan: "[plan]",
+      bypassPermissions: "[bypass]"
+    };
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx8(Text8, { color, bold: isBypass, children: short[mode] }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " shift+tab" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs8(Text8, { color, bold: isBypass, children: [
+      "\u25B6\u25B6 ",
+      label
+    ] }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " (shift+tab to cycle)" })
+  ] });
+}
+
+// src/llm/providers/openai-compatible.ts
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { streamText, jsonSchema, tool } from "ai";
+
+// src/log/index.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { homedir } from "os";
+import { join } from "path";
+var LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50
+};
+var Logger = class {
+  level = "info";
+  logPath;
+  fileEnabled = true;
+  constructor() {
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    this.logPath = join(homedir(), ".muse", "logs", `${date}.jsonl`);
+    try {
+      mkdirSync(dirname(this.logPath), { recursive: true });
+    } catch {
+      this.fileEnabled = false;
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  write(level, msg, extra) {
+    if (LEVELS[level] < LEVELS[this.level]) return;
+    const entry = {
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      msg,
+      ...extra
+    };
+    if (this.fileEnabled) {
+      try {
+        appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
+      } catch {
+      }
+    }
+    if (level === "warn" || level === "error") {
+      const prefix = level === "error" ? "[error]" : "[warn]";
+      process.stderr.write(`${prefix} ${msg}
+`);
+    }
+  }
+  trace(msg, extra) {
+    this.write("trace", msg, extra);
+  }
+  debug(msg, extra) {
+    this.write("debug", msg, extra);
+  }
+  info(msg, extra) {
+    this.write("info", msg, extra);
+  }
+  warn(msg, extra) {
+    this.write("warn", msg, extra);
+  }
+  error(msg, extra) {
+    this.write("error", msg, extra);
+  }
+};
+var log = new Logger();
+function redactApiKey(key) {
+  if (!key) return "<unset>";
+  if (key.length <= 12) return "***";
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+
+// src/llm/providers/openai-compatible.ts
+var DEFAULT_CAPABILITIES = {
+  toolCalling: true,
+  parallelToolCalls: true,
+  vision: false,
+  jsonMode: true,
+  maxContextWindow: 32e3
+};
+var OpenAICompatibleClient = class {
+  providerName;
+  model;
+  capabilities;
+  modelProvider;
+  constructor(opts) {
+    this.providerName = opts.providerName;
+    this.model = opts.model;
+    this.capabilities = { ...DEFAULT_CAPABILITIES, ...opts.capabilities };
+    const provider = createOpenAICompatible({
+      name: opts.providerName,
+      baseURL: opts.baseUrl,
+      apiKey: opts.apiKey
+    });
+    this.modelProvider = provider(opts.model);
+    log.debug("LLM provider initialized", {
+      provider: opts.providerName,
+      model: opts.model,
+      baseUrl: opts.baseUrl,
+      apiKey: redactApiKey(opts.apiKey)
+    });
+  }
+  async *stream(opts) {
+    const { messages, tools, systemPrompt, temperature, maxTokens, abortSignal } = opts;
+    const aiMessages = convertMessages(messages, systemPrompt);
+    const aiTools = tools ? convertTools(tools) : void 0;
+    try {
+      const result = streamText({
+        model: this.modelProvider,
+        messages: aiMessages,
+        tools: aiTools,
+        temperature,
+        maxTokens,
+        abortSignal
+      });
+      const seenToolCalls = /* @__PURE__ */ new Set();
+      for await (const part of result.fullStream) {
+        switch (part.type) {
+          case "text-delta":
+            yield { type: "text", delta: part.textDelta };
+            break;
+          case "tool-call":
+            if (!seenToolCalls.has(part.toolCallId)) {
+              seenToolCalls.add(part.toolCallId);
+              yield { type: "tool_call_start", id: part.toolCallId, name: part.toolName };
+            }
+            yield {
+              type: "tool_call_complete",
+              id: part.toolCallId,
+              name: part.toolName,
+              args: part.args
+            };
+            break;
+          case "finish":
+            yield {
+              type: "finish",
+              reason: mapFinishReason(part.finishReason),
+              usage: part.usage ? {
+                inputTokens: part.usage.promptTokens ?? 0,
+                outputTokens: part.usage.completionTokens ?? 0,
+                totalTokens: part.usage.totalTokens ?? 0
+              } : void 0
+            };
+            break;
+          case "error":
+            yield { type: "error", error: part.error instanceof Error ? part.error : new Error(String(part.error)) };
+            break;
+          default:
+            break;
+        }
+      }
+    } catch (err) {
+      yield { type: "error", error: err instanceof Error ? err : new Error(String(err)) };
+    }
+  }
+};
+function convertMessages(messages, systemPrompt) {
+  const result = [];
+  if (systemPrompt) {
+    result.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        result.push({ role: "system", content: msg.content });
+        break;
+      case "user":
+        if (typeof msg.content === "string") {
+          result.push({ role: "user", content: msg.content });
+        } else {
+          const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+          result.push({ role: "user", content: text });
+        }
+        break;
+      case "assistant":
+        result.push({ role: "assistant", content: convertAssistantContent(msg) });
+        break;
+      case "tool":
+        result.push({
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: msg.toolUseId,
+              toolName: "_tool",
+              result: msg.content,
+              isError: msg.isError ?? false
+            }
+          ]
+        });
+        break;
+    }
+  }
+  return result;
+}
+function convertAssistantContent(msg) {
+  const parts = [];
+  for (const part of msg.content) {
+    if (part.type === "text") {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "tool_use") {
+      parts.push({
+        type: "tool-call",
+        toolCallId: part.id,
+        toolName: part.name,
+        args: part.args
+      });
+    }
+  }
+  if (parts.length === 0) return "";
+  return parts;
+}
+function convertTools(tools) {
+  const result = {};
+  for (const t of tools) {
+    result[t.name] = tool({
+      description: t.description,
+      parameters: jsonSchema(t.parameters)
+    });
+  }
+  return result;
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+    case "stop-sequence":
+      return "stop";
+    case "tool-calls":
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content-filter":
+    case "content_filter":
+      return "content_filter";
+    case "error":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+var PRESETS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o-mini"
+  },
+  deepseek: {
+    baseUrl: "https://api.deepseek.com/v1",
+    defaultModel: "deepseek-chat",
+    capabilities: { maxContextWindow: 128e3 }
+  },
+  qwen: {
+    baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    defaultModel: "qwen-plus",
+    capabilities: { maxContextWindow: 128e3 }
+  },
+  moonshot: {
+    baseUrl: "https://api.moonshot.cn/v1",
+    defaultModel: "moonshot-v1-32k",
+    capabilities: { maxContextWindow: 32e3 }
+  },
+  zhipu: {
+    baseUrl: "https://open.bigmodel.cn/api/paas/v4",
+    defaultModel: "glm-4-flash",
+    capabilities: { maxContextWindow: 128e3 }
+  },
+  ollama: {
+    baseUrl: "http://localhost:11434/v1",
+    defaultModel: "llama3.1",
+    capabilities: { maxContextWindow: 8e3 }
+  },
+  openrouter: {
+    baseUrl: "https://openrouter.ai/api/v1",
+    defaultModel: "openai/gpt-4o-mini"
+  }
+};
+function createPresetClient(providerName, config, model) {
+  const preset = PRESETS[providerName];
+  if (!preset) {
+    throw new Error(`Unknown provider preset: ${providerName}. Available: ${Object.keys(PRESETS).join(", ")}`);
+  }
+  return new OpenAICompatibleClient({
+    providerName,
+    baseUrl: config.baseUrl ?? preset.baseUrl,
+    apiKey: config.apiKey ?? "",
+    model: model ?? preset.defaultModel,
+    capabilities: preset.capabilities
+  });
+}
+
+// src/types/index.ts
+var MuseError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "MuseError";
+  }
+  code;
+  cause;
+};
+var ToolError = class extends MuseError {
+  constructor(message, toolName, cause) {
+    super(message, "TOOL_ERROR", cause);
+    this.toolName = toolName;
+    this.name = "ToolError";
+  }
+  toolName;
+};
+
+// src/llm/client.ts
+var ACTIVE_API_KEY_ENV = "MUSE_ACTIVE_API_KEY";
+function setActiveModelEnv(entry) {
+  if (entry.apiKey) {
+    process.env[ACTIVE_API_KEY_ENV] = entry.apiKey;
+  } else {
+    delete process.env[ACTIVE_API_KEY_ENV];
+  }
+}
+function createLLMClientFromModelEntry(entry) {
+  const apiKey = process.env[ACTIVE_API_KEY_ENV] ?? "";
+  if (!apiKey && !entry.baseUrl.includes("localhost")) {
+    throw new MuseError(
+      `Model "${entry.id}" has no apiKey in env ${ACTIVE_API_KEY_ENV}. Check models.json (or models.local.json) and ensure setActiveModelEnv() was called.`,
+      "MISSING_API_KEY"
+    );
+  }
+  const capabilities = {};
+  if (entry.supportsToolCall !== void 0) capabilities.toolCalling = entry.supportsToolCall;
+  if (entry.supportsImages !== void 0) capabilities.vision = entry.supportsImages;
+  if (entry.contextWindow !== void 0) capabilities.maxContextWindow = entry.contextWindow;
+  return new OpenAICompatibleClient({
+    providerName: entry.vendor ?? "custom",
+    baseUrl: entry.baseUrl,
+    apiKey,
+    model: entry.id,
+    capabilities
+  });
+}
+function createLLMClient(opts) {
+  const { provider, model, providers } = opts;
+  const config = providers[provider];
+  if (!config) {
+    throw new MuseError(
+      `Provider "${provider}" is not configured. Add a "providers.${provider}" entry to your settings.json.`,
+      "PROVIDER_NOT_CONFIGURED"
+    );
+  }
+  if (PRESETS[provider]) {
+    if (!config.apiKey && provider !== "ollama") {
+      throw new MuseError(
+        `Provider "${provider}" requires apiKey. Set it in settings.json or via the corresponding env var.`,
+        "MISSING_API_KEY"
+      );
+    }
+    return createPresetClient(provider, config, model);
+  }
+  if (config.baseUrl) {
+    return new OpenAICompatibleClient({
+      providerName: provider,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey ?? "",
+      model
+    });
+  }
+  throw new MuseError(
+    `Unknown provider "${provider}". Either use a preset (${Object.keys(PRESETS).join(", ")}) or set "baseUrl" in providers.${provider}.`,
+    "UNKNOWN_PROVIDER"
+  );
+}
+
+// src/loop/agent.ts
+var Agent = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  messages = [];
+  getMessages() {
+    return this.messages;
+  }
+  setMessages(msgs) {
+    this.messages = msgs;
+  }
+  /** 执行一次完整的"用户输入 → 助手响应（含工具循环） → 等待下一轮输入"。 */
+  async runTurn(userInput) {
+    const userMessage = { role: "user", content: userInput };
+    this.messages.push(userMessage);
+    await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: userMessage });
+    while (true) {
+      const mode = this.ctx.permissions.getMode();
+      const tools = this.ctx.tools.toLLMDefinitions(
+        mode === "plan" ? (t) => t.permission === "read" : void 0
+      );
+      const stream = this.ctx.llm.stream({
+        messages: this.messages,
+        tools,
+        systemPrompt: this.ctx.systemPrompt,
+        abortSignal: this.ctx.abortSignal
+      });
+      const assistantParts = [];
+      const toolCallsToRun = [];
+      let lastError;
+      for await (const ev of stream) {
+        this.handleEvent(ev, assistantParts, toolCallsToRun, (e) => {
+          lastError = e;
+        });
+        if (lastError) break;
+      }
+      if (lastError) {
+        this.ctx.events?.onError?.(lastError);
+        log.error("agent stream error", { msg: lastError.message });
+        return;
+      }
+      const assistantMessage = { role: "assistant", content: assistantParts };
+      this.messages.push(assistantMessage);
+      await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: assistantMessage });
+      if (toolCallsToRun.length === 0) {
+        this.ctx.events?.onTurnEnd?.();
+        return;
+      }
+      for (const call of toolCallsToRun) {
+        await this.runToolCall(call);
+      }
+    }
+  }
+  handleEvent(ev, assistantParts, toolCallsToRun, onError) {
+    switch (ev.type) {
+      case "text":
+        {
+          const last = assistantParts[assistantParts.length - 1];
+          if (last && last.type === "text") {
+            last.text += ev.delta;
+          } else {
+            assistantParts.push({ type: "text", text: ev.delta });
+          }
+        }
+        this.ctx.events?.onText?.(ev.delta);
+        break;
+      case "tool_call_start":
+        this.ctx.events?.onToolCallStart?.(ev.id, ev.name);
+        break;
+      case "tool_call_complete": {
+        const callPart = { type: "tool_use", id: ev.id, name: ev.name, args: ev.args };
+        assistantParts.push(callPart);
+        toolCallsToRun.push(callPart);
+        this.ctx.events?.onToolCallArgs?.(ev.id, ev.args);
+        break;
+      }
+      case "finish":
+        if (ev.usage) {
+          this.ctx.events?.onUsage?.(ev.usage);
+          this.ctx.session.append({
+            type: "usage",
+            time: (/* @__PURE__ */ new Date()).toISOString(),
+            usage: ev.usage,
+            provider: this.ctx.llm.providerName,
+            model: this.ctx.llm.model
+          });
+        }
+        break;
+      case "error":
+        onError(ev.error);
+        break;
+    }
+  }
+  async runToolCall(call) {
+    const tool2 = this.ctx.tools.get(call.name);
+    if (!tool2) {
+      const result2 = `Tool "${call.name}" is not available.`;
+      this.recordToolResult(call.id, call.name, result2, true);
+      return;
+    }
+    const summary = tool2.summarize?.(call.args) ?? `${call.name}(...)`;
+    const decision = this.ctx.permissions.decide({
+      toolName: call.name,
+      args: call.args,
+      permission: tool2.permission
+    });
+    let approved = decision === "allow";
+    if (decision === "deny") {
+      const reason = this.ctx.permissions.getMode() === "plan" ? `Denied: you are in plan mode. Only read-only tools are available. Propose changes instead of executing.` : `Denied by policy: ${call.name}.`;
+      this.recordToolResult(call.id, call.name, reason, true);
+      return;
+    }
+    if (decision === "ask") {
+      approved = await this.ctx.events?.onPermissionRequest?.(call.name, call.args, summary) ?? false;
+      if (!approved) {
+        this.recordToolResult(call.id, call.name, `User rejected ${call.name}.`, true);
+        return;
+      }
+    }
+    const toolCtx = {
+      cwd: this.ctx.cwd,
+      abortSignal: this.ctx.abortSignal,
+      askPermission: async () => true
+      // 已在外层处理
+    };
+    const result = await this.ctx.tools.execute(call.name, call.args, toolCtx);
+    this.recordToolResult(call.id, call.name, result.content, result.isError ?? false, result.summary);
+  }
+  recordToolResult(id, name, content, isError, summary) {
+    const toolMsg = {
+      role: "tool",
+      toolUseId: id,
+      content,
+      isError
+    };
+    this.messages.push(toolMsg);
+    this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: toolMsg });
+    this.ctx.events?.onToolResult?.(id, name, content, isError, summary);
+  }
+};
+
+// src/loop/system-prompt.ts
+import { homedir as homedir2 } from "os";
+function buildSystemPrompt(opts) {
+  const { cwd, model, provider, lang, toolNames } = opts;
+  const home = homedir2();
+  const displayCwd = cwd.startsWith(home) ? cwd.replace(home, "~") : cwd;
+  const sections = [];
+  sections.push(`You are Muse, a CLI coding assistant. You are running on the user's local machine via a terminal interface.`);
+  sections.push(
+    `# Environment
+- Working directory: ${displayCwd}
+- LLM backend: ${provider} (${model})
+- Date: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`
+  );
+  sections.push(
+    `# Available tools
+` + toolNames.map((n) => `- ${n}`).join("\n") + `
+
+Prefer the dedicated tool over Bash when one fits (Read for file reading, Edit for partial updates, Write for new files / full rewrites, Grep for content search, Glob for file lookup).`
+  );
+  sections.push(
+    `# Behavior
+- Be concise. State results, not your thinking. Don't narrate every step.
+- Before editing a file you have not seen, Read it first.
+- For Write/Edit/Bash the user may need to approve \u2014 proceed normally; the host will gate dangerous calls.
+- If a command may be destructive (rm -rf, force push, drop table, etc.), warn first and let the user run it manually.
+- When the user asks a question that does not need tools, just answer.`
+  );
+  if (lang === "zh-CN") {
+    sections.push(`# Output language
+Reply in Chinese (\u7B80\u4F53\u4E2D\u6587) unless the user writes in English.`);
+  }
+  return sections.join("\n\n");
+}
+
+// src/config/loader.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join2, resolve } from "path";
+
+// src/config/types.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  extraHeaders: z.record(z.string()).optional()
+}).passthrough();
+var LLMConfigSchema = z.object({
+  provider: z.string().optional().describe("Fallback provider preset (only used when no models.json entry matches)."),
+  model: z.string().optional().describe("Active model id; should match an id in models.json."),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional()
+});
+var PermissionsSchema = z.object({
+  allow: z.array(z.string()).optional(),
+  ask: z.array(z.string()).optional(),
+  deny: z.array(z.string()).optional(),
+  defaultMode: z.enum(["strict", "relaxed", "ask"]).optional()
+});
+var UISchema = z.object({
+  theme: z.enum(["dark", "light"]).optional(),
+  lang: z.enum(["en", "zh-CN"]).optional(),
+  showBanner: z.boolean().optional()
+});
+var SettingsSchema = z.object({
+  llm: LLMConfigSchema.optional(),
+  providers: z.record(ProviderConfigSchema).optional(),
+  permissions: PermissionsSchema.optional(),
+  ui: UISchema.optional(),
+  mcpServers: z.record(z.unknown()).optional(),
+  skills: z.object({
+    enabled: z.boolean().optional(),
+    disabled: z.array(z.string()).optional()
+  }).optional()
+}).passthrough();
+
+// src/config/_env.ts
+var ENV_PATTERN = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+function expandEnvVars(value) {
+  if (typeof value === "string") {
+    return value.replace(ENV_PATTERN, (_match, name) => process.env[name] ?? "");
+  }
+  if (Array.isArray(value)) {
+    return value.map(expandEnvVars);
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = expandEnvVars(v);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/config/loader.ts
+function formatZodIssues(issues) {
+  return issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+}
+var DEFAULTS = {
+  llm: {
+    provider: "deepseek",
+    model: "deepseek-chat"
+  },
+  providers: {
+    deepseek: { apiKey: "${DEEPSEEK_API_KEY}" },
+    openai: { apiKey: "${OPENAI_API_KEY}" },
+    qwen: { apiKey: "${DASHSCOPE_API_KEY}" },
+    moonshot: { apiKey: "${MOONSHOT_API_KEY}" },
+    zhipu: { apiKey: "${ZHIPU_API_KEY}" },
+    openrouter: { apiKey: "${OPENROUTER_API_KEY}" },
+    ollama: { baseUrl: "http://localhost:11434/v1" }
+  },
+  permissions: {
+    allow: ["Read", "Grep", "Glob"],
+    ask: ["Write", "Edit", "Bash"],
+    deny: [],
+    defaultMode: "ask"
+  },
+  ui: {
+    showBanner: true,
+    lang: "en"
+  }
+};
+async function readJsonIfExists(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    const raw = await readFile(path, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    log.warn(`Failed to parse settings at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+function deepMerge(low, high) {
+  if (high == null) return low;
+  if (typeof low !== "object" || typeof high !== "object" || low === null || high === null) {
+    return high;
+  }
+  if (Array.isArray(high)) return high;
+  const result = { ...low };
+  for (const [k, v] of Object.entries(high)) {
+    const existing = low[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      result[k] = deepMerge(existing, v);
+    } else {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+async function loadSettings(cwd = process.cwd()) {
+  const sources = ["<defaults>"];
+  let merged = DEFAULTS;
+  const candidates = [
+    join2(homedir3(), ".muse", "settings.json"),
+    join2(cwd, ".muse", "settings.json"),
+    join2(cwd, ".muse", "settings.local.json")
+  ];
+  for (const path of candidates) {
+    const raw = await readJsonIfExists(path);
+    if (raw != null) {
+      const parsed = SettingsSchema.safeParse(raw);
+      if (parsed.success) {
+        merged = deepMerge(merged, parsed.data);
+        sources.push(path);
+      } else {
+        log.warn(`Invalid settings at ${path}: ${formatZodIssues(parsed.error.issues)}`);
+      }
+    }
+  }
+  if (process.env.MUSE_PROVIDER && merged.llm) {
+    merged = { ...merged, llm: { ...merged.llm, provider: process.env.MUSE_PROVIDER } };
+    sources.push("env:MUSE_PROVIDER");
+  }
+  if (process.env.MUSE_MODEL && merged.llm) {
+    merged = { ...merged, llm: { ...merged.llm, model: process.env.MUSE_MODEL } };
+    sources.push("env:MUSE_MODEL");
+  }
+  merged = expandEnvVars(merged);
+  return { settings: merged, sources };
+}
+
+// src/config/models.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join3 } from "path";
+import { z as z2 } from "zod";
+var ModelEntryInputSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().optional(),
+  vendor: z2.string().optional(),
+  apiKey: z2.string().optional(),
+  baseUrl: z2.string().optional(),
+  url: z2.string().optional(),
+  supportsToolCall: z2.boolean().optional(),
+  supportsImages: z2.boolean().optional(),
+  contextWindow: z2.number().int().positive().optional()
+}).passthrough().refine((d) => Boolean(d.baseUrl || d.url), {
+  message: "Either 'baseUrl' or 'url' is required",
+  path: ["baseUrl"]
+});
+var ModelsRegistryInputSchema = z2.object({
+  models: z2.array(ModelEntryInputSchema),
+  /** 不填 = 全部 models 都进 selector；填了就是 selector 子集（按顺序）。 */
+  availableModels: z2.array(z2.string()).optional()
+}).passthrough();
+var CANDIDATES = () => [
+  join3(homedir4(), ".muse", "models.json"),
+  join3(homedir4(), ".muse", "models.local.json")
+];
+async function loadModelsRegistry() {
+  const sources = [];
+  const errors = [];
+  let merged;
+  for (const path of CANDIDATES()) {
+    if (!existsSync2(path)) continue;
+    let raw;
+    try {
+      raw = JSON.parse(await readFile2(path, "utf-8"));
+    } catch (err) {
+      const msg = `JSON parse error: ${err instanceof Error ? err.message : String(err)}`;
+      log.warn(`Failed to parse ${path}: ${msg}`);
+      errors.push({ path, message: msg });
+      continue;
+    }
+    const parsed = ModelsRegistryInputSchema.safeParse(raw);
+    if (!parsed.success) {
+      const msg = formatZodIssues2(parsed.error.issues);
+      log.warn(`Invalid models registry at ${path}: ${msg}`);
+      errors.push({ path, message: msg });
+      continue;
+    }
+    const normalized = {
+      ...parsed.data,
+      models: parsed.data.models.map(normalizeModelEntry)
+    };
+    merged = mergeRegistries(merged, normalized);
+    sources.push(path);
+  }
+  if (!merged) return { registry: void 0, sources, errors };
+  const expanded = expandEnvVars(merged);
+  return { registry: expanded, sources, errors };
+}
+function formatZodIssues2(issues) {
+  return issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+}
+function mergeRegistries(low, high) {
+  if (!low) return high;
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of low.models) byId.set(m.id, m);
+  for (const m of high.models) byId.set(m.id, m);
+  return {
+    ...low,
+    ...high,
+    models: [...byId.values()],
+    availableModels: high.availableModels ?? low.availableModels
+  };
+}
+function normalizeModelEntry(entry) {
+  let baseUrl = (entry.baseUrl ?? entry.url ?? "").replace(/\/+$/, "");
+  if (baseUrl.endsWith("/chat/completions")) {
+    baseUrl = baseUrl.slice(0, -"/chat/completions".length);
+  }
+  const { url: _url, ...rest } = entry;
+  return { ...rest, baseUrl };
+}
+function findEntry(registry, modelId) {
+  return registry.models.find((m) => m.id === modelId);
+}
+function visibleEntries(registry) {
+  if (!registry.availableModels || registry.availableModels.length === 0) {
+    return registry.models;
+  }
+  const result = [];
+  for (const id of registry.availableModels) {
+    const e = registry.models.find((m) => m.id === id);
+    if (e) result.push(e);
+  }
+  return result;
+}
+
+// src/slash/registry.ts
+var SlashRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  order = [];
+  register(cmd) {
+    if (this.byName.has(cmd.name)) {
+      throw new Error(`Duplicate slash command: /${cmd.name}`);
+    }
+    this.byName.set(cmd.name, cmd);
+    this.order.push(cmd);
+    for (const a of cmd.aliases ?? []) {
+      if (!this.byName.has(a)) this.byName.set(a, cmd);
+    }
+  }
+  registerAll(cmds) {
+    for (const c of cmds) this.register(c);
+  }
+  get(name) {
+    return this.byName.get(name);
+  }
+  list() {
+    return [...this.order];
+  }
+};
+function parseSlash(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/") || trimmed.length < 2) return null;
+  const body = trimmed.slice(1);
+  const space = body.search(/\s/);
+  if (space === -1) return { name: body, args: "" };
+  return { name: body.slice(0, space), args: body.slice(space + 1).trim() };
+}
+
+// src/llm/pricing.ts
+var PRICING = {
+  openai: {
+    "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6 },
+    "gpt-4-turbo": { inputPer1M: 10, outputPer1M: 30 }
+  },
+  deepseek: {
+    "deepseek-chat": { inputPer1M: 0.14, outputPer1M: 0.28 },
+    "deepseek-reasoner": { inputPer1M: 0.55, outputPer1M: 2.19 }
+  },
+  qwen: {
+    "qwen-plus": { inputPer1M: 0.4, outputPer1M: 1.2 },
+    "qwen-max": { inputPer1M: 2.8, outputPer1M: 8.4 },
+    "qwen-turbo": { inputPer1M: 0.05, outputPer1M: 0.2 }
+  },
+  moonshot: {
+    "moonshot-v1-8k": { inputPer1M: 1.68, outputPer1M: 1.68 },
+    "moonshot-v1-32k": { inputPer1M: 3.36, outputPer1M: 3.36 },
+    "moonshot-v1-128k": { inputPer1M: 8.4, outputPer1M: 8.4 }
+  },
+  zhipu: {
+    "glm-4-flash": { inputPer1M: 0, outputPer1M: 0 },
+    "glm-4-plus": { inputPer1M: 7, outputPer1M: 7 }
+  },
+  ollama: {
+    // 本地模型零成本
+  }
+};
+function lookupPricing(provider, model) {
+  return PRICING[provider]?.[model];
+}
+function estimateCostUSD(provider, model, inputTokens, outputTokens) {
+  const p = lookupPricing(provider, model);
+  if (!p) return void 0;
+  return inputTokens / 1e6 * p.inputPer1M + outputTokens / 1e6 * p.outputPer1M;
+}
+function formatUSD(usd) {
+  if (usd === 0) return "$0.00";
+  if (usd < 1e-4) return `<$0.0001`;
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(4)}`;
+}
+
+// src/loop/context.ts
+async function compactMessages(messages, opts) {
+  const keepRecent = opts.keepRecent ?? 4;
+  const cutoff = findSafeCutoff(messages, keepRecent);
+  if (cutoff <= 0) {
+    return {
+      newMessages: messages,
+      summary: "",
+      originalCount: messages.length,
+      newCount: messages.length,
+      noop: true
+    };
+  }
+  const older = messages.slice(0, cutoff);
+  const recent = messages.slice(cutoff);
+  const summary = await summarizeConversation(older, opts.llm, opts.abortSignal);
+  const summaryMessage = {
+    role: "user",
+    content: `[Previous conversation summary]
+
+${summary}
+
+[End of summary. The conversation continues below.]`
+  };
+  const newMessages = [summaryMessage, ...recent];
+  return {
+    newMessages,
+    summary,
+    originalCount: messages.length,
+    newCount: newMessages.length,
+    noop: false
+  };
+}
+function findSafeCutoff(messages, keepRecent) {
+  if (messages.length <= keepRecent) return 0;
+  const ideal = Math.max(0, messages.length - keepRecent);
+  for (let i = ideal; i > 0; i--) {
+    if (messages[i].role !== "user") continue;
+    if (hasUnresolvedToolUse(messages.slice(0, i))) continue;
+    return i;
+  }
+  return 0;
+}
+function hasUnresolvedToolUse(older) {
+  const seenToolUseIds = /* @__PURE__ */ new Set();
+  const seenToolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of older) {
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (part.type === "tool_use") seenToolUseIds.add(part.id);
+      }
+    } else if (msg.role === "tool") {
+      seenToolResultIds.add(msg.toolUseId);
+    }
+  }
+  for (const id of seenToolUseIds) {
+    if (!seenToolResultIds.has(id)) return true;
+  }
+  return false;
+}
+async function summarizeConversation(older, llm, abortSignal) {
+  const transcript = renderTranscript(older);
+  const prompt = [
+    {
+      role: "user",
+      content: `Summarize the following conversation in 200-400 words. Focus on:
+1. The user's task and goals
+2. Key decisions and approaches taken
+3. Files or code touched (paths + what changed)
+4. Outstanding questions or pending work
+
+Be concrete. Do not invent details. Use short bullet points where appropriate.
+
+--- BEGIN CONVERSATION ---
+${transcript}
+--- END CONVERSATION ---`
+    }
+  ];
+  let text = "";
+  for await (const ev of llm.stream({ messages: prompt, abortSignal })) {
+    if (ev.type === "text") text += ev.delta;
+    else if (ev.type === "error") throw ev.error;
+  }
+  return text.trim() || "(empty summary)";
+}
+function renderTranscript(messages) {
+  const lines = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        lines.push(`[system]
+${msg.content}
+`);
+        break;
+      case "user":
+        lines.push(`[user]
+${typeof msg.content === "string" ? msg.content : flattenContent(msg.content)}
+`);
+        break;
+      case "assistant":
+        lines.push(`[assistant]
+${renderAssistant(msg)}
+`);
+        break;
+      case "tool":
+        lines.push(`[tool result${msg.isError ? " ERROR" : ""}]
+${msg.content}
+`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+function renderAssistant(msg) {
+  const parts = [];
+  for (const part of msg.content) {
+    if (part.type === "text") parts.push(part.text);
+    else if (part.type === "tool_use") {
+      parts.push(`<tool_call name="${part.name}" args=${JSON.stringify(part.args)} />`);
+    }
+  }
+  return parts.join("\n");
+}
+function flattenContent(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+
+// src/mcp/index.ts
+var NOT_IMPLEMENTED = "MCP client not implemented (planned for v0.3)";
+function getMCPStatus(settings) {
+  const servers = settings.mcpServers ?? {};
+  return Object.entries(servers).map(([name, config]) => ({
+    name,
+    configured: true,
+    connected: false,
+    toolCount: 0,
+    error: NOT_IMPLEMENTED,
+    config
+  }));
+}
+
+// src/session/jsonl.ts
+import { appendFile, mkdir, readdir, readFile as readFile3, stat } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+import { createHash, randomUUID } from "crypto";
+function projectHash(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function sessionsDir(cwd) {
+  return join4(homedir5(), ".muse", "projects", projectHash(cwd), "sessions");
+}
+var Session = class _Session {
+  meta;
+  writeQueue = Promise.resolve();
+  constructor(meta) {
+    this.meta = meta;
+  }
+  static async create(cwd) {
+    const id = randomUUID();
+    const dir = sessionsDir(cwd);
+    await mkdir(dir, { recursive: true });
+    const path = join4(dir, `${id}.jsonl`);
+    const meta = {
+      id,
+      cwd,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      path
+    };
+    log.debug("session created", { id, path });
+    return new _Session(meta);
+  }
+  static async findLatest(cwd) {
+    const list = await _Session.listAll(cwd, 1);
+    return list[0];
+  }
+  static async resolve(cwd, idOrPrefix) {
+    const dir = sessionsDir(cwd);
+    if (!existsSync3(dir)) return void 0;
+    const entries = await readdir(dir);
+    const matches = entries.filter((e) => e.endsWith(".jsonl") && e.startsWith(idOrPrefix));
+    if (matches.length === 0) return void 0;
+    if (matches.length > 1) {
+      throw new Error(`Ambiguous session id "${idOrPrefix}" matches ${matches.length} sessions; use more characters.`);
+    }
+    const top = matches[0];
+    const st = await stat(join4(dir, top));
+    return {
+      id: top.replace(/\.jsonl$/, ""),
+      cwd,
+      createdAt: st.mtime.toISOString(),
+      path: join4(dir, top)
+    };
+  }
+  /**
+   * 按修改时间倒序列出当前 cwd 下的 session，附带 preview 与消息数。
+   * 读 preview 需要打开每个文件；调用方通过 limit 控制 IO 量。
+   */
+  static async listAll(cwd, limit) {
+    const dir = sessionsDir(cwd);
+    if (!existsSync3(dir)) return [];
+    const entries = await readdir(dir);
+    const files = entries.filter((e) => e.endsWith(".jsonl"));
+    if (files.length === 0) return [];
+    const stats = await Promise.all(
+      files.map(async (f) => {
+        const path = join4(dir, f);
+        const st = await stat(path);
+        return { file: f, path, mtime: st.mtime };
+      })
+    );
+    stats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const truncated = typeof limit === "number" ? stats.slice(0, limit) : stats;
+    const summaries = [];
+    for (const s of truncated) {
+      const meta = {
+        id: s.file.replace(/\.jsonl$/, ""),
+        cwd,
+        createdAt: s.mtime.toISOString(),
+        path: s.path
+      };
+      const summary = await readSummary(meta);
+      summaries.push(summary);
+    }
+    return summaries;
+  }
+  static async open(meta) {
+    const session = new _Session(meta);
+    const events = await session.readAll();
+    return { session, events };
+  }
+  /** 从已加载的 events 重建 messages 数组（按时序）。 */
+  static messagesFromEvents(events) {
+    const out = [];
+    for (const ev of events) {
+      if (ev.type === "message") out.push(ev.message);
+    }
+    return out;
+  }
+  async append(event) {
+    const line = JSON.stringify(event) + "\n";
+    this.writeQueue = this.writeQueue.then(async () => {
+      try {
+        await mkdir(dirname2(this.meta.path), { recursive: true });
+        await appendFile(this.meta.path, line, "utf-8");
+      } catch (err) {
+        log.warn(`session append failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+    return this.writeQueue;
+  }
+  async readAll() {
+    if (!existsSync3(this.meta.path)) return [];
+    const raw = await readFile3(this.meta.path, "utf-8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return events;
+  }
+};
+async function readSummary(meta) {
+  let events = [];
+  try {
+    const raw = await readFile3(meta.path, "utf-8");
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const messages = events.filter((e) => e.type === "message");
+  const firstUser = messages.find((e) => e.message.role === "user");
+  let preview;
+  if (firstUser) {
+    const c = firstUser.message.content;
+    const text = typeof c === "string" ? c : c.map((p) => p.type === "text" ? p.text : "").join(" ").trim();
+    preview = text.slice(0, 60).replace(/\s+/g, " ");
+  }
+  return { ...meta, preview, messageCount: messages.length };
+}
+
+// src/slash/_format.ts
+import { homedir as homedir6 } from "os";
+function shortPath(p) {
+  const home = homedir6();
+  if (p === home) return "~";
+  if (p.startsWith(home + "/")) return "~" + p.slice(home.length);
+  return p;
+}
+function formatList(list) {
+  if (!list || list.length === 0) return "(none)";
+  return list.join(", ");
+}
+function parseArgs(raw) {
+  const tokens = raw.trim().split(/\s+/).filter(Boolean);
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.startsWith("--")) {
+      const key = t.slice(2);
+      const next = tokens[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(t);
+    }
+  }
+  return { positional, flags };
+}
+function formatTime2(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return iso;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+// src/slash/builtin.ts
+var HELP = {
+  name: "help",
+  description: "show available slash commands",
+  execute(ctx) {
+    const cmds = ctx.listCommands();
+    const heads = cmds.map(headOf);
+    const width = Math.max(...heads.map((h) => h.length));
+    const lines = ["Built-in commands:"];
+    for (let i = 0; i < cmds.length; i++) {
+      const aliasNote = cmds[i].aliases?.length ? `  (alias: ${cmds[i].aliases.map((a) => `/${a}`).join(", ")})` : "";
+      lines.push(`  /${heads[i].padEnd(width)}   ${cmds[i].description}${aliasNote}`);
+    }
+    lines.push("", "Keys:  Ctrl+C  exit");
+    return { display: lines.join("\n") };
+  }
+};
+function headOf(c) {
+  return c.argsHint ? `${c.name} ${c.argsHint}` : c.name;
+}
+var CLEAR = {
+  name: "clear",
+  description: "clear conversation history",
+  execute(ctx) {
+    ctx.actions.setMessages([]);
+    return { display: "(history cleared)" };
+  }
+};
+var QUIT = {
+  name: "quit",
+  aliases: ["exit"],
+  description: "exit Muse",
+  execute() {
+    return { exit: true };
+  }
+};
+var COST = {
+  name: "cost",
+  description: "show token usage and estimated cost for this session",
+  execute(ctx) {
+    const { tokens, llm } = ctx;
+    const pricing = lookupPricing(llm.providerName, llm.model);
+    const lines = [
+      `Session cost`,
+      `  provider/model:  ${llm.providerName} / ${llm.model}`,
+      `  input tokens:    ${tokens.inputTokens.toLocaleString()}`,
+      `  output tokens:   ${tokens.outputTokens.toLocaleString()}`,
+      `  total tokens:    ${tokens.totalTokens.toLocaleString()}`
+    ];
+    if (pricing) {
+      const cost = estimateCostUSD(llm.providerName, llm.model, tokens.inputTokens, tokens.outputTokens) ?? 0;
+      lines.push(
+        `  price (per 1M):  input $${pricing.inputPer1M}  /  output $${pricing.outputPer1M}`,
+        `  estimated cost:  ${formatUSD(cost)}`
+      );
+    } else {
+      lines.push(`  estimated cost:  (no pricing data for ${llm.providerName}/${llm.model})`);
+    }
+    return { display: lines.join("\n") };
+  }
+};
+var COMPACT = {
+  name: "compact",
+  description: "summarize older messages to free up context space",
+  argsHint: "[--keep N]",
+  async execute(ctx) {
+    if (ctx.history.length === 0) return { display: "(empty history; nothing to compact)" };
+    const { flags } = parseArgs(ctx.args);
+    const keepRecent = typeof flags.keep === "string" ? Math.max(1, parseInt(flags.keep, 10)) : 4;
+    if (Number.isNaN(keepRecent)) return { display: `Invalid --keep value: ${flags.keep}` };
+    const result = await compactMessages(ctx.history, { llm: ctx.llm, keepRecent });
+    if (result.noop) {
+      return { display: `(history has ${result.originalCount} messages; not enough to compact with --keep ${keepRecent})` };
+    }
+    ctx.actions.setMessages(result.newMessages);
+    const preview = result.summary.length > 240 ? result.summary.slice(0, 240) + "\u2026" : result.summary;
+    return {
+      display: `Compacted ${result.originalCount} \u2192 ${result.newCount} messages (kept last ${keepRecent}).
+
+Summary:
+${preview}`
+    };
+  }
+};
+var MODELS = {
+  name: "models",
+  description: "pick a model from ~/.muse/models.json (\u2191\u2193 to navigate)",
+  async execute(ctx) {
+    let registry = ctx.modelsRegistry;
+    let errors = [];
+    if (!registry) {
+      const r = await loadModelsRegistry();
+      registry = r.registry;
+      errors = r.errors;
+    }
+    if (!registry) {
+      if (errors.length > 0) {
+        return { display: renderLoadErrors(errors) };
+      }
+      return { display: renderEmptyRegistryHint() };
+    }
+    const visible = visibleEntries(registry);
+    if (visible.length === 0) {
+      return {
+        display: `models.json has no available models.
+Check that "availableModels" lists at least one id present in "models".`
+      };
+    }
+    const picked = await ctx.actions.pickModel(visible, ctx.llm.model);
+    if (!picked) return { display: "(cancelled)" };
+    if (picked.id === ctx.llm.model) return { display: `Already on ${picked.id}.` };
+    try {
+      await ctx.actions.switchModel(picked.id);
+      return { display: `Switched to ${picked.id}${picked.vendor ? ` (${picked.vendor})` : ""}.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { display: `Failed to switch: ${msg}` };
+    }
+  }
+};
+function renderLoadErrors(errors) {
+  return [
+    `models.json was found but failed to load:`,
+    ``,
+    ...errors.flatMap((e) => [`  ${shortPath(e.path)}`, `    ${e.message}`]),
+    ``,
+    `Fix the file above, then run /models again (it re-reads on each call).`,
+    `Hint: each entry needs "id" and "baseUrl" (or "url"); "apiKey" supports \${ENV_VAR}.`
+  ].join("\n");
+}
+function renderEmptyRegistryHint() {
+  return [
+    `No models registry found.`,
+    `Create ~/.muse/models.json with a "models" array. Example:`,
+    ``,
+    `{`,
+    `  "models": [`,
+    `    {`,
+    `      "id": "<your-model-id>",`,
+    `      "vendor": "<vendor-name>",`,
+    `      "baseUrl": "https://...",`,
+    `      "apiKey": "\${YOUR_API_KEY}",`,
+    `      "supportsToolCall": true`,
+    `    }`,
+    `  ],`,
+    `  "availableModels": ["<your-model-id>"]`,
+    `}`,
+    ``,
+    `Then run /models again (no restart needed).`
+  ].join("\n");
+}
+var CONFIG = {
+  name: "config",
+  description: "show / reload configuration (API keys redacted)",
+  argsHint: "[reload | path]",
+  async execute(ctx) {
+    const sub = ctx.args.trim();
+    if (sub === "reload") {
+      try {
+        const { sources } = await ctx.actions.reloadSettings();
+        return { display: `Reloaded from ${sources.length} sources:
+` + sources.map((s) => `  - ${shortPath(s)}`).join("\n") };
+      } catch (err) {
+        return { display: `Reload failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    }
+    if (sub === "path") {
+      return { display: renderConfigPaths(ctx) };
+    }
+    if (sub && sub !== "show") {
+      return { display: `Unknown subcommand: /config ${sub}. Use: /config [show|reload|path]` };
+    }
+    return { display: renderConfigShow(ctx) };
+  }
+};
+function renderConfigShow(ctx) {
+  const s = ctx.settings;
+  const lines = [
+    `Effective configuration`,
+    `  sources:`,
+    ...ctx.settingsSources.map((src) => `    - ${shortPath(src)}`),
+    ``,
+    `  llm:`,
+    `    provider:  ${s.llm?.provider ?? "(unset)"}`,
+    `    model:     ${s.llm?.model ?? "(unset)"}`
+  ];
+  if (s.llm?.temperature !== void 0) lines.push(`    temperature: ${s.llm.temperature}`);
+  if (s.llm?.maxTokens !== void 0) lines.push(`    maxTokens:   ${s.llm.maxTokens}`);
+  lines.push(``, `  providers (apiKey redacted):`);
+  for (const [name, cfg] of Object.entries(s.providers ?? {})) {
+    lines.push(`    ${name}:  apiKey=${redactApiKey(cfg.apiKey)}  baseUrl=${cfg.baseUrl ?? "(default)"}`);
+  }
+  lines.push(``, `  permissions:`);
+  lines.push(`    defaultMode: ${s.permissions?.defaultMode ?? "ask"}`);
+  lines.push(`    allow:       ${formatList(s.permissions?.allow)}`);
+  lines.push(`    ask:         ${formatList(s.permissions?.ask)}`);
+  lines.push(`    deny:        ${formatList(s.permissions?.deny)}`);
+  lines.push(``, `  ui:`);
+  lines.push(`    lang:        ${s.ui?.lang ?? "(default)"}`);
+  lines.push(`    showBanner:  ${s.ui?.showBanner ?? true}`);
+  return lines.join("\n");
+}
+function renderConfigPaths(ctx) {
+  const home = process.env.HOME ?? "~";
+  return [
+    `Configuration file paths (high to low precedence):`,
+    `  1. CLI flags / env (MUSE_PROVIDER, MUSE_MODEL, \u2026)`,
+    `  2. ${shortPath(`${ctx.cwd}/.muse/settings.local.json`)}  (project, gitignored)`,
+    `  3. ${shortPath(`${ctx.cwd}/.muse/settings.json`)}        (project, committable)`,
+    `  4. ${shortPath(`${home}/.muse/settings.json`)}            (global)`,
+    `  5. <built-in defaults>`,
+    ``,
+    `Edit any of the above, then run /config reload (no restart needed).`
+  ].join("\n");
+}
+var MCP = {
+  name: "mcp",
+  description: "show MCP server status",
+  execute(ctx) {
+    const status = getMCPStatus(ctx.settings);
+    if (status.length === 0) {
+      return {
+        display: `No MCP servers configured.
+Add servers under "mcpServers" in your settings.json.
+Note: MCP client integration is planned for v0.3; current /mcp only inspects configuration.`
+      };
+    }
+    const lines = [`MCP servers (${status.length}):`];
+    for (const s of status) {
+      const indicator = s.connected ? "\u25CF" : "\u25CB";
+      lines.push(`  ${indicator} ${s.name}`);
+      lines.push(`      configured: ${s.configured}`);
+      lines.push(`      connected:  ${s.connected}${s.error ? `  (${s.error})` : ""}`);
+      if (s.connected) lines.push(`      tools:      ${s.toolCount}`);
+      if (s.config?.command) lines.push(`      command:    ${s.config.command}${s.config.args ? " " + s.config.args.join(" ") : ""}`);
+      if (s.config?.url) lines.push(`      url:        ${s.config.url}`);
+    }
+    return { display: lines.join("\n") };
+  }
+};
+var RESUME = {
+  name: "resume",
+  description: "resume a past session (\u2191\u2193 to pick, or pass an id-prefix)",
+  argsHint: "[session-id-prefix]",
+  async execute(ctx) {
+    if (ctx.args) {
+      let meta;
+      try {
+        meta = await Session.resolve(ctx.cwd, ctx.args);
+      } catch (err) {
+        return { display: err instanceof Error ? err.message : String(err) };
+      }
+      if (!meta) return { display: `No session matches "${ctx.args}".` };
+      return loadAndReport(meta, ctx);
+    }
+    const list = await Session.listAll(ctx.cwd, 20);
+    if (list.length === 0) return { display: "No past sessions in this directory." };
+    const picked = await ctx.actions.pickSession(list, ctx.session.meta.id);
+    if (!picked) return { display: "(cancelled)" };
+    if (picked.id === ctx.session.meta.id) return { display: "Already on this session." };
+    return loadAndReport(picked, ctx);
+  }
+};
+async function loadAndReport(meta, ctx) {
+  const { events } = await Session.open(meta);
+  const messages = Session.messagesFromEvents(events);
+  ctx.actions.setMessages(messages);
+  return {
+    display: `Resumed session ${meta.id.slice(0, 8)} (${messages.length} messages from ${formatTime2(meta.createdAt)}).`
+  };
+}
+var BUILTIN_SLASH_COMMANDS = [
+  HELP,
+  CLEAR,
+  COMPACT,
+  MODELS,
+  CONFIG,
+  MCP,
+  COST,
+  RESUME,
+  QUIT
+];
+
+// src/app.tsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function reducer(state, action) {
+  switch (action.type) {
+    case "user_submit":
+      return { ...state, streamingText: "", status: "streaming" };
+    case "history_set":
+      return { ...state, history: action.messages };
+    case "stream_delta":
+      return { ...state, streamingText: state.streamingText + action.delta };
+    case "stream_reset":
+      return { ...state, streamingText: "" };
+    case "set_status":
+      return { ...state, status: action.status };
+    case "add_usage":
+      return {
+        ...state,
+        inputTokens: state.inputTokens + action.usage.inputTokens,
+        outputTokens: state.outputTokens + action.usage.outputTokens,
+        totalTokens: state.totalTokens + action.usage.totalTokens
+      };
+  }
+}
+function App({
+  llm: initialLLM,
+  tools,
+  permissions: initialPermissions,
+  session,
+  settings: initialSettings,
+  settingsSources: initialSources,
+  modelsRegistry: initialModelsRegistry,
+  cwd,
+  lang,
+  showBanner,
+  initialMessages
+}) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const termWidth = stdout?.columns ?? 80;
+  const [llm, setLLM] = useState2(initialLLM);
+  const [permissions, setPermissions] = useState2(initialPermissions);
+  const [settings, setSettings] = useState2(initialSettings);
+  const [settingsSources, setSettingsSources] = useState2(initialSources);
+  const [modelsRegistry, setModelsRegistry] = useState2(initialModelsRegistry);
+  const [mode, setMode] = useState2(initialPermissions.getMode());
+  const [state, dispatch] = useReducer(reducer, {
+    history: initialMessages ?? [],
+    streamingText: "",
+    status: "idle",
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  });
+  const messagesRef = useRef(initialMessages ?? []);
+  const [input, setInput] = useState2("");
+  const [inputRemountKey, setInputRemountKey] = useState2(0);
+  const commitInput = (value) => {
+    setInput(value);
+    setInputRemountKey((k) => k + 1);
+  };
+  const [pending, setPending] = useState2(null);
+  const [picker, setPicker] = useState2(null);
+  const [sessionPicker, setSessionPicker] = useState2(null);
+  const [autocompleteIndex, setAutocompleteIndex] = useState2(0);
+  const agentRef = useRef(null);
+  const slash = useMemo2(() => {
+    const r = new SlashRegistry();
+    r.registerAll(BUILTIN_SLASH_COMMANDS);
+    return r;
+  }, []);
+  const autocomplete = useMemo2(() => {
+    if (!input.startsWith("/")) return null;
+    const body = input.slice(1);
+    if (body.includes(" ")) return null;
+    const query = body.toLowerCase();
+    const all = slash.list();
+    const matches = query ? all.filter(
+      (c) => c.name.toLowerCase().includes(query) || c.aliases?.some((a) => a.toLowerCase().includes(query))
+    ) : all;
+    return { matches, query };
+  }, [input, slash]);
+  useEffect(() => {
+    const len = autocomplete?.matches.length ?? 0;
+    if (autocompleteIndex >= len) setAutocompleteIndex(0);
+  }, [autocomplete, autocompleteIndex]);
+  useEffect(() => {
+    const systemPrompt = buildSystemPrompt({
+      cwd,
+      model: llm.model,
+      provider: llm.providerName,
+      lang,
+      toolNames: tools.list().map((t) => t.name)
+    });
+    const agent = new Agent({
+      llm,
+      tools,
+      permissions,
+      session,
+      cwd,
+      systemPrompt,
+      events: {
+        onText: (delta) => dispatch({ type: "stream_delta", delta }),
+        onToolCallStart: () => dispatch({ type: "set_status", status: "tool" }),
+        onUsage: (usage) => dispatch({ type: "add_usage", usage }),
+        onTurnEnd: () => {
+          const msgs = [...agent.getMessages()];
+          messagesRef.current = msgs;
+          dispatch({ type: "history_set", messages: msgs });
+          dispatch({ type: "stream_reset" });
+          dispatch({ type: "set_status", status: "idle" });
+        },
+        onError: (err) => {
+          dispatch({ type: "stream_delta", delta: `
+[error] ${err.message}
+` });
+          dispatch({ type: "set_status", status: "idle" });
+        },
+        onPermissionRequest: (toolName, args, summary) => new Promise((resolve5) => {
+          setPending({ toolName, args, summary, resolve: resolve5 });
+        })
+      }
+    });
+    agent.setMessages(messagesRef.current);
+    agentRef.current = agent;
+  }, [llm, tools, permissions, session, cwd, lang]);
+  useInput3(
+    (inputKey, key) => {
+      if (key.ctrl && inputKey === "c") {
+        exit();
+        return;
+      }
+      if (key.shift && key.tab) {
+        const next = permissions.cycleMode();
+        setMode(next);
+        return;
+      }
+      if (!autocomplete || autocomplete.matches.length === 0) return;
+      const len = autocomplete.matches.length;
+      if (key.upArrow) {
+        setAutocompleteIndex((i) => (i - 1 + len) % len);
+      } else if (key.downArrow) {
+        setAutocompleteIndex((i) => (i + 1) % len);
+      } else if (key.tab) {
+        const picked = autocomplete.matches[autocompleteIndex];
+        if (picked) commitInput(`/${picked.name}`);
+      } else if (key.escape) {
+        commitInput("");
+      }
+    },
+    { isActive: state.status === "idle" && !pending && !picker && !sessionPicker }
+  );
+  const acceptingInput = state.status === "idle" && pending === null && picker === null && sessionPicker === null;
+  const actions = useMemo2(
+    () => ({
+      setMessages: (msgs) => {
+        messagesRef.current = msgs;
+        agentRef.current?.setMessages(msgs);
+        dispatch({ type: "history_set", messages: msgs });
+      },
+      pickModel: (items, currentId) => new Promise((resolve5) => {
+        setPicker({ items, currentId, resolve: resolve5 });
+      }),
+      pickSession: (items, currentId) => new Promise((resolve5) => {
+        setSessionPicker({ items, currentId, resolve: resolve5 });
+      }),
+      switchModel: async (modelId) => {
+        if (!modelsRegistry) throw new Error("No models registry loaded.");
+        const entry = findEntry(modelsRegistry, modelId);
+        if (!entry) throw new Error(`Model id "${modelId}" not in registry.`);
+        setActiveModelEnv(entry);
+        const next = createLLMClientFromModelEntry(entry);
+        setLLM(next);
+        await persistActiveModel(modelId);
+      },
+      reloadSettings: async () => {
+        const { settings: nextSettings, sources } = await loadSettings(cwd);
+        const { registry: nextModels } = await loadModelsRegistry();
+        setSettings(nextSettings);
+        setSettingsSources(sources);
+        setPermissions(new PermissionGate(nextSettings.permissions));
+        setModelsRegistry(nextModels);
+        const wantModel = nextSettings.llm?.model;
+        if (wantModel && wantModel !== llm.model) {
+          try {
+            const entry = nextModels ? findEntry(nextModels, wantModel) : void 0;
+            if (entry) {
+              setActiveModelEnv(entry);
+              setLLM(createLLMClientFromModelEntry(entry));
+            } else if (nextSettings.llm?.provider) {
+              setLLM(
+                createLLMClient({
+                  provider: nextSettings.llm.provider,
+                  model: wantModel,
+                  providers: nextSettings.providers ?? {}
+                })
+              );
+            }
+          } catch {
+          }
+        }
+        return { settings: nextSettings, sources };
+      }
+    }),
+    [cwd, modelsRegistry, llm.model]
+  );
+  const handleSubmit = useCallback(
+    async (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) return;
+      if (autocomplete && autocomplete.matches.length > 0) {
+        const exact = autocomplete.matches.find(
+          (c) => c.name === autocomplete.query || c.aliases?.includes(autocomplete.query)
+        );
+        if (!exact) {
+          const picked = autocomplete.matches[autocompleteIndex] ?? autocomplete.matches[0];
+          commitInput(`/${picked.name}`);
+          return;
+        }
+      }
+      const parsed = parseSlash(trimmed);
+      if (parsed) {
+        const cmd = slash.get(parsed.name);
+        commitInput("");
+        if (!cmd) {
+          appendAssistantText(`Unknown command: /${parsed.name}. Try /help.`);
+          return;
+        }
+        try {
+          const result = await cmd.execute({
+            args: parsed.args,
+            cwd,
+            llm,
+            session,
+            settings,
+            settingsSources,
+            modelsRegistry,
+            // 用 ref 而非 state.history：命令体可能在 await 期间调 setMessages
+            // 改变 messages（如 /resume / /compact），后续 display 必须基于最新值
+            history: messagesRef.current,
+            tokens: {
+              inputTokens: state.inputTokens,
+              outputTokens: state.outputTokens,
+              totalTokens: state.totalTokens
+            },
+            listCommands: () => slash.list(),
+            actions
+          });
+          applySlashResult(result);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          appendAssistantText(`[error] /${parsed.name}: ${msg}`);
+        }
+        return;
+      }
+      commitInput("");
+      dispatch({ type: "user_submit" });
+      try {
+        await agentRef.current?.runTurn(trimmed);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        dispatch({ type: "stream_delta", delta: `
+[error] ${msg}
+` });
+        dispatch({ type: "set_status", status: "idle" });
+      }
+    },
+    [slash, cwd, llm, session, settings, settingsSources, modelsRegistry, state.inputTokens, state.outputTokens, state.totalTokens, actions, autocomplete, autocompleteIndex]
+  );
+  function appendAssistantText(text) {
+    const msg = { role: "assistant", content: [{ type: "text", text }] };
+    const next = [...messagesRef.current, msg];
+    messagesRef.current = next;
+    dispatch({ type: "history_set", messages: next });
+  }
+  function applySlashResult(result) {
+    if (result.exit) {
+      exit();
+      return;
+    }
+    if (result.display !== void 0) {
+      appendAssistantText(result.display);
+    }
+  }
+  const banner = !showBanner ? null : pickBanner(termWidth, { version: "0.1.0", model: llm.model, cwd: shortCwd(cwd) });
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    banner,
+    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, children: [
+      state.history.map((msg, i) => /* @__PURE__ */ jsx9(MessageView, { message: msg }, i)),
+      state.streamingText && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { children: state.streamingText }) })
+    ] }),
+    pending && /* @__PURE__ */ jsx9(
+      PermissionPrompt,
+      {
+        request: {
+          ...pending,
+          resolve: (ok) => {
+            pending.resolve(ok);
+            setPending(null);
+          }
+        }
+      }
+    ),
+    picker && /* @__PURE__ */ jsx9(
+      ModelSelector,
+      {
+        request: {
+          ...picker,
+          resolve: (m) => {
+            picker.resolve(m);
+            setPicker(null);
+          }
+        }
+      }
+    ),
+    sessionPicker && /* @__PURE__ */ jsx9(
+      SessionSelector,
+      {
+        request: {
+          ...sessionPicker,
+          resolve: (s) => {
+            sessionPicker.resolve(s);
+            setSessionPicker(null);
+          }
+        }
+      }
+    ),
+    acceptingInput && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx9(Text9, { color: "cyan", children: "> " }),
+        /* @__PURE__ */ jsx9(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit }, inputRemountKey)
+      ] }),
+      autocomplete && autocomplete.matches.length > 0 && /* @__PURE__ */ jsx9(SlashAutocomplete, { matches: autocomplete.matches, index: autocompleteIndex })
+    ] }),
+    state.status === "streaming" && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "... (streaming)" }) }),
+    state.status === "tool" && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "... (running tool)" }) }),
+    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(PermissionModeBar, { mode, compact: termWidth < 60 }) })
+  ] });
+}
+function shortCwd(cwd) {
+  const home = homedir7();
+  if (cwd === home) return "~";
+  if (cwd.startsWith(home + "/")) return "~" + cwd.slice(home.length);
+  return cwd;
+}
+async function persistActiveModel(modelId) {
+  const path = join5(homedir7(), ".muse", "settings.json");
+  let current = {};
+  if (existsSync4(path)) {
+    try {
+      current = JSON.parse(await readFile4(path, "utf-8"));
+    } catch {
+      current = {};
+    }
+  }
+  const llm = current.llm ?? {};
+  const next = { ...current, llm: { ...llm, model: modelId } };
+  await mkdir2(dirname3(path), { recursive: true });
+  await writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+}
+
+// src/tools/registry.ts
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  if (def.typeName === "ZodObject") {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      properties[key] = zodToJsonSchema(value);
+      if (!value.isOptional?.()) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      additionalProperties: false
+    };
+  }
+  if (def.typeName === "ZodString") {
+    const d = def;
+    return { type: "string", ...d.description ? { description: d.description } : {} };
+  }
+  if (def.typeName === "ZodNumber") {
+    return { type: "number" };
+  }
+  if (def.typeName === "ZodBoolean") {
+    return { type: "boolean" };
+  }
+  if (def.typeName === "ZodArray") {
+    const inner = def.type;
+    return { type: "array", items: zodToJsonSchema(inner) };
+  }
+  if (def.typeName === "ZodOptional" || def.typeName === "ZodDefault") {
+    const inner = def.innerType;
+    return zodToJsonSchema(inner);
+  }
+  if (def.typeName === "ZodEnum") {
+    const values = def.values;
+    return { type: "string", enum: values };
+  }
+  if (def.typeName === "ZodUnion") {
+    const opts = def.options;
+    return { anyOf: opts.map(zodToJsonSchema) };
+  }
+  return {};
+}
+function getDescription(schema) {
+  return schema.description;
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool2) {
+    if (this.tools.has(tool2.name)) {
+      throw new Error(`Tool "${tool2.name}" already registered.`);
+    }
+    this.tools.set(tool2.name, tool2);
+  }
+  registerAll(tools) {
+    for (const tool2 of tools) this.register(tool2);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  /** 转为 LLM 可读的 tool definition 数组。可选 filter（如 plan 模式过滤只读工具）。 */
+  toLLMDefinitions(filter) {
+    let tools = this.list();
+    if (filter) tools = tools.filter(filter);
+    return tools.map((t) => {
+      const schema = zodToJsonSchema(t.parameters);
+      const desc = getDescription(t.parameters);
+      if (desc && typeof schema === "object" && schema !== null) {
+        schema.description = desc;
+      }
+      return {
+        name: t.name,
+        description: t.description,
+        parameters: schema
+      };
+    });
+  }
+  /** 调用工具：校验参数 → 执行。 */
+  async execute(name, rawArgs, ctx) {
+    const tool2 = this.tools.get(name);
+    if (!tool2) {
+      throw new ToolError(`Tool "${name}" not found.`, name);
+    }
+    const parseResult = tool2.parameters.safeParse(rawArgs);
+    if (!parseResult.success) {
+      return {
+        content: `Invalid arguments for ${name}: ${parseResult.error.message}`,
+        isError: true
+      };
+    }
+    try {
+      return await tool2.execute(parseResult.data, ctx);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: `Tool ${name} threw: ${msg}`, isError: true };
+    }
+  }
+};
+
+// src/tools/builtin/read.ts
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { resolve as resolve2, isAbsolute } from "path";
+import { z as z3 } from "zod";
+
+// src/tools/types.ts
+function defineTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    parameters: def.parameters,
+    permission: def.permission,
+    summarize: def.summarize,
+    execute: def.execute
+  };
+}
+
+// src/tools/builtin/read.ts
+var ReadArgs = z3.object({
+  file_path: z3.string().describe("Absolute or cwd-relative path to the file."),
+  offset: z3.number().int().min(0).optional().describe("Line offset (0-based)."),
+  limit: z3.number().int().positive().optional().describe("Max lines to read. Default 2000.")
+});
+var DEFAULT_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var ReadTool = defineTool({
+  name: "Read",
+  description: "Read a file from the local filesystem. Returns content with 1-indexed line numbers (cat -n format). Use offset/limit for large files.",
+  parameters: ReadArgs,
+  permission: "read",
+  summarize: (args) => `Read(${args.file_path}${args.offset != null ? `, offset=${args.offset}` : ""}${args.limit != null ? `, limit=${args.limit}` : ""})`,
+  async execute(args, ctx) {
+    const path = isAbsolute(args.file_path) ? args.file_path : resolve2(ctx.cwd, args.file_path);
+    let info;
+    try {
+      info = await stat2(path);
+    } catch (err) {
+      throw new ToolError(`File not found: ${path}`, "Read", err);
+    }
+    if (!info.isFile()) {
+      throw new ToolError(`Not a regular file: ${path}`, "Read");
+    }
+    const content = await readFile5(path, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const offset = args.offset ?? 0;
+    const limit = args.limit ?? DEFAULT_LIMIT;
+    const slice = lines.slice(offset, offset + limit);
+    const numbered = slice.map((line, i) => {
+      const lineNo = offset + i + 1;
+      const truncated = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "... [truncated]" : line;
+      return `${String(lineNo).padStart(5, " ")}	${truncated}`;
+    });
+    let result = numbered.join("\n");
+    if (offset + limit < lines.length) {
+      result += `
+... [${lines.length - offset - limit} more lines, use offset=${offset + limit} to read next]`;
+    }
+    return {
+      content: result || "(empty file)",
+      summary: `Read ${slice.length} lines from ${args.file_path}`
+    };
+  }
+});
+
+// src/tools/builtin/write.ts
+import { writeFile as writeFile2, mkdir as mkdir3, stat as stat3 } from "fs/promises";
+import { resolve as resolve3, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
+import { z as z4 } from "zod";
+var WriteArgs = z4.object({
+  file_path: z4.string().describe("Absolute or cwd-relative path to the file."),
+  content: z4.string().describe("Full content of the file.")
+});
+var WriteTool = defineTool({
+  name: "Write",
+  description: "Write a complete file to the local filesystem. Creates parent directories if needed. Overwrites existing files \u2014 prefer Edit for partial updates.",
+  parameters: WriteArgs,
+  permission: "write",
+  summarize: (args) => `Write(${args.file_path}, ${args.content.length} chars)`,
+  async execute(args, ctx) {
+    const path = isAbsolute2(args.file_path) ? args.file_path : resolve3(ctx.cwd, args.file_path);
+    let existed = false;
+    try {
+      const info = await stat3(path);
+      existed = info.isFile();
+    } catch {
+    }
+    await mkdir3(dirname4(path), { recursive: true });
+    await writeFile2(path, args.content, "utf-8");
+    return {
+      content: existed ? `Overwrote ${path} (${args.content.length} bytes).` : `Created ${path} (${args.content.length} bytes).`,
+      summary: `${existed ? "Overwrote" : "Created"} ${args.file_path}`
+    };
+  }
+});
+
+// src/tools/builtin/edit.ts
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve4, isAbsolute as isAbsolute3 } from "path";
+import { z as z5 } from "zod";
+var EditArgs = z5.object({
+  file_path: z5.string().describe("Absolute or cwd-relative path to the file."),
+  old_string: z5.string().describe("Exact substring to replace. Must be unique unless replace_all=true."),
+  new_string: z5.string().describe("Replacement string."),
+  replace_all: z5.boolean().optional().describe("Replace every occurrence. Default false.")
+});
+var EditTool = defineTool({
+  name: "Edit",
+  description: "Perform an exact string replacement in a file. Old string must be unique unless replace_all=true. Cheaper than Write when only a small part needs to change.",
+  parameters: EditArgs,
+  permission: "write",
+  summarize: (args) => `Edit(${args.file_path})`,
+  async execute(args, ctx) {
+    const path = isAbsolute3(args.file_path) ? args.file_path : resolve4(ctx.cwd, args.file_path);
+    let content;
+    try {
+      content = await readFile6(path, "utf-8");
+    } catch (err) {
+      throw new ToolError(`Cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`, "Edit", err);
+    }
+    if (args.old_string === args.new_string) {
+      return { content: "old_string is identical to new_string; nothing to do.", isError: true };
+    }
+    const occurrences = countOccurrences(content, args.old_string);
+    if (occurrences === 0) {
+      return {
+        content: `old_string not found in ${args.file_path}. Did you read the file first? Check whitespace and indentation.`,
+        isError: true
+      };
+    }
+    if (occurrences > 1 && !args.replace_all) {
+      return {
+        content: `old_string occurs ${occurrences} times in ${args.file_path}. Either expand context to make it unique, or set replace_all=true.`,
+        isError: true
+      };
+    }
+    const newContent = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
+    await writeFile3(path, newContent, "utf-8");
+    return {
+      content: `Edited ${path}: replaced ${args.replace_all ? occurrences : 1} occurrence(s).`,
+      summary: `Edited ${args.file_path}`
+    };
+  }
+});
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count += 1;
+    pos += needle.length;
+  }
+  return count;
+}
+
+// src/tools/builtin/bash.ts
+import { execa } from "execa";
+import { z as z6 } from "zod";
+var BashArgs = z6.object({
+  command: z6.string().describe("Shell command to run. Will be executed via sh -c."),
+  timeout: z6.number().int().positive().optional().describe("Timeout in milliseconds. Default 120000 (2 min). Max 600000."),
+  description: z6.string().optional().describe("Brief description (3-10 words) for the UI.")
+});
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+var MAX_OUTPUT_BYTES = 1e5;
+var HARD_DENY_PATTERNS = [
+  /\brm\s+-rf\s+\/(?:\s|$)/,
+  // rm -rf /
+  /\brm\s+-rf\s+~(?:\/|\s|$)/,
+  // rm -rf ~ or ~/...
+  /\brm\s+-rf\s+\*/,
+  // rm -rf *
+  /\bdd\s+.*of=\/dev\//,
+  // dd of=/dev/*
+  /\bmkfs\b/,
+  // mkfs
+  /:\(\)\s*\{\s*:\|:&\s*\}\s*;\s*:/,
+  // fork bomb
+  /\bsudo\b/,
+  // sudo（v0.1 简单粗暴禁掉）
+  /\bcurl\s+[^|]*\|\s*(?:sh|bash|zsh)/,
+  // curl ... | sh
+  /\bwget\s+[^|]*\|\s*(?:sh|bash|zsh)/
+  // wget ... | sh
+];
+function checkDangerous(command) {
+  for (const pattern of HARD_DENY_PATTERNS) {
+    if (pattern.test(command)) {
+      return { dangerous: true, reason: `matches pattern ${pattern}` };
+    }
+  }
+  return { dangerous: false };
+}
+var BashTool = defineTool({
+  name: "Bash",
+  description: "Execute a shell command via sh -c. Use for git, file system listings, builds, tests, etc. Avoid interactive commands (prefer non-interactive flags). For file edits use Edit/Write, not sed/echo.",
+  parameters: BashArgs,
+  permission: "execute",
+  summarize: (args) => args.description ?? `Bash: ${args.command.length > 60 ? args.command.slice(0, 60) + "..." : args.command}`,
+  async execute(args, ctx) {
+    const danger = checkDangerous(args.command);
+    if (danger.dangerous) {
+      return {
+        content: `Refused: command blocked by hard deny list (${danger.reason}). If you really need this, ask the user to run it manually.`,
+        isError: true
+      };
+    }
+    const timeout = Math.min(args.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    try {
+      const result = await execa(args.command, {
+        shell: "/bin/sh",
+        cwd: ctx.cwd,
+        timeout,
+        reject: false,
+        stripFinalNewline: false,
+        maxBuffer: MAX_OUTPUT_BYTES * 2,
+        cancelSignal: ctx.abortSignal
+      });
+      const stdout = truncate(result.stdout ?? "", MAX_OUTPUT_BYTES, "stdout");
+      const stderr = truncate(result.stderr ?? "", MAX_OUTPUT_BYTES, "stderr");
+      const parts = [];
+      if (stdout) parts.push(`<stdout>
+${stdout}
+</stdout>`);
+      if (stderr) parts.push(`<stderr>
+${stderr}
+</stderr>`);
+      if (result.timedOut) parts.push(`<timeout>Command exceeded ${timeout}ms.</timeout>`);
+      if (result.failed && !result.timedOut) parts.push(`<exit_code>${result.exitCode ?? "unknown"}</exit_code>`);
+      const body = parts.length > 0 ? parts.join("\n") : "(no output)";
+      return {
+        content: body,
+        isError: result.failed,
+        summary: result.failed ? `Bash exited ${result.exitCode ?? "?"}` : `Bash ok`
+      };
+    } catch (err) {
+      return {
+        content: `Bash threw: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+});
+function truncate(text, max, label) {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + `
+... [${label} truncated, original ${text.length} bytes]`;
+}
+
+// src/tools/builtin/grep.ts
+import { execa as execa2 } from "execa";
+import { z as z7 } from "zod";
+var GrepArgs = z7.object({
+  pattern: z7.string().describe("Regex pattern to search for."),
+  path: z7.string().optional().describe("File or directory to search in. Default: cwd."),
+  glob: z7.string().optional().describe('Glob filter, e.g. "*.ts" or "src/**/*.tsx".'),
+  output_mode: z7.enum(["content", "files_with_matches", "count"]).optional().describe("Default: files_with_matches."),
+  context: z7.number().int().min(0).max(50).optional().describe("Context lines around each match (use only with output_mode=content)."),
+  case_insensitive: z7.boolean().optional()
+});
+var rgChecked = false;
+var rgAvailable = false;
+async function checkRipgrep() {
+  if (rgChecked) return rgAvailable;
+  try {
+    await execa2("rg", ["--version"], { reject: false });
+    rgAvailable = true;
+  } catch {
+    rgAvailable = false;
+  }
+  rgChecked = true;
+  return rgAvailable;
+}
+var GrepTool = defineTool({
+  name: "Grep",
+  description: "Search file contents using regex. Prefer this over Bash(grep|find) \u2014 handles ignore files & is much faster on large trees.",
+  parameters: GrepArgs,
+  permission: "read",
+  summarize: (args) => `Grep(${args.pattern}${args.path ? `, ${args.path}` : ""})`,
+  async execute(args, ctx) {
+    const hasRg = await checkRipgrep();
+    const mode = args.output_mode ?? "files_with_matches";
+    if (hasRg) {
+      const cliArgs2 = [];
+      if (args.case_insensitive) cliArgs2.push("-i");
+      if (mode === "files_with_matches") cliArgs2.push("-l");
+      else if (mode === "count") cliArgs2.push("-c");
+      else if (args.context != null) cliArgs2.push("-C", String(args.context));
+      if (args.glob) cliArgs2.push("--glob", args.glob);
+      cliArgs2.push("--", args.pattern, args.path ?? ".");
+      const result2 = await execa2("rg", cliArgs2, { cwd: ctx.cwd, reject: false, cancelSignal: ctx.abortSignal });
+      const out2 = (result2.stdout ?? "").trim();
+      if (result2.exitCode === 0 || result2.exitCode === 1) {
+        return { content: out2 || "(no matches)", summary: `Grep ${args.pattern}` };
+      }
+      return { content: `rg failed: ${result2.stderr}`, isError: true };
+    }
+    const cliArgs = ["-r", "-n"];
+    if (args.case_insensitive) cliArgs.push("-i");
+    if (mode === "files_with_matches") cliArgs.push("-l");
+    else if (mode === "count") cliArgs.push("-c");
+    cliArgs.push("-E", args.pattern, args.path ?? ".");
+    const result = await execa2("grep", cliArgs, { cwd: ctx.cwd, reject: false, cancelSignal: ctx.abortSignal });
+    const out = (result.stdout ?? "").trim();
+    if (result.exitCode === 0 || result.exitCode === 1) {
+      return { content: out || "(no matches)", summary: `Grep ${args.pattern}` };
+    }
+    return { content: `grep failed: ${result.stderr}`, isError: true };
+  }
+});
+
+// src/tools/builtin/glob.ts
+import fg from "fast-glob";
+import { z as z8 } from "zod";
+var GlobArgs = z8.object({
+  pattern: z8.string().describe('Glob pattern, e.g. "src/**/*.ts" or "**/*.{md,json}".'),
+  path: z8.string().optional().describe("Base directory to search from. Default: cwd."),
+  limit: z8.number().int().positive().max(1e3).optional().describe("Max results. Default 100.")
+});
+var DEFAULT_LIMIT2 = 100;
+var GlobTool = defineTool({
+  name: "Glob",
+  description: "Find files by glob pattern. Returns relative paths sorted by modification time (newest first).",
+  parameters: GlobArgs,
+  permission: "read",
+  summarize: (args) => `Glob(${args.pattern}${args.path ? `, ${args.path}` : ""})`,
+  async execute(args, ctx) {
+    const cwd = args.path ?? ctx.cwd;
+    const limit = args.limit ?? DEFAULT_LIMIT2;
+    const entries = await fg(args.pattern, {
+      cwd,
+      onlyFiles: true,
+      stats: true,
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.muse/**"]
+    });
+    entries.sort((a, b) => {
+      const ta = a.stats?.mtime?.getTime() ?? 0;
+      const tb = b.stats?.mtime?.getTime() ?? 0;
+      return tb - ta;
+    });
+    const truncated = entries.length > limit;
+    const paths = entries.slice(0, limit).map((e) => e.path);
+    let result = paths.join("\n") || "(no matches)";
+    if (truncated) {
+      result += `
+... [${entries.length - limit} more, increase limit to see]`;
+    }
+    return { content: result, summary: `Glob found ${entries.length} file(s)` };
+  }
+});
+
+// src/tools/builtin/index.ts
+var BUILTIN_TOOLS = [
+  ReadTool,
+  WriteTool,
+  EditTool,
+  BashTool,
+  GrepTool,
+  GlobTool
+];
+
+// src/cli.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var VERSION = "0.1.0";
+async function main() {
+  const program = new Command();
+  program.name("muse").description("A Claude Code-style agent CLI. Provider-agnostic. First-class support for Chinese / self-hostable LLMs.").version(VERSION, "-v, --version", "print version");
+  program.argument("[prompt...]", "one-shot prompt (omit for interactive mode)").option("-m, --model <model>", "override model").option("-p, --provider <provider>", "override provider").option("--no-banner", "skip startup banner").option("--quiet", "minimal output (implies --no-banner)").option("--continue", "resume last session in this directory").option("--debug", "verbose logging").action(async (promptArgs, opts) => {
+    if (opts.debug) log.setLevel("debug");
+    const cwd = process.cwd();
+    const { settings, sources } = await loadSettings(cwd);
+    const { registry: modelsRegistry, sources: modelsSources } = await loadModelsRegistry();
+    log.debug("config loaded", { settingsSources: sources, modelsSources });
+    const model = opts.model ?? settings.llm?.model;
+    const provider = opts.provider ?? settings.llm?.provider;
+    let llm;
+    let llmProviderName;
+    let llmModelName;
+    try {
+      const entry = modelsRegistry && model ? findEntry(modelsRegistry, model) : void 0;
+      if (entry) {
+        setActiveModelEnv(entry);
+        llm = createLLMClientFromModelEntry(entry);
+        llmProviderName = llm.providerName;
+        llmModelName = llm.model;
+      } else {
+        if (!provider || !model) {
+          die("No model configured. Either define one in ~/.muse/models.json or set llm.provider+llm.model in settings.json.");
+        }
+        llm = createLLMClient({ provider, model, providers: settings.providers ?? {} });
+        llmProviderName = provider;
+        llmModelName = model;
+      }
+    } catch (err) {
+      if (err instanceof MuseError) die(err.message);
+      throw err;
+    }
+    const tools = new ToolRegistry();
+    tools.registerAll(BUILTIN_TOOLS);
+    const permissions = new PermissionGate(settings.permissions);
+    const session = await Session.create(cwd);
+    await session.append({
+      type: "session_start",
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd,
+      provider: llmProviderName,
+      model: llmModelName
+    });
+    const showBanner = !opts.quiet && opts.banner !== false;
+    const lang = settings.ui?.lang ?? "en";
+    const pipedInput = await readStdinIfPiped();
+    const oneShotPrompt = [...promptArgs ?? [], pipedInput].filter(Boolean).join("\n").trim();
+    if (oneShotPrompt) {
+      await runOneShot({ llm, tools, permissions, session, cwd, lang, prompt: oneShotPrompt, quiet: opts.quiet ?? false });
+      return;
+    }
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx10(
+        App,
+        {
+          llm,
+          tools,
+          permissions,
+          session,
+          settings,
+          settingsSources: sources,
+          modelsRegistry,
+          modelsSources,
+          cwd,
+          lang,
+          showBanner
+        }
+      )
+    );
+    await waitUntilExit();
+  });
+  await program.parseAsync(process.argv);
+}
+async function readStdinIfPiped() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function runOneShot(opts) {
+  const systemPrompt = buildSystemPrompt({
+    cwd: opts.cwd,
+    model: opts.llm.model,
+    provider: opts.llm.providerName,
+    lang: opts.lang,
+    toolNames: opts.tools.list().map((t) => t.name)
+  });
+  const agent = new Agent({
+    llm: opts.llm,
+    tools: opts.tools,
+    permissions: opts.permissions,
+    session: opts.session,
+    cwd: opts.cwd,
+    systemPrompt,
+    events: {
+      onText: (delta) => process.stdout.write(delta),
+      onToolCallStart: (_id, name) => {
+        if (!opts.quiet) process.stderr.write(`
+\u2192 ${name}
+`);
+      },
+      onError: (err) => process.stderr.write(`
+[error] ${err.message}
+`),
+      onPermissionRequest: async (toolName, _args, summary) => {
+        if (!opts.quiet) process.stderr.write(`
+[denied: ${toolName} \u2014 ${summary}; run in interactive mode to approve]
+`);
+        return false;
+      }
+    }
+  });
+  await agent.runTurn(opts.prompt);
+  process.stdout.write("\n");
+}
+function die(msg) {
+  process.stderr.write(`muse: ${msg}
+`);
+  process.exit(1);
+}
+main().catch((err) => {
+  log.error("fatal", { msg: err instanceof Error ? err.message : String(err) });
+  process.stderr.write(`muse: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map