@coze-arch/cli 0.0.15-alpha.a0f5b9 → 0.0.15-alpha.dfd4c4

package/lib/__templates__/pi-agent/tests/feishu-channel.test.ts

@@ -1,149 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createFeishuChannel } from "../src/channels/feishu/index.js";
-
-test("feishu channel adds and removes thinking reaction around replies", async () => {
-  const operations: string[] = [];
-  let nextReactionId = 0;
-
-  const channel = createFeishuChannel(
-    {
-      thinkingReaction: {
-        enabled: true,
-        emojiType: "OneSecond"
-      },
-      transport: {
-        addReaction({ messageId, emojiType }) {
-          nextReactionId += 1;
-          operations.push(`add:${messageId}:${emojiType}`);
-          return {
-            reactionId: `reaction-${nextReactionId}`,
-            emojiType
-          };
-        },
-        removeReaction({ messageId, reactionId, emojiType }) {
-          operations.push(`remove:${messageId}:${reactionId}:${emojiType}`);
-        },
-        send(message) {
-          operations.push(`send:${message.replyToMessageId}:${message.text}`);
-        }
-      }
-    },
-    {
-      async onMessage() {
-        operations.push("handler:start");
-        await Promise.resolve();
-        operations.push("handler:end");
-        return {
-          text: "reply text"
-        };
-      }
-    }
-  );
-
-  const result = await channel.simulateIncomingText({
-    text: "hello",
-    senderId: "user-1",
-    conversationId: "dm-1",
-    isDirectMessage: true
-  });
-
-  assert.equal(result.handled, true);
-  assert.equal(result.reply?.text, "reply text");
-  assert.deepEqual(operations, [
-    `add:${result.message?.messageId}:OneSecond`,
-    "handler:start",
-    "handler:end",
-    `remove:${result.message?.messageId}:reaction-1:OneSecond`,
-    `send:${result.message?.messageId}:reply text`
-  ]);
-});
-
-test("feishu channel defaults thinking reaction emoji to OneSecond", async () => {
-  const operations: string[] = [];
-
-  const channel = createFeishuChannel(
-    {
-      transport: {
-        addReaction({ messageId, emojiType }) {
-          operations.push(`add:${messageId}:${emojiType}`);
-          return {
-            reactionId: "reaction-1",
-            emojiType
-          };
-        },
-        removeReaction({ messageId, reactionId, emojiType }) {
-          operations.push(`remove:${messageId}:${reactionId}:${emojiType}`);
-        },
-        send(message) {
-          operations.push(`send:${message.replyToMessageId}:${message.text}`);
-        }
-      }
-    },
-    {
-      onMessage() {
-        return {
-          text: "reply text"
-        };
-      }
-    }
-  );
-
-  const result = await channel.simulateIncomingText({
-    text: "hello",
-    senderId: "user-default",
-    conversationId: "dm-default",
-    isDirectMessage: true
-  });
-
-  assert.equal(result.handled, true);
-  assert.deepEqual(operations, [
-    `add:${result.message?.messageId}:OneSecond`,
-    `remove:${result.message?.messageId}:reaction-1:OneSecond`,
-    `send:${result.message?.messageId}:reply text`
-  ]);
-});
-
-test("feishu channel still replies when thinking reaction fails", async () => {
-  const operations: string[] = [];
-
-  const channel = createFeishuChannel(
-    {
-      thinkingReaction: {
-        enabled: true,
-        emojiType: "OneSecond"
-      },
-      transport: {
-        addReaction() {
-          operations.push("add-failed");
-          throw new Error("reaction unavailable");
-        },
-        send(message) {
-          operations.push(`send:${message.replyToMessageId}:${message.text}`);
-        }
-      }
-    },
-    {
-      onMessage() {
-        operations.push("handler");
-        return {
-          text: "reply after failure"
-        };
-      }
-    }
-  );
-
-  const result = await channel.simulateIncomingText({
-    text: "hello",
-    senderId: "user-2",
-    conversationId: "dm-2",
-    isDirectMessage: true
-  });
-
-  assert.equal(result.handled, true);
-  assert.deepEqual(operations, [
-    "add-failed",
-    "handler",
-    `send:${result.message?.messageId}:reply after failure`
-  ]);
-});

