@jiangxiaosheng/digital-agent-platform 1.0.0

package/src/lib/models-config.ts

@@ -0,0 +1,55 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+export interface ModelEntry {
+  id: string;
+  name?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  input?: string[];
+  cost?: { input: number; output: number; cacheRead?: number; cacheWrite?: number };
+  reasoning?: boolean;
+  thinkingLevelMap?: Record<string, string | null>;
+}
+
+export interface ProviderEntry {
+  baseUrl?: string;
+  api?: string;
+  apiKey?: string;
+  models?: ModelEntry[];
+}
+
+export interface ModelsConfig {
+  providers: Record<string, ProviderEntry>;
+}
+
+export function getAgentDir(): string {
+  return process.env.PI_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+}
+export function getModelsPath(): string { return path.join(getAgentDir(), "models.json"); }
+export function getAuthPath(): string    { return path.join(getAgentDir(), "auth.json"); }
+
+export function readModelsConfig(): ModelsConfig {
+  const p = getModelsPath();
+  if (!fs.existsSync(p)) return { providers: {} };
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return { providers: {} }; }
+}
+
+export function writeModelsConfig(cfg: ModelsConfig): void {
+  const p = getModelsPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2), "utf8");
+}
+
+export function readAuthConfig(): Record<string, { type: string; key: string }> {
+  const p = getAuthPath();
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+
+export function writeAuthConfig(auth: Record<string, { type: string; key: string }>): void {
+  const p = getAuthPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(auth, null, 2), "utf8");
+}

package/src/lib/settings.ts

@@ -0,0 +1,33 @@
+import { getDb } from "./db/client";
+import type { AppSettings } from "@/types/settings";
+import { DEFAULT_SETTINGS } from "@/types/settings";
+import path from "path";
+import os from "os";
+
+const SETTINGS_KEY = "app_settings";
+
+export function getSettings(): AppSettings {
+  const db = getDb();
+  const row = db.prepare("SELECT value FROM settings WHERE key = ?").get(SETTINGS_KEY) as
+    | { value: string }
+    | undefined;
+  if (!row) return { ...DEFAULT_SETTINGS, storagePath: path.join(os.homedir(), ".digital-agents") };
+  try {
+    return JSON.parse(row.value) as AppSettings;
+  } catch {
+    return { ...DEFAULT_SETTINGS, storagePath: path.join(os.homedir(), ".digital-agents") };
+  }
+}
+
+export function saveSettings(settings: AppSettings): void {
+  const db = getDb();
+  db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(
+    SETTINGS_KEY,
+    JSON.stringify(settings)
+  );
+}
+
+export function getApiKey(provider: string): string | undefined {
+  const settings = getSettings();
+  return (settings.apiKeys as Record<string, string>)[provider];
+}

package/src/lib/skills.ts

