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

package/lib/__templates__/pi-agent/src/dashboard/web/src/styles.css

@@ -0,0 +1,294 @@
+@import "tailwindcss";
+@source "../../../../node_modules/streamdown/dist/*.js";
+@source "../../../../node_modules/@streamdown/code/dist/*.js";
+
+:root {
+  color-scheme: light;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --destructive-foreground: oklch(0.985 0 0);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --radius: 0.625rem;
+}
+
+.dark {
+  color-scheme: dark;
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --destructive-foreground: oklch(0.985 0 0);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+}
+
+@theme inline {
+  --font-sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, Arial, "Apple Color Emoji", "Segoe UI Emoji";
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --radius-sm: calc(var(--radius) - 6px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 8px);
+}
+
+@layer base {
+  * {
+    box-sizing: border-box;
+  }
+
+  body {
+    @apply bg-background font-sans text-foreground antialiased transition-colors;
+    height: 100vh;
+    overflow: hidden;
+  }
+
+  #root {
+    height: 100%;
+  }
+
+  a {
+    @apply text-inherit;
+  }
+
+  h1,
+  h2,
+  h3,
+  p {
+    @apply m-0;
+  }
+}
+
+@supports (height: 100dvh) {
+  @layer base {
+    body {
+      height: 100dvh;
+    }
+  }
+}
+
+.streamdown-content [data-streamdown] {
+  overflow-wrap: anywhere;
+}
+
+.streamdown-content [data-streamdown="code-block"] {
+  position: relative;
+  margin: 1rem 0;
+  gap: 0.5rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.875rem;
+  background: color-mix(in oklab, var(--muted) 65%, var(--background));
+  padding: 0.75rem;
+}
+
+.streamdown-content [data-streamdown="code-block-header"] {
+  display: flex;
+  min-height: 1.75rem;
+  align-items: center;
+  height: auto;
+  padding: 0 4.5rem 0 0.125rem;
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+}
+
+.streamdown-content [data-streamdown="code-block-header"] + div {
+  position: absolute;
+  top: 0.75rem;
+  right: 0.75rem;
+  left: auto;
+  z-index: 20;
+  margin: 0;
+  padding: 0;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] {
+  gap: 0.375rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.625rem;
+  background: color-mix(in oklab, var(--background) 88%, transparent);
+  padding: 0.25rem;
+  box-shadow: none;
+  backdrop-filter: none;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button {
+  display: inline-flex;
+  height: 1.75rem;
+  width: 1.75rem;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  border-radius: 0.5rem;
+  background: transparent;
+  color: var(--muted-foreground);
+  transition:
+    background-color 150ms ease,
+    color 150ms ease;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button:hover {
+  background: color-mix(in oklab, var(--accent) 100%, transparent);
+  color: var(--foreground);
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button:focus-visible {
+  outline: 2px solid color-mix(in oklab, var(--ring) 65%, transparent);
+  outline-offset: 1px;
+}
+
+.streamdown-content [data-streamdown="code-block-body"] {
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.75rem;
+  background: color-mix(in oklab, var(--background) 92%, var(--muted));
+  margin-top: 0.5rem;
+  padding: 0.875rem 1rem;
+}
+
+.streamdown-content [data-streamdown="code-block-body"] pre {
+  margin: 0;
+  background: transparent;
+}
+
+.streamdown-content pre {
+  overflow: auto;
+}
+
+.streamdown-content img {
+  max-width: 100%;
+  height: auto;
+}
+
+.docs-content [data-streamdown] {
+  overflow-wrap: anywhere;
+}
+
+.docs-content h1,
+.docs-content h2,
+.docs-content h3,
+.docs-content h4 {
+  margin: 1.5rem 0 0.75rem;
+  font-weight: 600;
+  letter-spacing: -0.02em;
+}
+
+.docs-content h1:first-child,
+.docs-content h2:first-child,
+.docs-content h3:first-child {
+  margin-top: 0;
+}
+
+.docs-content h1 {
+  font-size: 1.5rem;
+}
+
+.docs-content h2 {
+  font-size: 1.2rem;
+}
+
+.docs-content h3 {
+  font-size: 1rem;
+}
+
+.docs-content p,
+.docs-content ul,
+.docs-content ol,
+.docs-content table,
+.docs-content blockquote {
+  margin: 0.75rem 0;
+}
+
+.docs-content ul,
+.docs-content ol {
+  padding-left: 1.25rem;
+}
+
+.docs-content li + li {
+  margin-top: 0.35rem;
+}
+
+.docs-content a {
+  color: var(--primary);
+  text-decoration: underline;
+  text-underline-offset: 0.2em;
+}
+
+.docs-content hr {
+  margin: 1.25rem 0;
+  border: 0;
+  border-top: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+}
+
+.docs-content blockquote {
+  border-left: 3px solid color-mix(in oklab, var(--border) 100%, transparent);
+  padding-left: 1rem;
+  color: var(--muted-foreground);
+}
+
+.docs-content table {
+  width: 100%;
+  border-collapse: collapse;
+  overflow: hidden;
+  border-radius: 0.875rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+}
+
+.docs-content th,
+.docs-content td {
+  border-bottom: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  padding: 0.75rem;
+  text-align: left;
+  vertical-align: top;
+}
+
+.docs-content th {
+  background: color-mix(in oklab, var(--muted) 80%, var(--background));
+  font-weight: 600;
+}
+
+.docs-content tbody tr:last-child td {
+  border-bottom: 0;
+}

package/lib/__templates__/pi-agent/src/dashboard/web/src/utils/index.ts

@@ -0,0 +1,11 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+import { cloneDeep } from "lodash-es";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function deepClone<T>(value: T): T {
+  return cloneDeep(value);
+}

package/lib/__templates__/pi-agent/src/dashboard/web/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["vite/client"],
+    "noEmit": true
+  },
+  "include": ["vite.config.ts", "src/**/*.ts", "src/**/*.tsx"]
+}
+

package/lib/__templates__/pi-agent/src/dashboard/web/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+const DIR = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: DIR,
+  plugins: [react()],
+  base: "/",
+  build: {
+    outDir: resolve(DIR, "dist"),
+    emptyOutDir: true,
+  },
+});
+

