foliko 1.1.92 → 2.0.0

package/src/tool/schema.js

@@ -0,0 +1,108 @@
+'use strict';
+
+/**
+ * Tool Schema utilities
+ * Zod/JSON-Schema adaptation helpers
+ */
+
+const { z } = require('zod');
+
+/**
+ * Convert JSON Schema to Zod schema
+ * @param {Object} jsonSchema
+ * @param {boolean} [required] - Whether this schema is required (optional when false)
+ * @returns {z.ZodType}
+ */
+function jsonSchemaToZod(jsonSchema, required) {
+  if (!jsonSchema || typeof jsonSchema !== 'object') {
+    return z.any();
+  }
+
+  return _convertSchema(jsonSchema, required);
+}
+
+function _convertSchema(schema, required = false) {
+  if (!schema) return z.any();
+
+  let type = schema.type;
+  if (Array.isArray(type)) {
+    const nonNull = type.filter(t => t !== 'null');
+    type = nonNull.length === 1 ? nonNull[0] : 'any';
+  }
+
+  let zodType;
+
+  switch (type) {
+    case 'string': {
+      zodType = z.string();
+      if (schema.enum) zodType = z.enum(schema.enum);
+      if (schema.pattern) zodType = zodType.regex(new RegExp(schema.pattern));
+      if (schema.minLength) zodType = zodType.min(schema.minLength);
+      if (schema.maxLength) zodType = zodType.max(schema.maxLength);
+      break;
+    }
+    case 'number':
+      zodType = z.number();
+      if (schema.minimum !== undefined) zodType = zodType.min(schema.minimum);
+      if (schema.maximum !== undefined) zodType = zodType.max(schema.maximum);
+      break;
+    case 'integer':
+      zodType = z.number().int();
+      if (schema.minimum !== undefined) zodType = zodType.min(schema.minimum);
+      if (schema.maximum !== undefined) zodType = zodType.max(schema.maximum);
+      break;
+    case 'boolean':
+      zodType = z.boolean();
+      break;
+    case 'array': {
+      if (schema.items) {
+        zodType = z.array(_convertSchema(schema.items, true));
+      } else {
+        zodType = z.array(z.any());
+      }
+      break;
+    }
+    case 'object': {
+      if (!schema.properties || Object.keys(schema.properties).length === 0) {
+        zodType = z.record(z.any());
+        break;
+      }
+      const shape = {};
+      const req = schema.required || [];
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        shape[key] = _convertSchema(prop, req.includes(key));
+      }
+      const obj = z.object(shape);
+      zodType = req.length === Object.keys(shape).length ? obj : obj.partial();
+      break;
+    }
+    case 'null':
+      zodType = z.null();
+      break;
+    default:
+      zodType = z.any();
+  }
+
+  if (schema.nullable) zodType = zodType.nullable();
+  if (!required && schema.default === undefined) zodType = zodType.optional();
+
+  return zodType;
+}
+
+/**
+ * Convert tool definition to AI SDK tool format
+ */
+function toAISDKTool(toolDef) {
+  const parameters = toolDef.inputSchema || toolDef.parameters;
+  return {
+    type: 'function',
+    name: toolDef.name,
+    description: toolDef.description || '',
+    parameters: parameters || { type: 'object', properties: {} },
+  };
+}
+
+module.exports = {
+  jsonSchemaToZod,
+  toAISDKTool,
+};

package/src/utils/data-splitter.js

@@ -12,7 +12,7 @@
  * - 任何超过上下文限制的工具结果
  */
 
-const { logger } = require('./logger');
+const { logger } = require('../common/logger');
 
 // 默认分块大小 (字符数，约 50K tokens)
 const DEFAULT_CHUNK_SIZE = 60000;

package/src/utils/download.js

@@ -6,7 +6,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { fileTypeFromFile, fileTypeFromBuffer } = require('file-type');
 const { downloadAndDecryptMedia } = require('@chnak/weixin-bot');