package/lib/__templates__/pi-agent/tests/feishu-streaming-card.test.ts

@@ -1,15 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mergeStreamingText } from "../src/channels/feishu/streaming-card.js";
-
-test("mergeStreamingText prefers progressive full-text updates", () => {
-  assert.equal(mergeStreamingText("", "hel"), "hel");
-  assert.equal(mergeStreamingText("hel", "hello"), "hello");
-  assert.equal(mergeStreamingText("hello", "hello world"), "hello world");
-});
-
-test("mergeStreamingText merges overlapping chunks without duplicating suffixes", () => {
-  assert.equal(mergeStreamingText("hello", "lo world"), "hello world");
-  assert.equal(mergeStreamingText("abc", "bcdef"), "abcdef");
-});
-

package/lib/__templates__/pi-agent/tests/pi-resources.test.ts

@@ -1,73 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { SettingsManager } from "@mariozechner/pi-coding-agent";
-import {
-  buildPiResourceLoaderOptions,
-  createPiResourceLoader,
-  getPiResourcesDir
-} from "../src/pi-resources.js";
-
-test("buildPiResourceLoaderOptions includes repo-managed resource directories", () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), "pi-bot-pi-resources-"));
-  const options = buildPiResourceLoaderOptions({
-    cwd,
-    agentDir: cwd,
-    settingsManager: SettingsManager.inMemory()
-  });
-
-  const resourcesDir = getPiResourcesDir();
-  assert.ok((options.additionalExtensionPaths ?? []).includes(path.join(resourcesDir, "extensions", "test-ping.ts")));
-  assert.ok(
-    (options.additionalExtensionPaths ?? []).includes(
-      path.join(resourcesDir, "extensions", "preference-memory", "index.ts")
-    )
-  );
-  assert.deepEqual(options.additionalSkillPaths, [path.join(resourcesDir, "skills")]);
-  assert.deepEqual(options.additionalPromptTemplatePaths, [path.join(resourcesDir, "prompts")]);
-  assert.deepEqual(options.agentsFilesOverride?.({ agentsFiles: [{ path: "/tmp/AGENTS.md", content: "x" }] }), {
-    agentsFiles: []
-  });
-});
-
-test("buildPiResourceLoaderOptions prefers local .pi SYSTEM.md over repo-managed SYSTEM.md", () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), "pi-bot-pi-resources-local-system-"));
-  mkdirSync(path.join(cwd, ".pi"), { recursive: true });
-  writeFileSync(path.join(cwd, ".pi", "SYSTEM.md"), "local-system");
-
-  const options = buildPiResourceLoaderOptions({
-    cwd,
-    agentDir: cwd,
-    settingsManager: SettingsManager.inMemory()
-  });
-
-  assert.equal(options.systemPrompt, path.join(cwd, ".pi", "SYSTEM.md"));
-});
-
-test("buildPiResourceLoaderOptions falls back to repo-managed SYSTEM.md when no local override exists", () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), "pi-bot-pi-resources-source-system-"));
-  const options = buildPiResourceLoaderOptions({
-    cwd,
-    agentDir: cwd,
-    settingsManager: SettingsManager.inMemory()
-  });
-
-  assert.equal(options.systemPrompt, path.join(getPiResourcesDir(), "SYSTEM.md"));
-});
-
-test("createPiResourceLoader loads repo-managed extensions without errors", async () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), "pi-bot-pi-resources-loader-"));
-  const loader = createPiResourceLoader({
-    cwd,
-    agentDir: cwd,
-    settingsManager: SettingsManager.inMemory()
-  });
-
-  await loader.reload();
-
-  const result = loader.getExtensions();
-  assert.equal(result.errors.length, 0);
-  assert.ok(result.extensions.length >= 2);
-});

package/lib/__templates__/pi-agent/tests/preference-memory.test.ts

