@coze-arch/cli 0.0.18 → 0.0.19-beta.1

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

@@ -0,0 +1,275 @@
+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);
+});

package/lib/__templates__/pi-agent/tests/web-fetch.test.ts

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { FetchClient, type FetchResponse } from "coze-coding-dev-sdk";
+import { cozeWebFetchTool } from "../src/tools/web-fetch/index.js";
+
+function resultText(result: { content: { type: string; text?: string }[] }): string {
+  return result.content[0].text ?? "";
+}
+
+function makeFetchResponse(overrides: Partial<FetchResponse> = {}): FetchResponse {
+  return {
+    url: "https://example.com",
+    title: "Example Page",
+    content: [
+      { type: "text", text: "Hello world" },
+      { type: "link", text: "Link A", url: "https://a.com" },
+      { type: "image", image: { display_url: "https://img.com/1.png", width: 640, height: 480 } },
+    ],
+    ...overrides,
+  };
+}
+
+test("web-fetch: text format renders numbered items with links and images", async (t) => {
+  const resp = makeFetchResponse();
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const result = await cozeWebFetchTool.execute("call-1", { urls: "https://example.com" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("1. Example Page"));
+  assert.ok(text.includes("URL: https://example.com"));
+  assert.ok(text.includes("Hello world"));
+  assert.ok(text.includes("Link A: https://a.com"));
+  assert.ok(text.includes("https://img.com/1.png (640x480)"));
+});
+
+test("web-fetch: markdown format renders headings and markdown links", async (t) => {
+  const resp = makeFetchResponse();
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const result = await cozeWebFetchTool.execute("call-2", { urls: ["https://example.com"], format: "markdown" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("# Example Page"));
+  assert.ok(text.includes("- [Link A](https://a.com)"));
+});
+
+test("web-fetch: json format returns valid JSON", async (t) => {
+  const resp = makeFetchResponse();
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const result = await cozeWebFetchTool.execute("call-3", { urls: "https://example.com", format: "json" }, undefined as any, undefined as any, undefined as any);
+  const parsed = JSON.parse(resultText(result));
+
+  assert.equal(Array.isArray(parsed), true);
+  assert.equal(parsed[0].url, "https://example.com");
+  assert.equal(parsed[0].title, "Example Page");
+  assert.equal(parsed[0].links.length, 1);
+  assert.equal(parsed[0].images.length, 1);
+});
+
+test("web-fetch: textOnly omits links and images", async (t) => {
+  const resp = makeFetchResponse();
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const result = await cozeWebFetchTool.execute("call-4", { urls: "https://example.com", format: "json", textOnly: true }, undefined as any, undefined as any, undefined as any);
+  const parsed = JSON.parse(resultText(result));
+
+  assert.equal(parsed[0].links.length, 0);
+  assert.equal(parsed[0].images.length, 0);
+});
+
+test("web-fetch: filters out links with missing url", async (t) => {
+  const resp = makeFetchResponse({
+    content: [
+      { type: "text", text: "body" },
+      { type: "link", text: "Valid", url: "https://valid.com" },
+      { type: "link", text: "Missing URL" },
+      { type: "link", text: undefined, url: undefined },
+    ],
+  });
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const textResult = await cozeWebFetchTool.execute("call-5a", { urls: "https://example.com" }, undefined as any, undefined as any, undefined as any);
+  assert.ok(resultText(textResult).includes("Valid: https://valid.com"));
+  assert.ok(!resultText(textResult).includes("Missing URL"));
+
+  const mdResult = await cozeWebFetchTool.execute("call-5b", { urls: "https://example.com", format: "markdown" }, undefined as any, undefined as any, undefined as any);
+  assert.ok(resultText(mdResult).includes("[Valid](https://valid.com)"));
+  assert.ok(!resultText(mdResult).includes("Missing URL"));
+});
+
+test("web-fetch: image dimensions only shown when both width and height are numbers", async (t) => {
+  const resp = makeFetchResponse({
+    content: [
+      { type: "text", text: "body" },
+      { type: "image", image: { display_url: "https://img.com/a.png", width: 100, height: 200 } },
+      { type: "image", image: { display_url: "https://img.com/b.png", width: 100 } },
+      { type: "image", image: { display_url: "https://img.com/c.png" } },
+    ],
+  });
+  t.mock.method(FetchClient.prototype, "fetch", async () => resp);
+
+  const result = await cozeWebFetchTool.execute("call-6", { urls: "https://example.com" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("https://img.com/a.png (100x200)"));
+  assert.ok(text.includes("https://img.com/b.png"));
+  assert.ok(!text.includes("b.png (100x"));
+  assert.ok(text.includes("https://img.com/c.png"));
+  assert.ok(!text.includes("c.png ("));
+});
+
+test("web-fetch: concurrent fetching preserves order", async (t) => {
+  const callOrder: number[] = [];
+  let callIndex = 0;
+
+  t.mock.method(FetchClient.prototype, "fetch", async (url: string) => {
+    const idx = callIndex++;
+    const delay = url.includes("slow") ? 50 : 10;
+    await new Promise((r) => setTimeout(r, delay));
+    callOrder.push(idx);
+    return makeFetchResponse({ url, title: `Page ${idx}` });
+  });
+
+  const urls = ["https://slow.com", "https://fast1.com", "https://fast2.com"];
+  const result = await cozeWebFetchTool.execute("call-7", { urls, format: "json" }, undefined as any, undefined as any, undefined as any);
+  const parsed = JSON.parse(resultText(result));
+
+  assert.equal(parsed.length, 3);
+  assert.equal(parsed[0].url, "https://slow.com");
+  assert.equal(parsed[1].url, "https://fast1.com");
+  assert.equal(parsed[2].url, "https://fast2.com");
+});
+
+test("web-fetch: returns error content on fetch failure", async (t) => {
+  t.mock.method(FetchClient.prototype, "fetch", async () => {
+    throw new Error("Connection refused");
+  });
+
+  const result = await cozeWebFetchTool.execute("call-8", { urls: "https://example.com" }, undefined as any, undefined as any, undefined as any);
+
+  assert.ok(resultText(result).includes("Error: Connection refused"));
+  assert.equal((result as any).details.error, true);
+});
+
+test("web-fetch: single url string is normalized to array", async (t) => {
+  const calls: string[] = [];
+  t.mock.method(FetchClient.prototype, "fetch", async (url: string) => {
+    calls.push(url);
+    return makeFetchResponse({ url });
+  });
+
+  await cozeWebFetchTool.execute("call-9", { urls: "https://single.com" }, undefined as any, undefined as any, undefined as any);
+
+  assert.deepEqual(calls, ["https://single.com"]);
+});

package/lib/__templates__/pi-agent/tests/web-search.test.ts

@@ -0,0 +1,208 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SearchClient, type SearchResponse } from "coze-coding-dev-sdk";
+import { cozeWebSearchTool } from "../src/tools/web-search/index.js";
+
+function resultText(result: { content: { type: string; text?: string }[] }): string {
+  return result.content[0].text ?? "";
+}
+
+function makeWebSearchResponse(overrides: Partial<SearchResponse> = {}): SearchResponse {
+  return {
+    web_items: [
+      {
+        id: "1",
+        sort_id: 1,
+        title: "Result A",
+        site_name: "example.com",
+        url: "https://example.com/a",
+        snippet: "Snippet A",
+        auth_info_des: "",
+        auth_info_level: 0,
+      },
+      {
+        id: "2",
+        sort_id: 2,
+        title: "Result B",
+        url: "https://example.com/b",
+        snippet: "Snippet B",
+        publish_time: "2025-01-01",
+        auth_info_des: "",
+        auth_info_level: 0,
+      },
+    ],
+    image_items: [],
+    ...overrides,
+  };
+}
+
+function makeImageSearchResponse(): SearchResponse {
+  return {
+    web_items: [],
+    image_items: [
+      {
+        id: "img-1",
+        sort_id: 1,
+        title: "Cat Photo",
+        url: "https://example.com/cat",
+        site_name: "photos.com",
+        image: { url: "https://cdn.com/cat.jpg", width: 800, height: 600, shape: "rect" },
+      },
+      {
+        id: "img-2",
+        sort_id: 2,
+        url: "https://example.com/dog",
+        image: { url: "https://cdn.com/dog.jpg", width: 1024, height: 768, shape: "rect" },
+      },
+    ],
+  };
+}
+
+test("web-search: basic web search returns formatted text", async (t) => {
+  const resp = makeWebSearchResponse();
+  t.mock.method(SearchClient.prototype, "webSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-1", { query: "test" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("Coze web search: test"));
+  assert.ok(text.includes("Results (2)"));
+  assert.ok(text.includes("1. Result A"));
+  assert.ok(text.includes("URL: https://example.com/a"));
+  assert.ok(text.includes("Source: example.com"));
+  assert.ok(text.includes("Snippet A"));
+  assert.ok(text.includes("2. Result B"));
+  assert.ok(text.includes("Published: 2025-01-01"));
+});
+
+test("web-search: includes summary when present", async (t) => {
+  const resp = makeWebSearchResponse({ summary: "This is the summary" });
+  t.mock.method(SearchClient.prototype, "webSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-2", { query: "test", needSummary: true }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("Summary: This is the summary"));
+});
+
+test("web-search: includes content when needContent is true", async (t) => {
+  const resp = makeWebSearchResponse();
+  resp.web_items[0].content = "Full page content here";
+  t.mock.method(SearchClient.prototype, "advancedSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-3", { query: "test", needContent: true }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("Content:"));
+  assert.ok(text.includes("Full page content here"));
+});
+
+test("web-search: image search maps image items", async (t) => {
+  const resp = makeImageSearchResponse();
+  t.mock.method(SearchClient.prototype, "imageSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-4", { query: "cats", type: "image" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("1. Cat Photo"));
+  assert.ok(text.includes("Image: https://cdn.com/cat.jpg"));
+  assert.ok(text.includes("2. Untitled"));
+  assert.ok(text.includes("Image: https://cdn.com/dog.jpg"));
+  assert.equal((result as any).details.type, "image");
+});
+
+test("web-search: uses advancedSearch when filters are present", async (t) => {
+  const resp = makeWebSearchResponse();
+  const calls: string[] = [];
+  t.mock.method(SearchClient.prototype, "advancedSearch", async () => {
+    calls.push("advancedSearch");
+    return resp;
+  });
+  t.mock.method(SearchClient.prototype, "webSearch", async () => {
+    calls.push("webSearch");
+    return resp;
+  });
+
+  await cozeWebSearchTool.execute("call-5", { query: "test", timeRange: "1d" }, undefined as any, undefined as any, undefined as any);
+  assert.deepEqual(calls, ["advancedSearch"]);
+});
+
+test("web-search: uses webSearch when no filters present", async (t) => {
+  const resp = makeWebSearchResponse();
+  const calls: string[] = [];
+  t.mock.method(SearchClient.prototype, "advancedSearch", async () => {
+    calls.push("advancedSearch");
+    return resp;
+  });
+  t.mock.method(SearchClient.prototype, "webSearch", async () => {
+    calls.push("webSearch");
+    return resp;
+  });
+
+  await cozeWebSearchTool.execute("call-6", { query: "test" }, undefined as any, undefined as any, undefined as any);
+  assert.deepEqual(calls, ["webSearch"]);
+});
+
+test("web-search: uses advancedSearch when sites filter is set", async (t) => {
+  const resp = makeWebSearchResponse();
+  const calls: string[] = [];
+  t.mock.method(SearchClient.prototype, "advancedSearch", async () => {
+    calls.push("advancedSearch");
+    return resp;
+  });
+  t.mock.method(SearchClient.prototype, "webSearch", async () => {
+    calls.push("webSearch");
+    return resp;
+  });
+
+  await cozeWebSearchTool.execute("call-7", { query: "test", sites: "example.com" }, undefined as any, undefined as any, undefined as any);
+  assert.deepEqual(calls, ["advancedSearch"]);
+});
+
+test("web-search: returns error content on search failure", async (t) => {
+  t.mock.method(SearchClient.prototype, "webSearch", async () => {
+    throw new Error("API timeout");
+  });
+
+  const result = await cozeWebSearchTool.execute("call-8", { query: "test" }, undefined as any, undefined as any, undefined as any);
+
+  assert.ok(resultText(result).includes("Error: API timeout"));
+  assert.equal((result as any).details.error, true);
+});
+
+test("web-search: defaults count to 10 and type to web", async (t) => {
+  const captured: any[] = [];
+  t.mock.method(SearchClient.prototype, "webSearch", async (query: string, count: number, needSummary?: boolean) => {
+    captured.push({ query, count, needSummary });
+    return makeWebSearchResponse();
+  });
+
+  await cozeWebSearchTool.execute("call-9", { query: "hello" }, undefined as any, undefined as any, undefined as any);
+
+  assert.equal(captured[0].query, "hello");
+  assert.equal(captured[0].count, 10);
+  assert.equal((captured[0] as any).needSummary, undefined);
+});
+
+test("web-search: details contain correct metadata", async (t) => {
+  const resp = makeWebSearchResponse({ summary: "Sum" });
+  t.mock.method(SearchClient.prototype, "webSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-10", { query: "meta test" }, undefined as any, undefined as any, undefined as any);
+
+  assert.equal((result as any).details.query, "meta test");
+  assert.equal((result as any).details.type, "web");
+  assert.equal((result as any).details.summary, "Sum");
+  assert.equal((result as any).details.count, 2);
+});
+
+test("web-search: empty results produces correct output", async (t) => {
+  const resp: SearchResponse = { web_items: [], image_items: [] };
+  t.mock.method(SearchClient.prototype, "webSearch", async () => resp);
+
+  const result = await cozeWebSearchTool.execute("call-11", { query: "nothing" }, undefined as any, undefined as any, undefined as any);
+  const text = resultText(result);
+
+  assert.ok(text.includes("Results (0)"));
+  assert.equal((result as any).details.count, 0);
+});

package/lib/__templates__/pi-agent/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "baseUrl": "."
+  },
+  "include": [
+    "src/**/*.ts",
+    "pi-resources/extensions/**/*.ts",
+    "tests/**/*.ts",
+    "types/**/*.d.ts"
+  ]
+}