foliko 1.1.93 → 2.0.1

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);
-});