@@ -1,43 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  extractPreferencesFromText,
-  getPreferencesFilePath,
-  renderPreferencesDocument,
-  upsertPreferencesDocument
-} from "../pi-resources/extensions/preference-memory/index.js";
-
-test("getPreferencesFilePath points to workspace root preference.md", () => {
-  const filePath = getPreferencesFilePath("/tmp/pi-workspace");
-  assert.equal(filePath, "/tmp/pi-workspace/preference.md");
-});
-
-test("extractPreferencesFromText captures stable reply and project preferences", () => {
-  const preferences = extractPreferencesFromText(
-    "以后都用中文回复，回答尽量简洁。这个项目统一使用 pnpm。后续资源都写到 workspace/.pi。"
-  );
-
-  assert.deepEqual(
-    preferences.map((preference) => preference.key).sort(),
-    ["package-manager", "reply-language", "reply-style", "runtime-resource-dir"]
-  );
-});
-
-test("extractPreferencesFromText ignores temporary one-off instructions", () => {
-  const preferences = extractPreferencesFromText("这次请用中文回复，先不要删文件。");
-  assert.deepEqual(preferences, []);
-});
-
-test("upsertPreferencesDocument replaces existing values instead of appending duplicates", () => {
-  const initial = renderPreferencesDocument([
-    { key: "reply-language", section: "回复偏好", label: "回复语言", value: "中文" }
-  ]);
-  const updated = upsertPreferencesDocument(initial, [
-    { key: "reply-language", section: "回复偏好", label: "回复语言", value: "英文" },
-    { key: "package-manager", section: "项目约定", label: "包管理器", value: "pnpm" }
-  ]);
-
-  assert.match(updated, /回复语言：英文/);
-  assert.doesNotMatch(updated, /回复语言：中文/);
-  assert.match(updated, /包管理器：pnpm/);
-});

package/lib/__templates__/pi-agent/tests/session-store.test.ts

