create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/plugins/tool-catalog/client.js

@@ -0,0 +1,333 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-tool-catalog",
+  factory(require) {
+    const React = require("react"),
+      h = React.createElement;
+    const {
+      Button,
+      Input,
+      Tag,
+    } = require("@deepseek-ai/dsh-client-ui-primitives");
+    async function useToolInConversation(ctx, tool, close) {
+      if (
+        !tool ||
+        typeof tool.displayName !== "string" ||
+        !tool.displayName.trim()
+      )
+        throw new Error("工具信息不可用，请刷新目录。");
+      const scope = tool.categoryLabel ? `（${tool.categoryLabel}）` : "";
+      const prompt = `请使用「${tool.displayName}」${scope}处理当前研判任务；请先确认所需信息和当前范围，参数不齐时向我询问。`;
+      const rows = Object.values(ctx.sessions.list.getSnapshot().byId);
+      const selected = rows.filter((row) => (row.retainedBy.mainView || 0) > 0);
+      if (selected.length > 1)
+        throw new Error("正在切换对话，请稍后再选择工具。");
+      const current = selected[0];
+      if (!current) {
+        ctx.uiWorkspace.startSession(undefined, {
+          prompt,
+          clearPreviousDraft: false,
+        });
+        close();
+        return;
+      }
+      await ctx.sessions.using(
+        current.id,
+        { source: "controllerOperation" },
+        async (reference) => {
+          const binding = await reference.ready;
+          const latest = Object.values(
+            ctx.sessions.list.getSnapshot().byId,
+          ).filter((row) => (row.retainedBy.mainView || 0) > 0);
+          if (latest.length !== 1 || latest[0].id !== current.id)
+            throw new Error("当前对话已切换，请重新选择工具。");
+          const input = ctx.conversation.input.for(binding.ctx),
+            snapshot = input.state.getSnapshot();
+          if (snapshot.phase !== "plain")
+            throw new Error("输入框正在处理内容，请稍后再试。");
+          if (snapshot.draft.endsWith(prompt)) {
+            ctx.uiWorkspace.openSession(current.id);
+            close();
+            input.focus();
+            return;
+          }
+          const end = snapshot.draft.length;
+          const applied = binding.ctx.bail(
+            binding.ctx,
+            "slash/input-insert-text",
+            {
+              text: `${end ? "\n\n" : ""}${prompt}`,
+              span: { start: end, end, draftRev: snapshot.draftRev },
+            },
+          );
+          if (applied !== true) throw new Error("草稿已变化，请重新选择工具。");
+          ctx.uiWorkspace.openSession(current.id);
+          close();
+          input.focus();
+        },
+      );
+    }
+    function ToolCatalogue({ close, onUse }) {
+      const [query, setQuery] = React.useState(""),
+        [page, setPage] = React.useState(1);
+      const [data, setData] = React.useState({
+        items: [],
+        total: 0,
+        pageSize: 20,
+      });
+      const [loading, setLoading] = React.useState(true),
+        [error, setError] = React.useState("");
+      const [retry, setRetry] = React.useState(0);
+      const [category, setCategory] = React.useState("");
+      const [usingTool, setUsingTool] = React.useState("");
+      const [useError, setUseError] = React.useState(null);
+      const cache = React.useRef(new Map());
+      async function choose(tool) {
+        setUsingTool(tool.name);
+        setUseError(null);
+        try {
+          await onUse(tool, close);
+        } catch (reason) {
+          setUseError({
+            name: tool.name,
+            message: reason.message || "无法使用工具，请稍后重试。",
+          });
+        } finally {
+          setUsingTool("");
+        }
+      }
+      React.useEffect(() => {
+        const controller = new AbortController();
+        const key = JSON.stringify([query, category, page]);
+        const cached = cache.current.get(key);
+        if (cached) {
+          cache.current.delete(key);
+          cache.current.set(key, cached);
+          setData(cached);
+          setError("");
+          setLoading(false);
+          return;
+        }
+        setLoading(true);
+        setError("");
+        const timer = setTimeout(async () => {
+          try {
+            const url = new URL("windy/tool-catalog", document.baseURI);
+            url.search = new URLSearchParams({
+              query,
+              page: String(page),
+              ...(category ? { category } : {}),
+            }).toString();
+            const response = await fetch(url, {
+              credentials: "same-origin",
+              signal: controller.signal,
+            });
+            if (response.status === 400 && category) {
+              setCategory("");
+              setPage(1);
+              return;
+            }
+            if (!response.ok)
+              throw new Error("工具目录暂不可用，请检查登录状态后重试。");
+            const next = await response.json();
+            if (!controller.signal.aborted) {
+              cache.current.set(key, next);
+              if (cache.current.size > 24)
+                cache.current.delete(cache.current.keys().next().value);
+              setData(next);
+            }
+          } catch (reason) {
+            if (!controller.signal.aborted) {
+              setData({ items: [], total: 0, pageSize: 20 });
+              setError(reason.message);
+            }
+          } finally {
+            if (!controller.signal.aborted) setLoading(false);
+          }
+        }, 180);
+        return () => {
+          clearTimeout(timer);
+          controller.abort();
+        };
+      }, [query, category, page, retry]);
+      return h(
+        "section",
+        { className: "windy-tool-catalog" },
+        h(
+          "header",
+          { className: "windy-tool-page-head" },
+          h(
+            "div",
+            null,
+            h("h2", null, "工具"),
+            h("p", { className: "windy-tool-intro" }, "按任务选择所需工具。"),
+          ),
+          h(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              disabled: loading,
+              onClick: () => {
+                cache.current.clear();
+                setRetry((value) => value + 1);
+              },
+            },
+            "刷新",
+          ),
+        ),
+        h(
+          "div",
+          { className: "windy-tool-toolbar" },
+          h(Input, {
+            className: "windy-tool-search",
+            "aria-label": "搜索工具",
+            placeholder: "搜索工具",
+            value: query,
+            onChange: (event) => {
+              setQuery(event.target.value);
+              setCategory("");
+              setPage(1);
+            },
+          }),
+          !loading &&
+            !error &&
+            h("span", { className: "windy-tool-count" }, `共 ${data.total} 项`),
+        ),
+        h(
+          "nav",
+          { className: "windy-tool-scopes", "aria-label": "工具业务分类" },
+          ...[
+            {
+              categoryKey: "",
+              categoryLabel: "全部",
+              count: data.matchedTotal ?? data.total,
+            },
+            ...(data.groups || []),
+          ].map((group) =>
+            h(
+              Button,
+              {
+                key: group.categoryKey,
+                size: "sm",
+                variant: category === group.categoryKey ? "outline" : "ghost",
+                "aria-pressed": category === group.categoryKey,
+                onClick: () => {
+                  setCategory(group.categoryKey);
+                  setPage(1);
+                },
+              },
+              `${group.categoryLabel} ${group.count}`,
+            ),
+          ),
+        ),
+        loading && h("p", { role: "status" }, "正在读取工具目录…"),
+        error && h("p", { role: "alert" }, error),
+        !loading &&
+          !error &&
+          data.items.length === 0 &&
+          h("p", null, "没有匹配的工具。"),
+        !loading &&
+          !error &&
+          h(
+            "ul",
+            {
+              className: "windy-tool-grid",
+              role: "list",
+              "aria-label": "工具列表",
+            },
+            ...data.items.map((tool) =>
+              h(
+                "li",
+                { key: tool.name },
+                h(
+                  "div",
+                  { className: "windy-tool-heading" },
+                  h(
+                    "h3",
+                    null,
+                    h(
+                      "button",
+                      {
+                        type: "button",
+                        className: "windy-tool-use",
+                        disabled: Boolean(usingTool),
+                        "aria-label": `使用${tool.displayName || "工具"}`,
+                        title: "带入当前对话",
+                        onClick: () => choose(tool),
+                      },
+                      usingTool === tool.name
+                        ? "正在打开…"
+                        : tool.displayName || "其他工具",
+                    ),
+                  ),
+                  h(
+                    Tag,
+                    { tone: "neutral" },
+                    tool.strategyLabel ||
+                      (tool.strategy === "on-demand" ? "按需使用" : "默认可用"),
+                  ),
+                ),
+                h(
+                  "p",
+                  { className: "windy-tool-summary" },
+                  tool.summary || "按当前权限使用。",
+                ),
+                useError?.name === tool.name &&
+                  h("p", { role: "alert" }, useError.message),
+              ),
+            ),
+          ),
+        h(
+          "nav",
+          { className: "windy-tool-pagination", "aria-label": "工具目录分页" },
+          h(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              disabled: loading || page === 1,
+              onClick: () => setPage(page - 1),
+            },
+            "上一页",
+          ),
+          h(
+            "span",
+            null,
+            `${page} / ${Math.max(1, Math.ceil(data.total / data.pageSize))}`,
+          ),
+          h(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              disabled: loading || page * data.pageSize >= data.total,
+              onClick: () => setPage(page + 1),
+            },
+            "下一页",
+          ),
+        ),
+      );
+    }
+    return {
+      useToolInConversation,
+      inject: ["slots", "sessions", "conversation", "uiWorkspace"],
+      apply(ctx) {
+        ctx.slots.inject("settings.section", () =>
+          ctx.slots.register(
+            {
+              name: "settings.section",
+              id: "windy-business-tools",
+              order: 35,
+              label: () => "工具",
+            },
+            (props) =>
+              h(ToolCatalogue, {
+                ...props,
+                onUse: (tool, close) => useToolInConversation(ctx, tool, close),
+              }),
+          ),
+        );
+      },
+    };
+  },
+});