-const { logger } = require('./logger');
+const { logger } = require('../common/logger');
 class FileDownloader {
   constructor(options = {}) {
     this.timeout = options.timeout || 30000;

package/src/utils/index.js

@@ -3,7 +3,7 @@
  */
 
 // 日志系统
-const { Logger, logger, LOG_LEVELS } = require('./logger');
+const { Logger, logger, LOG_LEVELS } = require('../common/logger');
 
 // ID 生成器
 const {
@@ -17,7 +17,7 @@ const {
   messageId,
   ruleId,
   resetSnowflake,
-} = require('./id');
+} = require('../common/id');
 
 // 错误处理
 const {
@@ -33,10 +33,10 @@ const {
   PluginNotFoundError,
   isErrorOfType,
   safeErrorInfo,
-} = require('./error');
+} = require('../common/errors');
 
 // 重试策略
-const { withRetry, retryable, isNetworkError, PRESETS } = require('./retry');
+const { withRetry, retryable, isNetworkError, PRESETS } = require('../common/retry');
 
 // 错误边界
 const {
@@ -45,7 +45,7 @@ const {
   RecoveryAction,
   createErrorBoundary,
   combineBoundaries,
-} = require('./error-boundary');
+} = require('../common/errors');
 
 /**
  * 清理 LLM 回复中的思考标记
@@ -538,5 +538,5 @@ module.exports = {
   prepareMessagesForAPI,
 
   // Edit/Diff
-  editDiff: require('./edit-diff'),
+  editDiff: require('../common/diff'),
 };

package/src/utils/message-validator.js

@@ -8,7 +8,7 @@
  * - 减少消息数组多次遍历
  */
 
-const { logger } = require('./logger');
+const { logger } = require('../common/logger');
 
 /**
  * 收集所有 assistant 消息中的 tool-call ID

package/tests/core/context-storage.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+
+describe('ContextStorage', () => {
+  it('should provide request/session/agent context isolation', () => {
+    const storage = require('../../src/context/storage');
+
+    const results = [];
+
+    storage.runRequest({ req: 'A' }, () => {
+      results.push(storage.getRequest());
+    });
+
+    storage.runSession({ sess: 'B' }, () => {
+      results.push(storage.getSession());
+    });
+
+    storage.runAgent({ agent: 'C' }, () => {
+      results.push(storage.getAgent());
+    });
+
+    expect(results[0]).toEqual({ req: 'A' });
+    expect(results[1]).toEqual({ sess: 'B' });
+    expect(results[2]).toEqual({ agent: 'C' });
+  });
+
+  it('should maintain isolation between nested contexts', () => {
+    const storage = require('../../src/context/storage');
+
+    const collected = [];
+
+    storage.runRequest({ id: 1 }, () => {
+      storage.runSession({ sid: 's1' }, () => {
+        collected.push({ req: storage.getRequest(), sess: storage.getSession() });
+      });
+    });
+
+    storage.runRequest({ id: 2 }, () => {
+      collected.push({ req: storage.getRequest(), sess: storage.getSession() });
+    });
+
+    expect(collected[0].req.id).toBe(1);
+    expect(collected[0].sess.sid).toBe('s1');
+    expect(collected[1].req.id).toBe(2);
+    expect(collected[1].sess).toBeUndefined();
+  });
+});

package/tests/core/llm.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+
+describe('LLM Module', () => {
+  it('should export all expected symbols', () => {
+    const llm = require('../../src/llm');
+    expect(llm.createAI).toBeDefined();
+    expect(llm.createModel).toBeDefined();
+    expect(llm.getAvailableProviders).toBeDefined();
+    expect(llm.DEFAULT_PROVIDERS).toBeDefined();
+    expect(llm.isThinkingModel).toBeDefined();
+    expect(llm.ProviderRegistry).toBeDefined();
+    expect(llm.getProviderRegistry).toBeDefined();
+    expect(llm.TokenCounter).toBeDefined();
+    expect(llm.encode).toBeDefined();
+    expect(llm.estimateTokens).toBeDefined();
+    expect(llm.estimateContextTokens).toBeDefined();
+    expect(llm.shouldCompact).toBeDefined();
+  });
+
+  it('should detect thinking models', () => {
+    const { isThinkingModel } = require('../../src/llm');
+    expect(isThinkingModel('deepseek-v4-pro')).toBe(true);
+    expect(isThinkingModel('deepseek-v4-flash')).toBe(true);
+    expect(isThinkingModel('deepseek-reasoner')).toBe(true);
+    expect(isThinkingModel('gpt-4o')).toBe(false);
+    expect(isThinkingModel(null)).toBe(false);
+  });
+
+  it('should provide default provider list', () => {
+    const { getAvailableProviders, DEFAULT_PROVIDERS } = require('../../src/llm');
+    const providers = getAvailableProviders();
+    expect(Array.isArray(providers)).toBe(true);
+    expect(providers.length).toBeGreaterThan(0);
+    expect(DEFAULT_PROVIDERS.deepseek).toBeDefined();
+    expect(DEFAULT_PROVIDERS.anthropic).toBeDefined();
+  });
+
+  it('should have ProviderRegistry singleton', () => {
+    const { getProviderRegistry } = require('../../src/llm');
+    const reg1 = getProviderRegistry();
+    const reg2 = getProviderRegistry();
+    expect(reg1).toBe(reg2);
+    expect(reg1.getProviderNames().length).toBeGreaterThan(0);
+  });
+
+  it('should count tokens correctly', () => {
+    const { TokenCounter, encode } = require('../../src/llm');
+    const counter = new TokenCounter();
+    expect(typeof counter.countText).toBe('function');
+    expect(typeof counter.countMessages).toBe('function');
+    expect(encode('hello world')).toBeGreaterThan(0);
+    expect(encode('')).toBe(0);
+  });
+});

package/tests/core/plugin.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Plugin Module', () => {
+  it('should export all expected symbols', () => {
+    const plugin = require('../../src/plugin');
+    expect(plugin.Plugin).toBeDefined();
+    expect(plugin.PluginType).toBeDefined();
+    expect(plugin.PluginManager).toBeDefined();
+    expect(plugin.resolvePluginPath).toBeDefined();
+    expect(plugin.scanPluginNames).toBeDefined();
+    expect(plugin.loadPluginFromPath).toBeDefined();
+  });
+
+  it('should have Plugin base class with default values', () => {
+    const { Plugin } = require('../../src/plugin');
+    const p = new Plugin();
+    expect(p.name).toBe('unnamed-plugin');
+    expect(p.version).toBe('1.0.0');
+    expect(p.priority).toBe(100);
+    expect(p.enabled).toBe(true);
+    expect(p.system).toBe(false);
+  });
+
+  it('should have PluginType constants', () => {
+    const { PluginType } = require('../../src/plugin');
+    expect(PluginType.AI).toBe('ai');
+    expect(PluginType.TOOLS).toBe('tools');
+    expect(PluginType.EXECUTOR).toBe('executor');
+    expect(PluginType.CAPABILITY).toBe('capability');
+  });
+
+  it('should create and configure PluginManager', () => {
+    const { PluginManager, PluginType } = require('../../src/plugin');
+    const framework = { getCwd: () => '/test', logger: { child: () => ({ debug: () => {}, info: () => {}, warn: () => {} }) } };
+    const pm = new PluginManager(framework);
+    expect(pm.count()).toBe(0);
+
+    const mockPlugin = { name: 'test', version: '1.0', enabled: true };
+    // PluginManager.register expects Plugin instance
+    expect(() => pm.register(mockPlugin)).toThrow('must be an instance of Plugin');
+  });
+});

package/tests/core/tool.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Tool Module', () => {
+  it('should export all expected symbols', () => {
+    const tool = require('../../src/tool');
+    expect(tool.ToolRegistry).toBeDefined();
+    expect(tool.ToolExecutor).toBeDefined();
+    expect(tool.ToolRouter).toBeDefined();
+    expect(tool.jsonSchemaToZod).toBeDefined();
+    expect(tool.toAISDKTool).toBeDefined();
+    expect(tool.INTENT_PATTERNS).toBeDefined();
+  });
+
+  it('should register and execute tools via ToolRegistry', async () => {
+    const { ToolRegistry } = require('../../src/tool');
+    const registry = new ToolRegistry();
+
+    const testTool = {
+      name: 'echo',
+      description: 'Echo back input',
+      execute: async (args) => ({ result: args.input }),
+    };
+
+    registry.register(testTool);
+    expect(registry.has('echo')).toBe(true);
+    expect(registry.get('echo').name).toBe('echo');
+    expect(registry.count()).toBe(1);
+
+    const result = await registry.execute('echo', { input: 'hello' });
+    expect(result.result).toBe('hello');
+  });
+
+  it('should throw on missing tool name', () => {
+    const { ToolRegistry } = require('../../src/tool');
+    const registry = new ToolRegistry();
+    expect(() => registry.register({ execute: async () => {} })).toThrow('Tool must have a name');
+  });
+
+  it('should get all tool names', () => {
+    const { ToolRegistry } = require('../../src/tool');
+    const registry = new ToolRegistry();
+    registry.register({ name: 'a', execute: async () => {} });
+    registry.register({ name: 'b', execute: async () => {} });
+    expect(registry.getNames()).toEqual(['a', 'b']);
+  });
+
+  it('should clear all tools', () => {
+    const { ToolRegistry } = require('../../src/tool');
+    const registry = new ToolRegistry();
+    registry.register({ name: 'a', execute: async () => {} });
+    registry.clear();
+    expect(registry.count()).toBe(0);
+  });
+
+  it('should throw on tool not found', async () => {
+    const { ToolRegistry } = require('../../src/tool');
+    const registry = new ToolRegistry();
+    await expect(registry.execute('nonexistent', {})).rejects.toThrow('not found');
+  });
+});

package/tests/setup.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// Test setup for Foliko
+const path = require('path');
+
+// Set test environment
+process.env.NODE_ENV = 'test';
+
+// Suppress logger output during tests
+process.env.LOG_LEVEL = 'silent';

package/tests/smoke.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Foliko Framework - Smoke Tests', () => {
+  it('should load main module exports', () => {
+    const foliko = require('../src/index');
+    expect(foliko.Framework).toBeDefined();
+    expect(foliko.Agent).toBeDefined();
+    expect(foliko.Plugin).toBeDefined();
+    expect(foliko.PluginManager).toBeDefined();
+    expect(foliko.ToolRegistry).toBeDefined();
+    expect(foliko.EventEmitter).toBeDefined();
+    expect(foliko.SkillManagerPlugin).toBeDefined();
+    expect(foliko.WorkflowPlugin).toBeDefined();
+  });
+
+  it('should create a Framework instance', () => {
+    const { Framework } = require('../src/index');
+    const framework = new Framework();
+    expect(framework).toBeDefined();
+    expect(framework.constructor.name).toBe('Framework');
+  });
+
+  it('should register and retrieve tools via ToolRegistry', () => {
+    const { ToolRegistry } = require('../src/index');
+    const registry = new ToolRegistry();
+
+    const testTool = {
+      name: 'test_tool',
+      description: 'A test tool',
+      execute: async () => ({ result: 'ok' }),
+    };
+
+    registry.register(testTool);
+    expect(registry.get('test_tool')).toBeDefined();
+    expect(registry.get('test_tool').name).toBe('test_tool');
+  });
+
+  it('should handle EventEmitter events', () => {
+    const { EventEmitter } = require('../src/index');
+    const emitter = new EventEmitter();
+    const events = [];
+    emitter.on('test', (msg) => events.push(msg));
+    emitter.emit('test', 'hello');
+    expect(events).toEqual(['hello']);
+  });
+
+  it('should load framework utilities', () => {
+    const { logger } = require('../src/common/logger');
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+  });
+
+  it('should load core constants', () => {
+    const constants = require('../src/common/constants');
+    expect(constants).toBeDefined();
+    expect(constants.PROMPT_PRIORITY).toBeDefined();
+  });
+});

package/vitest.config.js

@@ -0,0 +1,9 @@
+const { defineConfig } = require('vitest/config');
+
+module.exports = defineConfig({
+  test: {
+    globals: true,
+    setupFiles: ['./tests/setup.js'],
+    include: ['tests/**/*.test.js'],
+  },
+});

