pulse-coder-engine 0.0.1-alpha.1

package/src/built-in/skills-plugin/index.ts

@@ -0,0 +1,223 @@
+/**
+ * Built-in Skills Plugin for Pulse Coder Engine
+ * 将技能系统作为引擎内置插件
+ */
+
+import { EnginePlugin, EnginePluginContext } from '../../plugin/EnginePlugin';
+import { Tool } from '../../shared/types';
+import { existsSync, readFileSync } from 'fs';
+import { globSync } from 'glob';
+import matter from 'gray-matter';
+import { homedir } from 'os';
+import * as path from 'path';
+import { z } from 'zod';
+
+/**
+ * 技能信息接口
+ */
+export interface SkillInfo {
+  name: string;
+  description: string;
+  location: string;
+  content: string;
+  metadata?: Record<string, any>;
+}
+
+/**
+ * 技能注册表
+ */
+export class BuiltInSkillRegistry {
+  private skills: Map<string, SkillInfo> = new Map();
+  private initialized = false;
+
+  /**
+   * 初始化注册表，扫描并加载所有技能
+   */
+  async initialize(cwd: string): Promise<void> {
+    if (this.initialized) {
+      console.warn('SkillRegistry already initialized');
+      return;
+    }
+
+    console.log('Scanning built-in skills...');
+    const skillList = await this.scanSkills(cwd);
+
+    this.skills.clear();
+    for (const skill of skillList) {
+      this.skills.set(skill.name, skill);
+    }
+
+    this.initialized = true;
+    console.log(`Loaded ${this.skills.size} built-in skill(s)`);
+  }
+
+  /**
+   * 扫描技能文件
+   */
+  private async scanSkills(cwd: string): Promise<SkillInfo[]> {
+    const skills: SkillInfo[] = [];
+    
+    const scanPaths = [
+      // 项目级技能（优先 .pulse-coder，兼容旧版 .coder 和 .claude）
+      { base: cwd, pattern: '.pulse-coder/skills/**/SKILL.md' },
+      { base: cwd, pattern: '.coder/skills/**/SKILL.md' },
+      { base: cwd, pattern: '.claude/skills/**/SKILL.md' },
+      // 用户级技能（优先 .pulse-coder，兼容旧版 .coder）
+      { base: homedir(), pattern: '.pulse-coder/skills/**/SKILL.md' },
+      { base: homedir(), pattern: '.coder/skills/**/SKILL.md' }
+    ];
+
+    for (const { base, pattern } of scanPaths) {
+      try {
+        const files = globSync(pattern, { cwd: base, absolute: true });
+        
+        for (const filePath of files) {
+          try {
+            const skillInfo = this.parseSkillFile(filePath);
+            if (skillInfo) {
+              skills.push(skillInfo);
+            }
+          } catch (error) {
+            console.warn(`Failed to parse skill file ${filePath}:`, error);
+          }
+        }
+      } catch (error) {
+        console.debug(`Skip scanning ${pattern} in ${base}:`, error);
+      }
+    }
+
+    return skills;
+  }
+
+  /**
+   * 解析技能文件
+   */
+  private parseSkillFile(filePath: string): SkillInfo | null {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const { data, content: markdownContent } = matter(content);
+
+      if (!data.name || !data.description) {
+        console.warn(`Skill file ${filePath} missing required fields (name or description)`);
+        return null;
+      }
+
+      return {
+        name: data.name,
+        description: data.description,
+        location: filePath,
+        content: markdownContent,
+        metadata: data
+      };
+    } catch (error) {
+      console.warn(`Failed to read skill file ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * 获取所有技能
+   */
+  getAll(): SkillInfo[] {
+    return Array.from(this.skills.values());
+  }
+
+  /**
+   * 根据名称获取技能
+   */
+  get(name: string): SkillInfo | undefined {
+    return this.skills.get(name);
+  }
+
+  /**
+   * 检查技能是否存在
+   */
+  has(name: string): boolean {
+    return this.skills.has(name);
+  }
+
+  /**
+   * 搜索技能（模糊匹配）
+   */
+  search(keyword: string): SkillInfo[] {
+    const lowerKeyword = keyword.toLowerCase();
+    return this.getAll().filter(
+      (skill) =>
+        skill.name.toLowerCase().includes(lowerKeyword) ||
+        skill.description.toLowerCase().includes(lowerKeyword)
+    );
+  }
+}
+
+/**
+ * 技能工具参数 schema
+ */
+const skillToolSchema = z.object({
+  name: z.string().describe('The name of the skill to execute')
+});
+
+type SkillToolInput = z.infer<typeof skillToolSchema>;
+
+/**
+ * 生成技能工具
+ */
+function generateSkillTool(skills: SkillInfo[]): Tool<SkillToolInput, SkillInfo> {
+  const getSkillsPrompt = (availableSkills: SkillInfo[]) => {
+    return [
+      "If query matches an available skill's description or instruction [use skill], use the skill tool to get detailed instructions.",
+      "Load a skill to get detailed instructions for a specific task.",
+      "Skills provide specialized knowledge and step-by-step guidance.",
+      "Use this when a task matches an available skill's description.",
+      "Only the skills listed here are available:",
+      "[!important] You should follow the skill's step-by-step guidance. If the skill is not complete, ask the user for more information.",
+      "<available_skills>",
+      ...availableSkills.flatMap((skill) => [
+        `  <skill>`,
+        `    <name>${skill.name}</name>`,
+        `    <description>${skill.description}</description>`,
+        `  </skill>`
+      ]),
+      "</available_skills>"
+    ].join(" ");
+  };
+
+  return {
+    name: "skill",
+    description: getSkillsPrompt(skills),
+    inputSchema: skillToolSchema,
+    execute: async ({ name }) => {
+      const skill = skills.find((skill) => skill.name === name);
+      if (!skill) {
+        throw new Error(`Skill ${name} not found`);
+      }
+      return skill;
+    }
+  };
+}
+
+/**
+ * 内置技能插件
+ */
+export const builtInSkillsPlugin: EnginePlugin = {
+  name: '@pulse-coder/engine/built-in-skills',
+  version: '1.0.0',
+
+  async initialize(context: EnginePluginContext) {
+    const registry = new BuiltInSkillRegistry();
+    await registry.initialize(process.cwd());
+
+    const skills = registry.getAll();
+    if (skills.length === 0) {
+      console.log('[Skills] No skills found');
+      return;
+    }
+
+    const skillTool = generateSkillTool(skills);
+    context.registerTool('skill', skillTool);
+    context.registerService('skillRegistry', registry);
+
+    console.log(`[Skills] Registered ${skills.length} skill(s)`);
+  }
+};
+
+export default builtInSkillsPlugin;

package/src/built-in/sub-agent-plugin/index.ts

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+import { promises as fs } from 'fs';
+import path from 'path';
+import type { EnginePlugin, EnginePluginContext } from '../../plugin/EnginePlugin';
+import type { Context } from '../../shared/types.js';
+import { loop } from '../../core/loop';
+import { BuiltinToolsMap } from '../../tools';
+import { Tool } from 'ai';
+
+interface AgentConfig {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  filePath: string;
+}
+
+class ConfigLoader {
+
+  async getAgentFilesInfo(configDirs: string[]) {
+    const fileInfos: Array<{ files: string[], configDir: string }> = [];
+    for (let configDir of configDirs) {
+      try {
+        await fs.access(configDir);
+
+        const files = await fs.readdir(configDir);
+        fileInfos.push({ files, configDir });
+      } catch {
+        continue;
+      }
+    }
+
+    return fileInfos;
+  }
+
+  async loadAgentConfigs(configDir: string | string[] = ['.pulse-coder/agents', '.coder/agents']): Promise<AgentConfig[]> {
+    const configs: AgentConfig[] = [];
+
+    const configDirs = Array.isArray(configDir) ? configDir : [configDir];
+
+    try {
+      const filesInfo = await this.getAgentFilesInfo(configDirs);
+
+      for (const fileInfo of filesInfo) {
+        const files = fileInfo.files;
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            const config = await this.parseConfig(path.join(fileInfo.configDir, file));
+            if (config) configs.push(config);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to scan agent configs: ${error}`);
+    }
+
+    return configs;
+  }
+
+  private async parseConfig(filePath: string): Promise<AgentConfig | null> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+
+      let name = '';
+      let description = '';
+      let systemPrompt = '';
+      let inFrontmatter = false;
+      let frontmatterEnd = false;
+
+      for (const line of lines) {
+        if (line.trim() === '---') {
+          if (!inFrontmatter) {
+            inFrontmatter = true;
+            continue;
+          } else {
+            frontmatterEnd = true;
+            continue;
+          }
+        }
+
+        if (inFrontmatter && !frontmatterEnd) {
+          const match = line.match(/^\s*(\w+)\s*:\s*(.+)$/);
+          if (match) {
+            const [, key, value] = match;
+            if (key === 'name') name = value.trim();
+            if (key === 'description') description = value.trim();
+          }
+        } else if (frontmatterEnd) {
+          systemPrompt += line + '\n';
+        }
+      }
+
+      if (!name) {
+        name = path.basename(filePath, '.md');
+      }
+
+      return {
+        name: name.trim(),
+        description: description.trim(),
+        systemPrompt: systemPrompt.trim(),
+        filePath
+      };
+    } catch (error) {
+      console.warn(`Failed to parse agent config ${filePath}: ${error}`);
+      return null;
+    }
+  }
+}
+
+class AgentRunner {
+  async runAgent(
+    config: AgentConfig,
+    task: string,
+    context?: Record<string, any>,
+    tools?: Record<string, any>
+  ): Promise<string> {
+    const subContext: Context = {
+      messages: [
+        { role: 'system', content: config.systemPrompt },
+        { role: 'user', content: task }
+      ]
+    };
+
+    if (context && Object.keys(context).length > 0) {
+      subContext.messages.push({
+        role: 'user',
+        content: `上下文信息：\n${JSON.stringify(context, null, 2)}`
+      });
+    }
+
+    return await loop(subContext, { tools });
+  }
+}
+
+export class SubAgentPlugin implements EnginePlugin {
+  name = 'sub-agent';
+  version = '1.0.0';
+
+  private configLoader = new ConfigLoader();
+  private agentRunner = new AgentRunner();
+
+  async initialize(context: EnginePluginContext): Promise<void> {
+    try {
+      const configs = await this.configLoader.loadAgentConfigs();
+
+      // 获取插件管理器提供的所有工具
+      const tools = this.getAvailableTools(context);
+
+      for (const config of configs) {
+        this.registerAgentTool(context, config, tools);
+      }
+
+      context.logger.info(`SubAgentPlugin loaded ${configs.length} agents.`);
+    } catch (error) {
+      context.logger.error('Failed to initialize SubAgentPlugin', error as Error);
+    }
+  }
+
+  private getAvailableTools(context: EnginePluginContext): Record<string, any> {
+    // 从插件上下文中获取所有注册的工具
+    // 在初始化阶段，所有工具已经通过插件系统注册
+    const allTools: Record<string, any> = {};
+
+    // 这里我们假设工具通过某种方式可用
+    // 实际使用时，引擎会提供所有可用的工具
+    return BuiltinToolsMap;
+  }
+
+  private registerAgentTool(
+    context: EnginePluginContext,
+    config: AgentConfig,
+    tools: Record<string, any>
+  ): void {
+    const toolName = `${config.name}_agent`;
+
+    const tool: Tool = {
+      description: config.description,
+      inputSchema: z.object({
+        task: z.string().describe('要执行的任务描述'),
+        context: z.any().optional().describe('任务上下文信息')
+      }),
+      execute: async ({ task, context: taskContext }: { task: string; context?: Record<string, any> }) => {
+        try {
+          context.logger.info(`Running agent ${config.name}: ${task}`);
+          const result = await this.agentRunner.runAgent(config, task, taskContext, tools);
+          context.logger.info(`Agent ${config.name} completed successfully`);
+          return result;
+        } catch (error) {
+          context.logger.error(`Agent ${config.name} failed`, error as Error);
+          throw new Error(`Agent ${config.name} failed: ${error}`);
+        }
+      }
+    };
+
+    context.registerTool(toolName, tool);
+  }
+
+  async destroy(context: EnginePluginContext): Promise<void> {
+    context.logger.info('SubAgentPlugin destroyed');
+  }
+}
+
+export default SubAgentPlugin;