@@ -0,0 +1,79 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+export interface SkillInfo {
+  name: string;
+  description: string;
+  filePath: string;
+  source: "global";
+  hasSetup: boolean;
+  /** SDK will only load skills that have a non-empty description in frontmatter */
+  sdkCompatible: boolean;
+}
+
+export function getSkillsDir(): string {
+  return path.join(os.homedir(), ".pi", "agent", "skills");
+}
+
+export function parseFrontmatter(content: string): Record<string, unknown> {
+  const m = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const fm: Record<string, unknown> = {};
+  for (const line of m[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    // Handle multi-line values (|, >)
+    const rawVal = line.slice(idx + 1).trim();
+    const val = rawVal.replace(/^[|>]\s*$/, "");
+    fm[key] = val;
+  }
+  return fm;
+}
+
+export function loadSkillFromPath(skillPath: string, entryName: string): SkillInfo | null {
+  try {
+    const stat = fs.statSync(skillPath);
+    let mdPath: string;
+    let isDir = false;
+    if (stat.isDirectory()) {
+      mdPath = path.join(skillPath, "SKILL.md");
+      isDir = true;
+    } else {
+      mdPath = skillPath;
+    }
+    if (!fs.existsSync(mdPath)) return null;
+    const content = fs.readFileSync(mdPath, "utf8");
+    const fm = parseFrontmatter(content);
+
+    // Skill name: prefer frontmatter name, fall back to entry/directory name
+    const name = ((fm.name as string) || "").trim() || entryName.replace(/\.md$/, "");
+
+    // Description: required by SDK — if missing, SDK won't discover this skill
+    const description = ((fm.description as string) || "").trim();
+
+    // SDK compatibility: requires non-empty description in frontmatter
+    const hasFrontmatter = content.trimStart().startsWith("---");
+    const sdkCompatible = hasFrontmatter && description.length > 0;
+
+    return {
+      name,
+      description,
+      filePath: isDir ? skillPath : mdPath,
+      source: "global",
+      hasSetup: content.toLowerCase().includes("## setup"),
+      sdkCompatible,
+    };
+  } catch { return null; }
+}
+
+export function listInstalledSkills(): SkillInfo[] {
+  const dir = getSkillsDir();
+  if (!fs.existsSync(dir)) return [];
+  const entries = fs.readdirSync(dir);
+  return entries
+    .map((e) => loadSkillFromPath(path.join(dir, e), e))
+    .filter((s): s is SkillInfo => s !== null)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/lib/system-prompt.ts

@@ -0,0 +1,52 @@
+import type { DigitalAgent } from "@/types/agent";
+import { readEnvVars } from "./env-vars";
+import os from "os";
+import path from "path";
+
+export function buildSystemPrompt(agent: DigitalAgent, ragContext?: string): string {
+  const { persona, name, description, systemPrompt } = agent;
+
+  const toneMap: Record<string, string> = {
+    formal: "正式、专业",
+    casual: "随意、轻松",
+    friendly: "友善、亲切",
+    professional: "专业、严谨",
+  };
+
+  const lines: string[] = [];
+
+  // ── 身份标识（始终注入，优先级最高）──────────────────
+  lines.push(`你是「${name}」。${description ? description : ""}`);
+  lines.push(`语气风格：${toneMap[persona.tone] ?? persona.tone}。交流语言：${persona.language}。`);
+  lines.push(`当前时间：${new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" })}。`);
+
+  // ── 系统环境变量配置信息 ──────────────────────────
+  const envVars = readEnvVars();
+  const envKeys = Object.keys(envVars);
+  const envConfigPath = path.join(os.homedir(), ".digital-agents", "env.json");
+  if (envKeys.length > 0) {
+    lines.push(`
+<system_env>
+以下环境变量已在系统中配置，可直接在 bash 命令中使用：
+${envKeys.map(k => `- ${k}`).join("\n")}
+配置文件路径：${envConfigPath}
+</system_env>`);
+  }
+
+  // ── 用户自定义人设 Prompt ──────────────────────────
+  if (systemPrompt.trim()) {
+    lines.push("\n" + systemPrompt.trim());
+  }
+
+  // ── RAG 知识库检索结果 ────────────────────────────
+  if (ragContext?.trim()) {
+    lines.push(`
+<knowledge_context>
+以下是与用户问题相关的参考资料，请优先基于此回答：
+
+${ragContext}
+</knowledge_context>`);
+  }
+
+  return lines.join("\n");
+}

package/src/lib/tool-builder.ts

@@ -0,0 +1,19 @@
+import type { DigitalAgent } from "@/types/agent";
+
+// Returns { builtinNames, customTools } for createAgentSession
+// Note: webSearch (Tavily) removed — handled by tavily-search skill + TAVILY_API_KEY env var
+export function buildToolConfig(agent: DigitalAgent) {
+  const { tools } = agent;
+
+  const builtinNames: string[] = [];
+  if (tools.fileRead)  builtinNames.push("read");
+  if (tools.fileWrite) builtinNames.push("write", "edit");
+  if (tools.bash)      builtinNames.push("bash");
+  if (tools.grep)      builtinNames.push("grep");
+  if (tools.find)      builtinNames.push("find", "ls");
+
+  const customTools: { name: string }[] = [];
+  if (tools.calculator) customTools.push({ name: "calculator" });
+
+  return { builtinNames, customTools };
+}

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/lib/voice-providers-config.ts

@@ -0,0 +1,71 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+export type VoiceProviderType = "aliyun" | "tencent" | "baidu" | "openai";
+
+export interface AliyunTTSConfig {
+  appKey: string;
+  accessKeyId: string;
+  accessKeySecret: string;
+}
+
+export interface TencentTTSConfig {
+  secretId: string;
+  secretKey: string;
+  region?: string;
+}
+
+export interface BaiduTTSConfig {
+  apiKey: string;
+  secretKey: string;
+}
+
+export interface OpenAITTSConfig {
+  apiKey: string;
+  model?: "tts-1" | "tts-1-hd";
+  voice?: "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer";
+}
+
+export interface VoiceProviderConfig {
+  currentProvider: VoiceProviderType;
+  providers: {
+    aliyun?: AliyunTTSConfig;
+    tencent?: TencentTTSConfig;
+    baidu?: BaiduTTSConfig;
+    openai?: OpenAITTSConfig;
+  };
+}
+
+export function getAgentDir(): string {
+  return process.env.PI_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+}
+
+export function getVoiceProviderPath(): string {
+  return path.join(getAgentDir(), "voice-provider.json");
+}
+
+export function readVoiceProviderConfig(): VoiceProviderConfig {
+  const p = getVoiceProviderPath();
+  if (!fs.existsSync(p)) {
+    return {
+      currentProvider: "openai",
+      providers: {},
+    };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return {
+      currentProvider: "openai",
+      providers: {},
+    };
+  }
+}
+
+export function writeVoiceProviderConfig(cfg: VoiceProviderConfig): void {
+  const p = getVoiceProviderPath();
+  const dir = path.dirname(p);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2), "utf8");
+}