package/cli/src/daemon.js

@@ -1,149 +0,0 @@
-/**
- * Foliko 后台服务入口
- * 使用 framework.bootstrap() 自动加载 .foliko/ 目录配置
- * 持续运行，不退出
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// 默认配置
-const DEFAULT_CONFIG = {
-  model: 'MiniMax-M2.7',
-  provider: 'minimax',
-  baseURL: 'https://api.minimaxi.com/v1',
-  apiKey: null,
-};
-
-// Provider 默认配置
-const PROVIDER_DEFAULTS = {
-  minimax: {
-    model: 'MiniMax-M2.7',
-    baseURL: 'https://api.minimaxi.com/v1',
-  },
-  deepseek: {
-    model: 'deepseek-chat',
-    baseURL: 'https://api.deepseek.com/v1',
-  },
-};
-
-// 解析命令行参数 --cwd <path>
-const cwdArg = process.argv.find((arg) => arg === '--cwd');
-const daemonCwd = cwdArg ? process.argv[process.argv.indexOf(cwdArg) + 1] : process.cwd();
-
-// 切换到工作目录
-if (daemonCwd !== process.cwd()) {
-  process.chdir(daemonCwd);
-}
-
-// 日志文件
-const LOG_FILE = path.join(process.cwd(), '.foliko.log');
-
-// 覆盖 console.log，同时写日志和终端
-const originalLog = console.log;
-const originalError = console.error;
-console.log = (...args) => {
-  const msg = `[${new Date().toISOString()}] ` + args.join(' ');
-  fs.appendFileSync(LOG_FILE, msg + '\n');
-  originalLog.apply(console, args);
-};
-console.error = (...args) => {
-  const msg = `[${new Date().toISOString()}] ERROR ` + args.join(' ');
-  fs.appendFileSync(LOG_FILE, msg + '\n');
-  originalError.apply(console, args);
-};
-
-// 覆盖 process.stdout.write，只写日志（捕获框架日志）
-const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-process.stdout.write = (chunk) => {
-  fs.appendFileSync(LOG_FILE, chunk.toString());
-  return originalStdoutWrite(chunk);
-};
-
-// 覆盖 process.stderr.write
-const originalStderrWrite = process.stderr.write.bind(process.stderr);
-process.stderr.write = (chunk) => {
-  fs.appendFileSync(LOG_FILE, chunk.toString());
-  return originalStderrWrite(chunk);
-};
-
-// 环境变量已在 commands/daemon.js 中通过 spawn 传递
-const { Framework } = require('../../src');
-
-// 调试：打印接收到的环境变量
-console.log('[DEBUG] process.env.QQ_APP_ID =', process.env.QQ_APP_ID);
-console.log('[DEBUG] process.env.QQ_CLIENT_SECRET =', process.env.QQ_CLIENT_SECRET ? '***' + process.env.QQ_CLIENT_SECRET.slice(-6) : 'undefined');
-console.log('[DEBUG] process.env.FOLIKO_API_KEY =', process.env.FOLIKO_API_KEY ? '***' + process.env.FOLIKO_API_KEY.slice(-6) : 'undefined');
-
-/**
- * 获取环境变量配置
- */
-function getEnvConfig() {
-  const provider = process.env.FOLIKO_PROVIDER || DEFAULT_CONFIG.provider;
-  const providerDefaults = PROVIDER_DEFAULTS[provider] || PROVIDER_DEFAULTS.minimax;
-
-  // 支持多种 API key 环境变量名
-  let apiKey = process.env.FOLIKO_API_KEY || null;
-  if (!apiKey) {
-    // 根据 provider 查找对应的 API key
-    const upperProvider = provider.toUpperCase().replace(/-/g, '_');
-    apiKey = process.env[`${upperProvider}_API_KEY`] || null;
-  }
-
-  return {
-    model: process.env.FOLIKO_MODEL || providerDefaults.model,
-    provider: provider,
-    baseURL: process.env.FOLIKO_BASE_URL || providerDefaults.baseURL,
-    apiKey: apiKey,
-  };
-}
-
-/**
- * 解析命令行参数（命令行参数优先于环境变量）
- */
-function parseArgs(args) {
-  // 先获取环境变量配置（作为默认值）
-  const envConfig = getEnvConfig();
-  const options = { ...envConfig };
-
-  return options;
-}
-
-
-async function main(args = process.argv.slice(2)) {
-  console.log('[Foliko] 启动后台服务...');
-  const options = parseArgs(args);
-  // 创建框架
-  const framework = new Framework({ debug: false });
-
-  // 使用 bootstrap 自动加载所有默认插件
-  await framework.bootstrap({
-    agentDir: './.foliko',
-    aiConfig: {
-      provider: options.provider,
-      model: options.model,
-      apiKey: options.apiKey,
-      baseURL: options.baseURL,
-    },
-  });
-
-  console.log('[Foliko] 框架已就绪');
-  console.log('[Foliko] 已加载插件:', framework.pluginManager.getAll().map((p) => p.name));
-  console.log('[Foliko] 后台服务运行中 (PID: ' + process.pid + ')');
-
-  // 优雅退出
-  const shutdown = async () => {
-    console.log('[Foliko] 正在关闭...');
-    await framework.destroy();
-    console.log('[Foliko] 已关闭');
-    process.exit(0);
-  };
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-}
-
-main().catch((err) => {
-  console.log('[Foliko] 启动失败:', err.message);
-  process.exit(1);
-});