package/src/config/index.ts

@@ -0,0 +1,35 @@
+import dotenv from "dotenv";
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { LanguageModel } from "ai";
+
+dotenv.config();
+
+export const CoderAI = (process.env.USE_ANTHROPIC
+  ? createAnthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY || '',
+    baseURL: process.env.ANTHROPIC_API_URL || 'https://api.anthropic.com/v1'
+  })
+  : createOpenAI({
+    apiKey: process.env.OPENAI_API_KEY || '',
+    baseURL: process.env.OPENAI_API_URL || 'https://api.openai.com/v1'
+  }).chat) as (model: string) => LanguageModel;
+
+export const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || process.env.OPENAI_MODEL || 'novita/deepseek/deepseek_v3';
+
+export const MAX_TURNS = 100;
+export const MAX_ERROR_COUNT = 3;
+export const MAX_STEPS = 100;
+export const MAX_TOOL_OUTPUT_LENGTH = 30_000;
+
+export const CONTEXT_WINDOW_TOKENS = Number(process.env.CONTEXT_WINDOW_TOKENS ?? 64_000);
+export const COMPACT_TRIGGER = Number(process.env.COMPACT_TRIGGER ?? Math.floor(CONTEXT_WINDOW_TOKENS * 0.75));
+export const COMPACT_TARGET = Number(process.env.COMPACT_TARGET ?? Math.floor(CONTEXT_WINDOW_TOKENS * 0.5));
+export const KEEP_LAST_TURNS = Number(process.env.KEEP_LAST_TURNS ?? 6);
+export const COMPACT_SUMMARY_MAX_TOKENS = Number(process.env.COMPACT_SUMMARY_MAX_TOKENS ?? 1200);
+export const MAX_COMPACTION_ATTEMPTS = Number(process.env.MAX_COMPACTION_ATTEMPTS ?? 2);
+export const OPENAI_REASONING_EFFORT = process.env.OPENAI_REASONING_EFFORT;
+
+// Clarification settings
+export const CLARIFICATION_TIMEOUT = Number(process.env.CLARIFICATION_TIMEOUT ?? 300_000); // 5 minutes
+export const CLARIFICATION_ENABLED = process.env.CLARIFICATION_ENABLED !== 'false';