package/template/apps/agent-server/plugins/tool-catalog/client.test.ts

@@ -0,0 +1,136 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+
+type Element = {
+  type: string;
+  props: Record<string, unknown>;
+  children: unknown[];
+};
+
+test("tool settings use Chinese cards and short display copy instead of execution metadata", () => {
+  let render!: () => Element;
+  const states: unknown[] = [
+    "",
+    1,
+    {
+      total: 2,
+      pageSize: 20,
+      matchedTotal: 2,
+      groups: [
+        { categoryKey: "case", categoryLabel: "案件", count: 1 },
+        { categoryKey: "workspace.commands", categoryLabel: "命令", count: 1 },
+      ],
+      items: [
+        {
+          name: "bash",
+          description: "Execute commands with internal DSH variables",
+          source: "dsh",
+          displayName: "执行命令",
+          summary: "运行工作区中的命令。",
+          strategy: "default",
+          strategyLabel: "默认可用",
+        },
+        {
+          name: "mcp__windy__case_search_123",
+          description: "full tool schema instructions",
+          displayName: "查询案件",
+          summary: "查找获准访问的案件。",
+          strategy: "on-demand",
+          strategyLabel: "按需使用",
+        },
+      ],
+    },
+    false,
+    "",
+    0,
+    "",
+    "",
+    null,
+  ];
+  const writes: { index: number; value: unknown }[] = [];
+  let stateIndex = 0;
+  let plugin!: { apply(ctx: unknown): void };
+  runInNewContext(readFileSync(new URL("client.js", import.meta.url), "utf8"), {
+    window: {
+      __ModuleLoader__: {
+        load: (definition: {
+          factory(require: (name: string) => unknown): typeof plugin;
+        }) => {
+          plugin = definition.factory((name) =>
+            name === "react"
+              ? {
+                  createElement: (
+                    type:
+                      | string
+                      | ((props: Record<string, unknown>) => Element),
+                    props: Record<string, unknown>,
+                    ...children: unknown[]
+                  ) =>
+                    typeof type === "function"
+                      ? type({ ...props, children })
+                      : { type, props, children },
+                  useState: () => {
+                    const index = stateIndex++;
+                    return [
+                      states.shift(),
+                      (value: unknown) => writes.push({ index, value }),
+                    ];
+                  },
+                  useEffect() {},
+                  useRef: () => ({ current: new Map() }),
+                }
+              : { Button: "button", Input: "input", Tag: "span" },
+          );
+        },
+      },
+    },
+  });
+  plugin.apply({
+    slots: {
+      inject: (_name: string, run: () => void) => run(),
+      register: (_row: unknown, component: typeof render) => {
+        render = component;
+      },
+    },
+  });
+  const tree = render();
+  const json = JSON.stringify(tree);
+  expect(json).toContain("按任务选择所需工具。");
+  expect(json).toContain("执行命令");
+  expect(json).toContain("查询案件");
+  expect(json).toContain("运行工作区中的命令。");
+  expect(json).toContain("windy-tool-grid");
+  expect(json).toContain("按需使用");
+  function visibleText(value: unknown): string {
+    if (typeof value === "string") return value;
+    if (!value || typeof value !== "object" || !("children" in value))
+      return "";
+    return (value as Element).children.map(visibleText).join(" ");
+  }
+  expect(visibleText(tree)).not.toMatch(
+    /DSH|mcp__|Execute commands|full tool schema|业务 MCP/,
+  );
+  function descendants(value: unknown): Element[] {
+    if (!value || typeof value !== "object" || !("type" in value)) return [];
+    const element = value as Element;
+    return [element, ...element.children.flatMap(descendants)];
+  }
+  const elements = descendants(tree);
+  expect(elements.filter((element) => element.type === "li")).toHaveLength(2);
+  const caseFilter = elements.find(
+    (element) =>
+      element.type === "button" && element.children.includes("案件 1"),
+  )!;
+  (caseFilter.props.onClick as () => void)();
+  expect(writes).toContainEqual({ index: 6, value: "case" });
+  expect(writes).toContainEqual({ index: 1, value: 1 });
+  expect(
+    elements.find((element) => element.props?.["aria-label"] === "使用查询案件")
+      ?.type,
+  ).toBe("button");
+  expect(elements.filter((element) => element.type === "h3")).toHaveLength(2);
+  expect(
+    elements.find((element) => element.type === "input")?.props["aria-label"],
+  ).toBe("搜索工具");
+});

package/template/apps/agent-server/plugins/tool-catalog/discovery.d.mts

@@ -0,0 +1,42 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { ToolDisplayMetadata } from "./presentation.mjs";
+export const DISCOVER: string;
+export function businessTools(
+  ctx: Context,
+  scope?: object,
+): { name: string; description: string; parameters: Record<string, unknown> }[];
+export function catalogue(
+  ctx: Context,
+  options?: {
+    query?: string;
+    category?: string;
+    page?: number;
+    includeNative?: boolean;
+    scope?: object;
+    metadata?: Map<string, ToolDisplayMetadata>;
+    pageSize?: number;
+  },
+): {
+  total: number;
+  matchedTotal: number;
+  category: string;
+  groups: { categoryKey: string; categoryLabel: string; count: number }[];
+  page: number;
+  pageSize: number;
+  items: {
+    name: string;
+    displayName: string;
+    summary: string;
+    sourceLabel: string;
+    strategyLabel: string;
+    description: string;
+    strategy: string;
+    source: string;
+    categoryKey: string;
+    categoryLabel: string;
+  }[];
+};
+export function installDiscovery(
+  ctx: Context,
+  metadata?: Map<string, ToolDisplayMetadata>,
+): void;