package/lib/__templates__/pi-agent/src/index.ts

@@ -0,0 +1,123 @@
+import { fileURLToPath } from "node:url";
+import type { BotAppConfig } from "./core.js";
+import type { FeishuChannel } from "./channels/feishu/index.js";
+import { createFeishuChannel } from "./channels/feishu/index.js";
+import type { WechatChannel } from "./channels/wechat/index.js";
+import { createWechatChannel } from "./channels/wechat/index.js";
+import { loadBotAppConfig } from "./config.js";
+import { createAgentRuntime } from "./agent.js";
+import type { DashboardServer } from "./dashboard/types.js";
+import { createDashboard } from "./dashboard/index.js";
+import type { ConfigStore } from "./dashboard/config-store.js";
+
+export interface BotApp {
+  config: BotAppConfig;
+  channels: {
+    feishu?: FeishuChannel;
+    wechat?: WechatChannel;
+  };
+  dashboard: DashboardServer;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+
+export async function createBotApp(
+  config: BotAppConfig = loadBotAppConfig(),
+  options: { dashboardConfigStore?: ConfigStore } = {},
+): Promise<BotApp> {
+  const runtime = await createAgentRuntime(config.agent);
+  const channels: BotApp["channels"] = {};
+
+  if (config.channels.feishu?.enabled) {
+    channels.feishu = createFeishuChannel(
+      {
+        appId: config.channels.feishu.appId,
+        appSecret: config.channels.feishu.appSecret,
+        domain: config.channels.feishu.domain,
+        encryptKey: config.channels.feishu.encryptKey,
+        verificationToken: config.channels.feishu.verificationToken,
+        routing: {
+          groupRequireMention: config.routing.feishuGroupRequireMention
+        }
+      },
+      {
+        async onMessage(message) {
+          const text = await runtime.run(message);
+          return { text };
+        },
+        async onStreamMessage(message, handlers) {
+          const result = await runtime.stream(message, {
+            onMeta: handlers.onMeta,
+            onDelta: handlers.onDelta,
+            onError: handlers.onError
+          });
+          return { text: result.finalText };
+        }
+      }
+    );
+  }
+
+  if (config.channels.wechat?.enabled) {
+    channels.wechat = createWechatChannel(
+      {
+        routing: {
+          groupRequireMention: config.routing.wechatGroupRequireMention
+        }
+      },
+      {
+        async onMessage(message) {
+          const text = await runtime.run(message);
+          return { text };
+        }
+      }
+    );
+  }
+
+  const dashboard = createDashboard({
+    botConfig: config,
+    channels,
+    agentRuntime: runtime,
+    configStore: options.dashboardConfigStore,
+  });
+
+  return {
+    config,
+    channels,
+    dashboard,
+    async start() {
+      await Promise.all([
+        ...Object.values(channels).map((channel) => channel.start()),
+        dashboard.start()
+      ]);
+    },
+    async stop() {
+      await Promise.all([
+        ...Object.values(channels).map((channel) => channel.stop()),
+        dashboard.stop()
+      ]);
+      await runtime.dispose();
+    }
+  };
+}
+
+export async function main(): Promise<void> {
+  const config = loadBotAppConfig();
+  const app = await createBotApp(config);
+  await app.start();
+
+  console.log(`[${config.appName}] started`);
+  console.log(`Feishu enabled: ${Boolean(app.channels.feishu)}`);
+  console.log(`WeChat enabled: ${Boolean(app.channels.wechat)}`);
+  console.log(`Dashboard: ${app.dashboard.getUrl()}`);
+  console.log(`Agent mode: ${config.agent.mode}`);
+  console.log(`Workspace dir: ${config.agent.cwd}`);
+  console.log(`Agent dir: ${config.agent.agentDir}`);
+}
+
+const entrypoint = process.argv[1];
+if (entrypoint && fileURLToPath(import.meta.url) === entrypoint) {
+  main().catch((error: unknown) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

package/lib/__templates__/pi-agent/src/pi-resources.ts

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { DefaultResourceLoader, type SettingsManager } from "@mariozechner/pi-coding-agent";
+import { getProjectRoot } from "./config.js";
+
+type PiResourceLoaderArgs = {
+  cwd: string;
+  agentDir?: string;
+  settingsManager: SettingsManager;
+};
+
+export function getPiResourcesDir(): string {
+  return join(getProjectRoot(), "pi-resources");
+}
+
+export function buildPiResourceLoaderOptions(
+  args: PiResourceLoaderArgs
+): ConstructorParameters<typeof DefaultResourceLoader>[0] {
+  const piResourcesDir = getPiResourcesDir();
+  const repoSystemPromptPath = join(piResourcesDir, "SYSTEM.md");
+  const repoAppendSystemPromptPath = join(piResourcesDir, "APPEND_SYSTEM.md");
+  const localSystemPromptPath = join(args.cwd, ".pi", "SYSTEM.md");
+  const localAppendSystemPromptPath = join(args.cwd, ".pi", "APPEND_SYSTEM.md");
+  const systemPromptSource = pickFirstExistingPath([localSystemPromptPath, repoSystemPromptPath]);
+  const appendSystemPromptSource = pickFirstExistingPath([
+    localAppendSystemPromptPath,
+    repoAppendSystemPromptPath
+  ]);
+
+  return {
+    cwd: args.cwd,
+    agentDir: args.agentDir,
+    settingsManager: args.settingsManager,
+    additionalExtensionPaths: discoverExtensionEntries(join(piResourcesDir, "extensions")),
+    additionalSkillPaths: existingPaths([join(piResourcesDir, "skills")]),
+    additionalPromptTemplatePaths: existingPaths([join(piResourcesDir, "prompts")]),
+    // Keep the bot runtime independent from repo/workspace AGENTS.md files.
+    agentsFilesOverride: () => ({ agentsFiles: [] }),
+    // Make source precedence explicit instead of expressing it indirectly through
+    // override callbacks: workspace/.pi wins, then repo-managed resources, then the
+    // loader's own defaults when neither exists.
+    systemPrompt: systemPromptSource,
+    appendSystemPrompt: appendSystemPromptSource
+  };
+}
+
+export function createPiResourceLoader(args: PiResourceLoaderArgs): DefaultResourceLoader {
+  return new DefaultResourceLoader(buildPiResourceLoaderOptions(args));
+}
+
+function existingPaths(paths: string[]): string[] {
+  return paths.filter((path) => existsSync(path));
+}
+
+function pickFirstExistingPath(paths: string[]): string | undefined {
+  return paths.find((path) => existsSync(path));
+}
+
+function discoverExtensionEntries(dir: string): string[] {
+  if (!existsSync(dir)) {
+    return [];
+  }
+
+  const discovered = new Set<string>();
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+
+    const entryPath = join(dir, entry.name);
+    if (entry.isFile() && isExtensionModule(entry.name)) {
+      discovered.add(entryPath);
+      continue;
+    }
+
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    for (const extensionEntry of resolveExtensionEntries(entryPath)) {
+      discovered.add(extensionEntry);
+    }
+  }
+
+  return Array.from(discovered);
+}
+
+function resolveExtensionEntries(dir: string): string[] {
+  const packageJsonPath = join(dir, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const manifest = readPiManifest(packageJsonPath);
+    if (manifest?.extensions?.length) {
+      return manifest.extensions
+        .map((extensionPath) => join(dir, extensionPath))
+        .filter((extensionPath) => existsSync(extensionPath));
+    }
+  }
+
+  const indexTs = join(dir, "index.ts");
+  if (existsSync(indexTs)) {
+    return [indexTs];
+  }
+
+  const indexJs = join(dir, "index.js");
+  if (existsSync(indexJs)) {
+    return [indexJs];
+  }
+
+  return [];
+}
+
+function readPiManifest(packageJsonPath: string): { extensions?: string[] } | undefined {
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
+      pi?: { extensions?: string[] };
+    };
+    return pkg.pi;
+  } catch {
+    return undefined;
+  }
+}
+
+function isExtensionModule(fileName: string): boolean {
+  return fileName.endsWith(".ts") || fileName.endsWith(".js");
+}