pulse-coder-engine 0.0.1-alpha.1

package/examples/new-engine-usage.ts

@@ -0,0 +1,52 @@
+import { Engine } from '../src/Engine.js';
+import { skillRegistryPlugin } from '../src/plugins/skill-registry.plugin.js';
+
+// 示例1：基础使用
+async function basicUsage() {
+  const engine = new Engine();
+  
+  // 加载引擎插件（包括技能系统）
+  await engine.initialize();
+  
+  console.log('✅ Engine initialized with plugin system');
+  console.log('📊 Plugin status:', engine.getPluginStatus());
+}
+
+// 示例2：自定义配置
+async function customConfigUsage() {
+  const engine = new Engine({
+    enginePlugins: {
+      plugins: [skillRegistryPlugin],
+      dirs: ['./custom-engine-plugins']
+    },
+    userConfigPlugins: {
+      dirs: ['./config', '~/.coder/config'],
+      scan: true
+    }
+  });
+  
+  await engine.initialize();
+  
+  const context = { messages: [] };
+  const result = await engine.run(context);
+  console.log('🎯 Execution result:', result);
+}
+
+// 示例3：动态添加用户配置
+async function dynamicConfigUsage() {
+  const engine = new Engine();
+  await engine.initialize();
+  
+  // 运行时添加用户配置
+  // 这将在第二阶段实现
+  console.log('🔄 Dynamic config will be available in phase 2');
+}
+
+// 运行示例
+async function main() {
+  await basicUsage();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pulse-coder-engine",
+  "version": "0.0.1-alpha.1",
+  "description": "Plugin-based AI engine for Pulse Coder",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./src": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./built-in": {
+      "types": "./dist/built-in/index.d.ts",
+      "import": "./dist/built-in/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.42",
+    "@ai-sdk/mcp": "^1.0.19",
+    "@ai-sdk/openai": "^3.0.21",
+    "@requesty/ai-sdk": "^3.1.0",
+    "ai": "^6.0.57",
+    "dotenv": "^17.2.3",
+    "glob": "^11.0.0",
+    "gray-matter": "^4.0.3",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/node": "^25.0.10",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}

package/src/Engine.ts

@@ -0,0 +1,150 @@
+import type { Context } from './shared/types';
+import type { LoopOptions } from './core/loop';
+import type { EnginePluginLoadOptions } from './plugin/EnginePlugin.js';
+import type { UserConfigPluginLoadOptions } from './plugin/UserConfigPlugin.js';
+
+import { loop } from './core/loop.js';
+import { BuiltinToolsMap } from './tools/index.js';
+import { PluginManager } from './plugin/PluginManager.js';
+import { builtInPlugins } from './built-in/index.js';
+
+/**
+ * 引擎配置选项
+ */
+export interface EngineOptions {
+  // 引擎插件配置
+  enginePlugins?: EnginePluginLoadOptions;
+
+  // 用户配置插件配置
+  userConfigPlugins?: UserConfigPluginLoadOptions;
+
+  // 是否禁用内置插件（默认启用）
+  disableBuiltInPlugins?: boolean;
+
+  // 全局配置
+  config?: Record<string, any>;
+}
+
+/**
+ * 重构后的引擎类
+ * 自动包含内置插件，支持可选禁用
+ */
+export class Engine {
+  private pluginManager: PluginManager;
+  private tools: Record<string, any> = { ...BuiltinToolsMap };
+  private options: EngineOptions = {};
+  private config: Record<string, any> = {};
+
+  constructor(options?: EngineOptions) {
+    this.pluginManager = new PluginManager();
+
+    // 初始化全局配置
+    this.config = options?.config || {};
+    this.options = options || {};
+  }
+
+  /**
+   * 初始化引擎和插件系统
+   * 自动包含内置插件
+   */
+  async initialize(): Promise<void> {
+    console.log('Initializing engine...', this.config);
+
+    // 准备插件列表：内置插件 + 用户配置插件
+    const allEnginePlugins = this.prepareEnginePlugins();
+
+    // 插件管理器会自动处理加载顺序
+    await this.pluginManager.initialize({
+      enginePlugins: {
+        ...allEnginePlugins
+      },
+      userConfigPlugins: {
+        ...(this.options.userConfigPlugins || {})
+      }
+    });
+
+    // 合并插件工具到引擎工具库
+    const pluginTools = this.pluginManager.getTools();
+    this.tools = { ...this.tools, ...pluginTools };
+  }
+
+  /**
+   * 准备引擎插件列表（包含内置插件）
+   */
+  private prepareEnginePlugins(): EnginePluginLoadOptions {
+    const userPlugins = this.options.enginePlugins || {};
+    
+    // 如果用户禁用了内置插件，只返回用户插件
+    if (this.options.disableBuiltInPlugins) {
+      return userPlugins;
+    }
+
+    // 合并内置插件和用户插件
+    const builtInPluginList = [...builtInPlugins];
+    const userPluginList = userPlugins.plugins || [];
+
+    return {
+      plugins: [...builtInPluginList, ...userPluginList],
+      dirs: userPlugins.dirs || ['.pulse-coder/engine-plugins', '.coder/engine-plugins', '~/.pulse-coder/engine-plugins', '~/.coder/engine-plugins'],
+      scan: userPlugins.scan !== false // 默认启用扫描
+    };
+  }
+
+  /**
+   * 运行AI循环
+   */
+  async run(context: Context, options?: LoopOptions): Promise<string> {
+    return loop(context, {
+      ...options,
+      tools: this.tools,
+      onToolCall: (toolCall) => {
+        options?.onToolCall?.(toolCall);
+      },
+      onClarificationRequest: options?.onClarificationRequest,
+    });
+  }
+
+  /**
+   * 获取插件状态
+   */
+  getPluginStatus() {
+    return this.pluginManager.getStatus();
+  }
+
+  /**
+   * 获取工具
+   */
+  getTools(): Record<string, any> {
+    return { ...this.tools };
+  }
+
+  /**
+   * 获取服务
+   */
+  getService<T>(name: string): T | undefined {
+    return this.pluginManager.getService<T>(name);
+  }
+
+  /**
+   * 获取配置
+   */
+  getConfig<T>(key: string): T | undefined {
+    return this.config[key];
+  }
+
+  /**
+   * 设置配置
+   */
+  setConfig<T>(key: string, value: T): void {
+    this.config[key] = value;
+  }
+}
+
+// 重新导出类型
+export * from './shared/types.js';
+export * from './plugin/EnginePlugin.js';
+export * from './plugin/UserConfigPlugin.js';
+export { loop } from './core/loop.js';
+export { streamTextAI } from './ai/index.js';
+export { maybeCompactContext } from './context/index.js';
+export * from './tools/index.js';

package/src/ai/index.ts

@@ -0,0 +1,116 @@
+import { generateText, streamText, tool, type ModelMessage, type StepResult, type Tool } from 'ai';
+import { CoderAI, DEFAULT_MODEL, COMPACT_SUMMARY_MAX_TOKENS, OPENAI_REASONING_EFFORT } from '../config';
+import z from 'zod';
+import { generateSystemPrompt } from '../prompt';
+import type { Tool as CoderTool, ToolExecutionContext } from '../shared/types';
+
+
+const providerOptions = OPENAI_REASONING_EFFORT
+  ? { openai: { reasoningEffort: OPENAI_REASONING_EFFORT } }
+  : undefined;
+
+export const generateTextAI = (messages: ModelMessage[], tools: Record<string, Tool>) => {
+  const finalMessages = [
+    {
+      role: 'system',
+      content: generateSystemPrompt(),
+    },
+    ...messages,
+  ] as ModelMessage[];
+
+  return generateText({
+    model: CoderAI(DEFAULT_MODEL),
+    messages: finalMessages,
+    tools,
+    providerOptions,
+  }) as unknown as ReturnType<typeof generateText> & { steps: StepResult<any>[]; finishReason: string };
+}
+
+export interface StreamOptions {
+  abortSignal?: AbortSignal;
+  onStepFinish?: (event: StepResult<any>) => void;
+  onChunk?: (event: { chunk: any }) => void;
+  toolExecutionContext?: ToolExecutionContext;
+}
+
+/**
+ * Wraps tools to inject ToolExecutionContext before execution
+ */
+export const wrapToolsWithContext = (
+  tools: Record<string, CoderTool>,
+  context?: ToolExecutionContext
+): Record<string, Tool> => {
+  const wrappedTools: Record<string, Tool> = {};
+
+  for (const [name, tool] of Object.entries(tools)) {
+    wrappedTools[name] = {
+      ...tool,
+      execute: async (input: any) => {
+        // Call the original execute with context
+        return await tool.execute(input, context);
+      }
+    } as Tool;
+  }
+
+  return wrappedTools;
+};
+
+export const streamTextAI = (messages: ModelMessage[], tools: Record<string, CoderTool>, options?: StreamOptions) => {
+
+  const finalMessages = [
+    {
+      role: 'system',
+      content: generateSystemPrompt(),
+    },
+    ...messages,
+  ] as ModelMessage[];
+
+  // Wrap tools with execution context if provided
+  const wrappedTools = options?.toolExecutionContext
+    ? wrapToolsWithContext(tools, options.toolExecutionContext)
+    : tools;
+
+  return streamText({
+    model: CoderAI(DEFAULT_MODEL),
+    messages: finalMessages,
+    tools: wrappedTools as Record<string, Tool>,
+    providerOptions,
+    abortSignal: options?.abortSignal,
+    onStepFinish: options?.onStepFinish,
+    onChunk: options?.onChunk,
+  }) as unknown as ReturnType<typeof streamText> & { steps: StepResult<any>[]; finishReason: string };
+}
+
+export const summarizeMessages = async (
+  messages: ModelMessage[],
+  options?: { maxOutputTokens?: number }
+): Promise<string> => {
+  const SUMMARY_SYSTEM_PROMPT =
+    '你是负责压缩对话上下文的助手。请基于给定历史消息，提炼关键事实与决策，避免臆测或扩展。';
+
+  const SUMMARY_USER_PROMPT = [
+    '请将以上对话压缩为以下格式，使用中文：',
+    '[COMPACTED_CONTEXT]',
+    '- 目标: ...',
+    '- 进展: ...',
+    '- 关键结果: ...',
+    '- 文件与变更: ...',
+    '- 关键片段: "..." / `...` / "..."',
+    '- 待确认: ...',
+    '',
+    '要求：内容简洁准确，不要编造。',
+  ].join('\n');
+
+  const result = await generateText({
+    model: CoderAI(DEFAULT_MODEL),
+    messages: [
+      { role: 'system', content: SUMMARY_SYSTEM_PROMPT },
+      ...messages,
+      { role: 'user', content: SUMMARY_USER_PROMPT },
+    ],
+    maxOutputTokens: options?.maxOutputTokens ?? COMPACT_SUMMARY_MAX_TOKENS,
+    providerOptions,
+  });
+
+  return result.text ?? '';
+}

package/src/built-in/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Built-in plugins for Pulse Coder Engine
+ * 引擎内置插件集合
+ */
+
+import { builtInMCPPlugin } from './mcp-plugin';
+import { builtInSkillsPlugin } from './skills-plugin';
+import { SubAgentPlugin } from './sub-agent-plugin';
+
+/**
+ * 默认内置插件列表
+ * 这些插件会在引擎启动时自动加载
+ */
+export const builtInPlugins = [
+  builtInMCPPlugin,
+  builtInSkillsPlugin,
+  new SubAgentPlugin()
+];
+
+/**
+ * 单独导出各个内置插件，便于外部使用
+ */
+export { builtInMCPPlugin } from './mcp-plugin';
+export { builtInSkillsPlugin, BuiltInSkillRegistry } from './skills-plugin';
+export { SubAgentPlugin } from './sub-agent-plugin';
+
+export default builtInPlugins;

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

@@ -0,0 +1,104 @@
+/**
+ * Built-in MCP Plugin for Pulse Coder Engine
+ * 将 MCP 功能作为引擎内置插件
+ */
+
+import { EnginePlugin, EnginePluginContext } from '../../plugin/EnginePlugin';
+import { createMCPClient } from '@ai-sdk/mcp';
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+
+export interface MCPPluginConfig {
+  servers: Record<string, { url: string }>;
+}
+
+export async function loadMCPConfig(cwd: string): Promise<MCPPluginConfig> {
+  // 优先读取 .pulse-coder/mcp.json，兼容旧版 .coder/mcp.json
+  const newConfigPath = path.join(cwd, '.pulse-coder', 'mcp.json');
+  const legacyConfigPath = path.join(cwd, '.coder', 'mcp.json');
+  const configPath = existsSync(newConfigPath) ? newConfigPath : legacyConfigPath;
+
+  if (!existsSync(configPath)) {
+    return { servers: {} };
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    
+    if (!parsed.servers || typeof parsed.servers !== 'object') {
+      console.warn('[MCP] Invalid config: missing "servers" object');
+      return { servers: {} };
+    }
+
+    return { servers: parsed.servers };
+  } catch (error) {
+    console.warn(`[MCP] Failed to load config: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    return { servers: {} };
+  }
+}
+
+function createHTTPTransport(config: { url: string }) {
+  return {
+    type: 'http' as const,
+    url: config.url
+  };
+}
+
+export const builtInMCPPlugin: EnginePlugin = {
+  name: '@pulse-coder/engine/built-in-mcp',
+  version: '1.0.0',
+
+  async initialize(context: EnginePluginContext) {
+    const config = await loadMCPConfig(process.cwd());
+
+    const serverCount = Object.keys(config.servers).length;
+    if (serverCount === 0) {
+      console.log('[MCP] No MCP servers configured');
+      return;
+    }
+
+    let loadedCount = 0;
+
+    for (const [serverName, serverConfig] of Object.entries(config.servers)) {
+      try {
+        if (!serverConfig.url) {
+          console.warn(`[MCP] Server "${serverName}" missing URL, skipping`);
+          continue;
+        }
+
+        const transport = createHTTPTransport(serverConfig);
+        const client = await createMCPClient({ transport });
+
+        const tools = await client.tools();
+
+        // 注册工具到引擎，使用命名空间前缀
+        const namespacedTools = Object.fromEntries(
+          Object.entries(tools).map(([toolName, tool]) => [
+            `mcp_${serverName}_${toolName}`,
+            tool as any
+          ])
+        );
+
+        context.registerTools(namespacedTools);
+
+        loadedCount++;
+        console.log(`[MCP] Server "${serverName}" loaded (${Object.keys(tools).length} tools)`);
+
+        // 注册服务供其他插件使用
+        context.registerService(`mcp:${serverName}`, client);
+
+      } catch (error) {
+        console.warn(`[MCP] Failed to load server "${serverName}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    if (loadedCount > 0) {
+      console.log(`[MCP] Successfully loaded ${loadedCount}/${serverCount} MCP servers`);
+    } else {
+      console.warn('[MCP] No MCP servers were loaded successfully');
+    }
+  }
+};
+
+export default builtInMCPPlugin;