@qcluffy/agent-bootstrap 0.0.3 → 0.0.4

package/hooks/bootstrap-system/handler.js

@@ -1,176 +1,107 @@
 /**
- * Bootstrap System Hook Handler
+ * Bootstrap System Hook Handler - TypeScript 版本
  * 
- * 集成 Python bootstrap-system 到 OpenClaw
+ * 直接调用 TypeScript 编译后的 bootstrap 模块
  */
 
-const fs = require('fs').promises;
 const path = require('path');
-const { spawn } = require('child_process');
-const os = require('os');
+const fs = require('fs');
 
-// 配置
+// 获取插件目录
+const pluginDir = __dirname;
+
+// 配置 - 指向 dist/systems
 const CONFIG = {
-  bootstrapSystemPath: 'templates/bootstrap-system',
-  mainScript: 'main.py',
+  bootstrapSystemPath: path.join(pluginDir, 'dist', 'systems'),
 };
 
 /**
- * 运行 Python bootstrap-system CLI
+ * 加载 TypeScript 编译后的 BootstrapEngine
  */
-async function runPythonCli(args = []) {
-  const workspaceDir = process.env.OPENCLAW_WORKSPACE || 
-    path.join(os.homedir(), '.openclaw', 'workspace');
-  const pythonScript = path.join(workspaceDir, CONFIG.bootstrapSystemPath, CONFIG.mainScript);
-  
-  return new Promise((resolve) => {
-    fs.access(pythonScript).then(() => {
-      const proc = spawn('python3', [pythonScript, ...args], {
-        cwd: workspaceDir,
-        env: { 
-          ...process.env, 
-          OPENCLAW_WORKSPACE: workspaceDir,
-          PYTHONPATH: path.join(workspaceDir, CONFIG.bootstrapSystemPath)
-        }
-      });
-      
-      let output = '';
-      let error = '';
-      
-      proc.stdout.on('data', (data) => { output += data.toString(); });
-      proc.stderr.on('data', (data) => { error += data.toString(); });
-      
-      proc.on('close', (code) => {
-        resolve({ success: code === 0, output, error });
-      });
-      
-      proc.on('error', (err) => {
-        resolve({ success: false, error: err.message });
-      });
-      
-    }).catch(() => {
-      resolve({ success: false, error: 'Bootstrap system not found' });
-    });
-  });
-}
+let BootstrapEngine = null;
 