package/src/middleware.ts

@@ -0,0 +1,9 @@
+import createMiddleware from "next-intl/middleware";
+import { routing } from "./i18n/routing";
+
+export default createMiddleware(routing);
+
+export const config = {
+  // Only match page routes — exclude API routes, Next.js internals, and static files
+  matcher: ["/((?!api|_next|_vercel|.*\\..*).*)" ],
+};

package/src/types/agent.ts

@@ -0,0 +1,124 @@
+export type AttachedImage = {
+  id: string;
+  data: string;       // raw base64 (no data: prefix)
+  mimeType: string;   // "image/jpeg" | "image/png" | etc.
+  name: string;
+  previewUrl: string; // data URL for <img> display
+};
+
+export type DigitalAgent = {
+  id: string;
+  name: string;
+  avatar: string;
+  description: string;
+  systemPrompt: string;
+  persona: {
+    tone: "formal" | "casual" | "friendly" | "professional";
+    language: string;
+  };
+  model: {
+    provider: string;
+    modelId: string;
+    temperature: number;
+    maxTokens: number;
+    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+  };
+  voice: {
+    enabled: boolean;
+  };
+  tools: {
+    bash: boolean;
+    fileRead: boolean;
+    fileWrite: boolean;
+    grep: boolean;
+    find: boolean;
+    calculator: boolean;
+  };
+  knowledgeBases: string[];
+  enabledSkills: string[];
+  workspacePath: string;   // 数字人专属工作区目录，空字符串表示使用 ~/.pi/agent
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type CreateAgentInput = Omit<DigitalAgent, "id" | "createdAt" | "updatedAt">;
+export type UpdateAgentInput = Partial<CreateAgentInput>;
+
+export const DEFAULT_AGENT: CreateAgentInput = {
+  name: "",
+  avatar: "🤖",
+  description: "",
+  systemPrompt: "",
+  persona: { tone: "friendly", language: "zh-CN" },
+  model: {
+    provider: "anthropic",
+    modelId: "claude-opus-4-5",
+    temperature: 0.7,
+    maxTokens: 8192,
+    thinkingLevel: "medium",
+  },
+  voice: {
+    enabled: false,
+  },
+  tools: {
+    bash: false,
+    fileRead: false,
+    fileWrite: false,
+    grep: false,
+    find: false,
+    calculator: false,
+  },
+  knowledgeBases: [],
+  enabledSkills: [],
+  workspacePath: "",
+};
+
+export const AVATAR_OPTIONS = [
+  "🤖", "🧠", "💡", "🎯", "🌟", "🦾", "👾", "🎭",
+  "👨‍💼", "👩‍💼", "👨‍🏫", "👩‍🏫", "👨‍💻", "👩‍💻", "🧑‍🎨", "🧑‍🔬",
+  "🐉", "🦊", "🐼", "🦁", "🐬", "🦋", "🌈", "⚡",
+];
+
+export type SessionStats = {
+  tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number };
+  cost: number;
+  contextUsage?: { tokens: number; percent: number; contextWindow: number };
+  userMessages: number;
+  assistantMessages: number;
+};
+
+export type AgentChatEvent =
+  | { type: "message_update"; delta: string }
+  | { type: "tool_start"; toolName: string; toolCallId: string }
+  | { type: "tool_update"; toolCallId: string; content: string }
+  | { type: "tool_end"; toolCallId: string; toolName?: string; isError: boolean; output?: string; fullOutputPath?: string; truncated?: boolean }
+  | { type: "thinking_delta"; delta: string }
+  | { type: "compaction_start" }
+  | { type: "compaction_end" }
+  | { type: "session_file"; path: string }
+  | { type: "session_stats"; stats: SessionStats }
+  | { type: "aborted" }
+  | { type: "error"; message: string }
+  | { type: "done" };
+
+export type ChatMessage = {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  thinking?: string;
+  toolCalls?: ToolCall[];
+  images?: AttachedImage[];
+  entryId?: string;
+  createdAt: Date;
+};
+
+export type ToolCall = {
+  id: string;
+  name: string;
+  input?: string;
+  output?: string;
+  fullOutputPath?: string;
+  truncated?: boolean;
+  isError?: boolean;
+  isLoading?: boolean;
+};

