create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/plugins/skill-library/client-ui.test.ts

@@ -0,0 +1,268 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { unzipSync } from "fflate";
+import { fixture, markdown } from "./test-fixture";
+
+type Element = {
+  type: unknown;
+  props: Record<string, unknown>;
+  children: unknown[];
+};
+function clientFixture() {
+  type Entry = {
+    options: { name: string; label?: () => string };
+    component: (props: unknown) => Element;
+  };
+  type Plugin = {
+    apply(ctx: unknown): void;
+    useSkill(
+      ctx: unknown,
+      workspaceId: string,
+      item: { name: string; userInvocable?: boolean },
+    ): void;
+  };
+  const entries = new Map<string, Entry>();
+  const starts: unknown[] = [];
+  const writes: unknown[] = [];
+  const items = [
+    {
+      name: "windy-case-overview",
+      displayName: "案件概述",
+      description: "汇总案件资料。",
+      source: "defaults",
+      readOnly: true,
+    },
+    {
+      name: "personal-skill",
+      displayName: "我的技能",
+      description: "处理所选资料。",
+      source: "personal",
+      readOnly: false,
+    },
+    {
+      name: "auto-only",
+      displayName: "自动技能",
+      description: "按需自动调用。",
+      source: "personal",
+      readOnly: false,
+      userInvocable: false,
+    },
+  ];
+  const values: unknown[] = ["case", items, null, false, "", "", false];
+  let index = 0;
+  let plugin!: Plugin;
+  runInNewContext(
+    readFileSync(new URL("./client.js", import.meta.url), "utf8"),
+    {
+      AbortController,
+      window: {
+        __ModuleLoader__: {
+          load(definition: {
+            factory(require: (name: string) => unknown): Plugin;
+          }) {
+            plugin = definition.factory(
+              Object.assign(
+                (name: string) =>
+                  name === "react"
+                    ? {
+                        createElement(
+                          type: unknown,
+                          props: object,
+                          ...children: unknown[]
+                        ) {
+                          return typeof type === "function"
+                            ? type({ ...props, children })
+                            : { type, props: props || {}, children };
+                        },
+                        lazy: () => "Editor",
+                        Fragment: "Fragment",
+                        useRef: () => ({ current: undefined }),
+                        useState: () => [
+                          values[index++],
+                          (value: unknown) => writes.push(value),
+                        ],
+                        useEffect() {},
+                      }
+                    : {
+                        Button: "button",
+                        IconSkillOutlineRegular: "SkillIcon",
+                      },
+                {
+                  async: async () => ({
+                    useSkill: (
+                      _ctx: unknown,
+                      workspaceId: string,
+                      item: { name: string },
+                      signal: AbortSignal,
+                    ) => {
+                      signal.throwIfAborted();
+                      starts.push([workspaceId, item.name]);
+                    },
+                  }),
+                },
+              ),
+            );
+          },
+        },
+      },
+    },
+  );
+  plugin.apply({
+    uiWorkspace: { startSession: (...args: unknown[]) => starts.push(args) },
+    slots: {
+      inject: (_slot: string, callback: () => void) => callback(),
+      register: (options: Entry["options"], component: Entry["component"]) =>
+        entries.set(options.name, { options, component }),
+    },
+  });
+  const ctx = {
+    uiWorkspace: { startSession: (...args: unknown[]) => starts.push(args) },
+  };
+  const tree = entries.get("main")!.component({
+    useWorkspaces: (
+      select: (state: {
+        items: { workspaceId: string; title: string }[];
+      }) => unknown,
+    ) =>
+      select({
+        items: [
+          { workspaceId: "global", title: "全局研判" },
+          { workspaceId: "case", title: "当前案件" },
+        ],
+      }),
+  });
+  return { tree, starts, writes, entries, plugin, ctx };
+}
+function descendants(value: unknown): Element[] {
+  if (Array.isArray(value)) return value.flatMap(descendants);
+  if (!value || typeof value !== "object" || !("type" in value)) return [];
+  const element = value as Element;
+  return [element, ...element.children.flatMap(descendants)];
+}
+test("skill grid uses one sidebar seat and the selected workspace's official slash draft", async () => {
+  const f = clientFixture();
+  expect(f.entries.has("settings.section")).toBe(false);
+  expect(f.entries.get("sidebar.panellist")!.options.label!()).toBe("技能");
+  const elements = descendants(f.tree);
+  expect(elements.find((row) => row.type === "h1")!.children).toEqual(["技能"]);
+  expect(elements.filter((row) => row.type === "SkillIcon")).toHaveLength(3);
+  expect(
+    elements.find((row) => row.props.className === "windy-skills-grid"),
+  ).toBeDefined();
+  const use = elements.find(
+    (row) => row.props["aria-label"] === "使用案件概述",
+  )!;
+  (use.props.onClick as () => void)();
+  await Promise.resolve();
+  expect(f.starts).toEqual([["case", "windy-case-overview"]]);
+  expect(
+    elements.find((row) => row.props["aria-label"] === "使用自动技能")!.props
+      .disabled,
+  ).toBe(true);
+  expect(f.starts).toHaveLength(1);
+});
+
+test("new skill opens an empty guided form instead of a prefilled Markdown template", () => {
+  const f = clientFixture();
+  const create = descendants(f.tree).find((row) =>
+    row.children.includes("新建技能"),
+  )!;
+  (create.props.onClick as () => void)();
+  expect(f.writes).toContainEqual(
+    expect.objectContaining({
+      isNew: true,
+      structured: true,
+      fields: {},
+      raw: "",
+      source: "personal",
+    }),
+  );
+});
+
+test("ZIP download uses the validated Chinese skill name while retaining importable original paths", async () => {
+  const f = await fixture();
+  const raw = markdown("chinese-title").replace(
+    "description:",
+    "metadata:\n  displayName: 案件概述\ndescription:",
+  );
+  expect((await f.call({ action: "create", raw })).status).toBe(200);
+  const response = await f.call({
+    action: "export",
+    name: "chinese-title",
+    source: "personal",
+  });
+  expect(response.status).toBe(200);
+  const disposition = response.headers.get("content-disposition")!;
+  expect(decodeURIComponent(disposition)).toContain(
+    "filename*=UTF-8''案件概述.zip",
+  );
+  expect(disposition).toContain('filename="chinese-title.zip"');
+  const blob = await response.blob();
+  expect(
+    Object.keys(unzipSync(new Uint8Array(await blob.arrayBuffer()))),
+  ).toEqual(["chinese-title/SKILL.md"]);
+  let transfer!: {
+    downloadSkill(response: Response, blob: Blob, item: { name: string }): void;
+  };
+  let download = "";
+  let clicked = false;
+  const revoked: string[] = [];
+  const link = {
+    href: "",
+    set download(value: string) {
+      download = value;
+    },
+    click() {
+      clicked = true;
+    },
+  };
+  runInNewContext(
+    readFileSync(new URL("./client.transfer.js", import.meta.url), "utf8"),
+    {
+      URL: {
+        createObjectURL: () => "blob:synthetic",
+        revokeObjectURL: (url: string) => revoked.push(url),
+      },
+      document: { createElement: () => link },
+      setTimeout: (callback: () => void) => callback(),
+      window: {
+        __ModuleLoader__: {
+          load(definition: { factory(): typeof transfer }) {
+            transfer = definition.factory();
+          },
+        },
+      },
+    },
+  );
+  transfer.downloadSkill(response, blob, { name: "chinese-title" });
+  expect(download).toBe("案件概述.zip");
+  expect(clicked).toBe(true);
+  expect(revoked).toEqual(["blob:synthetic"]);
+});
+
+test("export sanitizes filename characters and preserves non-invocable skill metadata", async () => {
+  const f = await fixture();
+  const raw = markdown("auto-only")
+    .replace("user-invocable: true", "user-invocable: false")
+    .replace(
+      "description:",
+      'metadata:\n  displayName: "材料/对照: 核查?"\ndescription:',
+    );
+  expect((await f.call({ action: "create", raw })).status).toBe(200);
+  const listed = await (await f.call({ action: "list" })).json();
+  expect(
+    listed.items.find(
+      (item: { name: string; userInvocable: boolean }) =>
+        item.name === "auto-only",
+    ).userInvocable,
+  ).toBe(false);
+  const exported = await f.call({
+    action: "export",
+    name: "auto-only",
+    source: "personal",
+  });
+  expect(
+    decodeURIComponent(exported.headers.get("content-disposition")!),
+  ).toContain("材料-对照- 核查-.zip");
+});