package/src/context/index.ts

@@ -0,0 +1,134 @@
+import { pruneMessages, type ModelMessage } from "ai";
+import { summarizeMessages } from "../ai";
+import {
+  COMPACT_TRIGGER,
+  COMPACT_TARGET,
+  KEEP_LAST_TURNS,
+} from "../config/index";
+import type { Context } from "../shared/types";
+
+type CompactResult = {
+  didCompact: boolean;
+  reason?: string;
+  newMessages?: ModelMessage[];
+};
+
+const ensureSummaryPrefix = (summary: string): string => {
+  const trimmed = summary.trim();
+  if (trimmed.length === 0) {
+    return '';
+  }
+  if (trimmed.startsWith('[COMPACTED_CONTEXT]')) {
+    return trimmed;
+  }
+  return `[COMPACTED_CONTEXT]\n${trimmed}`;
+};
+
+const safeStringify = (value: unknown): string => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const estimateTokens = (messages: ModelMessage[]): number => {
+  let totalChars = 0;
+  for (const message of messages) {
+    totalChars += message.role.length;
+    if (typeof message.content === 'string') {
+      totalChars += message.content.length;
+    } else {
+      totalChars += safeStringify(message.content).length;
+    }
+  }
+  return Math.ceil(totalChars / 4);
+};
+
+const splitByTurns = (messages: ModelMessage[], keepLastTurns: number) => {
+  const userIndices: number[] = [];
+  messages.forEach((message, index) => {
+    if (message.role === 'user') {
+      userIndices.push(index);
+    }
+  });
+
+  if (userIndices.length <= keepLastTurns) {
+    return { oldMessages: [], recentMessages: messages };
+  }
+
+  const cutIndex = userIndices[userIndices.length - keepLastTurns];
+  return {
+    oldMessages: messages.slice(0, cutIndex),
+    recentMessages: messages.slice(cutIndex),
+  };
+};
+
+const takeLastTurns = (messages: ModelMessage[], keepLastTurns: number): ModelMessage[] => {
+  const userIndices: number[] = [];
+  messages.forEach((message, index) => {
+    if (message.role === 'user') {
+      userIndices.push(index);
+    }
+  });
+
+  if (userIndices.length === 0) {
+    return messages;
+  }
+
+  if (userIndices.length <= keepLastTurns) {
+    return messages;
+  }
+
+  const startIndex = userIndices[userIndices.length - keepLastTurns];
+  return messages.slice(startIndex);
+};
+
+export const maybeCompactContext = async (
+  context: Context,
+  options?: { force?: boolean }
+): Promise<CompactResult> => {
+  const { messages } = context;
+  if (messages.length === 0) {
+    return { didCompact: false };
+  }
+
+  const estimatedTokens = estimateTokens(messages);
+  if (!options?.force && estimatedTokens < COMPACT_TRIGGER) {
+    return { didCompact: false };
+  }
+
+  const { oldMessages, recentMessages } = splitByTurns(messages, KEEP_LAST_TURNS);
+  if (oldMessages.length === 0) {
+    return { didCompact: false };
+  }
+
+  try {
+    const summary = await summarizeMessages(oldMessages);
+    const summaryText = ensureSummaryPrefix(summary);
+    if (!summaryText) {
+      throw new Error('Empty summary result');
+    }
+
+    const nextMessages: ModelMessage[] = [
+      { role: 'assistant', content: summaryText },
+      ...recentMessages,
+    ];
+
+    if (estimateTokens(nextMessages) > COMPACT_TARGET) {
+      const newMessages = takeLastTurns(messages, KEEP_LAST_TURNS);
+      return { didCompact: true, reason: 'summary-too-large', newMessages };
+    }
+
+    return { didCompact: true, newMessages: nextMessages };
+  } catch (error) {
+    const pruned = pruneMessages({
+      messages,
+      reasoning: 'all',
+      toolCalls: 'all',
+      emptyMessages: 'remove',
+    });
+    const newMessages = takeLastTurns(pruned, KEEP_LAST_TURNS);
+    return { didCompact: true, reason: 'fallback', newMessages };
+  }
+};