-/**
- * 从会话消息中提取文本内容
- */
-function extractMessageText(message) {
-  if (!message || !message.content) return '';
-  
-  if (typeof message.content === 'string') {
-    return message.content;
-  }
-  
-  if (Array.isArray(message.content)) {
-    return message.content
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text || '')
-      .join('');
+async function getBootstrapEngine() {
+  if (!BootstrapEngine) {
+    try {
+      const module = await import(path.join(CONFIG.bootstrapSystemPath, 'bootstrap.js'));
+      BootstrapEngine = module.BootstrapEngine || module.default;
+    } catch (e) {
+      console.error('[bootstrap-system] Failed to load bootstrap module:', e.message);
+      return null;
+    }
   }
-  
-  return '';
+  return BootstrapEngine;
 }
 
 /**
- * 处理 session_start - 检查是否需要引导
+ * 检查是否需要引导
  */
-async function handleSessionStart(event) {
+async function checkBootstrap(event) {
   console.log('[bootstrap-system] Checking bootstrap status...');
   
-  const result = await runPythonCli(['status', '--json']);
-  
-  if (result.success && result.output) {
-    try {
-      const status = JSON.parse(result.output);
-      event.context = event.context || {};
-      event.context.bootstrap = status;
-      
-      if (!status.is_completed && status.status === 'not_started') {
-        // 需要开始引导
-        event.needsBootstrap = true;
-        console.log('[bootstrap-system] Bootstrap needed');
-      } else if (status.is_completed) {
-        console.log('[bootstrap-system] Bootstrap already completed');
-      }
-    } catch (e) {
-      console.log('[bootstrap-system] Parse error:', e.message);
+  try {
+    const workspaceDir = process.env.OPENCLAW_WORKSPACE || 
+      path.join(process.env.HOME || '', '.openclaw', 'workspace');
+    
+    // 检查关键文件是否存在
+    const requiredFiles = ['IDENTITY.md', 'SOUL.md', 'USER.md'];
+    const missing = requiredFiles.filter(f => 
+      !fs.existsSync(path.join(workspaceDir, f))
+    );
+    
+    if (missing.length > 0) {
+      console.log('[bootstrap-system] Bootstrap needed, missing:', missing);
+      event.needsBootstrap = true;
+      event.bootstrapFiles = missing;
+    } else {
+      console.log('[bootstrap-system] Bootstrap not needed');
+      event.needsBootstrap = false;
     }
+  } catch (e) {
+    console.log('[bootstrap-system] Check error:', e.message);
   }
   
   return event;
 }
 
 /**
- * 处理 bootstrap 命令
+ * 处理 bootstrap:start - 开始引导
  */
-async function handleBootstrapCommand(event) {
-  const action = event.action;
-  const input = event.input || '';
+async function handleBootstrapStart(event) {
+  console.log('[bootstrap-system] Starting bootstrap...');
   
-  if (action === 'start' || action === 'begin') {
-    // 开始引导
-    const result = await runPythonCli(['start']);
-    event.response = result.output;
-  }
-  else if (action === 'step') {
-    // 查看当前步骤
-    const result = await runPythonCli(['step']);
-    event.response = result.output;
-  }
-  else if (action === 'submit' || action === 'next') {
-    // 提交输入
-    const result = await runPythonCli(['submit', input]);
-    event.response = result.output;
-    
-    // 检查是否完成
-    if (result.output.includes('初始化完成') || result.output.includes('completed')) {
-      event.bootstrapCompleted = true;
+  try {
+    const BootstrapClass = await getBootstrapEngine();
+    if (BootstrapClass) {
+      const bootstrap = new BootstrapEngine();
+      const context = await bootstrap.start();
+      
+      event.bootstrapContext = context;
+      console.log('[bootstrap-system] Bootstrap started');
     }
-  }
-  else if (action === 'status') {
-    // 查看状态
-    const result = await runPythonCli(['status']);
-    event.response = result.output;
-  }
-  else if (action === 'reset') {
-    // 重置
-    const result = await runPythonCli(['reset']);
-    event.response = '✓ 引导已重置，请重新开始';
+  } catch (e) {
+    console.log('[bootstrap-system] Bootstrap error:', e.message);
   }
   
   return event;
 }
 
 /**
- * 处理用户消息 - 检查是否是引导输入
+ * 处理 bootstrap:complete - 引导完成
  */
-async function handleMessage(event) {
-  const context = event.context || {};
+async function handleBootstrapComplete(event) {
+  console.log('[bootstrap-system] Bootstrap completed...');
   
-  // 检查是否正在进行引导
-  if (context.bootstrap && context.bootstrap.status === 'in_progress') {
-    const messages = context.messages || [];
-    const reversed = [...messages].reverse();
-    const lastUserMsg = reversed.find((m) => m.role === 'user');
-    
-    if (lastUserMsg) {
-      const userText = extractMessageText(lastUserMsg);
+  try {
+    const BootstrapClass = await getBootstrapEngine();
+    if (BootstrapClass) {
+      const bootstrap = new BootstrapEngine();
+      await bootstrap.complete(event.bootstrapData);
       
-      if (userText && !userText.startsWith('/')) {
-        // 提交作为引导输入
-        console.log('[bootstrap-system] Submitting bootstrap input:', userText.substring(0, 20));
-        const result = await runPythonCli(['submit', userText]);
-        
-        event.bootstrapResponse = result.output;
-        
-        if (result.output.includes('初始化完成') || result.output.includes('completed')) {
-          event.bootstrapCompleted = true;
-        }
-      }
+      console.log('[bootstrap-system] Bootstrap completed');
     }
+  } catch (e) {
+    console.log('[bootstrap-system] Complete error:', e.message);
   }
   
   return event;
@@ -187,19 +118,13 @@ async function handle(event) {
   
   try {
     if (type === 'session' || type === 'session:start') {
-      await handleSessionStart(event);
+      await checkBootstrap(event);
     }
-    else if (type === 'message' || type === 'message:received') {
-      await handleMessage(event);
+    else if (type === 'bootstrap' || type === 'bootstrap:start') {
+      await handleBootstrapStart(event);
     }
-    else if (type === 'command') {
-      // 处理引导命令
-      if (action === 'bootstrap' || action === '引导' || action === '开始') {
-        await handleBootstrapCommand(event);
-      }
-      else if (['start', 'step', 'submit', 'status', 'reset'].includes(action)) {
-        await handleBootstrapCommand(event);
-      }
+    else if (type === 'bootstrap' || type === 'bootstrap:complete') {
+      await handleBootstrapComplete(event);
     }
   } catch (error) {
     console.error('[bootstrap-system] Handler error:', error.message);
@@ -212,8 +137,8 @@ module.exports = handle;
 module.exports.handle = handle;
 module.exports.metadata = {
   name: 'bootstrap-system',
-  description: '初始化引导系统，交互式收集用户配置、塑造Agent人格',
-  events: ['session', 'message', 'command'],
+  description: 'Bootstrap System: interactive agent initialization and configuration',
+  events: ['session', 'bootstrap'],
   version: '1.0.0',
 };
 

package/hooks/cognition-system/handler.js

@@ -1,143 +1,79 @@
 /**
- * Cognition System Hook Handler
+ * Cognition System Hook Handler - TypeScript 版本
  * 
- * 集成 Python cognition-system 到 OpenClaw
+ * 直接调用 TypeScript 编译后的 cognition 模块
  */
 
-const fs = require('fs').promises;
 const path = require('path');
-const { spawn } = require('child_process');
-const os = require('os');
 
-// 配置
+// 获取插件目录
+const pluginDir = __dirname;
+
+// 配置 - 指向 dist/systems
 const CONFIG = {
-  cognitionSystemPath: 'templates/cognition-system',
-  mainScript: 'main.py',
+  cognitionSystemPath: path.join(pluginDir, 'dist', 'systems'),
 };
 
 /**
- * 运行 Python cognition-system CLI
+ * 加载 TypeScript 编译后的 CognitionSystem
  */
-async function runPythonCli(args = []) {
-  const workspaceDir = process.env.OPENCLAW_WORKSPACE || 
-    path.join(os.homedir(), '.openclaw', 'workspace');
-  const pythonScript = path.join(workspaceDir, CONFIG.cognitionSystemPath, CONFIG.mainScript);
-  
-  return new Promise((resolve) => {
-    fs.access(pythonScript).then(() => {
-      const proc = spawn('python3', [pythonScript, ...args], {
-        cwd: workspaceDir,
-        env: { 
-          ...process.env, 
-          OPENCLAW_WORKSPACE: workspaceDir,
-          PYTHONPATH: path.join(workspaceDir, CONFIG.cognitionSystemPath)
-        }
-      });
-      
-      let output = '';
-      let error = '';
-      
-      proc.stdout.on('data', (data) => { output += data.toString(); });
-      proc.stderr.on('data', (data) => { error += data.toString(); });
-      
-      proc.on('close', (code) => {
-        resolve({ success: code === 0, output, error });
-      });
-      
-      proc.on('error', (err) => {
-        resolve({ success: false, error: err.message });
-      });
-      
-    }).catch(() => {
-      resolve({ success: false, error: 'Cognition system not found' });
-    });
-  });
-}
+let CognitionSystem = null;
 
-/**
- * 从会话消息中提取文本内容
- */
-function extractMessageText(message) {
-  if (!message || !message.content) return '';
-  
-  if (typeof message.content === 'string') {
-    return message.content;
-  }
-  
-  if (Array.isArray(message.content)) {
-    return message.content
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text || '')
-      .join('');
+async function getCognitionSystem() {
+  if (!CognitionSystem) {
+    try {
+      const module = await import(path.join(CONFIG.cognitionSystemPath, 'cognition.js'));
+      CognitionSystem = module.CognitionSystem || module.default;
+    } catch (e) {
+      console.error('[cognition-system] Failed to load cognition module:', e.message);
+      return null;
+    }
   }
-  
-  return '';
+  return CognitionSystem;
 }
 
 /**
- * 处理 message:received - 认知处理
+ * 处理 message:received - 更新认知上下文
  */
 async function handleMessageReceived(event) {
-  console.log('[cognition-system] Processing with cognition...');
-  
-  const context = event.context || {};
-  const messages = context.messages || [];
-  
-  if (messages.length === 0) return event;
-  
-  // 获取最新用户消息
-  const reversed = [...messages].reverse();
-  const lastUserMsg = reversed.find((m) => m.role === 'user');
-  
-  if (!lastUserMsg) return event;
-  
-  const userText = extractMessageText(lastUserMsg);
-  
-  if (!userText || userText.startsWith('/')) return event;
+  console.log('[cognition-system] Updating cognition context...');
   
-  // 获取已分析的意图（来自 input-system）
-  const intent = context.intent || {};
-  
-  if (intent.type) {
-    // 使用认知系统处理
-    const result = await runPythonCli(['process', JSON.stringify({
-      action: intent.action || intent.type,
-      type: intent.type,
-    }), '--json']);
-    
-    if (result.success && result.output) {
-      try {
-        const cognitionResult = JSON.parse(result.output);
-        context.cognition = cognitionResult;
-        
-        // 根据任务步骤调整回复策略
-        if (cognitionResult.allowed && cognitionResult.next_step) {
-          context.replyStrategy = {
-            ...context.replyStrategy,
-            task: cognitionResult.task,
-            nextStep: cognitionResult.next_step,
-          };
-        }
-        
-        console.log('[cognition-system] Cognition result:', cognitionResult.allowed ? 'allowed' : 'denied');
-      } catch (e) {
-        console.log('[cognition-system] Parse error:', e.message);
-      }
+  try {
+    const CognitionClass = await getCognitionSystem();
+    if (CognitionClass) {
+      const cognition = new CognitionClass();
+      const context = event.context || {};
+      const messages = context.messages || [];
+      
+      cognition.updateFromContext(messages);
+      console.log('[cognition-system] Context updated');
     }
+  } catch (e) {
+    console.log('[cognition-system] Update error:', e.message);
   }
   
   return event;
 }
 
 /**
- * 处理 feedback 命令
+ * 处理 agent:before - 推理规划
  */
-async function handleFeedback(event) {
-  const feedback = event.feedback || event.text || '';
+async function handleBeforeAgent(event) {
+  console.log('[cognition-system] Reasoning and planning...');
   
-  if (feedback) {
-    const result = await runPythonCli(['learn', feedback]);
-    console.log('[cognition-system] Learning:', feedback);
+  try {
+    const CognitionClass = await getCognitionSystem();
+    if (CognitionClass) {
+      const cognition = new CognitionClass();
+      const context = event.context || {};
+      
+      // 可以在这里进行任务分解、决策等
+      // 目前是占位符
+      
+      console.log('[cognition-system] Reasoning completed');
+    }
+  } catch (e) {
+    console.log('[cognition-system] Reasoning error:', e.message);
   }
   
   return event;
@@ -148,24 +84,15 @@ async function handleFeedback(event) {
  */
 async function handle(event) {
   const type = event.type || event.event || '';
-  const action = event.action || '';
   
-  console.log(`[cognition-system] Event: ${type}/${action}`);
+  console.log(`[cognition-system] Event: ${type}`);
   
   try {
     if (type === 'message' || type === 'message:received') {
       await handleMessageReceived(event);
     }
-    else if (type === 'command') {
-      if (action === 'learn' || action === 'feedback') {
-        await handleFeedback(event);
-      }
-      else if (action === 'cognition' || action === 'status') {
-        const result = await runPythonCli(['status', '--json']);
-        if (result.success) {
-          event.response = result.output;
-        }
-      }
+    else if (type === 'agent' || type === 'agent:before') {
+      await handleBeforeAgent(event);
     }
   } catch (error) {
     console.error('[cognition-system] Handler error:', error.message);
@@ -178,8 +105,8 @@ module.exports = handle;
 module.exports.handle = handle;
 module.exports.metadata = {
   name: 'cognition-system',
-  description: '认知系统，推理规划、任务分解、学习适应、决策判断',
-  events: ['message', 'command'],
+  description: 'Cognition System: reasoning, planning, task decomposition',
+  events: ['message', 'agent'],
   version: '1.0.0',
 };