miantiao.me 0.2.0 → 0.4.0

package/dist/app-RHHRYSSP.js

@@ -0,0 +1,3310 @@
+import {
+  define_TERMINAL_CODE_COLORS_default,
+  define_TERMINAL_HOME_default,
+  define_TERMINAL_PALETTES_default
+} from "./chunk-CPSJKI42.js";
+
+// packages/cli/src/app.tsx
+import { AssistantRuntimeProvider } from "@assistant-ui/react-ink";
+import { Box as Box22, render, Text as Text25, useApp as useApp2, useInput as useInput11, useWindowSize as useWindowSize3 } from "ink";
+import { useEffect as useEffect11, useState as useState14 } from "react";
+
+// src/terminal/schema.ts
+import { z } from "zod";
+var terminalApiPath = "/api/terminal/v1";
+var linkSchema = z.object({ title: z.string(), href: z.string() });
+var pageSchema = z.object({
+  path: z.string(),
+  title: z.string(),
+  documentUrl: z.string()
+});
+var terminalProjectSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  url: z.string(),
+  repo: z.string(),
+  stars: z.number()
+});
+var terminalPostSchema = z.object({
+  slug: z.string(),
+  title: z.string(),
+  description: z.string(),
+  date: z.string(),
+  tags: z.array(z.string()),
+  path: z.string(),
+  url: z.string(),
+  documentUrl: z.string()
+});
+var terminalIndexSchema = z.object({
+  schemaVersion: z.literal(1),
+  revision: z.string().min(1),
+  site: z.object({
+    name: z.string(),
+    description: z.string(),
+    url: z.string(),
+    feedUrl: z.string(),
+    sponsorUrl: z.string().optional(),
+    pageSize: z.number().int().positive().optional(),
+    author: z.object({ name: z.string(), roles: z.array(z.string()) }),
+    nav: z.array(linkSchema),
+    socials: z.array(linkSchema),
+    friends: z.array(linkSchema)
+  }),
+  ai: z.object({ baseUrl: z.string(), model: z.string() }),
+  pages: z.object({ home: pageSchema, about: pageSchema }),
+  posts: z.array(terminalPostSchema),
+  projects: z.array(terminalProjectSchema),
+  tags: z.array(
+    z.object({ name: z.string(), path: z.string(), count: z.number().int().nonnegative() })
+  ),
+  searchIndexUrl: z.string()
+});
+var sectionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("welcome"),
+    markdown: z.string(),
+    logo: z.string().optional(),
+    menu: z.array(linkSchema.extend({ command: z.string() })).optional()
+  }),
+  z.object({
+    kind: z.literal("turn"),
+    prompt: z.string(),
+    markdown: z.string(),
+    list: z.discriminatedUnion("kind", [
+      z.object({
+        kind: z.literal("projects"),
+        before: z.string(),
+        after: z.string(),
+        items: z.array(terminalProjectSchema)
+      }),
+      z.object({
+        kind: z.literal("posts"),
+        before: z.string(),
+        after: z.string(),
+        items: z.array(terminalPostSchema)
+      })
+    ]).optional()
+  })
+]);
+var terminalDocumentSchema = z.object({
+  schemaVersion: z.literal(1),
+  revision: z.string().min(1),
+  path: z.string(),
+  title: z.string(),
+  markdown: z.string().min(1),
+  sections: z.array(sectionSchema).optional()
+});
+
+// src/utils/search-core.ts
+import { Document } from "flexsearch";
+var SearchManager = class _SearchManager {
+  index;
+  dataById;
+  constructor(searchData) {
+    this.index = new Document({
+      document: {
+        id: "id",
+        index: [
+          { field: "searchTitle", tokenize: "forward", resolution: 9 },
+          { field: "searchDescription", tokenize: "strict", resolution: 7 },
+          {
+            field: "searchContent",
+            tokenize: "forward",
+            resolution: 5,
+            context: {
+              depth: 1,
+              resolution: 3,
+              bidirectional: true
+            }
+          },
+          { field: "searchTags", tokenize: "strict", resolution: 9 }
+        ]
+      },
+      cache: 100,
+      fastupdate: false
+    });
+    this.dataById = new Map(searchData.map((doc) => [doc.id, doc]));
+    searchData.forEach((doc) => this.index.add(doc));
+  }
+  static fromData(data) {
+    return new _SearchManager(data);
+  }
+  search(query, limit = 20) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery || limit <= 0) return [];
+    const phraseTerms = /[\u4E00-\u9FFF]{4,}/.test(trimmedQuery) ? trimmedQuery.toLowerCase().match(/[\u4E00-\u9FFF]+|[a-z0-9]+/g) : null;
+    const matchesPhrase = (document) => {
+      if (!phraseTerms) return true;
+      const fields = [document.title, document.description, document.content, ...document.tags];
+      const words = new Set(
+        fields.flatMap((field) => field.toLowerCase().match(/[a-z0-9]+/g) ?? [])
+      );
+      return phraseTerms.every(
+        (term) => /^[a-z0-9]+$/.test(term) ? words.has(term) : fields.some((field) => field.includes(term))
+      );
+    };
+    const results = this.index.search(trimmedQuery, {
+      limit,
+      suggest: true
+    });
+    const seenIds = /* @__PURE__ */ new Set();
+    const documents = [];
+    for (const fieldResult of results) {
+      for (const docId of fieldResult.result) {
+        const id = String(docId);
+        if (seenIds.has(id)) continue;
+        const document = this.dataById.get(id);
+        if (!document || !matchesPhrase(document)) continue;
+        seenIds.add(id);
+        documents.push(document);
+        if (documents.length >= limit) return documents;
+      }
+    }
+    if (phraseTerms) {
+      for (const document of this.dataById.values()) {
+        if (seenIds.has(document.id) || !matchesPhrase(document)) continue;
+        seenIds.add(document.id);
+        documents.push(document);
+        if (documents.length >= limit) break;
+      }
+    }
+    return documents;
+  }
+};
+
+// src/utils/search-schema.ts
+import { z as z2 } from "zod";
+var searchIndexSchema = z2.array(
+  z2.object({
+    id: z2.string(),
+    title: z2.string(),
+    description: z2.string(),
+    content: z2.string(),
+    url: z2.string(),
+    date: z2.string(),
+    tags: z2.array(z2.string()),
+    searchTitle: z2.string(),
+    searchDescription: z2.string(),
+    searchContent: z2.string(),
+    searchTags: z2.string()
+  })
+);
+
+// packages/cli/src/client.ts
+var ContentError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var TerminalClient = class {
+  constructor(site, fetcher = fetch) {
+    this.site = site;
+    this.fetcher = fetcher;
+  }
+  site;
+  fetcher;
+  cache = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  revision;
+  searchLoad;
+  warning = "";
+  async request(path, schema, signal) {
+    signal?.throwIfAborted();
+    const url = new URL(path, this.site).href;
+    const running = this.pending.get(url);
+    if (running && running.signal === signal) return running.promise;
+    const promise = this.fetchDocument(url, schema, signal);
+    this.pending.set(url, { promise, signal });
+    try {
+      return await promise;
+    } finally {
+      if (this.pending.get(url)?.promise === promise) this.pending.delete(url);
+    }
+  }
+  async fetchDocument(url, schema, signal) {
+    const cached = this.cache.get(url);
+    const headers = new Headers({ Accept: "application/json" });
+    if (cached?.etag) headers.set("If-None-Match", cached.etag);
+    else if (cached?.modified) headers.set("If-Modified-Since", cached.modified);
+    try {
+      const response = await this.fetcher(url, {
+        headers,
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3)
+      });
+      if (response.status >= 500) {
+        await response.body?.cancel();
+        throw new Error(`HTTP ${response.status}`);
+      }
+      if (response.status === 304 && cached) return cached.value;
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new ContentError(
+          response.status === 404 ? "\u5B98\u7F51\u5C1A\u672A\u63D0\u4F9B\u8BE5\u5185\u5BB9\uFF0C\u6216\u5185\u5BB9\u5DF2\u66F4\u65B0\uFF1B\u8BF7\u4F7F\u7528 /refresh \u91CD\u8BD5\u3002" : `\u5B98\u7F51\u5185\u5BB9\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${response.status}\uFF09\u3002`,
+          response.status
+        );
+      }
+      signal?.throwIfAborted();
+      const body = await response.json();
+      signal?.throwIfAborted();
+      const value = schema.safeParse(body);
+      if (!value.success)
+        throw new ContentError("\u5B98\u7F51\u5185\u5BB9\u683C\u5F0F\u4E0E\u5F53\u524D CLI \u4E0D\u517C\u5BB9\uFF0C\u8BF7\u8FD0\u884C npx miantiao.me@latest\u3002");
+      this.cache.set(url, {
+        value: value.data,
+        etag: response.headers.get("etag"),
+        modified: response.headers.get("last-modified")
+      });
+      return value.data;
+    } catch (error) {
+      if (signal?.aborted || error instanceof ContentError) throw error;
+      if (error instanceof SyntaxError)
+        throw new ContentError("\u5B98\u7F51\u8FD4\u56DE\u4E86\u65E0\u6CD5\u8BFB\u53D6\u7684\u5185\u5BB9\uFF0C\u8BF7\u7A0D\u540E /refresh \u91CD\u8BD5\u3002");
+      if (cached) {
+        this.warning = "\u7F51\u7EDC\u4E0D\u53EF\u7528\uFF0C\u663E\u793A\u672C\u6B21\u4F1A\u8BDD\u5DF2\u8BFB\u53D6\u7684\u5185\u5BB9\uFF1B/refresh \u91CD\u8BD5\u3002";
+        return cached.value;
+      }
+      throw new ContentError("\u65E0\u6CD5\u8FDE\u63A5\u5B98\u7F51\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u4F7F\u7528 /refresh \u91CD\u8BD5\u3002");
+    }
+  }
+  async getIndex(signal) {
+    this.warning = "";
+    const index = await this.request(`${terminalApiPath}/index.json`, terminalIndexSchema, signal);
+    if (this.revision && this.revision !== index.revision) {
+      const indexUrl = new URL(`${terminalApiPath}/index.json`, this.site).href;
+      for (const key of this.cache.keys()) {
+        if (key !== indexUrl) this.cache.delete(key);
+      }
+      this.cancelSearch();
+    }
+    this.revision = index.revision;
+    return index;
+  }
+  async getDocument(path, index, signal) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const page = [...Object.values(index.pages), ...index.posts].find(
+        (item) => item.path === path
+      );
+      if (!page) throw new ContentError("\u627E\u4E0D\u5230\u8FD9\u4E2A\u9875\u9762\uFF0C\u8BF7\u4F7F\u7528 /blog \u6216 /search \u67E5\u627E\u3002");
+      try {
+        const document = await this.request(page.documentUrl, terminalDocumentSchema, signal);
+        if (document.revision === index.revision && document.path === path)
+          return { index, document };
+      } catch (error) {
+        if (!(error instanceof ContentError) || error.status !== 404) throw error;
+      }
+      if (attempt === 0) {
+        index = await this.getIndex(signal);
+        this.cache.delete(new URL(page.documentUrl, this.site).href);
+      }
+    }
+    throw new ContentError("\u5B98\u7F51\u6B63\u5728\u66F4\u65B0\uFF0C\u7D22\u5F15\u4E0E\u6B63\u6587\u6682\u65F6\u4E0D\u4E00\u81F4\uFF1B\u8BF7\u7A0D\u540E /refresh\u3002");
+  }
+  preloadSearch(index) {
+    if (this.searchLoad?.revision === index.revision && this.searchLoad.url === index.searchIndexUrl)
+      return this.searchLoad.promise;
+    this.cancelSearch();
+    const controller = new AbortController();
+    const load = {
+      revision: index.revision,
+      url: index.searchIndexUrl,
+      controller,
+      promise: this.request(index.searchIndexUrl, searchIndexSchema, controller.signal).then(
+        (data) => SearchManager.fromData(data)
+      )
+    };
+    this.searchLoad = load;
+    void load.promise.catch(() => {
+      if (this.searchLoad === load) this.searchLoad = void 0;
+    });
+    return load.promise;
+  }
+  cancelSearch() {
+    this.searchLoad?.controller.abort();
+    this.searchLoad = void 0;
+  }
+  async search(query, index, signal) {
+    signal?.throwIfAborted();
+    const manager = await this.preloadSearch(index);
+    signal?.throwIfAborted();
+    return manager.search(query);
+  }
+};
+
+// packages/cli/src/pages.ts
+import { lexer } from "marked";
+function homeSections(index, sections) {
+  return sections?.map((section) => {
+    if (section.kind !== "turn" || section.list) return section;
+    for (const token of lexer(section.markdown)) {
+      if (token.type !== "list") continue;
+      const links = token.items.map((item) => {
+        const heading = item.tokens.find(
+          (child) => child.type === "heading"
+        );
+        return heading?.tokens.find((child) => child.type === "link")?.href;
+      });
+      const projects = links.map(
+        (href) => index.projects.find((project) => new URL(project.url).href === href)
+      );
+      const posts = links.map(
+        (href) => index.posts.find((post) => new URL(post.path, index.site.url).href === href)
+      );
+      const list = projects.length && projects.every((project) => project !== void 0) ? { kind: "projects", items: projects } : posts.length && posts.every((post) => post !== void 0) ? { kind: "posts", items: posts } : void 0;
+      if (!list) continue;
+      const start = section.markdown.indexOf(token.raw);
+      return {
+        ...section,
+        list: {
+          ...list,
+          before: section.markdown.slice(0, start),
+          after: section.markdown.slice(start + token.raw.length)
+        }
+      };
+    }
+    return section;
+  });
+}
+function documentPage(index, document, site, search = "") {
+  const page = {
+    path: document.path + search,
+    title: document.title,
+    markdown: document.markdown,
+    sections: document.sections,
+    verb: "Read",
+    items: [],
+    command: document.path === "/" ? "/home" : document.path.replace(/\/$/, "")
+  };
+  const post = index.posts.find((post2) => post2.path === document.path);
+  if (post) {
+    page.post = post;
+    page.tool = { verb: "Read", target: `${post.path.replace(/^\//, "").replace(/\/$/, "")}.md` };
+    page.description = post.description;
+  }
+  if (document.path === "/about/") {
+    page.markdown = document.markdown.replace(/^\/about\s*\n+/, "").replace("~/.config/miantiao/PROFILE.md", "~/.config/miantiao/ABOUT.md");
+  }
+  if (document.path === index.pages.home.path) {
+    page.sections = homeSections(index, page.sections);
+    const welcome = page.sections?.find((section) => section.kind === "welcome");
+    const menu = welcome?.menu ?? index.site.nav.map((link) => ({ ...link, command: void 0 }));
+    const origins = new Set([site, index.site.url].map((url) => new URL(url).origin));
+    page.items = menu.map((link) => {
+      const destination = new URL(link.href, site);
+      const external = !origins.has(destination.origin);
+      return {
+        title: link.title,
+        description: link.command,
+        path: external ? destination.href : destination.pathname + destination.search,
+        external
+      };
+    });
+  }
+  return page;
+}
+async function loadPage(client, path, signal, cachedIndex) {
+  signal?.throwIfAborted();
+  const index = cachedIndex ?? await client.getIndex(signal);
+  const url = new URL(path, client.site);
+  const pathname = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
+  const page = { path: pathname + url.search, title: "", verb: "List", items: [] };
+  const document = [...Object.values(index.pages), ...index.posts].find(
+    (item) => new URL(item.path, client.site).pathname === pathname
+  );
+  if (document) {
+    const result = await client.getDocument(document.path, index, signal);
+    return {
+      index: result.index,
+      page: documentPage(result.index, result.document, client.site, url.search)
+    };
+  } else if (pathname === "/blog/" || /^\/blog\/\d+\/$/.test(pathname)) {
+    const size = index.site.pageSize ?? 10;
+    const total = Math.max(1, Math.ceil(index.posts.length / size));
+    const current = Number(pathname.match(/\d+/)?.[0] ?? 1);
+    if (current < 1 || current > total) throw new Error("\u627E\u4E0D\u5230\u8FD9\u4E00\u9875\uFF0C\u8BF7\u4F7F\u7528 /blog \u6D4F\u89C8\u6587\u7AE0\u3002");
+    const start = (current - 1) * size;
+    page.title = "\u535A\u5BA2";
+    page.command = current === 1 ? "/blog" : `/blog ${current}`;
+    page.aside = `${current}/${total}`;
+    page.tool = {
+      verb: "List",
+      target: "posts/",
+      detail: `${start + 1}\u2013${Math.min(start + size, index.posts.length)} of ${index.posts.length}`
+    };
+    page.items = index.posts.slice(start, start + size).map((post) => ({
+      title: post.title,
+      date: post.date,
+      description: post.description,
+      path: post.path
+    }));
+    page.pagination = {
+      current,
+      total,
+      previous: current > 1 ? current === 2 ? "/blog/" : `/blog/${current - 1}/` : void 0,
+      next: current < total ? `/blog/${current + 1}/` : void 0
+    };
+  } else if (pathname === "/projects/") {
+    page.title = "\u9879\u76EE";
+    page.command = "/projects";
+    page.tool = {
+      verb: "List",
+      target: "projects/",
+      detail: `\u6309 Star \u6392\u5E8F\uFF0C${index.projects.length} \u4E2A`
+    };
+    page.description = "\u8FD9\u91CC\u8BB0\u5F55\u6211\u5728\u5DE5\u4F5C\u4E4B\u5916\u6301\u7EED\u6298\u817E\u7684\u5C0F\u9879\u76EE\uFF1A\u6709\u4E9B\u662F\u5DE5\u5177\uFF0C\u6709\u4E9B\u662F\u5B9E\u9A8C\uFF0C\u4E5F\u6709\u4E9B\u53EA\u662F\u597D\u5947\u5FC3\u7684\u526F\u4EA7\u7269\u3002";
+    page.projects = index.projects;
+    page.items = index.projects.map((project) => ({
+      title: `${project.title} \xB7 \u2605 ${project.stars}`,
+      description: project.description,
+      path: project.url,
+      external: true
+    }));
+  } else if (pathname === "/tags/") {
+    page.title = "\u6807\u7B7E";
+    page.command = "/tags";
+    page.tool = { verb: "List", target: "tags/", detail: `${index.tags.length} \u4E2A` };
+    page.tags = index.tags;
+    page.items = index.tags.map((tag) => ({
+      title: `#${tag.name}`,
+      description: String(tag.count),
+      path: tag.path
+    }));
+  } else if (pathname.startsWith("/tags/")) {
+    const tag = index.tags.find((tag2) => tag2.path === pathname);
+    if (!tag) throw new Error("\u627E\u4E0D\u5230\u8FD9\u4E2A\u6807\u7B7E\uFF0C\u8BF7\u4F7F\u7528 /tags \u67E5\u627E\u3002");
+    page.title = `\u6807\u7B7E\uFF1A${tag.name}`;
+    page.command = `/tags ${tag.name}`;
+    page.items = index.posts.filter((post) => post.tags.includes(tag.name)).map((post) => ({
+      title: post.title,
+      date: post.date,
+      description: post.description,
+      path: post.path
+    }));
+    page.tool = { verb: "Grep", target: `#${tag.name}`, detail: `${page.items.length} \u7BC7` };
+    page.more = { title: "\u5168\u90E8\u6807\u7B7E", path: "/tags/" };
+  } else if (pathname === "/search/") {
+    const query = url.searchParams.get("q") ?? "";
+    page.title = "\u641C\u7D22";
+    page.command = query ? `/search ${query}` : "/search";
+    page.verb = "Search";
+    if (query) {
+      const results = await client.search(query, index, signal);
+      page.items = results.map((post) => ({
+        title: post.title,
+        description: post.description,
+        date: post.date,
+        path: post.url
+      }));
+    }
+    if (query) page.aside = `${page.items.length} \u6761`;
+    if (query && !page.items.length) page.markdown = `\u6CA1\u6709\u627E\u5230\u4E0E\u300C${query}\u300D\u76F8\u5173\u7684\u6587\u7AE0`;
+  } else if (pathname === "/rss/") {
+    page.title = "\u8BA2\u9605 RSS";
+    page.items = [{ title: index.site.feedUrl, path: index.site.feedUrl, external: true }];
+  } else {
+    throw new Error("\u627E\u4E0D\u5230\u8FD9\u4E2A\u9875\u9762\uFF0C\u8BF7\u4F7F\u7528 /help \u67E5\u770B\u547D\u4EE4\u3002");
+  }
+  return { index, page };
+}
+
+// packages/cli/src/home.ts
+function bundledHome(site) {
+  if (typeof define_TERMINAL_HOME_default === "undefined" || new URL(site).origin !== new URL(define_TERMINAL_HOME_default.index.site.url).origin)
+    return;
+  const { index, document } = define_TERMINAL_HOME_default;
+  return {
+    index,
+    page: { ...documentPage(index, document, site), postsStatus: "loading" }
+  };
+}
+function withHomePosts(page, index) {
+  const posts = index.posts.slice(0, 5);
+  return {
+    ...page,
+    postsStatus: void 0,
+    sections: page.sections?.map((section) => {
+      if (section.kind !== "turn" || section.list?.kind !== "posts") return section;
+      return {
+        ...section,
+        list: {
+          ...section.list,
+          items: posts,
+          before: section.list.before.replace(
+            /^◆[^\n]+/m,
+            `\u25C6 **Read** posts/ (\u6700\u65B0 ${posts.length} of ${index.posts.length})`
+          )
+        }
+      };
+    })
+  };
+}
+
+// packages/cli/src/console.tsx
+import { ThreadPrimitive as ThreadPrimitive2 } from "@assistant-ui/react-ink";
+import { useRef as useRef11 } from "react";
+
+// packages/cli/src/chat.tsx
+import { ThreadPrimitive, useAuiState } from "@assistant-ui/react-ink";
+import { Box as Box10, Text as Text10 } from "ink";
+
+// src/theme-data.ts
+var themes = [
+  {
+    id: "ayu-dark",
+    name: "Ayu Dark",
+    description: "\u6696\u8272\u70B9\u7F00\u7684\u6DF1\u8272\u4E3B\u9898",
+    dark: true,
+    color: "#0f1419"
+  },
+  {
+    id: "ayu-light",
+    name: "Ayu Light",
+    description: "\u660E\u4EAE\u67D4\u548C\u7684\u6D45\u8272\u4E3B\u9898",
+    dark: false,
+    color: "#fcfcfc"
+  },
+  {
+    id: "solarized-light",
+    name: "Solarized Light",
+    description: "\u6696\u7EB8\u8272\u80CC\u666F\u4E0E\u4F4E\u9971\u548C\u914D\u8272",
+    dark: false,
+    color: "#fdf6e3"
+  },
+  { id: "nord", name: "Nord", description: "\u6E05\u51B7\u7684\u84DD\u7070\u6697\u8272", dark: true, color: "#2e3440" },
+  {
+    id: "dracula",
+    name: "Dracula",
+    description: "\u7D2B\u7070\u80CC\u666F\u4E0E\u660E\u4EAE\u70B9\u7F00",
+    dark: true,
+    color: "#282a36"
+  },
+  { id: "gruvbox", name: "Gruvbox", description: "\u6E29\u6696\u7684\u590D\u53E4\u6697\u8272", dark: true, color: "#282828" }
+];
+var themeOptions = [
+  ...themes,
+  { id: "auto", name: "Auto", description: "\u8DDF\u968F\u7CFB\u7EDF\u5207\u6362 Ayu \u6DF1\u6D45\u8272" }
+];
+var themeAliases = {
+  dark: "ayu-dark",
+  night: "ayu-dark",
+  ayu: "ayu-dark",
+  light: "ayu-light",
+  day: "ayu-light",
+  solarized: "solarized-light",
+  groknight: "ayu-dark",
+  "grok-night": "ayu-dark",
+  grokday: "ayu-light",
+  "grok-day": "ayu-light",
+  tokyonight: "nord",
+  tokyo: "nord",
+  "tokyo-night": "nord",
+  rosepine: "dracula",
+  "rose-pine": "dracula",
+  "rosepine-moon": "dracula",
+  "rose-pine-moon": "dracula",
+  oscura: "ayu-dark",
+  "oscura-midnight": "ayu-dark",
+  system: "auto"
+};
+function parseThemePreference(input) {
+  const name = input?.trim().toLowerCase();
+  if (!name) return void 0;
+  return themeOptions.find((option) => option.id === name)?.id ?? (Object.hasOwn(themeAliases, name) ? themeAliases[name] : void 0);
+}
+function resolveTheme(preference, prefersDark2) {
+  return preference === "auto" ? prefersDark2 ? "ayu-dark" : "ayu-light" : preference;
+}
+function getThemeName(id) {
+  return themeOptions.find((option) => option.id === id)?.name ?? id;
+}
+
+// src/agent/tool-header.ts
+function getToolHeader({ toolName, args }) {
+  switch (toolName) {
+    case "set_theme": {
+      const theme = typeof args?.theme === "string" ? args.theme : "";
+      const preference = parseThemePreference(theme);
+      return { verb: "Theme", target: preference ? getThemeName(preference) : theme };
+    }
+    case "open_page":
+      return { verb: "Open", target: typeof args?.path === "string" ? args.path : "" };
+    default:
+      return { verb: toolName, target: "" };
+  }
+}
+
+// packages/cli/src/theme.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// packages/cli/src/code-highlighter.ts
+import { Chalk } from "chalk";
+import { useEffect, useState } from "react";
+var ansi = new Chalk({ level: 3 });
+var languages = [
+  "typescript",
+  "javascript",
+  "tsx",
+  "jsx",
+  "python",
+  "bash",
+  "json",
+  "html",
+  "css",
+  "rust",
+  "go",
+  "java"
+];
+async function createCodeHighlighter(colors) {
+  const { createHighlighter, createCssVariablesTheme } = await import("shiki");
+  const theme = createCssVariablesTheme({
+    name: "css-variables",
+    variablePrefix: "--shiki-",
+    fontStyle: true
+  });
+  const highlighter = await createHighlighter({ themes: [theme], langs: languages });
+  return {
+    highlight(code, language) {
+      const lang = highlighter.getLoadedLanguages().find((loaded) => loaded === language);
+      if (!lang) return code;
+      return highlighter.codeToTokensBase(code, { lang, theme }).map(
+        (line) => line.map((token) => {
+          let style = ansi.hex(colors[token.color ?? ""] ?? colors["var(--shiki-foreground)"]);
+          const fontStyle = token.fontStyle ?? 0;
+          if (fontStyle & 1) style = style.italic;
+          if (fontStyle & 2) style = style.bold;
+          if (fontStyle & 4) style = style.underline;
+          return style(token.content);
+        }).join("")
+      ).join("\n");
+    },
+    dispose: () => highlighter.dispose()
+  };
+}
+function useCodeHighlighter(id) {
+  const [result, setResult] = useState();
+  useEffect(() => {
+    let disposed = false;
+    let current;
+    createCodeHighlighter(define_TERMINAL_CODE_COLORS_default[id]).then((highlighter) => {
+      if (disposed) highlighter.dispose();
+      else {
+        current = highlighter;
+        setResult({ id, highlight: highlighter.highlight });
+      }
+    }).catch(() => {
+    });
+    return () => {
+      disposed = true;
+      current?.dispose();
+    };
+  }, [id]);
+  return result?.id === id ? result.highlight : void 0;
+}
+
+// packages/cli/src/theme.tsx
+import { stripVTControlCharacters } from "node:util";
+import { jsx } from "react/jsx-runtime";
+function cleanText(text) {
+  return stripVTControlCharacters(text).replace(
+    /[\p{Cc}\p{Cf}]/gu,
+    (character) => /[\n\t]/.test(character) ? character : ""
+  );
+}
+function prefersDark() {
+  const background = process.env.COLORFGBG?.split(";").at(-1);
+  return background === void 0 || Number(background) < 8;
+}
+var StyleContext = createContext(null);
+function TerminalTheme({
+  preference,
+  width,
+  children
+}) {
+  const id = resolveTheme(preference, prefersDark());
+  const highlighter = useCodeHighlighter(id);
+  const style = useMemo(() => {
+    const colors = define_TERMINAL_PALETTES_default[id];
+    return {
+      colors,
+      width,
+      highlighter,
+      markdownTheme: {
+        heading: { color: colors.h1, bold: true },
+        strong: { color: colors["fg-soft"], bold: true },
+        inlineCode: { color: colors.code, bold: true },
+        code: { color: colors.code },
+        link: { color: colors.link, underline: true },
+        quote: { color: colors.muted },
+        hr: { color: colors.line },
+        listMarker: { color: colors.muted },
+        tableHeader: { color: colors.fg, bold: true }
+      }
+    };
+  }, [id, width, highlighter]);
+  return /* @__PURE__ */ jsx(StyleContext, { value: style, children });
+}
+function useTerminalStyle() {
+  const style = useContext(StyleContext);
+  if (!style) throw new Error("TerminalTheme is required");
+  return style;
+}
+
+// packages/cli/src/markdown.tsx
+import { MarkdownText } from "@assistant-ui/react-ink-markdown";
+import { Box as Box6, Text as Text6, useBoxMetrics } from "ink";
+import { lexer as lexer2 } from "marked";
+import { useMemo as useMemo2, useRef as useRef3 } from "react";
+
+// packages/cli/src/home-links.tsx
+import { Text as Text2 } from "ink";
+
+// packages/cli/src/components/ui/grid.tsx
+import { chunk } from "es-toolkit";
+import { Box } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Grid({
+  children,
+  columns = 2,
+  gap = 2,
+  rowGap = 0,
+  width
+}) {
+  const cellWidth = Math.max(1, Math.floor((width - gap * (columns - 1)) / columns));
+  return /* @__PURE__ */ jsx2(Box, { flexDirection: "column", rowGap, children: chunk(children, columns).map((row) => /* @__PURE__ */ jsx2(Box, { columnGap: gap, children: row.map((child) => /* @__PURE__ */ jsx2(Box, { width: cellWidth, flexShrink: 0, children: child }, child.key)) }, row[0].key)) });
+}
+
+// packages/cli/src/components/ui/link.tsx
+import { Text, useFocus, useFocusManager, useInput } from "ink";
+import InkLink from "ink-link";
+import { useId, useLayoutEffect as useLayoutEffect2 } from "react";
+
+// packages/cli/src/mouse.tsx
+import { Box as Box2, useStdin, useStdout } from "ink";
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useRef,
+  useState as useState2
+} from "react";
+
+// packages/cli/src/mouse-hit.ts
+import { measureElement } from "ink";
+function bounds(element) {
+  const rect = measureElement(element);
+  for (let parent = element.parentNode; parent; parent = parent.parentNode) {
+    rect.x -= Math.trunc(parent.style.contentOffsetX ?? 0);
+    rect.y -= Math.trunc(parent.style.contentOffsetY ?? 0);
+  }
+  return rect;
+}
+function contains(element, x, y) {
+  const rect = bounds(element);
+  if (x < rect.x || x >= rect.x + rect.width || y < rect.y || y >= rect.y + rect.height)
+    return false;
+  for (let parent = element; parent; parent = parent.parentNode) {
+    if (parent.isHidden || parent.style.display === "none") return false;
+    const clip = bounds(parent);
+    if ((parent.style.overflowX ?? parent.style.overflow) === "hidden" && (x < clip.x || x >= clip.x + clip.width))
+      return false;
+    if ((parent.style.overflowY ?? parent.style.overflow) === "hidden" && (y < clip.y || y >= clip.y + clip.height))
+      return false;
+  }
+  return true;
+}
+function paintOrder(a, b) {
+  const path = (element) => {
+    const nodes = [];
+    for (let node = element; node; node = node.parentNode)
+      nodes.unshift(node);
+    return nodes;
+  };
+  const left = path(a);
+  const right = path(b);
+  const index = left.findIndex((node, i) => node !== right[i]);
+  if (index < 0) return left.length - right.length;
+  if (!right[index]) return 1;
+  const siblings = left[index].parentNode?.childNodes ?? [];
+  return siblings.indexOf(left[index]) - siblings.indexOf(right[index]);
+}
+
+// packages/cli/src/mouse-input.ts
+function mouseParser(onEvent) {
+  let pending = "";
+  return (chunk2) => {
+    const input = pending + chunk2.toString();
+    for (const match of input.matchAll(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g)) {
+      onEvent({
+        button: Number(match[1]),
+        x: Number(match[2]) - 1,
+        y: Number(match[3]) - 1,
+        release: match[4] === "m"
+      });
+    }
+    const tail = input.slice(input.lastIndexOf("\x1B"));
+    pending = /^\x1b(?:\[(?:<[\d;]*)?)?$/.test(tail) ? tail : "";
+  };
+}
+
+// packages/cli/src/mouse.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var MouseContext = createContext2(null);
+function MouseProvider({ children }) {
+  const { stdin } = useStdin();
+  const { stdout } = useStdout();
+  const [regions] = useState2(() => /* @__PURE__ */ new Set());
+  useEffect2(() => {
+    if (!("isTTY" in stdin && stdin.isTTY) || !("isTTY" in stdout && stdout.isTTY) || process.env.TERM === "dumb" || process.env.NO_MOUSE)
+      return;
+    let pressed;
+    const handleInput = mouseParser((event) => {
+      if (event.button & 28) return;
+      const wheel = !!(event.button & 64);
+      const candidates = [...regions].filter(
+        (region) => region.mouseEnabled !== false && (wheel ? region.onWheel : region.onClick) && region.ref.current && contains(region.ref.current, event.x, event.y)
+      );
+      const target = candidates.sort((a, b) => paintOrder(a.ref.current, b.ref.current)).at(-1);
+      if (wheel) {
+        if ((event.button & 3) < 2) target?.onWheel?.(event.button & 1 ? 1 : -1);
+      } else if ((event.button & 3) === 0) {
+        if (!event.release) pressed = target;
+        else {
+          if (target && target === pressed) target.onClick?.();
+          pressed = void 0;
+        }
+      }
+    });
+    const disable = () => stdout.write("\x1B[?1000l\x1B[?1006l");
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    stdin.on("data", handleInput);
+    process.once("exit", disable);
+    return () => {
+      stdin.off("data", handleInput);
+      process.off("exit", disable);
+      disable();
+    };
+  }, [stdin, stdout, regions]);
+  return /* @__PURE__ */ jsx3(MouseContext, { value: regions, children });
+}
+function MouseArea({
+  onClick,
+  onWheel,
+  mouseEnabled = true,
+  ref,
+  ...props
+}) {
+  const ownRef = useRef(null);
+  const position = ref ?? ownRef;
+  const regions = useContext2(MouseContext);
+  const [region] = useState2(() => ({ ref: position }));
+  useLayoutEffect(() => {
+    Object.assign(region, { ref: position, onClick, onWheel, mouseEnabled });
+  });
+  useLayoutEffect(() => {
+    regions?.add(region);
+    return () => {
+      regions?.delete(region);
+    };
+  }, [regions, region]);
+  return /* @__PURE__ */ jsx3(Box2, { ref: position, ...props });
+}
+
+// packages/cli/src/components/ui/link.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function Link({
+  href,
+  children,
+  onOpen,
+  onFocus,
+  isActive = true,
+  inline = false,
+  underline = true,
+  ...textProps
+}) {
+  const id = useId();
+  const { isFocused } = useFocus({ id, isActive: isActive && !!href });
+  const { focus, focusNext, focusPrevious } = useFocusManager();
+  useLayoutEffect2(() => {
+    if (isFocused) onFocus?.();
+  }, [isFocused, onFocus]);
+  useInput(
+    (_input, key) => {
+      if (key.eventType === "release") return;
+      if (key.return) onOpen();
+      else if (key.downArrow || key.rightArrow) focusNext();
+      else if (key.upArrow || key.leftArrow) focusPrevious();
+    },
+    { isActive: isActive && isFocused }
+  );
+  const text = /* @__PURE__ */ jsx4(Text, { ...textProps, inverse: isFocused, underline: isFocused || underline, children });
+  const link = href ? /* @__PURE__ */ jsx4(InkLink, { url: href, fallback: false, children: text }) : text;
+  return inline ? link : /* @__PURE__ */ jsx4(
+    MouseArea,
+    {
+      mouseEnabled: isActive && !!href,
+      onClick: () => {
+        focus(id);
+        onOpen();
+      },
+      flexShrink: 1,
+      minWidth: 0,
+      children: link
+    }
+  );
+}
+
+// packages/cli/src/link.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useLayoutEffect as useLayoutEffect3,
+  useRef as useRef2
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var LinkNavigation = createContext3(null);
+var LinkScope = createContext3(true);
+var LinkPosition = createContext3(null);
+function resolveLink(href, site, origin = site) {
+  if (!URL.canParse(href, site)) return;
+  const url = new URL(href, site);
+  if (!["http:", "https:", "mailto:"].includes(url.protocol)) return;
+  const external = !!url.hash || /\.[a-z\d]{2,8}$/i.test(url.pathname) || ![new URL(site).origin, new URL(origin).origin].includes(url.origin);
+  return {
+    url: url.href,
+    path: external ? url.href : url.pathname + url.search + url.hash,
+    external
+  };
+}
+function LinkRow({
+  children,
+  reveal = false,
+  onClick,
+  ...props
+}) {
+  const position = useRef2(null);
+  const navigation = useContext3(LinkNavigation);
+  const active = useContext3(LinkScope);
+  useLayoutEffect3(() => {
+    if (reveal && position.current) navigation?.scroll.current?.reveal(position.current);
+  }, [reveal, navigation]);
+  return /* @__PURE__ */ jsx5(LinkPosition, { value: position, children: /* @__PURE__ */ jsx5(MouseArea, { ref: position, mouseEnabled: active, onClick, ...props, children }) });
+}
+function TerminalLink({
+  href,
+  children,
+  color,
+  bold,
+  underline = true,
+  inline = false
+}) {
+  const navigation = useContext3(LinkNavigation);
+  const active = useContext3(LinkScope);
+  const position = useContext3(LinkPosition);
+  const { colors } = useTerminalStyle();
+  const target = resolveLink(
+    cleanText(href),
+    navigation?.site ?? "https://miantiao.me",
+    navigation?.origin
+  );
+  return /* @__PURE__ */ jsx5(
+    Link,
+    {
+      href: target?.url,
+      inline,
+      color: color ?? colors.link,
+      bold,
+      underline,
+      isActive: active && !!navigation,
+      onFocus: () => {
+        if (position?.current) navigation?.scroll.current?.reveal(position.current);
+      },
+      onOpen: () => {
+        if (target) navigation?.onSelect(target.path, target.external);
+      },
+      children
+    }
+  );
+}
+
+// packages/cli/src/home-links.tsx
+import { jsx as jsx6, jsxs } from "react/jsx-runtime";
+function homeLinks(list) {
+  if (list.ordered || !list.items.length) return;
+  const links = list.items.map((item) => {
+    if (item.tokens.length !== 1) return;
+    const block = item.tokens[0];
+    const inline = "tokens" in block ? block.tokens : void 0;
+    if (!inline) return;
+    const link = inline[0];
+    if (link?.type !== "link" || !URL.canParse(link.href)) return;
+    const host = inline.slice(1).map((token) => "text" in token ? token.text : "").join("").trim();
+    return host === new URL(link.href).hostname ? link : void 0;
+  });
+  if (links.every((link) => link !== void 0)) return links;
+}
+function HomeLinks({ items, width }) {
+  const { colors } = useTerminalStyle();
+  const columns = Math.min(3, Math.max(1, Math.floor((width + 2) / 30)));
+  return /* @__PURE__ */ jsx6(Grid, { columns, width, children: items.map((link) => /* @__PURE__ */ jsxs(LinkRow, { children: [
+    /* @__PURE__ */ jsx6(TerminalLink, { href: link.href, color: colors.fg, underline: false, children: cleanText(link.text) }),
+    /* @__PURE__ */ jsxs(Text2, { color: colors.muted, wrap: "truncate-end", children: [
+      " ",
+      new URL(link.href).hostname
+    ] })
+  ] }, link.href)) });
+}
+
+// packages/cli/src/tool.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
+function parseTool(text) {
+  const match = /^◆\s+\*\*([^*]+)\*\*\s+(\S+)(?:\s+\((.+)\))?\s*$/.exec(text.trim());
+  if (match) return { verb: match[1], target: match[2], detail: match[3] };
+}
+function Tool({
+  verb,
+  target,
+  detail,
+  aside,
+  state
+}) {
+  const { colors } = useTerminalStyle();
+  const description = state === "running" ? "\u6267\u884C\u4E2D\u2026" : detail;
+  return /* @__PURE__ */ jsxs2(Box3, { children: [
+    /* @__PURE__ */ jsx7(Text3, { color: state === "error" ? colors.err : colors.muted, children: state === "error" ? "\u2717 " : "\u25C6 " }),
+    /* @__PURE__ */ jsx7(Box3, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: /* @__PURE__ */ jsxs2(Text3, { children: [
+      /* @__PURE__ */ jsx7(Text3, { color: colors.fg, bold: true, children: cleanText(verb) }),
+      /* @__PURE__ */ jsxs2(Text3, { color: colors.path, children: [
+        " ",
+        cleanText(target)
+      ] }),
+      description && /* @__PURE__ */ jsxs2(Text3, { color: colors.muted, children: [
+        " (",
+        cleanText(description),
+        ")"
+      ] })
+    ] }) }),
+    aside && /* @__PURE__ */ jsx7(Box3, { paddingLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsx7(Text3, { color: colors.muted, children: cleanText(aside) }) })
+  ] });
+}
+
+// packages/cli/src/components/ui/table.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import stringWidth from "string-width";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+function Table({ header, rows, width }) {
+  const { colors } = useTerminalStyle();
+  const count = header.length;
+  if (!count) return null;
+  const natural = header.map(
+    (cell, column) => Math.max(
+      1,
+      ...[cell, ...rows.map((row) => row[column])].map((value) => stringWidth(value?.text ?? ""))
+    )
+  );
+  const available = Math.max(count, width - count * 3 - 1);
+  const widths = natural.map((size) => Math.min(size, Math.floor(available / count)));
+  let remaining = available - widths.reduce((total, size) => total + size, 0);
+  while (remaining > 0) {
+    const column = natural.findIndex((size, index) => size > widths[index]);
+    if (column < 0) break;
+    widths[column]++;
+    remaining--;
+  }
+  if (width < count * 4 + 1) {
+    return /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", gap: 1, children: rows.map((row, index) => /* @__PURE__ */ jsx8(LinkRow, { flexDirection: "column", children: row.map((cell, column) => /* @__PURE__ */ jsxs3(Text4, { color: colors["fg-soft"], children: [
+      /* @__PURE__ */ jsxs3(Text4, { bold: true, children: [
+        header[column]?.text,
+        ": "
+      ] }),
+      cell.content
+    ] }, column)) }, index)) });
+  }
+  return /* @__PURE__ */ jsx8(
+    Box4,
+    {
+      borderStyle: "single",
+      borderColor: colors.line,
+      flexDirection: "column",
+      alignSelf: "flex-start",
+      children: [header, ...rows].map((row, rowIndex) => /* @__PURE__ */ jsx8(LinkRow, { children: row.map((cell, column) => /* @__PURE__ */ jsx8(
+        Box4,
+        {
+          width: widths[column] + 2 + Number(column < count - 1),
+          paddingX: 1,
+          borderStyle: "single",
+          borderTop: false,
+          borderBottom: false,
+          borderLeft: false,
+          borderRight: column < count - 1,
+          borderColor: colors.line,
+          children: /* @__PURE__ */ jsx8(Text4, { bold: rowIndex === 0, color: rowIndex === 0 ? colors.fg : colors["fg-soft"], children: cell.content })
+        },
+        column
+      )) }, rowIndex))
+    }
+  );
+}
+
+// packages/cli/src/components/ui/thinking-block.tsx
+import { Box as Box5, Text as Text5, useFocus as useFocus2, useInput as useInput2 } from "ink";
+import { useContext as useContext4, useId as useId2, useState as useState4 } from "react";
+
+// src/agent/useElapsedTime.ts
+import { useEffect as useEffect3, useState as useState3 } from "react";
+function useElapsedTime(active, live = false) {
+  const [seconds, setSeconds] = useState3(0);
+  useEffect3(() => {
+    if (!active)
+      return;
+    const startedAt = Date.now();
+    const elapsed = () => (Date.now() - startedAt) / 1e3;
+    const finish = () => setSeconds(elapsed());
+    setSeconds(0);
+    if (!live)
+      return finish;
+    const timer = setInterval(finish, 1e3);
+    return () => {
+      clearInterval(timer);
+      finish();
+    };
+  }, [active, live]);
+  return seconds;
+}
+
+// packages/cli/src/components/ui/thinking-block.tsx
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+function Summary({
+  label,
+  collapsed,
+  streaming,
+  onToggle
+}) {
+  const { colors } = useTerminalStyle();
+  const active = useContext4(LinkScope);
+  const id = useId2();
+  const { isFocused, focus } = useFocus2({ id, isActive: active });
+  useInput2(
+    (input, key) => {
+      if (key.eventType !== "release" && (key.return || input === " ")) onToggle();
+    },
+    { isActive: active && isFocused }
+  );
+  return /* @__PURE__ */ jsx9(
+    LinkRow,
+    {
+      reveal: isFocused,
+      onClick: () => {
+        focus(id);
+        onToggle();
+      },
+      "aria-role": "button",
+      "aria-state": { expanded: !collapsed, busy: streaming },
+      children: /* @__PURE__ */ jsxs4(Text5, { color: colors.muted, inverse: isFocused, children: [
+        "\u25C6 ",
+        label,
+        " ",
+        collapsed ? "\u25B8" : "\u25BE"
+      ] })
+    }
+  );
+}
+function ThinkingBlock({
+  content = "",
+  streaming = false,
+  label,
+  children
+}) {
+  const { colors } = useTerminalStyle();
+  const active = useContext4(LinkScope);
+  const [collapsed, setCollapsed] = useState4(true);
+  const seconds = useElapsedTime(streaming);
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(
+      Summary,
+      {
+        label: label ?? (streaming ? "\u601D\u8003\u4E2D\u2026" : `\u601D\u8003 ${seconds.toFixed(1)}s`),
+        collapsed,
+        streaming,
+        onToggle: () => setCollapsed((value) => !value)
+      }
+    ),
+    /* @__PURE__ */ jsx9(LinkScope, { value: active && !collapsed, children: /* @__PURE__ */ jsx9(
+      Box5,
+      {
+        display: collapsed ? "none" : "flex",
+        flexDirection: "column",
+        gap: 1,
+        borderStyle: "single",
+        borderTop: false,
+        borderRight: false,
+        borderBottom: false,
+        borderColor: colors.dim,
+        paddingLeft: 2,
+        marginTop: 1,
+        children: children ?? /* @__PURE__ */ jsx9(Text5, { color: colors.muted, children: cleanText(content) })
+      }
+    ) })
+  ] });
+}
+
+// packages/cli/src/markdown.tsx
+import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
+function Inline({ tokens, plainLinks = false }) {
+  const { colors } = useTerminalStyle();
+  return tokens.map((token, index) => {
+    if (token.type === "link" || token.type === "image")
+      return /* @__PURE__ */ jsx10(
+        TerminalLink,
+        {
+          inline: true,
+          href: token.href,
+          color: plainLinks ? colors.fg : void 0,
+          underline: !plainLinks,
+          children: "tokens" in token && token.tokens ? /* @__PURE__ */ jsx10(Inline, { tokens: token.tokens, plainLinks }) : cleanText(token.text)
+        },
+        index
+      );
+    if (token.type === "br") return "\n";
+    if (!("text" in token)) return token.raw;
+    const children = "tokens" in token && token.tokens ? /* @__PURE__ */ jsx10(Inline, { tokens: token.tokens, plainLinks }) : cleanText(token.text);
+    return /* @__PURE__ */ jsx10(
+      Text6,
+      {
+        bold: token.type === "strong" || token.type === "codespan",
+        italic: token.type === "em",
+        strikethrough: token.type === "del",
+        color: token.type === "codespan" ? colors.code : token.type === "strong" ? colors["fg-soft"] : plainLinks ? colors.muted : void 0,
+        children
+      },
+      index
+    );
+  });
+}
+function hasLink(token) {
+  if (token.type === "link" || token.type === "image") return true;
+  if (token.type === "list")
+    return token.items.some((item) => item.tokens.some((child) => hasLink(child)));
+  if (token.type === "table")
+    return [token.header, ...token.rows].some(
+      (row) => row.some((cell) => cell.tokens.some((child) => hasLink(child)))
+    );
+  return "tokens" in token && !!token.tokens?.some((child) => hasLink(child));
+}
+function PlainMarkdown({ text, width }) {
+  const { colors, markdownTheme, highlighter } = useTerminalStyle();
+  return /* @__PURE__ */ jsx10(Text6, { color: colors["fg-soft"], children: /* @__PURE__ */ jsx10(
+    MarkdownText,
+    {
+      text,
+      width,
+      theme: markdownTheme,
+      highlighter,
+      codeWrap: true,
+      hyperlinks: true,
+      tableTruncate: false
+    }
+  ) });
+}
+function Blocks({
+  tokens,
+  width,
+  home = false,
+  plainLinks = false,
+  tone
+}) {
+  const { colors } = useTerminalStyle();
+  return tokens.filter((token) => token.type !== "space").map((token, index) => {
+    const tool2 = token.type === "paragraph" ? parseTool(token.text) : void 0;
+    if (tool2) return /* @__PURE__ */ jsx10(Tool, { ...tool2 }, index);
+    if (!home && !tone && !["heading", "table", "blockquote", "code"].includes(token.type) && !hasLink(token))
+      return /* @__PURE__ */ jsx10(PlainMarkdown, { text: token.raw, width }, index);
+    if (token.type === "code")
+      return /* @__PURE__ */ jsx10(Box6, { backgroundColor: colors.well, paddingX: 2, children: /* @__PURE__ */ jsx10(PlainMarkdown, { text: token.raw, width: Math.max(1, width - 4) }) }, index);
+    if (token.type === "list") {
+      const links = home ? homeLinks(token) : void 0;
+      if (links) return /* @__PURE__ */ jsx10(HomeLinks, { items: links, width }, index);
+      return /* @__PURE__ */ jsx10(Box6, { flexDirection: "column", gap: !home && token.loose ? 1 : 0, children: token.items.map((item, itemIndex) => /* @__PURE__ */ jsxs5(Box6, { children: [
+        /* @__PURE__ */ jsx10(Text6, { color: colors.muted, children: token.ordered ? `${Number(token.start) + itemIndex}. ` : "\u2022 " }),
+        /* @__PURE__ */ jsx10(Box6, { flexDirection: "column", flexShrink: 1, gap: 1, minWidth: 0, children: /* @__PURE__ */ jsx10(
+          Blocks,
+          {
+            tokens: item.tokens,
+            width: width - 2,
+            home,
+            plainLinks: home
+          }
+        ) })
+      ] }, itemIndex)) }, index);
+    }
+    if (token.type === "blockquote") {
+      if (token.text.startsWith("[!DETAILS]")) {
+        const content = lexer2(token.text.slice("[!DETAILS]".length).trim()).filter((child) => child.type !== "space");
+        const summary = content[0];
+        const label = summary?.type === "paragraph" ? summary.tokens.map((child) => "text" in child ? child.text : child.raw).join("") : "\u8BE6\u7EC6\u5185\u5BB9";
+        return /* @__PURE__ */ jsx10(ThinkingBlock, { label: cleanText(label), children: /* @__PURE__ */ jsx10(
+          Blocks,
+          {
+            tokens: content.slice(1),
+            width: width - 3,
+            home,
+            plainLinks
+          }
+        ) }, index);
+      }
+      const alert = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*\n?/i.exec(token.text);
+      return /* @__PURE__ */ jsx10(
+        Box6,
+        {
+          borderStyle: "single",
+          borderTop: false,
+          borderRight: false,
+          borderBottom: false,
+          borderColor: alert ? /WARNING|CAUTION/i.test(alert[1]) ? colors.warn : colors.accent : colors.dim,
+          paddingLeft: 2,
+          flexDirection: "column",
+          gap: 1,
+          children: /* @__PURE__ */ jsx10(
+            Blocks,
+            {
+              tokens: alert ? lexer2(token.text.slice(alert[0].length)) : token.tokens,
+              width: width - 3,
+              home,
+              plainLinks,
+              tone: alert ? void 0 : colors.muted
+            }
+          )
+        },
+        index
+      );
+    }
+    if (token.type === "table") {
+      const cells = (row) => row.map((cell) => ({
+        text: cleanText(cell.text),
+        content: /* @__PURE__ */ jsx10(Inline, { tokens: cell.tokens })
+      }));
+      return /* @__PURE__ */ jsx10(
+        Table,
+        {
+          header: cells(token.header),
+          rows: token.rows.map(cells),
+          width
+        },
+        index
+      );
+    }
+    let color = tone ?? colors["fg-soft"];
+    if (token.type === "heading") {
+      const level = Math.max(1, token.depth - 1);
+      color = colors[level <= 3 ? `h${level}` : "muted"];
+      if (home && token.depth === 1) color = colors.fg;
+    }
+    return /* @__PURE__ */ jsx10(LinkRow, { children: /* @__PURE__ */ jsx10(Text6, { bold: token.type === "heading", color, children: /* @__PURE__ */ jsx10(
+      Inline,
+      {
+        tokens: "tokens" in token ? token.tokens ?? [] : [],
+        plainLinks
+      }
+    ) }) }, index);
+  });
+}
+function Markdown({
+  text,
+  width: availableWidth,
+  home = false,
+  compact = false
+}) {
+  const { width } = useTerminalStyle();
+  const container = useRef3(null);
+  const { clientWidth } = useBoxMetrics(container);
+  const tokens = useMemo2(() => lexer2(text), [text]);
+  const available = Math.max(1, availableWidth ?? (clientWidth || width - 6));
+  const native = tokens.some(
+    (token) => home && token.type === "list" || ["heading", "table", "blockquote", "code"].includes(token.type) || hasLink(token)
+  );
+  return /* @__PURE__ */ jsx10(Box6, { ref: container, flexDirection: "column", gap: compact ? 0 : 1, minWidth: 0, children: native ? /* @__PURE__ */ jsx10(Blocks, { tokens, width: available, home }) : /* @__PURE__ */ jsx10(PlainMarkdown, { text, width: available }) });
+}
+
+// packages/cli/src/blocks.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+
+// packages/cli/src/page-list.tsx
+import { Box as Box7, Text as Text7, useBoxMetrics as useBoxMetrics2 } from "ink";
+import { useRef as useRef4 } from "react";
+
+// src/utils/time.ts
+import { parseISO } from "date-fns/parseISO";
+var shortDateFormatter = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Asia/Shanghai",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit"
+});
+function formatShortDate(date) {
+  const value = date instanceof Date ? date : parseISO(/^\d{4}-\d{2}-\d{2}$/.test(date) ? `${date}T00:00:00+08:00` : date);
+  return shortDateFormatter.format(value);
+}
+
+// packages/cli/src/page-list.tsx
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+function PageList({ items, compact = false }) {
+  const { colors, width } = useTerminalStyle();
+  const container = useRef4(null);
+  const { clientWidth } = useBoxMetrics2(container);
+  const stacked = !compact && (clientWidth || width - 6) < 55;
+  return /* @__PURE__ */ jsx11(
+    Box7,
+    {
+      ref: container,
+      flexDirection: "column",
+      marginTop: compact ? 1 : 0,
+      maxWidth: compact ? 44 : void 0,
+      children: items.map((item) => /* @__PURE__ */ jsxs6(
+        LinkRow,
+        {
+          flexDirection: compact ? "row" : "column",
+          justifyContent: compact ? "space-between" : void 0,
+          marginBottom: compact ? 0 : 1,
+          children: [
+            /* @__PURE__ */ jsxs6(Box7, { flexDirection: stacked ? "column" : "row", children: [
+              item.date && /* @__PURE__ */ jsxs6(Text7, { color: colors.muted, children: [
+                formatShortDate(item.date),
+                " "
+              ] }),
+              /* @__PURE__ */ jsxs6(Box7, { flexShrink: 1, minWidth: 0, children: [
+                !compact && /* @__PURE__ */ jsx11(Text7, { color: colors.muted, children: "\u2022 " }),
+                /* @__PURE__ */ jsx11(Box7, { flexShrink: 1, minWidth: 0, children: /* @__PURE__ */ jsx11(TerminalLink, { href: item.path, color: colors.fg, bold: compact, underline: false, children: cleanText(item.title) }) })
+              ] })
+            ] }),
+            item.description && /* @__PURE__ */ jsx11(Box7, { paddingLeft: compact ? 0 : item.date && !stacked ? 13 : 2, children: /* @__PURE__ */ jsx11(Text7, { color: colors.muted, children: cleanText(item.description) }) })
+          ]
+        },
+        item.path
+      ))
+    }
+  );
+}
+
+// packages/cli/src/home-list.tsx
+import { Box as Box8, Text as Text8, useBoxMetrics as useBoxMetrics3 } from "ink";
+import { useContext as useContext5, useRef as useRef5 } from "react";
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+function formatStars(stars) {
+  return stars >= 1e3 ? `${(stars / 1e3).toFixed(1)}k` : String(stars);
+}
+function HomeList({ list }) {
+  const { colors, width: availableWidth } = useTerminalStyle();
+  const active = useContext5(LinkScope);
+  const container = useRef5(null);
+  const { clientWidth } = useBoxMetrics3(container);
+  const width = clientWidth || availableWidth - 6;
+  if (list.kind === "posts")
+    return /* @__PURE__ */ jsx12(Box8, { ref: container, flexDirection: "column", children: Array.from({ length: Math.max(5, list.items.length) }, (_, slot) => slot).map((slot) => {
+      const post = list.items[slot];
+      return /* @__PURE__ */ jsx12(LinkScope, { value: active && !!post, children: /* @__PURE__ */ jsxs7(
+        LinkRow,
+        {
+          display: post ? "flex" : "none",
+          flexDirection: width < 55 ? "column" : "row",
+          children: [
+            /* @__PURE__ */ jsxs7(Text8, { color: colors.muted, children: [
+              post ? formatShortDate(post.date) : "",
+              " "
+            ] }),
+            /* @__PURE__ */ jsxs7(Box8, { flexShrink: 1, minWidth: 0, children: [
+              /* @__PURE__ */ jsx12(Text8, { color: colors.muted, children: "\u2022 " }),
+              /* @__PURE__ */ jsx12(Box8, { flexShrink: 1, minWidth: 0, children: /* @__PURE__ */ jsx12(TerminalLink, { href: post?.path ?? "/", color: colors.fg, underline: false, children: post ? cleanText(post.title) : "" }) })
+            ] })
+          ]
+        }
+      ) }, slot);
+    }) });
+  const nameWidth = 20;
+  return /* @__PURE__ */ jsx12(Box8, { ref: container, flexDirection: "column", children: list.items.map((project) => /* @__PURE__ */ jsxs7(LinkRow, { flexDirection: width >= 55 ? "row" : "column", children: [
+    /* @__PURE__ */ jsxs7(Box8, { flexShrink: 0, children: [
+      /* @__PURE__ */ jsx12(Box8, { width: nameWidth, flexShrink: 1, children: /* @__PURE__ */ jsx12(TerminalLink, { href: project.url, color: colors.fg, bold: true, underline: false, children: cleanText(project.title) }) }),
+      /* @__PURE__ */ jsx12(Box8, { width: 10, flexShrink: 0, children: project.repo ? /* @__PURE__ */ jsxs7(
+        TerminalLink,
+        {
+          href: `https://github.com/miantiao-me/${project.repo}`,
+          color: colors.warn,
+          underline: false,
+          children: [
+            "\u2605 ",
+            formatStars(project.stars)
+          ]
+        }
+      ) : /* @__PURE__ */ jsxs7(Text8, { color: colors.warn, children: [
+        "\u2605 ",
+        formatStars(project.stars)
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx12(Box8, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx12(Text8, { color: colors["fg-soft"], children: cleanText(project.description) }) })
+  ] }, project.url)) });
+}
+
+// packages/cli/src/blocks.tsx
+import { Fragment, jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+function Prompt({
+  text,
+  command = false,
+  aside
+}) {
+  const { colors } = useTerminalStyle();
+  return /* @__PURE__ */ jsxs8(Box9, { width: "100%", backgroundColor: colors.band, paddingX: 3, paddingY: 1, children: [
+    /* @__PURE__ */ jsx13(Text9, { color: colors.prompt, children: "\u276F " }),
+    /* @__PURE__ */ jsx13(Box9, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: /* @__PURE__ */ jsx13(Text9, { color: command ? colors.skill : colors.fg, children: cleanText(text) }) }),
+    aside && /* @__PURE__ */ jsx13(Box9, { paddingLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsx13(Text9, { color: colors.muted, children: cleanText(aside) }) })
+  ] });
+}
+function Welcome({
+  section,
+  ...selection
+}) {
+  const { colors, width } = useTerminalStyle();
+  return /* @__PURE__ */ jsxs8(
+    Box9,
+    {
+      borderStyle: "round",
+      borderColor: colors.line,
+      paddingX: 2,
+      paddingY: 1,
+      gap: 5,
+      alignItems: "center",
+      children: [
+        section.logo && width >= 90 && /* @__PURE__ */ jsx13(Text9, { color: colors.muted, children: cleanText(section.logo) }),
+        /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minWidth: 0, children: [
+          /* @__PURE__ */ jsx13(Markdown, { text: section.markdown, home: true, compact: true }),
+          section.menu && selection.items.length > 0 && /* @__PURE__ */ jsx13(PageList, { ...selection, compact: true })
+        ] })
+      ]
+    }
+  );
+}
+function HomeSections({ page }) {
+  const { colors } = useTerminalStyle();
+  return /* @__PURE__ */ jsx13(Box9, { flexDirection: "column", gap: 1, children: page.sections?.map(
+    (section) => section.kind === "welcome" ? /* @__PURE__ */ jsx13(Welcome, { section, items: page.items }, "welcome") : /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx13(Prompt, { text: section.prompt }),
+      /* @__PURE__ */ jsx13(Box9, { flexDirection: "column", paddingX: 3, gap: 1, children: section.list ? /* @__PURE__ */ jsxs8(Fragment, { children: [
+        section.list.before && /* @__PURE__ */ jsx13(Markdown, { text: section.list.before, home: true }),
+        section.list.kind === "posts" && !section.list.items.length && /* @__PURE__ */ jsx13(Text9, { color: colors.muted, children: page.postsStatus === "error" ? "\u6587\u7AE0\u6682\u65F6\u65E0\u6CD5\u52A0\u8F7D\uFF0C\u8F93\u5165 /refresh \u91CD\u8BD5\u3002" : page.postsStatus === "loading" ? "\u6B63\u5728\u52A0\u8F7D\u6587\u7AE0\u2026" : "\u6682\u65E0\u6587\u7AE0\u3002" }),
+        /* @__PURE__ */ jsx13(HomeList, { list: section.list }),
+        section.list.after && /* @__PURE__ */ jsx13(Markdown, { text: section.list.after, home: true })
+      ] }) : /* @__PURE__ */ jsx13(Markdown, { text: section.markdown, home: true }) })
+    ] }, section.prompt)
+  ) });
+}
+
+// packages/cli/src/chat.tsx
+import { jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+function MessageBody({ message }) {
+  const { colors } = useTerminalStyle();
+  if (message.role === "user") {
+    return /* @__PURE__ */ jsx14(Box10, { flexDirection: "column", marginY: 1, children: /* @__PURE__ */ jsx14(
+      Prompt,
+      {
+        aside: message.createdAt.toLocaleTimeString("zh-CN", {
+          hour: "2-digit",
+          minute: "2-digit"
+        }),
+        text: message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")
+      }
+    ) });
+  }
+  if (message.role !== "assistant") return null;
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", paddingX: 3, marginBottom: 1, children: [
+    message.content.map((part, index) => {
+      if (part.type === "text") return /* @__PURE__ */ jsx14(Markdown, { text: part.text }, index);
+      if (part.type === "reasoning") {
+        return /* @__PURE__ */ jsx14(
+          ThinkingBlock,
+          {
+            content: part.text,
+            streaming: message.status.type === "running" && index === message.content.length - 1
+          },
+          index
+        );
+      }
+      if (part.type === "tool-call") {
+        const { verb, target } = getToolHeader(part);
+        const failed = part.isError || part.result === void 0 && message.status.type === "incomplete";
+        return /* @__PURE__ */ jsx14(
+          Tool,
+          {
+            verb,
+            target,
+            detail: failed ? "\u6267\u884C\u5931\u8D25" : part.result === void 0 ? void 0 : cleanText(String(part.result)),
+            state: part.result === void 0 && message.status.type === "running" ? "running" : failed ? "error" : void 0
+          },
+          part.toolCallId
+        );
+      }
+      return null;
+    }),
+    message.status.type === "incomplete" && message.status.reason === "error" && /* @__PURE__ */ jsx14(Text10, { color: colors.err, children: "\u25C6 AI \u6682\u65F6\u65E0\u6CD5\u56DE\u590D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002" })
+  ] });
+}
+function Message() {
+  const message = useAuiState((state) => state.message);
+  return /* @__PURE__ */ jsx14(MessageBody, { message });
+}
+function ChatThread() {
+  return /* @__PURE__ */ jsx14(ThreadPrimitive.Messages, { components: { Message } });
+}
+
+// packages/cli/src/composer.tsx
+import { useAui, useAuiState as useAuiState2 } from "@assistant-ui/react-ink";
+import {
+  Box as Box18,
+  Text as Text18,
+  useBoxMetrics as useBoxMetrics7,
+  useFocus as useFocus5,
+  useFocusManager as useFocusManager2,
+  useInput as useInput8
+} from "ink";
+import { useEffect as useEffect6, useEffectEvent, useRef as useRef9 } from "react";
+
+// src/agent/appearance.ts
+var composerPlaceholder = "\u95EE\u70B9\u4EC0\u4E48\uFF0C\u6216\u8F93\u5165 / \u67E5\u770B\u547D\u4EE4";
+var composerBrand = { mark: "<MT/>", model: "V3.14 Pro" };
+
+// src/utils/tags.ts
+function getTagSlug(tag) {
+  return encodeURIComponent(tag);
+}
+function getTagPath(tag) {
+  return `/tags/${getTagSlug(tag)}/`;
+}
+
+// src/agent/commands.ts
+var commands = [
+  { id: "help", description: "\u67E5\u770B\u53EF\u7528\u547D\u4EE4" },
+  { id: "theme", args: "[\u4E3B\u9898]", description: "\u5207\u6362\u4E3B\u9898\uFF0C\u4E0D\u5E26\u53C2\u6570\u65F6\u6253\u5F00\u9009\u62E9\u5668" },
+  { id: "clear", description: "\u6E05\u7A7A\u5F53\u524D\u5BF9\u8BDD" },
+  { id: "home", description: "\u6253\u5F00\u9996\u9875" },
+  { id: "blog", description: "\u6D4F\u89C8\u5168\u90E8\u6587\u7AE0" },
+  { id: "projects", description: "\u67E5\u770B\u6298\u817E\u7684\u9879\u76EE" },
+  { id: "tags", args: "[\u6807\u7B7E]", description: "\u6309\u6807\u7B7E\u6D4F\u89C8\u6587\u7AE0" },
+  { id: "search", args: "[\u5173\u952E\u8BCD]", description: "\u641C\u7D22\u6587\u7AE0" },
+  { id: "about", description: "\u5173\u4E8E\u672C\u7AD9" },
+  { id: "rss", description: "\u8BA2\u9605 RSS" }
+];
+var pageCommands = {
+  home: "/",
+  blog: "/blog/",
+  projects: "/projects/",
+  tags: "/tags/",
+  about: "/about/"
+};
+function getCommandPath(name, args = "") {
+  if (name === "blog" && /^[1-9]\d*$/.test(args))
+    return args === "1" ? "/blog/" : `/blog/${args}/`;
+  if (name === "search")
+    return getSearchPath(args);
+  if (name === "tags" && args)
+    return getTagPath(args);
+  return Object.hasOwn(pageCommands, name) ? pageCommands[name] : void 0;
+}
+function parseCommand(input) {
+  const match = input.trim().match(/^\/(\S+)(?:\s+([\s\S]*))?$/);
+  if (!match)
+    return null;
+  return { name: match[1].toLowerCase(), args: (match[2] ?? "").trim() };
+}
+function getSearchPath(query) {
+  return query ? `/search/?q=${encodeURIComponent(query)}` : "/search/";
+}
+
+// packages/cli/src/command-menu.tsx
+import { Box as Box11, Text as Text11, useInput as useInput3 } from "ink";
+import { useImperativeHandle, useState as useState5 } from "react";
+
+// packages/cli/src/commands.ts
+var terminalCommands = [
+  ...commands,
+  { id: "read", args: "<slug \u6216\u8DEF\u5F84>", description: "\u9605\u8BFB\u6587\u7AE0\u5168\u6587" },
+  { id: "open", args: "[URL]", description: "\u5728\u6D4F\u89C8\u5668\u6253\u5F00\u5F53\u524D\u9875\u9762\u6216\u94FE\u63A5" },
+  { id: "refresh", description: "\u4ECE\u5B98\u7F51\u5237\u65B0\u5F53\u524D\u9875\u9762" },
+  { id: "quit", description: "\u9000\u51FA" }
+];
+function getCommandSuggestions(text) {
+  const match = text.match(/^\/([^\s]*)$/);
+  if (!match) return null;
+  const query = match[1].toLowerCase();
+  return terminalCommands.filter(
+    (command) => command.id.includes(query) || command.description.toLowerCase().includes(query)
+  );
+}
+function numberedItem(input, page) {
+  if (!/^\d+$/.test(input)) return void 0;
+  const item = page.items[Number(input) - 1];
+  if (!item) throw new Error("\u8BE5\u7F16\u53F7\u8D85\u51FA\u5F53\u524D\u5217\u8868\u8303\u56F4\uFF0C\u8BF7\u4F7F\u7528\u6587\u7AE0 slug \u6216\u8DEF\u5F84\u3002");
+  return item;
+}
+function resolveReadPath(input, page) {
+  if (!input) throw new Error("\u8F93\u5165 /read <slug \u6216\u7AD9\u5185\u8DEF\u5F84> \u9605\u8BFB\u6587\u7AE0\u3002");
+  const item = numberedItem(input, page);
+  if (item) {
+    if (item.external || !item.path.startsWith("/posts/"))
+      throw new Error("\u8FD9\u4E2A\u7F16\u53F7\u4E0D\u662F\u6587\u7AE0\uFF0C\u8BF7\u4F7F\u7528 /blog \u6216 /search \u67E5\u627E\u6587\u7AE0\u3002");
+    return item.path;
+  }
+  return input.startsWith("/") ? input : `/posts/${input.replace(/\/$/, "")}/`;
+}
+function resolveOpenTarget(input, page) {
+  return numberedItem(input, page)?.path ?? (input || page.path);
+}
+function resolveTagPath(input, index) {
+  if (!index.tags.length) return getTagPath(input);
+  const tag = index.tags.find((tag2) => tag2.name === input);
+  if (!tag) throw new Error("\u627E\u4E0D\u5230\u8FD9\u4E2A\u6807\u7B7E\uFF0C\u8BF7\u4F7F\u7528 /tags \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u3002");
+  return tag.path;
+}
+
+// packages/cli/src/command-menu.tsx
+import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
+function CommandMenu({
+  text,
+  focused,
+  availableHeight,
+  onSelect,
+  ref
+}) {
+  const { colors } = useTerminalStyle();
+  const [selected, setSelected] = useState5(0);
+  const [dismissed, setDismissed] = useState5(false);
+  const suggestions = getCommandSuggestions(text);
+  const matches = suggestions ?? [];
+  const open = focused && suggestions !== null && !dismissed;
+  const visibleCount = Math.max(1, Math.min(8, availableHeight - 4));
+  const start = Math.max(0, selected - visibleCount + 1);
+  useImperativeHandle(ref, () => ({
+    isOpen: () => open,
+    submit: (input) => {
+      if (!open || input !== text || !matches.length) return false;
+      onSelect(matches[selected]);
+      return true;
+    },
+    dismiss: () => {
+      if (!open) return false;
+      setDismissed(true);
+      return true;
+    }
+  }));
+  useInput3(
+    (_input, key) => {
+      if (!matches.length) return;
+      const direction = Number(key.downArrow) - Number(key.upArrow);
+      if (direction) setSelected((index) => (index + direction + matches.length) % matches.length);
+    },
+    { isActive: open }
+  );
+  if (!open) return null;
+  return /* @__PURE__ */ jsxs10(
+    MouseArea,
+    {
+      onClick: () => {
+      },
+      onWheel: (direction) => {
+        if (matches.length)
+          setSelected((index) => (index + direction + matches.length) % matches.length);
+      },
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: colors.line,
+      backgroundColor: colors.bg,
+      paddingX: 1,
+      marginBottom: 1,
+      children: [
+        matches.length === 0 && /* @__PURE__ */ jsx15(Text11, { color: colors.muted, children: "\u6CA1\u6709\u5339\u914D\u7684\u547D\u4EE4" }),
+        matches.slice(start, start + visibleCount).map((command, index) => {
+          const active = start + index === selected;
+          return /* @__PURE__ */ jsxs10(
+            MouseArea,
+            {
+              onClick: () => onSelect(command),
+              height: 1,
+              backgroundColor: active ? colors.band : void 0,
+              children: [
+                /* @__PURE__ */ jsx15(Box11, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsxs10(Text11, { color: colors.skill, children: [
+                  active ? "\u25B8" : " ",
+                  " /",
+                  command.id
+                ] }) }),
+                /* @__PURE__ */ jsx15(Box11, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx15(Text11, { color: colors.muted, wrap: "truncate-end", children: command.description }) })
+              ]
+            },
+            command.id
+          );
+        }),
+        /* @__PURE__ */ jsx15(Text11, { color: colors.muted, wrap: "truncate-end", children: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u786E\u8BA4 \xB7 Tab \u5207\u6362\u7126\u70B9 \xB7 Esc \u5173\u95ED" })
+      ]
+    }
+  );
+}
+
+// packages/cli/src/composer-input.tsx
+import { Box as Box12, Text as Text12, useBoxMetrics as useBoxMetrics4, useInput as useInput4, useWindowSize } from "ink";
+import { useRef as useRef6, useState as useState6 } from "react";
+
+// packages/cli/src/input-editor.ts
+import stringWidth2 from "string-width";
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function editorLines(text, width) {
+  const lines = [];
+  let start = 0;
+  let columns = 0;
+  for (const { segment, index } of segmenter.segment(text)) {
+    if (segment === "\n") {
+      lines.push({ start, end: index, text: text.slice(start, index) });
+      if (columns >= width) lines.push({ start: index, end: index, text: "" });
+      start = index + 1;
+      columns = 0;
+      continue;
+    }
+    const size = stringWidth2(segment);
+    if (columns && columns + size > width) {
+      lines.push({ start, end: index, text: text.slice(start, index) });
+      start = index;
+      columns = 0;
+    }
+    columns += size;
+  }
+  lines.push({ start, end: text.length, text: text.slice(start) });
+  if (columns >= width) lines.push({ start: text.length, end: text.length, text: "" });
+  return lines;
+}
+function cursorRow(lines, cursor) {
+  return lines.findLastIndex((line) => line.start <= cursor);
+}
+function editText(state, start, end, inserted = "") {
+  return {
+    text: state.text.slice(0, start) + inserted + state.text.slice(end),
+    cursor: start + inserted.length
+  };
+}
+function moveCursor(state, direction) {
+  const boundaries = [...segmenter.segment(state.text)].map((part) => part.index);
+  boundaries.push(state.text.length);
+  const cursor = direction < 0 ? boundaries.findLast((index) => index < state.cursor) ?? 0 : boundaries.find((index) => index > state.cursor) ?? state.text.length;
+  return { text: state.text, cursor };
+}
+function moveVertical(state, width, direction) {
+  const lines = editorLines(state.text, width);
+  const row = cursorRow(lines, state.cursor);
+  const column = state.column ?? stringWidth2(state.text.slice(lines[row].start, state.cursor));
+  const target = lines[Math.max(0, Math.min(lines.length - 1, row + direction))];
+  let cursor = target.start;
+  let cells = 0;
+  for (const { segment, index } of segmenter.segment(target.text)) {
+    cells += stringWidth2(segment);
+    if (cells > column) break;
+    cursor = target.start + index + segment.length;
+  }
+  return { text: state.text, cursor, column };
+}
+function wordCursor(state, direction) {
+  if (direction < 0) {
+    return state.cursor - (state.text.slice(0, state.cursor).match(/\S+\s*$|\s+$/u)?.[0].length ?? 0);
+  }
+  return state.cursor + (state.text.slice(state.cursor).match(/^\s*\S*/u)?.[0].length ?? 0);
+}
+function updateEditor(state, input, key, width) {
+  const { text, cursor } = state;
+  if (key.escape || key.tab || key.pageUp || key.pageDown) return;
+  if (key.upArrow || key.downArrow) return moveVertical(state, width, key.upArrow ? -1 : 1);
+  if (key.leftArrow || key.rightArrow) {
+    const direction = key.leftArrow ? -1 : 1;
+    return key.ctrl || key.meta ? { text, cursor: wordCursor(state, direction) } : moveCursor(state, direction);
+  }
+  const start = cursor === 0 ? 0 : text.lastIndexOf("\n", cursor - 1) + 1;
+  const nextBreak = text.indexOf("\n", cursor);
+  const end = nextBreak < 0 ? text.length : nextBreak;
+  if (key.home || key.ctrl && input === "a") return { text, cursor: start };
+  if (key.end || key.ctrl && input === "e") return { text, cursor: end };
+  if (key.return || key.ctrl && input === "j") return editText(state, cursor, cursor, "\n");
+  if (key.ctrl) {
+    if (input === "u") return editText(state, start, cursor);
+    if (input === "k") return editText(state, cursor, end);
+    if (input === "w") return editText(state, wordCursor(state, -1), cursor);
+    return;
+  }
+  if (key.backspace) return editText(state, moveCursor(state, -1).cursor, cursor);
+  if (key.delete) return editText(state, cursor, moveCursor(state, 1).cursor);
+  if (key.meta) return;
+  const inserted = input.replace(/\r\n?/g, "\n").replace(/\t/g, "  ").replace(new RegExp("\\p{Cc}", "gu"), (character) => character === "\n" ? character : "");
+  if (inserted) return editText(state, cursor, cursor, inserted);
+}
+
+// packages/cli/src/composer-input.tsx
+import { Fragment as Fragment2, jsx as jsx16, jsxs as jsxs11 } from "react/jsx-runtime";
+function ComposerInput({
+  value,
+  focused,
+  onChange,
+  onSubmit,
+  ignoreArrows,
+  placeholder = composerPlaceholder
+}) {
+  const { colors, width: availableWidth } = useTerminalStyle();
+  const { rows } = useWindowSize();
+  const container = useRef6(null);
+  const { clientWidth } = useBoxMetrics4(container);
+  const width = Math.max(1, clientWidth || availableWidth - 5);
+  const maximum = Math.max(1, Math.min(10, rows - 8));
+  const [editor, setEditor] = useState6({ text: value, cursor: value.length });
+  const [offset, setOffset] = useState6(0);
+  const state = editor.text === value ? editor : { text: value, cursor: value.length };
+  if (state !== editor) setEditor(state);
+  const lines = editorLines(value, width);
+  const row = cursorRow(lines, state.cursor);
+  const height = Math.min(maximum, lines.length);
+  const start = Math.max(0, Math.min(offset, lines.length - height, row));
+  const visibleStart = row >= start + height ? row - height + 1 : start;
+  if (visibleStart !== offset) setOffset(visibleStart);
+  useInput4(
+    (input, key) => {
+      if (key.return && !key.shift && !key.meta) {
+        onSubmit(value);
+        return;
+      }
+      if (ignoreArrows() && (key.upArrow || key.downArrow)) return;
+      const next = updateEditor(state, input, key, width);
+      if (!next) return;
+      setEditor(next);
+      if (next.text !== value) onChange(next.text);
+    },
+    { isActive: focused }
+  );
+  return /* @__PURE__ */ jsx16(Box12, { ref: container, flexGrow: 1, minWidth: 0, height, flexDirection: "column", children: lines.slice(visibleStart, visibleStart + height).map((line, index) => {
+    const current = visibleStart + index === row;
+    const cursor = current ? state.cursor - line.start : -1;
+    const after = current ? moveCursor(state, 1).cursor - line.start : -1;
+    return /* @__PURE__ */ jsx16(Text12, { color: colors.fg, wrap: "truncate-end", children: !value ? /* @__PURE__ */ jsxs11(Text12, { color: colors.muted, children: [
+      /* @__PURE__ */ jsx16(Text12, { inverse: focused, children: placeholder[0] }),
+      placeholder.slice(1)
+    ] }) : current && focused ? /* @__PURE__ */ jsxs11(Fragment2, { children: [
+      line.text.slice(0, cursor),
+      /* @__PURE__ */ jsx16(Text12, { inverse: true, children: line.text.slice(cursor, after) || " " }),
+      line.text.slice(after)
+    ] }) : line.text || " " }, line.start);
+  }) });
+}
+
+// packages/cli/src/panels.tsx
+import { Box as Box15, Text as Text15, useBoxMetrics as useBoxMetrics6, useInput as useInput7 } from "ink";
+import { useContext as useContext6, useImperativeHandle as useImperativeHandle3, useRef as useRef8, useState as useState9 } from "react";
+
+// packages/cli/src/scroll-area.tsx
+import { Box as Box13, Text as Text13, measureElement as measureElement2, useBoxMetrics as useBoxMetrics5, useFocus as useFocus3, useInput as useInput5 } from "ink";
+import { useImperativeHandle as useImperativeHandle2, useRef as useRef7, useState as useState7 } from "react";
+import { jsx as jsx17, jsxs as jsxs12 } from "react/jsx-runtime";
+function revealOffset(element, content, viewport, offset, height, maximum) {
+  let parent = element;
+  while (parent && parent !== content) parent = parent.parentNode;
+  if (!parent || !viewport) return offset;
+  const item = measureElement2(element);
+  const top = item.y - measureElement2(viewport).y;
+  if (top < offset || item.height > height) return Math.max(0, top);
+  if (top + item.height > offset + height) return Math.min(maximum, top + item.height - height);
+  return offset;
+}
+function ScrollArea({
+  children,
+  active = true,
+  ref
+}) {
+  const { colors } = useTerminalStyle();
+  const { isFocused, focus } = useFocus3({ id: "content", isActive: active });
+  const viewport = useRef7(null);
+  const content = useRef7(null);
+  const { clientHeight: height } = useBoxMetrics5(viewport);
+  const { height: contentHeight } = useBoxMetrics5(content);
+  const [anchor, setAnchor] = useState7(0);
+  const maximum = Math.max(0, contentHeight - height);
+  const offset = anchor === "end" ? maximum : Math.min(anchor, maximum);
+  useImperativeHandle2(
+    ref,
+    () => ({
+      end: () => setAnchor("end"),
+      reveal: (element) => setAnchor(
+        revealOffset(element, content.current, viewport.current, offset, height, maximum)
+      )
+    }),
+    [offset, height, maximum]
+  );
+  useInput5(
+    (_input, key) => {
+      let next = offset;
+      if (key.pageUp) next -= Math.max(1, height - 1);
+      else if (key.pageDown) next += Math.max(1, height - 1);
+      else if (isFocused && key.upArrow) next--;
+      else if (isFocused && key.downArrow) next++;
+      else if (isFocused && key.home) next = 0;
+      else if (isFocused && key.end) next = maximum;
+      else return;
+      setAnchor(next >= maximum ? "end" : Math.max(0, next));
+    },
+    { isActive: active }
+  );
+  const track = Math.max(0, height);
+  const thumbSize = Math.min(
+    track,
+    Math.max(1, Math.round(height * height / Math.max(1, contentHeight)))
+  );
+  const thumbTop = maximum > 0 ? Math.round(offset / maximum * (height - thumbSize)) : 0;
+  const before = Array(thumbTop).fill("\u2502").join("\n");
+  const thumb = Array(thumbSize).fill("\u2503").join("\n");
+  const after = Array(Math.max(0, track - thumbTop - thumbSize)).fill("\u2502").join("\n");
+  return /* @__PURE__ */ jsxs12(
+    MouseArea,
+    {
+      mouseEnabled: active,
+      onClick: () => focus("content"),
+      onWheel: (direction) => setAnchor(
+        (current) => Math.max(
+          0,
+          Math.min(
+            maximum,
+            (current === "end" ? maximum : Math.min(current, maximum)) + direction * 3
+          )
+        )
+      ),
+      flexGrow: 1,
+      flexShrink: 1,
+      minHeight: 1,
+      marginX: 2,
+      children: [
+        /* @__PURE__ */ jsx17(
+          Box13,
+          {
+            ref: viewport,
+            flexDirection: "column",
+            flexGrow: 1,
+            flexShrink: 1,
+            overflow: "hidden",
+            contentOffsetY: offset,
+            children: /* @__PURE__ */ jsx17(Box13, { ref: content, flexDirection: "column", flexShrink: 0, width: "100%", children })
+          }
+        ),
+        /* @__PURE__ */ jsx17(Box13, { width: 1, flexShrink: 0, "aria-hidden": true, children: /* @__PURE__ */ jsxs12(Text13, { color: colors.line, children: [
+          before,
+          before && "\n",
+          /* @__PURE__ */ jsx17(Text13, { color: isFocused ? colors.accent : colors.muted, children: thumb }),
+          after && "\n",
+          after
+        ] }) })
+      ]
+    }
+  );
+}
+
+// packages/cli/src/theme-picker.tsx
+import { Box as Box14, Text as Text14, useFocus as useFocus4, useInput as useInput6 } from "ink";
+import { useEffect as useEffect4, useState as useState8 } from "react";
+import { jsx as jsx18, jsxs as jsxs13 } from "react/jsx-runtime";
+function ThemePicker({
+  initial,
+  visibleCount,
+  onPreview,
+  onApply
+}) {
+  const { colors } = useTerminalStyle();
+  const { isFocused, focus } = useFocus4({ id: "theme-picker" });
+  const [selected, setSelected] = useState8(
+    () => Math.max(
+      0,
+      themeOptions.findIndex((option) => option.id === initial)
+    )
+  );
+  useEffect4(() => {
+    focus("theme-picker");
+    return () => onPreview(void 0);
+  }, [focus, onPreview]);
+  useInput6(
+    (input, key) => {
+      const direction = Number(key.downArrow || input === "j") - Number(key.upArrow || input === "k");
+      if (direction) {
+        const next = (selected + direction + themeOptions.length) % themeOptions.length;
+        setSelected(next);
+        onPreview(themeOptions[next].id);
+      } else if (key.return) {
+        onApply(themeOptions[selected].id);
+      }
+    },
+    { isActive: isFocused }
+  );
+  const start = Math.max(0, selected - visibleCount + 1);
+  return /* @__PURE__ */ jsx18(
+    MouseArea,
+    {
+      flexDirection: "column",
+      onWheel: (direction) => {
+        const next = (selected + direction + themeOptions.length) % themeOptions.length;
+        setSelected(next);
+        onPreview(themeOptions[next].id);
+      },
+      children: themeOptions.slice(start, start + visibleCount).map((option, index) => /* @__PURE__ */ jsxs13(
+        MouseArea,
+        {
+          onClick: () => {
+            focus("theme-picker");
+            setSelected(start + index);
+            onApply(option.id);
+          },
+          backgroundColor: start + index === selected ? colors.band : void 0,
+          children: [
+            /* @__PURE__ */ jsx18(Box14, { width: 20, flexShrink: 0, children: /* @__PURE__ */ jsxs13(Text14, { color: colors.fg, bold: true, children: [
+              start + index === selected ? "\u25B8" : " ",
+              " ",
+              option.name
+            ] }) }),
+            /* @__PURE__ */ jsx18(Box14, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs13(Text14, { color: colors.muted, wrap: "truncate-end", children: [
+              option.description,
+              option.id === initial ? "\uFF08\u5F53\u524D\uFF09" : ""
+            ] }) })
+          ]
+        },
+        option.id
+      ))
+    }
+  );
+}
+
+// packages/cli/src/panels.tsx
+import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
+function PanelBox({
+  title,
+  availableHeight,
+  children,
+  hints = "Esc:\u5173\u95ED"
+}) {
+  const { colors } = useTerminalStyle();
+  const viewport = useRef8(null);
+  const content = useRef8(null);
+  const { clientHeight: height } = useBoxMetrics6(viewport);
+  const { height: contentHeight } = useBoxMetrics6(content);
+  const [offset, setOffset] = useState9(0);
+  const maximum = Math.max(0, contentHeight - height);
+  const navigation = useContext6(LinkNavigation);
+  const scroll = useRef8(null);
+  useImperativeHandle3(
+    scroll,
+    () => ({
+      end: () => setOffset(maximum),
+      reveal: (element) => setOffset(
+        (current) => revealOffset(element, content.current, viewport.current, current, height, maximum)
+      )
+    }),
+    [height, maximum]
+  );
+  useInput7((_input, key) => {
+    const direction = Number(key.pageDown) - Number(key.pageUp);
+    if (direction)
+      setOffset(
+        (current) => Math.max(0, Math.min(maximum, current + direction * Math.max(1, height - 1)))
+      );
+  });
+  return /* @__PURE__ */ jsx19(LinkNavigation, { value: navigation ? { ...navigation, scroll } : null, children: /* @__PURE__ */ jsxs14(
+    MouseArea,
+    {
+      onClick: () => {
+      },
+      onWheel: (direction) => setOffset((current) => Math.max(0, Math.min(maximum, current + direction * 3))),
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: colors.line,
+      backgroundColor: colors.bg,
+      paddingX: 2,
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsx19(Text15, { color: colors.fg, bold: true, children: title }),
+        /* @__PURE__ */ jsx19(
+          Box15,
+          {
+            ref: viewport,
+            flexDirection: "column",
+            maxHeight: Math.max(1, availableHeight - 5),
+            overflow: "hidden",
+            contentOffsetY: Math.min(offset, maximum),
+            children: /* @__PURE__ */ jsx19(
+              Box15,
+              {
+                ref: content,
+                flexDirection: "column",
+                flexShrink: 0,
+                marginY: availableHeight >= 8 ? 1 : 0,
+                children
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs14(Text15, { color: colors.muted, wrap: "truncate-end", children: [
+          hints,
+          maximum > 0 ? " \u2502 PgUp/PgDn:\u6EDA\u52A8" : ""
+        ] })
+      ]
+    }
+  ) });
+}
+function TerminalPanels({
+  panel,
+  availableHeight,
+  savedTheme,
+  onPreviewTheme,
+  onApplyTheme,
+  site
+}) {
+  const { colors } = useTerminalStyle();
+  if (!panel) return null;
+  if (panel.type === "theme") {
+    return /* @__PURE__ */ jsx19(
+      PanelBox,
+      {
+        title: "\u9009\u62E9\u4E3B\u9898",
+        availableHeight,
+        hints: "\u2191\u2193:\u9884\u89C8 \u2502 Enter:\u5E94\u7528 \u2502 Esc:\u53D6\u6D88",
+        children: /* @__PURE__ */ jsx19(
+          ThemePicker,
+          {
+            initial: savedTheme,
+            visibleCount: Math.max(1, availableHeight - (availableHeight >= 8 ? 7 : 5)),
+            onPreview: onPreviewTheme,
+            onApply: onApplyTheme
+          }
+        )
+      }
+    );
+  }
+  if (panel.type === "help") {
+    return /* @__PURE__ */ jsxs14(PanelBox, { title: "\u547D\u4EE4", availableHeight, children: [
+      terminalCommands.map((command) => /* @__PURE__ */ jsxs14(Box15, { children: [
+        /* @__PURE__ */ jsx19(Box15, { width: 20, flexShrink: 0, children: /* @__PURE__ */ jsxs14(Text15, { color: colors.skill, children: [
+          "/",
+          command.id,
+          /* @__PURE__ */ jsx19(Text15, { color: colors.muted, children: command.args ? ` ${command.args}` : "" })
+        ] }) }),
+        /* @__PURE__ */ jsx19(Box15, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx19(Text15, { color: colors.muted, wrap: "truncate-end", children: command.description }) })
+      ] }, command.id)),
+      /* @__PURE__ */ jsx19(Text15, { color: colors["fg-soft"], children: "\u76F4\u63A5\u8F93\u5165\u95EE\u9898\uFF0CAI \u4F1A\u68C0\u7D22\u5168\u7AD9\u6587\u7AE0\u540E\u56DE\u7B54\uFF0C\u4E5F\u80FD\u5E2E\u4F60\u5207\u6362\u4E3B\u9898\u3001\u6253\u5F00\u9875\u9762\u3002" })
+    ] });
+  }
+  if (panel.type === "rss") {
+    return /* @__PURE__ */ jsx19(PanelBox, { title: "\u8BA2\u9605", availableHeight, children: /* @__PURE__ */ jsx19(
+      Markdown,
+      {
+        text: `RSS [${site.feedUrl}](${site.feedUrl})
+
+\u4E5F\u53EF\u4EE5\u901A\u8FC7 [Feedly](https://feedly.com/i/subscription/feed%2F${encodeURIComponent(site.feedUrl)}) \u6216 [Inoreader](https://www.inoreader.com/feed/${encodeURIComponent(site.feedUrl)}) \u8BA2\u9605\u3002`
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs14(
+    Text15,
+    {
+      color: panel.tone === "error" ? colors.err : colors["fg-soft"],
+      backgroundColor: colors.bg,
+      children: [
+        "\u25C6 ",
+        cleanText(panel.text)
+      ]
+    }
+  );
+}
+
+// packages/cli/src/components/ui/spinner.tsx
+import cliSpinners from "cli-spinners";
+import { Box as Box16, Text as Text16 } from "ink";
+
+// packages/cli/src/hooks/use-animation.ts
+import { useEffect as useEffect5, useState as useState10 } from "react";
+function useAnimation({
+  intervalMs,
+  isActive = true
+}) {
+  const [frame, setFrame] = useState10(0);
+  useEffect5(() => {
+    if (!isActive || process.env.CI || process.env.NO_MOTION) return;
+    const timer = setInterval(() => setFrame((value) => value + 1), intervalMs);
+    return () => clearInterval(timer);
+  }, [intervalMs, isActive]);
+  return frame;
+}
+
+// packages/cli/src/components/ui/spinner.tsx
+import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
+function Spinner({
+  type = "dots",
+  label,
+  color,
+  isActive = true
+}) {
+  const { colors } = useTerminalStyle();
+  const spinner = cliSpinners[type];
+  const frame = useAnimation({ intervalMs: spinner.interval, isActive });
+  return /* @__PURE__ */ jsxs15(Box16, { "aria-role": "progressbar", "aria-label": label ?? "\u52A0\u8F7D\u4E2D", "aria-state": { busy: isActive }, children: [
+    /* @__PURE__ */ jsx20(Text16, { "aria-hidden": true, color: color ?? colors.muted, children: spinner.frames[frame % spinner.frames.length] }),
+    label && /* @__PURE__ */ jsxs15(Text16, { color: colors.muted, children: [
+      " ",
+      label
+    ] })
+  ] });
+}
+
+// packages/cli/src/run-status.tsx
+import { Box as Box17, Text as Text17 } from "ink";
+import { jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
+function RunStatus({ running, loading }) {
+  const { colors } = useTerminalStyle();
+  const seconds = useElapsedTime(running, true);
+  if (!running && !loading) return null;
+  return /* @__PURE__ */ jsxs16(Box17, { paddingLeft: 3, height: 1, children: [
+    /* @__PURE__ */ jsx21(Spinner, {}),
+    /* @__PURE__ */ jsxs16(Text17, { color: colors.fg, children: [
+      " ",
+      loading ? "\u601D\u8003\u4E2D\u2026" : "\u56DE\u590D\u4E2D\u2026"
+    ] }),
+    running && /* @__PURE__ */ jsxs16(Text17, { color: colors.muted, children: [
+      " ",
+      Math.floor(seconds),
+      "s"
+    ] }),
+    /* @__PURE__ */ jsx21(Box17, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx21(Text17, { color: colors.muted, children: "[Esc \u505C\u6B62]" })
+  ] });
+}
+
+// packages/cli/src/composer.tsx
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
+function Composer({
+  runtime,
+  loading,
+  panel,
+  onCommand,
+  onCancel,
+  focusKey,
+  searchPage,
+  onSubmit,
+  ...panels
+}) {
+  const { colors } = useTerminalStyle();
+  const aui = useAui();
+  const { activeId, focus } = useFocusManager2();
+  const running = useAuiState2((state) => state.thread.isRunning);
+  const text = useAuiState2((state) => state.composer.text);
+  const menu = useRef9(null);
+  const dock = useRef9(null);
+  const { height, top } = useBoxMetrics7(dock);
+  const availableHeight = Math.max(6, top);
+  const { isFocused: focused } = useFocus5({ id: "composer", autoFocus: true });
+  const restoreComposerFocus = useEffectEvent(() => {
+    if (panel?.type !== "theme") focus(searchPage && !panel ? "search" : "composer");
+  });
+  useEffect6(() => {
+    restoreComposerFocus();
+  }, [focusKey, searchPage]);
+  useEffect6(() => {
+    if (panel?.type) restoreComposerFocus();
+  }, [panel?.type]);
+  useInput8((input, key) => {
+    if (key.escape) {
+      if (!menu.current?.dismiss()) onCancel();
+      focus("composer");
+    }
+    if (input === "/" && activeId !== "composer" && activeId !== "search") {
+      if (panel) onCancel();
+      focus("composer");
+      if (!text) aui.composer.setText("/");
+    }
+  });
+  return /* @__PURE__ */ jsxs17(Box18, { ref: dock, flexDirection: "column", marginX: 2, paddingTop: 1, flexShrink: 0, children: [
+    /* @__PURE__ */ jsx22(RunStatus, { loading, running }),
+    /* @__PURE__ */ jsxs17(
+      MouseArea,
+      {
+        onClick: () => focus("composer"),
+        borderStyle: "round",
+        borderColor: focused ? colors["line-strong"] : colors.line,
+        paddingX: 2,
+        alignItems: "flex-start",
+        children: [
+          /* @__PURE__ */ jsx22(Text18, { color: colors.prompt, children: "\u276F " }),
+          /* @__PURE__ */ jsx22(
+            ComposerInput,
+            {
+              value: text,
+              focused,
+              onChange: (value) => {
+                if (value.startsWith("/") && panel) onCancel();
+                aui.composer.setText(value);
+              },
+              ignoreArrows: () => menu.current?.isOpen() ?? false,
+              onSubmit: (text2) => {
+                const input = text2.trim();
+                if (!input) return;
+                if (menu.current?.submit(text2)) return;
+                if (input.startsWith("/")) {
+                  const command = parseCommand(input);
+                  aui.composer.setText("");
+                  void onCommand(command?.name ?? "help", command?.args ?? "");
+                } else if (!running) {
+                  onSubmit();
+                  runtime.thread.composer.send();
+                }
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx22(Box18, { position: "absolute", bottom: -1, right: 1, children: /* @__PURE__ */ jsxs17(Text18, { color: colors.muted, backgroundColor: colors.bg, children: [
+            " ",
+            composerBrand.mark,
+            " \xB7 ",
+            composerBrand.model,
+            " "
+          ] }) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs17(Box18, { justifyContent: "space-between", flexWrap: "wrap", columnGap: 2, children: [
+      /* @__PURE__ */ jsx22(Text18, { color: colors.muted, children: "Tab/Shift+Tab:\u5207\u6362 \u2502 Enter:\u6253\u5F00/\u53D1\u9001 \u2502 /:\u547D\u4EE4 \u2502 Esc:\u5173\u95ED/\u505C\u6B62" }),
+      /* @__PURE__ */ jsxs17(Box18, { columnGap: 2, children: [
+        /* @__PURE__ */ jsx22(TerminalLink, { href: panels.site.feedUrl, color: colors.muted, underline: false, children: "RSS" }),
+        panels.site.sponsorUrl && /* @__PURE__ */ jsx22(TerminalLink, { href: panels.site.sponsorUrl, color: colors.muted, underline: false, children: "\u8D5E\u8D4F" }),
+        /* @__PURE__ */ jsxs17(Text18, { color: colors.muted, children: [
+          "\xA9 ",
+          (/* @__PURE__ */ new Date()).getFullYear(),
+          " ",
+          panels.site.name
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx22(Box18, { position: "absolute", bottom: height, width: "100%", flexDirection: "column", children: /* @__PURE__ */ jsx22(LinkScope, { value: true, children: /* @__PURE__ */ jsx22(TerminalPanels, { panel, availableHeight, ...panels }) }) }),
+    /* @__PURE__ */ jsx22(Box18, { position: "absolute", bottom: height, width: "100%", flexDirection: "column", children: /* @__PURE__ */ jsx22(
+      CommandMenu,
+      {
+        ref: menu,
+        text,
+        focused,
+        availableHeight,
+        onSelect: (command) => {
+          if (command.id === "read") aui.composer.setText("/read ");
+          else {
+            aui.composer.setText("");
+            void onCommand(command.id, "");
+          }
+        }
+      },
+      text
+    ) })
+  ] });
+}
+
+// packages/cli/src/page-content.tsx
+import { Box as Box20, Text as Text23 } from "ink";
+import { memo } from "react";
+
+// packages/cli/src/article-page.tsx
+import { Box as Box19, Text as Text20 } from "ink";
+
+// packages/cli/src/components/ui/heading.tsx
+import { Text as Text19 } from "ink";
+import { jsx as jsx23 } from "react/jsx-runtime";
+function Heading({
+  level = 1,
+  children,
+  color
+}) {
+  const { colors } = useTerminalStyle();
+  const token = level <= 2 ? "h1" : level === 3 ? "h2" : level === 4 ? "h3" : "muted";
+  return /* @__PURE__ */ jsx23(Text19, { color: color ?? colors[token], bold: true, children });
+}
+
+// packages/cli/src/article-page.tsx
+import { jsx as jsx24, jsxs as jsxs18 } from "react/jsx-runtime";
+function ArticlePage({
+  post,
+  title,
+  description,
+  tool: tool2,
+  markdown
+}) {
+  const { colors } = useTerminalStyle();
+  return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", paddingX: 3, paddingTop: 1, marginBottom: 1, gap: 1, children: [
+    tool2 && /* @__PURE__ */ jsx24(Tool, { ...tool2, aside: formatShortDate(post.date) }),
+    /* @__PURE__ */ jsx24(Heading, { children: cleanText(title) }),
+    description && /* @__PURE__ */ jsx24(Text20, { color: colors.muted, children: cleanText(description) }),
+    /* @__PURE__ */ jsx24(Text20, { color: colors.muted, children: "\u2500\u2500\u2500" }),
+    /* @__PURE__ */ jsx24(Box19, { flexDirection: "column", maxWidth: 90, children: markdown && /* @__PURE__ */ jsx24(Markdown, { text: markdown }) }),
+    /* @__PURE__ */ jsxs18(LinkRow, { columnGap: 2, flexWrap: "wrap", marginTop: 1, children: [
+      post.tags.map((tag) => /* @__PURE__ */ jsxs18(TerminalLink, { href: getTagPath(tag), color: colors.muted, underline: false, children: [
+        "#",
+        cleanText(tag)
+      ] }, tag)),
+      /* @__PURE__ */ jsx24(Box19, { flexGrow: 1, justifyContent: "flex-end", children: /* @__PURE__ */ jsx24(TerminalLink, { href: "/blog/", underline: false, children: "\u2039 \u5168\u90E8\u6587\u7AE0" }) })
+    ] })
+  ] });
+}
+
+// packages/cli/src/search-input.tsx
+import { Text as Text21, useFocus as useFocus6, useInput as useInput9 } from "ink";
+import { useContext as useContext7, useEffect as useEffect7, useRef as useRef10, useState as useState11 } from "react";
+import { jsx as jsx25, jsxs as jsxs19 } from "react/jsx-runtime";
+function SearchInput({
+  path,
+  onSearch
+}) {
+  const { colors } = useTerminalStyle();
+  const active = useContext7(LinkScope);
+  const { isFocused, focus } = useFocus6({ id: "search", isActive: active });
+  const [query, setQuery] = useState11(
+    () => new URL(path, "https://miantiao.me").searchParams.get("q") ?? ""
+  );
+  const timer = useRef10(void 0);
+  useEffect7(() => () => clearTimeout(timer.current), []);
+  useEffect7(() => {
+    if (!active) clearTimeout(timer.current);
+  }, [active]);
+  useInput9((_input, key) => {
+    if (key.escape) clearTimeout(timer.current);
+  });
+  return /* @__PURE__ */ jsxs19(
+    LinkRow,
+    {
+      reveal: isFocused,
+      onClick: () => focus("search"),
+      borderStyle: "round",
+      borderColor: isFocused ? colors["line-strong"] : colors.line,
+      paddingX: 1,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsx25(Text21, { color: colors.prompt, children: "\u276F " }),
+        /* @__PURE__ */ jsx25(
+          ComposerInput,
+          {
+            value: query,
+            focused: active && isFocused,
+            placeholder: "\u641C\u7D22\u6807\u9898\u3001\u63CF\u8FF0\u3001\u6B63\u6587\u4E0E\u6807\u7B7E",
+            ignoreArrows: () => false,
+            onChange: (value) => {
+              setQuery(value);
+              clearTimeout(timer.current);
+              timer.current = setTimeout(() => onSearch(value.trim()), 300);
+            },
+            onSubmit: (value) => {
+              clearTimeout(timer.current);
+              onSearch(value.trim());
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+
+// packages/cli/src/components/ui/pagination.tsx
+import { Text as Text22 } from "ink";
+import { jsx as jsx26, jsxs as jsxs20 } from "react/jsx-runtime";
+function Pagination({
+  current,
+  total,
+  previous,
+  next
+}) {
+  const { colors } = useTerminalStyle();
+  if (total <= 1) return null;
+  return /* @__PURE__ */ jsxs20(LinkRow, { columnGap: 1, flexWrap: "wrap", children: [
+    previous ? /* @__PURE__ */ jsx26(TerminalLink, { href: previous, underline: false, children: "\u2039 \u4E0A\u4E00\u9875" }) : /* @__PURE__ */ jsx26(Text22, { color: colors.muted, children: "\u2039 \u4E0A\u4E00\u9875" }),
+    /* @__PURE__ */ jsx26(Text22, { color: colors.dim, children: "\u2502" }),
+    /* @__PURE__ */ jsxs20(Text22, { color: colors.muted, children: [
+      "\u7B2C ",
+      current,
+      " \u9875\uFF0C\u5171 ",
+      total,
+      " \u9875"
+    ] }),
+    /* @__PURE__ */ jsx26(Text22, { color: colors.dim, children: "\u2502" }),
+    next ? /* @__PURE__ */ jsx26(TerminalLink, { href: next, underline: false, children: "\u4E0B\u4E00\u9875 \u203A" }) : /* @__PURE__ */ jsx26(Text22, { color: colors.muted, children: "\u4E0B\u4E00\u9875 \u203A" })
+  ] });
+}
+
+// packages/cli/src/page-content.tsx
+import { jsx as jsx27, jsxs as jsxs21 } from "react/jsx-runtime";
+function PageEntries({ page }) {
+  const { colors } = useTerminalStyle();
+  if (page.projects)
+    return /* @__PURE__ */ jsx27(HomeList, { list: { kind: "projects", items: page.projects, before: "", after: "" } });
+  if (!page.tags) return page.items.length ? /* @__PURE__ */ jsx27(PageList, { items: page.items }) : null;
+  return /* @__PURE__ */ jsx27(Box20, { flexWrap: "wrap", columnGap: 3, children: page.tags.map((tag) => /* @__PURE__ */ jsxs21(LinkRow, { children: [
+    /* @__PURE__ */ jsxs21(TerminalLink, { href: tag.path, color: colors.fg, underline: false, children: [
+      "#",
+      cleanText(tag.name)
+    ] }),
+    /* @__PURE__ */ jsxs21(Text23, { color: colors.muted, children: [
+      " ",
+      tag.count
+    ] })
+  ] }, tag.path)) });
+}
+var PageContent = memo(function PageContent2({
+  page,
+  prompt,
+  onSearch
+}) {
+  const { colors } = useTerminalStyle();
+  if (page.sections) return /* @__PURE__ */ jsx27(HomeSections, { page });
+  if (page.post) return /* @__PURE__ */ jsx27(ArticlePage, { ...page, post: page.post });
+  return /* @__PURE__ */ jsxs21(Box20, { flexDirection: "column", marginBottom: 1, children: [
+    page.path !== "/" && /* @__PURE__ */ jsx27(Prompt, { text: page.command ?? prompt, command: true, aside: page.aside }),
+    /* @__PURE__ */ jsxs21(Box20, { flexDirection: "column", paddingX: 3, paddingTop: 1, gap: 1, children: [
+      page.tool && /* @__PURE__ */ jsx27(Tool, { ...page.tool }),
+      page.verb !== "Read" && /* @__PURE__ */ jsx27(Heading, { children: cleanText(page.title) }),
+      page.description && /* @__PURE__ */ jsx27(Text23, { color: colors["fg-soft"], children: cleanText(page.description) }),
+      page.path.startsWith("/search/") && /* @__PURE__ */ jsx27(SearchInput, { path: page.path, onSearch }),
+      page.markdown && /* @__PURE__ */ jsx27(Box20, { flexDirection: "column", maxWidth: page.verb === "Read" ? 90 : void 0, children: /* @__PURE__ */ jsx27(Markdown, { text: page.markdown }) }),
+      /* @__PURE__ */ jsx27(PageEntries, { page }),
+      page.more && /* @__PURE__ */ jsxs21(LinkRow, { children: [
+        /* @__PURE__ */ jsx27(Text23, { color: colors.muted, children: "\u203A " }),
+        /* @__PURE__ */ jsx27(TerminalLink, { href: page.more.path, children: page.more.title })
+      ] }),
+      page.pagination && /* @__PURE__ */ jsx27(Pagination, { ...page.pagination })
+    ] })
+  ] });
+});
+
+// packages/cli/src/terminal-layout.tsx
+import { Box as Box21, Text as Text24, useWindowSize as useWindowSize2 } from "ink";
+import { jsx as jsx28, jsxs as jsxs22 } from "react/jsx-runtime";
+function TerminalLayout({
+  path,
+  nav = [],
+  children
+}) {
+  const { columns, rows } = useWindowSize2();
+  const { colors } = useTerminalStyle();
+  const segments = new URL(path, "https://miantiao.me").pathname.split("/").filter(Boolean);
+  return /* @__PURE__ */ jsxs22(
+    Box21,
+    {
+      width: columns,
+      height: rows,
+      flexDirection: "column",
+      backgroundColor: colors.bg,
+      overflow: "hidden",
+      children: [
+        /* @__PURE__ */ jsxs22(Box21, { paddingX: 2, paddingY: 1, flexShrink: 0, flexDirection: columns < 70 ? "column" : "row", children: [
+          /* @__PURE__ */ jsxs22(Box21, { flexGrow: 1, flexShrink: 1, children: [
+            /* @__PURE__ */ jsx28(TerminalLink, { href: "/", color: colors.muted, underline: false, children: "~/miantiao.me" }),
+            segments.map((segment, index) => {
+              const prefix = `/${segments.slice(0, index + 1).join("/")}/`;
+              const href = segments[0] === "posts" && index < segments.length - 1 ? "/blog/" : prefix;
+              return /* @__PURE__ */ jsxs22(Box21, { flexShrink: 1, minWidth: 0, children: [
+                /* @__PURE__ */ jsx28(Text24, { color: colors.muted, children: "/" }),
+                /* @__PURE__ */ jsx28(TerminalLink, { href, color: colors.muted, underline: false, children: cleanText(decodeURIComponent(segment)) })
+              ] }, prefix);
+            })
+          ] }),
+          /* @__PURE__ */ jsx28(Box21, { columnGap: 2, flexWrap: "wrap", flexShrink: 0, children: nav.map((link) => /* @__PURE__ */ jsx28(Box21, { flexShrink: 0, children: /* @__PURE__ */ jsx28(
+            TerminalLink,
+            {
+              href: link.href,
+              color: path.startsWith(link.href) ? colors.fg : colors.muted,
+              underline: false,
+              children: cleanText(link.title)
+            }
+          ) }, link.href)) })
+        ] }),
+        children
+      ]
+    }
+  );
+}
+
+// packages/cli/src/console.tsx
+import { jsx as jsx29, jsxs as jsxs23 } from "react/jsx-runtime";
+function Console({
+  runtime,
+  page,
+  prompt,
+  locationKey,
+  site,
+  origin,
+  loading,
+  panel,
+  onCommand,
+  onCancel,
+  onSelect,
+  onSearch,
+  onClosePanel,
+  ...themePicker
+}) {
+  const scroll = useRef11(null);
+  const focusKey = String(locationKey);
+  return /* @__PURE__ */ jsx29(LinkNavigation, { value: { site: new URL(page.path, site.url).href, origin, onSelect, scroll }, children: /* @__PURE__ */ jsx29(LinkScope, { value: !panel || panel.type === "notice", children: /* @__PURE__ */ jsx29(TerminalLayout, { path: page.path, nav: site.nav, children: /* @__PURE__ */ jsxs23(ThreadPrimitive2.Root, { flexGrow: 1, flexShrink: 1, minHeight: 0, children: [
+    /* @__PURE__ */ jsxs23(ScrollArea, { ref: scroll, active: !panel || panel.type === "notice", children: [
+      /* @__PURE__ */ jsx29(PageContent, { page, prompt, onSearch }),
+      /* @__PURE__ */ jsx29(ChatThread, {})
+    ] }),
+    /* @__PURE__ */ jsx29(
+      Composer,
+      {
+        runtime,
+        focusKey,
+        searchPage: page.path.startsWith("/search/"),
+        loading,
+        panel,
+        site,
+        onCommand,
+        onCancel,
+        ...themePicker,
+        onSubmit: () => {
+          onClosePanel();
+          scroll.current?.end();
+        }
+      }
+    )
+  ] }) }, focusKey) }) });
+}
+
+// packages/cli/src/session.ts
+import { useApp, useInput as useInput10 } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect10, useState as useState13 } from "react";
+
+// packages/cli/src/preferences.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function themeFile() {
+  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "miantiao", "theme.json");
+}
+function readTheme() {
+  try {
+    return parseThemePreference(JSON.parse(readFileSync(themeFile(), "utf8"))) ?? "auto";
+  } catch {
+    return "auto";
+  }
+}
+function saveTheme(theme) {
+  try {
+    const file = themeFile();
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(theme) + "\n");
+  } catch {
+  }
+}
+
+// src/agent/command-actions.ts
+async function runSharedCommand(name, args, actions) {
+  const path = getCommandPath(name, args);
+  if (path) {
+    actions.setPanel(null);
+    await actions.navigate(path, `/${name} ${args}`.trim());
+    return true;
+  }
+  switch (name) {
+    case "help":
+    case "rss":
+      actions.setPanel({ type: name });
+      return true;
+    case "theme": {
+      if (!args) {
+        actions.setPanel({ type: "theme" });
+        return true;
+      }
+      const preference = parseThemePreference(args);
+      if (preference) {
+        actions.setTheme(preference);
+        actions.setPanel({ type: "notice", text: `\u5DF2\u5207\u6362\u5230 ${getThemeName(preference)}` });
+      } else {
+        actions.setPanel({ type: "notice", tone: "error", text: `\u672A\u77E5\u4E3B\u9898\uFF1A${args}\u3002\u53EF\u9009\uFF1A${themeOptions.map((option) => option.id).join("\u3001")}` });
+      }
+      return true;
+    }
+    case "clear":
+      actions.clear();
+      actions.setPanel(null);
+      return true;
+    default:
+      return false;
+  }
+}
+
+// packages/cli/src/agent.ts
+import { useChatRuntime } from "@assistant-ui/ai-sdk";
+import { useEffect as useEffect8, useMemo as useMemo3 } from "react";
+
+// src/agent/transport.ts
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { DirectChatTransport, isStepCount, tool, ToolLoopAgent } from "ai";
+import { z as z3 } from "zod";
+
+// src/agent/context-core.ts
+import { escapeRegExp } from "es-toolkit/string";
+function formatTime(now, timeZone) {
+  const parts = Object.fromEntries(
+    new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23",
+      timeZoneName: "longOffset"
+    }).formatToParts(now).map((part) => [part.type, part.value])
+  );
+  const offset = parts.timeZoneName === "GMT" ? "UTC+00:00" : parts.timeZoneName.replace("GMT", "UTC");
+  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute}:${parts.second} (${timeZone}, ${offset})`;
+}
+function describeDevice(userAgent, viewportWidth) {
+  const os = [
+    ["iOS", /iPhone|iPad|iPod/],
+    ["Android", /Android/],
+    ["Windows", /Windows/],
+    ["macOS", /Mac OS X|Macintosh/],
+    ["Linux", /Linux/]
+  ].find(([, pattern]) => pattern.test(userAgent))?.[0] ?? "Unknown OS";
+  const browser = [
+    ["Edge", /Edg\//],
+    ["Firefox", /Firefox\//],
+    ["Chrome", /Chrome\//],
+    ["Safari", /Safari\//]
+  ].find(([, pattern]) => pattern.test(userAgent))?.[0] ?? "Unknown browser";
+  return `${os} \xB7 ${browser} \xB7 ${viewportWidth < 768 ? "mobile" : "desktop"}`;
+}
+function buildContextMessage(context, siteName) {
+  const title = context.title.replace(new RegExp(`\\s*[|-]\\s*${escapeRegExp(siteName)}.*$`), "") || siteName;
+  const lines = [
+    `page: ${title} (${context.path})`,
+    `theme: ${context.theme}`,
+    `language: ${context.languages.slice(0, 3).join(", ")}`,
+    `time: ${formatTime(context.now, context.timeZone)}`,
+    `device: ${context.terminal ? `terminal \xB7 ${context.terminal.platform} \xB7 ${context.terminal.columns}x${context.terminal.rows}` : describeDevice(context.userAgent, context.viewportWidth)}`
+  ];
+  if (context.referrer && !context.referrer.startsWith(context.origin))
+    lines.push(`referrer: ${context.referrer}`);
+  return `<context>
+${lines.join("\n")}
+</context>`;
+}
+function retryContextMessage(message) {
+  return message.replace("\n</context>", "\nretry: 1\n</context>");
+}
+
+// src/agent/fetch.ts
+function stripSseEvent(body, eventName) {
+  const pattern = new RegExp(`^event:\\s*${eventName}\\s*$`, "m");
+  let buffer = "";
+  return body.pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
+    transform(text, controller) {
+      buffer += text;
+      const events = buffer.split(/\r?\n\r?\n/);
+      buffer = events.pop() ?? "";
+      for (const event of events) {
+        if (!pattern.test(event))
+          controller.enqueue(`${event}
+
+`);
+      }
+    },
+    flush(controller) {
+      if (buffer && !pattern.test(buffer))
+        controller.enqueue(buffer);
+    }
+  })).pipeThrough(new TextEncoderStream());
+}
+var aiSearchFetch = async (input, init) => {
+  let response = await fetch(input, init);
+  if (response.status >= 500 && typeof init?.body === "string") {
+    const body = JSON.parse(init.body);
+    const context = body.messages[0];
+    if (context?.role === "user" && typeof context.content === "string") {
+      context.content = retryContextMessage(context.content);
+      await response.body?.cancel();
+      response = await fetch(input, { ...init, body: JSON.stringify(body) });
+    }
+  }
+  if (!response.ok || !response.body || !response.headers.get("content-type")?.includes("text/event-stream"))
+    return response;
+  return new Response(stripSseEvent(response.body, "chunks"), response);
+};
+
+// src/agent/transport.ts
+var themeIds = themeOptions.map((option) => option.id);
+function createAgentTransport(handlers, options) {
+  const provider = createOpenAICompatible({
+    name: "miantiao",
+    baseURL: options.baseUrl,
+    fetch: aiSearchFetch
+  });
+  const agent = new ToolLoopAgent({
+    model: provider(options.model),
+    maxRetries: 0,
+    stopWhen: isStepCount(2),
+    // 工具执行后只生成答复，避免模型反复执行同一导航。
+    prepareStep: ({ stepNumber }) => stepNumber > 0 ? { toolChoice: "none" } : void 0,
+    tools: {
+      set_theme: tool({
+        description: "\u5207\u6362\u5F53\u524D\u754C\u9762\u4E3B\u9898",
+        inputSchema: z3.object({ theme: z3.enum(themeIds) }),
+        execute: async ({ theme }) => {
+          handlers.setTheme(theme);
+          return `\u5DF2\u5207\u6362\u5230 ${getThemeName(theme)}`;
+        }
+      }),
+      open_page: tool({
+        description: "\u6253\u5F00\u7AD9\u5185\u9875\u9762\uFF0C\u53C2\u6570\u4E3A\u4EE5 / \u5F00\u5934\u7684\u7AD9\u5185\u8DEF\u5F84",
+        inputSchema: z3.object({ path: z3.string().regex(/^\/(?!\/)[^\s\\]*$/) }),
+        execute: async ({ path }) => {
+          await handlers.openPage(path);
+          return `\u5DF2\u6253\u5F00 ${path}`;
+        }
+      })
+    },
+    // DirectChatTransport 以 `prompt` 传入完整的消息历史
+    prepareCall: ({ prompt, messages, ...rest }) => ({
+      ...rest,
+      messages: [
+        { role: "user", content: buildContextMessage(handlers.getContext(), options.siteName) },
+        { role: "assistant", content: "\u5DF2\u8BFB\u53D6\u4E0A\u4E0B\u6587\u3002" },
+        ...messages ?? (Array.isArray(prompt) ? prompt : [])
+      ]
+    })
+  });
+  return new DirectChatTransport({ agent, onError: () => "AI \u6682\u65F6\u65E0\u6CD5\u56DE\u590D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002" });
+}
+
+// packages/cli/src/agent.ts
+function useTerminalAgent({ site, index, page, theme, setTheme, navigate }) {
+  const transport = useMemo3(
+    () => createAgentTransport(
+      {
+        getContext: () => {
+          const locale = Intl.DateTimeFormat().resolvedOptions();
+          return {
+            title: page.title,
+            path: page.path,
+            theme,
+            languages: [locale.locale],
+            timeZone: locale.timeZone,
+            now: /* @__PURE__ */ new Date(),
+            userAgent: "",
+            viewportWidth: process.stdout.columns || 80,
+            referrer: "",
+            origin: site,
+            terminal: {
+              platform: process.platform,
+              columns: process.stdout.columns || 80,
+              rows: process.stdout.rows || 24
+            }
+          };
+        },
+        setTheme,
+        openPage: async (path) => {
+          if (!await navigate(path)) throw new Error("\u65E0\u6CD5\u6253\u5F00\u8FD9\u4E2A\u7AD9\u5185\u9875\u9762\u3002");
+        }
+      },
+      { baseUrl: index.ai.baseUrl, model: index.ai.model, siteName: index.site.name }
+    ),
+    [
+      site,
+      page.title,
+      page.path,
+      theme,
+      setTheme,
+      navigate,
+      index.ai.baseUrl,
+      index.ai.model,
+      index.site.name
+    ]
+  );
+  const runtime = useChatRuntime({ transport });
+  useEffect8(() => () => runtime.thread.cancelRun(), [runtime]);
+  return runtime;
+}
+
+// packages/cli/src/browser.ts
+import { spawn } from "node:child_process";
+async function openBrowser(input, site) {
+  const url = new URL(input, site);
+  if (!["http:", "https:", "mailto:"].includes(url.protocol))
+    throw new Error("\u53EA\u652F\u6301\u7F51\u9875\u6216\u90AE\u4EF6\u94FE\u63A5\u3002");
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, [url.href], { stdio: "ignore" });
+    child.once("error", () => reject(new Error(`\u65E0\u6CD5\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE ${url.href}`)));
+    child.once(
+      "exit",
+      (code) => code === 0 ? resolve() : reject(new Error(`\u65E0\u6CD5\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE ${url.href}`))
+    );
+  });
+}
+
+// packages/cli/src/navigation.ts
+import { useCallback, useEffect as useEffect9, useRef as useRef12, useState as useState12 } from "react";
+function useNavigation(client, initial) {
+  const [state, setState] = useState12({
+    ...initial,
+    status: "idle",
+    panel: client.warning ? { type: "notice", text: client.warning } : null,
+    prompt: "/home",
+    locationKey: 0
+  });
+  useEffect9(() => {
+    if (initial.page.postsStatus !== "loading") return;
+    const controller = new AbortController();
+    void client.getIndex(controller.signal).then((index2) => {
+      if (controller.signal.aborted) return;
+      setState(
+        (current) => current.page === initial.page ? { ...current, index: index2, page: withHomePosts(current.page, index2) } : current
+      );
+    }).catch(() => {
+      if (controller.signal.aborted) return;
+      setState(
+        (current) => current.page === initial.page ? { ...current, page: { ...current.page, postsStatus: "error" } } : current
+      );
+    });
+    return () => controller.abort();
+  }, [client, initial]);
+  const { index } = state;
+  useEffect9(() => {
+    if (index === initial.index && initial.page.postsStatus === "loading") return;
+    void client.preloadSearch(index).catch(() => void 0);
+  }, [client, index, initial]);
+  const active = useRef12(void 0);
+  useEffect9(
+    () => () => {
+      active.current?.controller.abort();
+      active.current = void 0;
+      client.cancelSearch();
+    },
+    [client]
+  );
+  const cancel = useCallback(() => {
+    active.current?.controller.abort();
+    active.current = void 0;
+    setState((current) => current.status === "idle" ? current : { ...current, status: "idle" });
+  }, []);
+  const setPanel = useCallback((panel) => {
+    setState((current) => ({ ...current, panel }));
+  }, []);
+  const notify = useCallback(
+    (text, tone) => {
+      setPanel({ type: "notice", text, tone });
+    },
+    [setPanel]
+  );
+  const navigate = useCallback(
+    async (path, prompt = path, replace = false) => {
+      if (replace && active.current && !active.current.replace) return false;
+      active.current?.controller.abort();
+      const request = { controller: new AbortController(), replace };
+      active.current = request;
+      setState((current) => ({ ...current, status: "loading", panel: null }));
+      let next;
+      try {
+        next = await loadPage(client, path, request.controller.signal, replace ? index : void 0);
+      } catch (error) {
+        if (active.current === request) {
+          active.current = void 0;
+          setState((current) => ({
+            ...current,
+            status: "idle",
+            panel: {
+              type: "notice",
+              tone: "error",
+              text: error instanceof Error ? error.message : "\u65E0\u6CD5\u8BFB\u53D6\u5B98\u7F51\u5185\u5BB9\u3002"
+            }
+          }));
+        }
+        return false;
+      }
+      if (active.current !== request) return false;
+      active.current = void 0;
+      setState((current) => ({
+        ...next,
+        status: "idle",
+        panel: client.warning ? { type: "notice", text: client.warning } : null,
+        prompt,
+        locationKey: current.locationKey + Number(!replace)
+      }));
+      return true;
+    },
+    [client, index]
+  );
+  return { ...state, navigate, setPanel, cancel, notify };
+}
+
+// packages/cli/src/session.ts
+function useTerminalSession(client, initial) {
+  const { exit } = useApp();
+  const [theme, setTheme] = useState13(readTheme);
+  useEffect10(() => saveTheme(theme), [theme]);
+  const [previewTheme, setPreviewTheme] = useState13();
+  const { index, page, prompt, locationKey, status, panel, navigate, setPanel, cancel, notify } = useNavigation(client, initial);
+  const runtime = useTerminalAgent({ site: client.site, index, page, theme, setTheme, navigate });
+  const stop = () => {
+    cancel();
+    runtime.thread.cancelRun();
+  };
+  useInput10((input, key) => {
+    if (key.ctrl && input === "c") {
+      stop();
+      exit();
+    }
+  });
+  const onClosePanel = () => {
+    setPreviewTheme(void 0);
+    setPanel(null);
+  };
+  const onCancel = () => {
+    if (panel) onClosePanel();
+    else stop();
+  };
+  const onApplyTheme = (preference) => {
+    setPreviewTheme(void 0);
+    setTheme(preference);
+    notify(`\u5DF2\u5207\u6362\u5230 ${getThemeName(preference)}`);
+  };
+  const onCommand = async (name, args) => {
+    setPreviewTheme(void 0);
+    if (name === "home" && page.path === "/") {
+      cancel();
+      setPanel(null);
+      return;
+    }
+    try {
+      if (await runSharedCommand(name, args, {
+        navigate: (path, prompt2) => navigate(name === "tags" && args ? resolveTagPath(args, index) : path, prompt2),
+        setPanel,
+        setTheme,
+        clear: () => {
+          stop();
+          runtime.thread.reset();
+        }
+      }))
+        return;
+      switch (name) {
+        case "read":
+          await navigate(resolveReadPath(args, page), `/read ${args}`);
+          break;
+        case "refresh":
+          await navigate(page.path, "/refresh");
+          break;
+        case "open":
+          await openBrowser(resolveOpenTarget(args, page), client.site);
+          break;
+        case "quit":
+          stop();
+          exit();
+          break;
+        default:
+          notify(`\u672A\u77E5\u547D\u4EE4\uFF1A/${name}\uFF0C\u8F93\u5165 /help \u67E5\u770B\u53EF\u7528\u547D\u4EE4`, "error");
+      }
+    } catch (error) {
+      notify(error instanceof Error ? error.message : "\u65E0\u6CD5\u6267\u884C\u547D\u4EE4\u3002", "error");
+    }
+  };
+  const onSelect = (path, external = false) => {
+    if (external) void onCommand("open", path);
+    else void navigate(path);
+  };
+  const onSearch = useCallback2(
+    (query) => {
+      void navigate(getSearchPath(query), `/search ${query}`.trim(), true);
+    },
+    [navigate]
+  );
+  return {
+    runtime,
+    page,
+    revision: index.revision,
+    locationKey,
+    prompt,
+    site: { ...initial.index.site, ...index.site },
+    origin: client.site,
+    loading: status === "loading",
+    panel,
+    onCommand,
+    onCancel,
+    onClosePanel,
+    onSelect,
+    onSearch,
+    theme: previewTheme ?? theme,
+    savedTheme: theme,
+    onPreviewTheme: setPreviewTheme,
+    onApplyTheme
+  };
+}
+
+// packages/cli/src/app.tsx
+import { jsx as jsx30, jsxs as jsxs24 } from "react/jsx-runtime";
+function Session({
+  client,
+  initial,
+  width
+}) {
+  const { theme, ...session } = useTerminalSession(client, initial);
+  return /* @__PURE__ */ jsx30(TerminalTheme, { preference: theme, width, children: /* @__PURE__ */ jsx30(AssistantRuntimeProvider, { runtime: session.runtime, children: /* @__PURE__ */ jsx30(Console, { ...session }) }) });
+}
+function App({ site }) {
+  const { exit } = useApp2();
+  const { columns } = useWindowSize3();
+  const [client] = useState14(() => new TerminalClient(site));
+  const [state, setState] = useState14(() => {
+    const content = bundledHome(site);
+    return content ? { status: "ready", content } : { status: "loading" };
+  });
+  const [attempt, setAttempt] = useState14(0);
+  const width = Math.max(10, columns - 5);
+  useEffect11(() => {
+    if (bundledHome(site)) return;
+    const request = new AbortController();
+    loadPage(client, "/", request.signal).then((content) => {
+      if (!request.signal.aborted) setState({ status: "ready", content });
+    }).catch((error) => {
+      if (!request.signal.aborted)
+        setState({
+          status: "error",
+          message: error instanceof Error ? error.message : "\u65E0\u6CD5\u8BFB\u53D6\u5B98\u7F51\u5185\u5BB9\u3002"
+        });
+    });
+    return () => request.abort();
+  }, [client, site, attempt]);
+  useInput11(
+    (input, key) => {
+      if (key.ctrl && input === "c" || input === "q") exit();
+      else if (state.status === "error" && (key.return || input === "r" || input === "/refresh")) {
+        setState({ status: "loading" });
+        setAttempt((value) => value + 1);
+      }
+    },
+    { isActive: state.status !== "ready" }
+  );
+  if (state.status === "ready")
+    return /* @__PURE__ */ jsx30(Session, { client, initial: state.content, width });
+  return /* @__PURE__ */ jsx30(TerminalTheme, { preference: "auto", width, children: /* @__PURE__ */ jsx30(TerminalLayout, { path: "/", children: /* @__PURE__ */ jsxs24(Box22, { flexDirection: "column", flexGrow: 1, padding: 2, children: [
+    /* @__PURE__ */ jsxs24(Text25, { children: [
+      "\u25C6 ",
+      state.status === "error" ? state.message : "\u601D\u8003\u4E2D\u2026\u2026"
+    ] }),
+    /* @__PURE__ */ jsx30(Text25, { children: state.status === "error" ? "Enter \u91CD\u8BD5 \xB7 q \u9000\u51FA" : "Ctrl+C \u9000\u51FA" })
+  ] }) }) });
+}
+async function run(site) {
+  const app = render(
+    /* @__PURE__ */ jsx30(MouseProvider, { children: /* @__PURE__ */ jsx30(App, { site }) }),
+    {
+      exitOnCtrlC: false,
+      alternateScreen: true,
+      incrementalRendering: true
+    }
+  );
+  await app.waitUntilExit();
+}
+export {
+  run
+};