@qxbyte/muse 0.1.0

package/dist/index.js

@@ -0,0 +1,1405 @@
+#!/usr/bin/env node
+
+// 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;
+};
+var PermissionDeniedError = class extends MuseError {
+  constructor(toolName, reason) {
+    super(`Permission denied for ${toolName}: ${reason}`, "PERMISSION_DENIED");
+    this.toolName = toolName;
+    this.reason = reason;
+    this.name = "PermissionDeniedError";
+  }
+  toolName;
+  reason;
+};
+
+// src/llm/client.ts
+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/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/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
+import { readFile, stat } from "fs/promises";
+import { resolve, isAbsolute } from "path";
+import { z } from "zod";
+var ReadArgs = z.object({
+  file_path: z.string().describe("Absolute or cwd-relative path to the file."),
+  offset: z.number().int().min(0).optional().describe("Line offset (0-based)."),
+  limit: z.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 : resolve(ctx.cwd, args.file_path);
+    let info;
+    try {
+      info = await stat(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 readFile(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, mkdir, stat as stat2 } from "fs/promises";
+import { resolve as resolve2, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { z as z2 } from "zod";
+var WriteArgs = z2.object({
+  file_path: z2.string().describe("Absolute or cwd-relative path to the file."),
+  content: z2.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 : resolve2(ctx.cwd, args.file_path);
+    let existed = false;
+    try {
+      const info = await stat2(path);
+      existed = info.isFile();
+    } catch {
+    }
+    await mkdir(dirname2(path), { recursive: true });
+    await writeFile(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 readFile2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve3, isAbsolute as isAbsolute3 } from "path";
+import { z as z3 } from "zod";
+var EditArgs = z3.object({
+  file_path: z3.string().describe("Absolute or cwd-relative path to the file."),
+  old_string: z3.string().describe("Exact substring to replace. Must be unique unless replace_all=true."),
+  new_string: z3.string().describe("Replacement string."),
+  replace_all: z3.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 : resolve3(ctx.cwd, args.file_path);
+    let content;
+    try {
+      content = await readFile2(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 writeFile2(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 z4 } from "zod";
+var BashArgs = z4.object({
+  command: z4.string().describe("Shell command to run. Will be executed via sh -c."),
+  timeout: z4.number().int().positive().optional().describe("Timeout in milliseconds. Default 120000 (2 min). Max 600000."),
+  description: z4.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 z5 } from "zod";
+var GrepArgs = z5.object({
+  pattern: z5.string().describe("Regex pattern to search for."),
+  path: z5.string().optional().describe("File or directory to search in. Default: cwd."),
+  glob: z5.string().optional().describe('Glob filter, e.g. "*.ts" or "src/**/*.tsx".'),
+  output_mode: z5.enum(["content", "files_with_matches", "count"]).optional().describe("Default: files_with_matches."),
+  context: z5.number().int().min(0).max(50).optional().describe("Context lines around each match (use only with output_mode=content)."),
+  case_insensitive: z5.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 z6 } from "zod";
+var GlobArgs = z6.object({
+  pattern: z6.string().describe('Glob pattern, e.g. "src/**/*.ts" or "**/*.{md,json}".'),
+  path: z6.string().optional().describe("Base directory to search from. Default: cwd."),
+  limit: z6.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/permission/index.ts
+var MODE_CYCLE = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions"
+];
+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/session/jsonl.ts
+import { appendFile, mkdir as mkdir2, readdir, readFile as readFile3, stat as stat3 } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join2 } from "path";
+import { createHash, randomUUID } from "crypto";
+function projectHash(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function sessionsDir(cwd) {
+  return join2(homedir2(), ".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 mkdir2(dir, { recursive: true });
+    const path = join2(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 (!existsSync(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 stat3(join2(dir, top));
+    return {
+      id: top.replace(/\.jsonl$/, ""),
+      cwd,
+      createdAt: st.mtime.toISOString(),
+      path: join2(dir, top)
+    };
+  }
+  /**
+   * 按修改时间倒序列出当前 cwd 下的 session，附带 preview 与消息数。
+   * 读 preview 需要打开每个文件；调用方通过 limit 控制 IO 量。
+   */
+  static async listAll(cwd, limit) {
+    const dir = sessionsDir(cwd);
+    if (!existsSync(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 = join2(dir, f);
+        const st = await stat3(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 mkdir2(dirname3(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 (!existsSync(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/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 homedir3 } from "os";
+function buildSystemPrompt(opts) {
+  const { cwd, model, provider, lang, toolNames } = opts;
+  const home = homedir3();
+  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 as readFile4 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join3, resolve as resolve4 } from "path";
+
+// src/config/types.ts
+import { z as z7 } from "zod";
+var ProviderConfigSchema = z7.object({
+  apiKey: z7.string().optional(),
+  baseUrl: z7.string().optional(),
+  extraHeaders: z7.record(z7.string()).optional()
+}).passthrough();
+var LLMConfigSchema = z7.object({
+  provider: z7.string().optional().describe("Fallback provider preset (only used when no models.json entry matches)."),
+  model: z7.string().optional().describe("Active model id; should match an id in models.json."),
+  temperature: z7.number().min(0).max(2).optional(),
+  maxTokens: z7.number().int().positive().optional()
+});
+var PermissionsSchema = z7.object({
+  allow: z7.array(z7.string()).optional(),
+  ask: z7.array(z7.string()).optional(),
+  deny: z7.array(z7.string()).optional(),
+  defaultMode: z7.enum(["strict", "relaxed", "ask"]).optional()
+});
+var UISchema = z7.object({
+  theme: z7.enum(["dark", "light"]).optional(),
+  lang: z7.enum(["en", "zh-CN"]).optional(),
+  showBanner: z7.boolean().optional()
+});
+var SettingsSchema = z7.object({
+  llm: LLMConfigSchema.optional(),
+  providers: z7.record(ProviderConfigSchema).optional(),
+  permissions: PermissionsSchema.optional(),
+  ui: UISchema.optional(),
+  mcpServers: z7.record(z7.unknown()).optional(),
+  skills: z7.object({
+    enabled: z7.boolean().optional(),
+    disabled: z7.array(z7.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 (!existsSync2(path)) return void 0;
+  try {
+    const raw = await readFile4(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 = [
+    join3(homedir4(), ".muse", "settings.json"),
+    join3(cwd, ".muse", "settings.json"),
+    join3(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 };
+}
+export {
+  Agent,
+  BUILTIN_TOOLS,
+  MuseError,
+  PRESETS,
+  PermissionDeniedError,
+  PermissionGate,
+  Session,
+  SettingsSchema,
+  ToolError,
+  ToolRegistry,
+  buildSystemPrompt,
+  createLLMClient,
+  defineTool,
+  loadSettings,
+  log,
+  redactApiKey
+};
+//# sourceMappingURL=index.js.map