package/template/apps/agent-server/plugins/skill-library/client-use.test.ts

@@ -0,0 +1,158 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+
+type Action = {
+  useSkill(
+    ctx: unknown,
+    workspaceId: string,
+    item: { name: string; userInvocable?: boolean },
+    signal: AbortSignal,
+  ): Promise<void>;
+};
+let action!: Action;
+runInNewContext(
+  readFileSync(new URL("client.use.js", import.meta.url), "utf8"),
+  {
+    window: {
+      __ModuleLoader__: {
+        load: (definition: { factory(): Action }) => {
+          action = definition.factory();
+        },
+      },
+    },
+  },
+);
+function fixture(draft = "", phase = "plain", accepted = true) {
+  const snapshot = {
+    draft,
+    phase,
+    draftRev: 7,
+    attachments: ["synthetic-evidence.pdf"],
+  };
+  const connected: string[] = [],
+    opened: string[] = [];
+  let focused = 0;
+  const input = {
+    state: { getSnapshot: () => snapshot },
+    focus: () => focused++,
+  };
+  const binding = {
+    ctx: {
+      bail(
+        _ctx: unknown,
+        event: string,
+        insert: {
+          text: string;
+          span: { start: number; end: number; draftRev: number };
+        },
+      ) {
+        expect(event).toBe("slash/input-insert-text");
+        expect(insert.span).toEqual({
+          start: snapshot.draft.length,
+          end: snapshot.draft.length,
+          draftRev: 7,
+        });
+        if (accepted) snapshot.draft += insert.text;
+        return accepted;
+      },
+    },
+  };
+  const ctx = {
+    uiWorkspace: {
+      connectWorkspace: async (id: string) => {
+        connected.push(id);
+        return "target-session";
+      },
+      openSession: (id: string) => opened.push(id),
+    },
+    sessions: {
+      using: async (
+        id: string,
+        options: object,
+        callback: (reference: {
+          ready: Promise<typeof binding>;
+        }) => Promise<void>,
+      ) => {
+        expect(id).toBe("target-session");
+        expect(options).toEqual({ source: "controllerOperation" });
+        return callback({ ready: Promise.resolve(binding) });
+      },
+    },
+    conversation: {
+      input: {
+        for: (bound: unknown) => {
+          expect(bound).toBe(binding.ctx);
+          return input;
+        },
+      },
+    },
+  };
+  return {
+    ctx,
+    snapshot,
+    connected,
+    opened,
+    get focused() {
+      return focused;
+    },
+  };
+}
+test("use skill targets the chosen workspace and appends the official ID without replacing text or attachments", async () => {
+  const f = fixture("先核查这些材料。");
+  await action.useSkill(
+    f.ctx,
+    "case-workspace",
+    { name: "windy-case-overview" },
+    new AbortController().signal,
+  );
+  expect(f.connected).toEqual(["case-workspace"]);
+  expect(f.snapshot.draft).toBe("先核查这些材料。\n\n/windy-case-overview ");
+  expect(f.snapshot.attachments).toEqual(["synthetic-evidence.pdf"]);
+  expect(f.opened).toEqual(["target-session"]);
+  expect(f.focused).toBe(1);
+});
+test("empty drafts receive slash tokens and repeated use does not duplicate the selected token", async () => {
+  const f = fixture();
+  const signal = new AbortController().signal;
+  await action.useSkill(f.ctx, "global", { name: "my-skill" }, signal);
+  await action.useSkill(f.ctx, "global", { name: "my-skill" }, signal);
+  expect(f.snapshot.draft).toBe("/my-skill ");
+});
+test("non-invocable skills, invalid IDs, changed drafts and active input phases are rejected", async () => {
+  const signal = new AbortController().signal;
+  for (const [workspaceId, item] of [
+    ["", { name: "valid" }],
+    ["case", { name: "../escape" }],
+    ["case", { name: "auto", userInvocable: false }],
+  ] as const) {
+    const f = fixture();
+    await expect(
+      action.useSkill(f.ctx, workspaceId, item, signal),
+    ).rejects.toThrow();
+    expect(f.connected).toHaveLength(0);
+  }
+  for (const f of [
+    fixture("existing", "composing"),
+    fixture("existing", "plain", false),
+  ]) {
+    await expect(
+      action.useSkill(f.ctx, "case", { name: "valid" }, signal),
+    ).rejects.toThrow();
+    expect(f.opened).toHaveLength(0);
+    expect(f.snapshot.draft).toBe("existing");
+  }
+});
+test("cancellation during workspace connection cannot append or navigate after the user leaves", async () => {
+  const f = fixture("existing"),
+    controller = new AbortController();
+  f.ctx.uiWorkspace.connectWorkspace = async () => {
+    controller.abort();
+    return "target-session";
+  };
+  await expect(
+    action.useSkill(f.ctx, "case", { name: "valid" }, controller.signal),
+  ).rejects.toThrow();
+  expect(f.snapshot.draft).toBe("existing");
+  expect(f.opened).toHaveLength(0);
+});