@@ -1,61 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { SessionStore } from "../src/session-store.js";
-
-test("SessionStore persists index + transcript header and can reload", () => {
-  const root = mkdtempSync(join(tmpdir(), "pi-bot-session-store-"));
-  try {
-    const store1 = new SessionStore(root);
-    store1.load();
-
-    const key = "dashboard:dm:dashboard-user";
-    const record1 = store1.ensureSession(key);
-
-    assert.equal(record1.sessionKey, key);
-    assert.ok(record1.sessionId);
-    assert.ok(record1.sessionFile.endsWith(".jsonl"));
-    assert.ok(existsSync(record1.sessionFile));
-
-    const firstLine = readFileSync(record1.sessionFile, "utf-8").split(/\r?\n/)[0] ?? "";
-    const header = JSON.parse(firstLine) as { type?: string; id?: string };
-    assert.equal(header.type, "session");
-    assert.equal(header.id, record1.sessionId);
-
-    const store2 = new SessionStore(root);
-    store2.load();
-    assert.deepEqual(store2.listSessionKeys(), [key]);
-    const record2 = store2.ensureSession(key);
-    assert.equal(record2.sessionId, record1.sessionId);
-    assert.equal(record2.sessionFile, record1.sessionFile);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("SessionStore reset archives prior transcript and rotates sessionId", () => {
-  const root = mkdtempSync(join(tmpdir(), "pi-bot-session-store-reset-"));
-  try {
-    const store = new SessionStore(root);
-    store.load();
-
-    const key = "feishu:dm:user-1";
-    const first = store.ensureSession(key);
-    assert.ok(existsSync(first.sessionFile));
-
-    const second = store.resetSession(key);
-    assert.notEqual(second.sessionId, first.sessionId);
-    assert.notEqual(second.sessionFile, first.sessionFile);
-    assert.ok(existsSync(second.sessionFile));
-
-    const sessionsDir = join(root, ".pi-bot", "sessions");
-    const archiveDir = join(sessionsDir, "archive");
-    // Old file should have been moved into archive (best-effort rename).
-    assert.ok(existsSync(archiveDir));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-

package/lib/__templates__/pi-agent/tests/smoke/run-smoke.ts

@@ -1,275 +0,0 @@
-import assert from "node:assert/strict";
-import { createServer } from "node:net";
-import { createBotApp } from "../../src/index.js";
-import { createMemoryConfigStore } from "../../src/dashboard/config-store.js";
-
-async function readJson(url: string, init?: RequestInit): Promise<unknown> {
-  const res = await fetch(url, init);
-  assert.equal(res.ok, true, `${init?.method ?? "GET"} ${url} failed with ${res.status}`);
-  return (await res.json()) as unknown;
-}
-
-async function allocateFreePort(): Promise<number> {
-  return await new Promise<number>((resolve, reject) => {
-    const server = createServer();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("Failed to allocate free port.")));
-        return;
-      }
-      const { port } = address;
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(port);
-      });
-    });
-  });
-}
-
-async function run(): Promise<void> {
-  const previousNodeEnv = process.env.NODE_ENV;
-  const previousDashboardPort = process.env.PI_BOT_DASHBOARD_PORT;
-  process.env.NODE_ENV = "production";
-  process.env.PI_BOT_DASHBOARD_PORT = String(await allocateFreePort());
-
-  const configStore = createMemoryConfigStore({
-    agents: {
-      defaults: {
-        model: {
-          primary: "coze/auto"
-        }
-      }
-    },
-    models: {
-      providers: {
-        coze: {
-          models: [
-            { id: "auto", name: "Auto" },
-            { id: "glm-4.7", name: "GLM-4.7" }
-          ]
-        }
-      }
-    },
-    channels: {
-      feishu: {
-        enabled: true,
-        requireMention: true,
-        appId: "app-id",
-        thinkingReaction: {
-          enabled: true,
-          emojiType: "SMILE"
-        }
-      },
-      wechat: {
-        enabled: true,
-        requireMention: false,
-        implementation: "mock"
-      }
-    }
-  });
-
-  let app: Awaited<ReturnType<typeof createBotApp>> | null = null;
-
-  try {
-    app = await createBotApp(
-      {
-        appName: "smoke-bot",
-        agent: {
-          mode: "mock"
-        },
-        routing: {
-          feishuGroupRequireMention: true,
-          wechatGroupRequireMention: false
-        },
-        channels: {
-          feishu: { enabled: true },
-          wechat: { enabled: true }
-        }
-      },
-      {
-        dashboardConfigStore: configStore
-      }
-    );
-
-    await app.start();
-
-    const dashboardUrl = app.dashboard.getUrl();
-    const initialModels = (await readJson(`${dashboardUrl}/api/models`)) as {
-      defaultModel: string;
-      options: Array<{ value: string; label: string }>;
-    };
-    assert.equal(initialModels.defaultModel, "coze/auto");
-    assert.deepEqual(initialModels.options, [
-      { value: "coze/auto", label: "coze / Auto" },
-      { value: "coze/glm-4.7", label: "coze / GLM-4.7" }
-    ]);
-
-    await readJson(`${dashboardUrl}/api/models`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        models: {
-          defaultModel: "coze/glm-4.7"
-        }
-      })
-    });
-    const savedModels = (await readJson(`${dashboardUrl}/api/models`)) as { defaultModel: string };
-    assert.equal(savedModels.defaultModel, "coze/glm-4.7");
-    assert.equal(
-      (((configStore.snapshot().agents as { defaults?: { model?: { primary?: string } } }).defaults?.model?.primary) ?? ""),
-      "coze/glm-4.7"
-    );
-
-    const initialChannels = (await readJson(`${dashboardUrl}/api/channels`)) as {
-      feishu: { enabled: boolean; thinkingReaction?: { enabled?: boolean; emojiType?: string } };
-      wechat: { enabled: boolean; implementation?: string };
-      routing: { feishuGroupRequireMention: boolean; wechatGroupRequireMention: boolean };
-    };
-    assert.equal(initialChannels.feishu.enabled, true);
-    assert.equal(initialChannels.feishu.thinkingReaction?.emojiType, "SMILE");
-    assert.equal(initialChannels.wechat.implementation, "mock");
-
-    await readJson(`${dashboardUrl}/api/channels`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        channels: {
-          routing: {
-            feishuGroupRequireMention: false,
-            wechatGroupRequireMention: true
-          },
-          feishu: {
-            enabled: false,
-            requireMention: false,
-            appId: "updated-app-id",
-            domain: "",
-            encryptKey: "",
-            verificationToken: "",
-            appSecret: "",
-            thinkingReaction: {
-              enabled: false,
-              emojiType: "THINK"
-            }
-          },
-          wechat: {
-            enabled: true,
-            requireMention: true,
-            implementation: "mock"
-          }
-        }
-      })
-    });
-    const savedChannels = (await readJson(`${dashboardUrl}/api/channels`)) as {
-      feishu: { enabled: boolean; appId?: string; thinkingReaction?: { enabled?: boolean; emojiType?: string } };
-      wechat: { requireMention?: boolean };
-    };
-    assert.equal(savedChannels.feishu.enabled, false);
-    assert.equal(savedChannels.feishu.appId, "updated-app-id");
-    assert.equal(savedChannels.feishu.thinkingReaction?.enabled, false);
-    assert.equal(savedChannels.wechat.requireMention, true);
-
-    const feishuResult = await app.channels.feishu?.simulateIncomingText({
-      text: "hello from feishu",
-      senderId: "feishu-user-1",
-      conversationId: "feishu-dm-1",
-      isDirectMessage: true
-    });
-    assert.ok(feishuResult);
-    assert.equal(feishuResult.handled, true);
-    assert.equal(feishuResult.reply?.text, "mock:feishu:dm:feishu-user-1: hello from feishu");
-
-    const duplicateFeishuEvent = {
-      message: {
-        message_id: "feishu-duplicate-1",
-        chat_id: "feishu-dm-duplicate",
-        chat_type: "p2p",
-        content: JSON.stringify({ text: "duplicate hello" })
-      },
-      sender: {
-        sender_id: {
-          open_id: "feishu-user-duplicate"
-        }
-      }
-    };
-
-    const firstDuplicateResult = await app.channels.feishu?.handleEvent(duplicateFeishuEvent);
-    assert.ok(firstDuplicateResult);
-    assert.equal(firstDuplicateResult.handled, true);
-
-    const secondDuplicateResult = await app.channels.feishu?.handleEvent(duplicateFeishuEvent);
-    assert.ok(secondDuplicateResult);
-    assert.equal(secondDuplicateResult.handled, false);
-    assert.equal(secondDuplicateResult.reason, "ignored");
-
-    const filteredGroupMessage = await app.channels.feishu?.simulateIncomingText({
-      text: "group message without mention",
-      senderId: "feishu-user-2",
-      conversationId: "feishu-group-1",
-      isDirectMessage: false,
-      mentions: []
-    });
-    assert.ok(filteredGroupMessage);
-    assert.equal(filteredGroupMessage.handled, false);
-
-    const handledGroupMessage = await app.channels.feishu?.simulateIncomingText({
-      text: "group message with mention",
-      senderId: "feishu-user-2",
-      conversationId: "feishu-group-1",
-      isDirectMessage: false,
-      mentions: [{ id: "bot" }]
-    });
-    assert.ok(handledGroupMessage);
-    assert.equal(handledGroupMessage.handled, true);
-
-    const wechatResult = await app.channels.wechat?.simulateIncomingText({
-      text: "hello from wechat",
-      senderId: "wechat-user-1",
-      conversationId: "wechat-dm-1",
-      isDirectMessage: true
-    });
-    assert.ok(wechatResult);
-    assert.equal(wechatResult.handled, true);
-    assert.equal(wechatResult.reply?.text, "mock:wechat:group:wechat-dm-1: hello from wechat");
-
-    const secondWechatResult = await app.channels.wechat?.simulateIncomingText({
-      text: "hello again from wechat",
-      senderId: "wechat-user-1",
-      conversationId: "wechat-dm-1",
-      isDirectMessage: true
-    });
-    assert.ok(secondWechatResult);
-    assert.equal(secondWechatResult.handled, true);
-    assert.equal(
-      secondWechatResult.reply?.text,
-      "mock:wechat:group:wechat-dm-1: hello again from wechat"
-    );
-  } finally {
-    await app?.stop();
-    if (previousNodeEnv === undefined) {
-      delete process.env.NODE_ENV;
-    } else {
-      process.env.NODE_ENV = previousNodeEnv;
-    }
-    if (previousDashboardPort === undefined) {
-      delete process.env.PI_BOT_DASHBOARD_PORT;
-    } else {
-      process.env.PI_BOT_DASHBOARD_PORT = previousDashboardPort;
-    }
-  }
-
-  console.log("smoke test passed");
-}
-
-run().catch((error: unknown) => {
-  console.error(error);
-  process.exit(1);
-});