package/src/types/knowledge.ts

@@ -0,0 +1,39 @@
+export type KnowledgeBase = {
+  id: string;
+  name: string;
+  description: string;
+  embeddingModel: string;
+  documentCount: number;
+  chunkCount: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type KbDocument = {
+  id: string;
+  kbId: string;
+  filename: string;
+  filePath: string;
+  mimeType: string;
+  chunkCount: number;
+  status: "processing" | "ready" | "error";
+  error?: string;
+  createdAt: string;
+};
+
+export type KbChunk = {
+  id: string;
+  kbId: string;
+  docId: string;
+  content: string;
+  metadata: {
+    filename: string;
+    pageNum?: number;
+    chunkIndex: number;
+  };
+};
+
+export type SearchResult = {
+  chunk: KbChunk;
+  score: number;
+};

package/src/types/settings.ts

@@ -0,0 +1,31 @@
+export type AppSettings = {
+  apiKeys: {
+    anthropic?: string;
+    openai?: string;
+    google?: string;
+  };
+  ollama: {
+    host: string;
+  };
+  defaultModel: {
+    provider: string;
+    modelId: string;
+  };
+  theme: "light" | "dark" | "system";
+  language: "zh" | "en";
+  storagePath: string;
+};
+
+export const DEFAULT_SETTINGS: AppSettings = {
+  apiKeys: {},
+  ollama: {
+    host: "http://localhost:11434",
+  },
+  defaultModel: {
+    provider: "anthropic",
+    modelId: "claude-opus-4-5",
+  },
+  theme: "system",
+  language: "zh",
+  storagePath: "",
+};

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    },
+    "target": "ES2017"
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}