package/template/apps/agent-server/plugins/skill-library/client.editor.js

@@ -0,0 +1,93 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-skill-library",
+  chunk: "client.editor.js",
+  factory(require) {
+    const React = require("react"),
+      h = React.createElement;
+    const { Button } = require("@deepseek-ai/dsh-client-ui-primitives");
+    const SkillForm = React.lazy(() => require.async("./client.form.js"));
+    function Editor({
+      editor,
+      busy,
+      save,
+      setEditor,
+      closeEditor,
+      exportSkill,
+      confirm,
+      setConfirm,
+      remove,
+      generate,
+      error,
+    }) {
+      const text = (value) => h("p", null, value);
+      const button = (label, onClick) =>
+        h(Button, { type: "button", disabled: busy, onClick }, label);
+      const actions = (...children) =>
+        h("div", { className: "windy-skills-actions" }, ...children);
+      if (editor.structured)
+        return h(
+          React.Suspense,
+          { fallback: text("正在打开表单…") },
+          h(SkillForm, {
+            editor,
+            setEditor,
+            busy,
+            save,
+            closeEditor,
+            generate,
+            error,
+          }),
+        );
+      return h(
+        "form",
+        { className: "windy-skills-editor", onSubmit: save },
+        h(
+          "h2",
+          null,
+          editor.isNew ? "新建个人技能" : editor.displayName || editor.name,
+        ),
+        text("请填写通用方法，移除案件材料、个人信息和凭据。"),
+        h(
+          "label",
+          null,
+          "SKILL.md 正文",
+          h("textarea", {
+            value: editor.raw,
+            required: true,
+            readOnly: editor.readOnly || busy,
+            spellCheck: false,
+            onChange: (event) =>
+              setEditor({ ...editor, raw: event.target.value }),
+          }),
+        ),
+        error ? h("p", { role: "alert" }, error) : null,
+        actions(
+          !editor.readOnly
+            ? h(
+                Button,
+                { type: "submit", disabled: busy, variant: "primary" },
+                "保存",
+              )
+            : null,
+          button("关闭", closeEditor),
+          !editor.isNew
+            ? button("导出分享包", () => exportSkill(editor))
+            : null,
+          !editor.isNew && !editor.readOnly
+            ? button("删除技能", () => setConfirm(true))
+            : null,
+        ),
+        confirm
+          ? h(
+              "div",
+              { role: "group", "aria-label": "确认删除技能" },
+              text("删除此个人技能及其附件？此操作不能撤销。"),
+              button("确认删除", remove),
+              button("取消删除", () => setConfirm(false)),
+            )
+          : null,
+      );
+    }
+    return { default: Editor };
+  },
+});