foliko 1.1.67 → 1.1.69

package/src/core/jsonl-storage.js

@@ -0,0 +1,253 @@
+/**
+ * JSONL Session Storage
+ * Append-only JSONL storage with tree structure and leaf tracking
+ * Ported from pi's session/jsonl-storage.ts
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { generateEntryId, EntryTypes } = require('./session-entry');
+
+const CURRENT_SESSION_VERSION = 3;
+
+const SessionErrors = {
+  NOT_FOUND: 'not_found',
+  INVALID_SESSION: 'invalid_session',
+  INVALID_ENTRY: 'invalid_entry'
+};
+
+class SessionError extends Error {
+  constructor(code, message, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = 'SessionError';
+    this.code = code;
+  }
+}
+
+function isRecord(value) {
+  return typeof value === 'object' && value !== null;
+}
+
+function invalidSession(filePath, message, cause) {
+  return new SessionError(SessionErrors.INVALID_SESSION, `Invalid JSONL session file ${filePath}: ${message}`, cause);
+}
+
+function invalidEntry(filePath, lineNumber, message, cause) {
+  return new SessionError(
+    SessionErrors.INVALID_ENTRY,
+    `Invalid JSONL session file ${filePath}: line ${lineNumber} ${message}`,
+    cause
+  );
+}
+
+function parseHeaderLine(line, filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw invalidSession(filePath, 'first line is not a valid session header', error);
+  }
+  if (!isRecord(parsed)) throw invalidSession(filePath, 'first line is not a valid session header');
+  if (parsed.type !== 'session') throw invalidSession(filePath, 'first line is not a valid session header');
+  if (parsed.version !== 3) throw invalidSession(filePath, 'unsupported session version');
+  if (typeof parsed.id !== 'string' || !parsed.id) throw invalidSession(filePath, 'session header is missing id');
+  if (typeof parsed.timestamp !== 'string' || !parsed.timestamp) {
+    throw invalidSession(filePath, 'session header is missing timestamp');
+  }
+  if (typeof parsed.cwd !== 'string' || !parsed.cwd) throw invalidSession(filePath, 'session header is missing cwd');
+  if (parsed.parentSession !== undefined && typeof parsed.parentSession !== 'string') {
+    throw invalidSession(filePath, 'session header parentSession must be a string');
+  }
+  return {
+    type: 'session',
+    version: 3,
+    id: parsed.id,
+    timestamp: parsed.timestamp,
+    cwd: parsed.cwd,
+    parentSession: parsed.parentSession
+  };
+}
+
+function parseEntryLine(line, filePath, lineNumber) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw invalidEntry(filePath, lineNumber, 'is not valid JSON', error);
+  }
+  if (!isRecord(parsed)) throw invalidEntry(filePath, lineNumber, 'is not valid session entry');
+  if (typeof parsed.type !== 'string') throw invalidEntry(filePath, lineNumber, 'is missing entry type');
+  if (typeof parsed.id !== 'string' || !parsed.id) throw invalidEntry(filePath, lineNumber, 'is missing entry id');
+  if (parsed.parentId !== null && typeof parsed.parentId !== 'string') {
+    throw invalidEntry(filePath, lineNumber, 'has invalid parentId');
+  }
+  if (typeof parsed.timestamp !== 'string' || !parsed.timestamp) {
+    throw invalidEntry(filePath, lineNumber, 'is missing timestamp');
+  }
+  if (parsed.type === EntryTypes.LEAF && parsed.targetId !== null && typeof parsed.targetId !== 'string') {
+    throw invalidEntry(filePath, lineNumber, 'has invalid targetId');
+  }
+  return parsed;
+}
+
+function leafIdAfterEntry(entry) {
+  return entry.type === EntryTypes.LEAF ? entry.targetId : entry.id;
+}
+
+function updateLabelCache(labelsById, entry) {
+  if (entry.type !== EntryTypes.LABEL) return;
+  const label = entry.label?.trim();
+  if (label) {
+    labelsById.set(entry.targetId, label);
+  } else {
+    labelsById.delete(entry.targetId);
+  }
+}
+
+function buildLabelsById(entries) {
+  const labelsById = new Map();
+  for (const entry of entries) {
+    updateLabelCache(labelsById, entry);
+  }
+  return labelsById;
+}
+
+class JsonlSessionStorage {
+  constructor(fsModule, filePath, header, entries, leafId) {
+    this.fs = fsModule;
+    this.filePath = filePath;
+    this.metadata = {
+      id: header.id,
+      createdAt: header.timestamp,
+      cwd: header.cwd,
+      path: filePath,
+      parentSessionPath: header.parentSession
+    };
+    this.entries = entries;
+    this.byId = new Map(entries.map(entry => [entry.id, entry]));
+    this.labelsById = buildLabelsById(entries);
+    this.currentLeafId = leafId;
+  }
+
+  static async open(filePath) {
+    const fsModule = fs;
+    const loaded = await this._loadJsonlStorage(fsModule, filePath);
+    return new JsonlSessionStorage(fsModule, filePath, loaded.header, loaded.entries, loaded.leafId);
+  }
+
+  static async _loadJsonlStorage(fsModule, filePath) {
+    const content = fsModule.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim());
+    if (lines.length === 0) {
+      throw invalidSession(filePath, 'missing session header');
+    }
+
+    const header = parseHeaderLine(lines[0], filePath);
+    const entries = [];
+    let leafId = null;
+    for (let i = 1; i < lines.length; i++) {
+      const entry = parseEntryLine(lines[i], filePath, i + 1);
+      entries.push(entry);
+      leafId = leafIdAfterEntry(entry);
+    }
+    return { header, entries, leafId };
+  }
+
+  static async create(filePath, options) {
+    const fsModule = fs;
+    const header = {
+      type: 'session',
+      version: CURRENT_SESSION_VERSION,
+      id: options.sessionId,
+      timestamp: new Date().toISOString(),
+      cwd: options.cwd,
+      parentSession: options.parentSessionPath
+    };
+
+    const dir = path.dirname(filePath);
+    if (!fsModule.existsSync(dir)) {
+      fsModule.mkdirSync(dir, { recursive: true });
+    }
+
+    fsModule.writeFileSync(filePath, JSON.stringify(header) + '\n');
+    return new JsonlSessionStorage(fsModule, filePath, header, [], null);
+  }
+
+  async getMetadata() {
+    return { ...this.metadata };
+  }
+
+  async getLeafId() {
+    if (this.currentLeafId !== null && !this.byId.has(this.currentLeafId)) {
+      throw new SessionError(SessionErrors.INVALID_SESSION, `Entry ${this.currentLeafId} not found`);
+    }
+    return this.currentLeafId;
+  }
+
+  async setLeafId(leafId) {
+    if (leafId !== null && !this.byId.has(leafId)) {
+      throw new SessionError(SessionErrors.NOT_FOUND, `Entry ${leafId} not found`);
+    }
+    const entry = {
+      type: EntryTypes.LEAF,
+      id: generateEntryId(this.byId),
+      parentId: this.currentLeafId,
+      timestamp: new Date().toISOString(),
+      targetId: leafId
+    };
+    fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n');
+    this.entries.push(entry);
+    this.byId.set(entry.id, entry);
+    this.currentLeafId = leafId;
+  }
+
+  async createEntryId() {
+    return generateEntryId(this.byId);
+  }
+
+  async appendEntry(entry) {
+    fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n');
+    this.entries.push(entry);
+    this.byId.set(entry.id, entry);
+    updateLabelCache(this.labelsById, entry);
+    this.currentLeafId = leafIdAfterEntry(entry);
+  }
+
+  async getEntry(id) {
+    return this.byId.get(id);
+  }
+
+  async findEntries(type) {
+    return this.entries.filter(entry => entry.type === type);
+  }
+
+  async getLabel(id) {
+    return this.labelsById.get(id);
+  }
+
+  async getPathToRoot(leafId) {
+    if (leafId === null) return [];
+    const path = [];
+    let current = this.byId.get(leafId);
+    if (!current) throw new SessionError(SessionErrors.NOT_FOUND, `Entry ${leafId} not found`);
+    while (current) {
+      path.unshift(current);
+      if (!current.parentId) break;
+      const parent = this.byId.get(current.parentId);
+      if (!parent) throw new SessionError(SessionErrors.INVALID_SESSION, `Entry ${current.parentId} not found`);
+      current = parent;
+    }
+    return path;
+  }
+
+  async getEntries() {
+    return [...this.entries];
+  }
+}
+
+module.exports = {
+  JsonlSessionStorage,
+  SessionError,
+  SessionErrors,
+  CURRENT_SESSION_VERSION
+};

package/src/core/plugin-base.js

@@ -286,10 +286,11 @@ class Plugin {
     this._promptParts.push({ name, priority, provider });
 
     // 如果主 agent 已存在，直接注册
-    if (this._framework._mainAgent) {
-      this._framework._mainAgent.registerPromptPart(name, priority, provider);
+    const mainAgent = this._framework.getMainAgent();
+    if (mainAgent) {
+      mainAgent.registerPromptPart(name, priority, provider);
       // 同步到所有子Agent
-      this._framework._syncPromptPartsToSubagents();
+      this._framework.syncPromptPartsToSubagents();
       return;
     }
 
@@ -307,14 +308,15 @@ class Plugin {
         if (this._deferredPromptParts) {
           for (const part of this._deferredPromptParts) {
             try {
-              this._framework._mainAgent?.registerPromptPart(part.name, part.priority, part.provider);
+              const mainAgent = this._framework.getMainAgent();
+              mainAgent?.registerPromptPart(part.name, part.priority, part.provider);
             } catch (err) {
               log.error(` Failed to register prompt part ${part.name}:`, err.message);
             }
           }
           this._deferredPromptParts = null;
           // 同步到所有子Agent
-          this._framework._syncPromptPartsToSubagents();
+          this._framework.syncPromptPartsToSubagents();
         }
       }, 100);
     });

package/src/core/plugin-manager.js

@@ -22,7 +22,7 @@ class PluginManager {
     this.framework = framework;
     this._plugins = new Map();
     this._loading = false;
-    this._stateFile = path.join(process.cwd(), '.agent', 'data', 'plugins-state.json');
+    this._stateFile = path.join(process.cwd(), '.foliko', 'data', 'plugins-state.json');
     this._knownPlugins = new Set(); // 已知插件列表（包括未加载的）
 
     // 创建子日志器
@@ -406,7 +406,7 @@ class PluginManager {
       entry.instance._started = false;
     }
 
-    // 2. 扫描 .agent/plugins 目录，加载新插件
+    // 2. 扫描 .foliko/plugins 目录，加载新插件
     await this._discoverCustomPlugins();
 
     // 3. 启动所有未启动的插件
@@ -416,8 +416,8 @@ class PluginManager {
   /**
    * 解析插件路径
    * 支持两种结构：
-   * 1. 文件夹结构: .agent/plugins/my-plugin/index.js
-   * 2. 单文件结构: .agent/plugins/my-plugin.js
+   * 1. 文件夹结构: .foliko/plugins/my-plugin/index.js
+   * 2. 单文件结构: .foliko/plugins/my-plugin.js
    * @param {string} pluginsDir - 插件目录
    * @param {string} name - 插件名称
    * @returns {{path: string, type: 'folder'|'file'}|null} 插件路径和类型
@@ -442,7 +442,7 @@ class PluginManager {
    * @private
    */
   async _discoverCustomPlugins() {
-    const pluginsDir = path.resolve(process.cwd(), '.agent', 'plugins');
+    const pluginsDir = path.resolve(process.cwd(), '.foliko', 'plugins');
     if (!fs.existsSync(pluginsDir)) {
       return;
     }
@@ -466,7 +466,7 @@ class PluginManager {
 
         // 添加模块路径到搜索路径（优先级从高到低）
         const modulePathsToAdd = [
-          agentNodeModules, // .agent/node_modules（项目本地安装的包）
+          agentNodeModules, // .foliko/node_modules（项目本地安装的包）
           path.join(__dirname, '..', '..', 'node_modules'), // 全局安装的包
         ];
         for (const mp of modulePathsToAdd) {
@@ -521,7 +521,7 @@ class PluginManager {
         }
 
         this._log.info(`Loading new plugin: ${pluginName} (${type})`);
-        // .agent/plugins 目录下的插件默认强制启用，不受 state 文件影响
+        // .foliko/plugins 目录下的插件默认强制启用，不受 state 文件影响
         await this.load(plugin, { forceEnabled: true });
       } catch (err) {
         this._log.error(`Failed to load plugin ${pluginName}:`, err.message);
@@ -861,14 +861,19 @@ class PluginManager {
       return result;
     }
 
-    // 支持对象形式: { name, version, install, start, ... }
+    // 支持 exports 对象形式: exports.id, exports.name, exports.version, ...
+    // 这种格式没有 install/start 等方法，只有数据属性
     class AnonymousPlugin extends Plugin {
       constructor() {
         super();
-        this.name = obj.name;
+        this.id = obj.id;
+        this.name = obj.name || obj.id;
         this.version = obj.version || '1.0.0';
         this.description = obj.description || '';
-        this.priority = obj.priority || 100;
+
+        // exports 形式的插件可以没有 priority/install 等
+        this.priority = obj.priority !== undefined ? obj.priority : 100;
+        this.system = obj.system || false;
 
         // 如果提供了 install/start/reload/uninstall 方法，绑定它们
         if (typeof obj.install === 'function') {

package/src/core/provider-registry.js

@@ -0,0 +1,159 @@
+/**
+ * ProviderRegistry - Dynamic LLM Provider Registration
+ * 允许插件动态注册 LLM Provider
+ */
+
+const { createOpenAICompatible } = require('ai');
+const { logger } = require('../utils/logger');
+
+class ProviderRegistry {
+  constructor() {
+    this._providers = new Map();
+    this._models = new Map();
+  }
+
+  /**
+   * 注册 Provider
+   * @param {string} name - Provider 名称 (如 'openai', 'deepseek')
+   * @param {Object} config - Provider 配置
+   * @param {string} config.baseURL - API base URL
+   * @param {string} [config.apiKey] - API key
+   * @param {string} [config.name] - 显示名称
+   * @param {string} [config.defaultModel] - 默认模型
+   * @param {Object} [config.headers] - 自定义 headers
+   */
+  registerProvider(name, config) {
+    this._providers.set(name, {
+      name: config.name || name,
+      baseURL: config.baseURL,
+      apiKey: config.apiKey || '',
+      defaultModel: config.defaultModel || '',
+      headers: config.headers || {},
+    });
+
+    if (config.defaultModel) {
+      this.registerModel(config.defaultModel, name, {
+        label: config.defaultModel,
+        description: `Default model for ${name}`,
+      });
+    }
+
+    logger.debug(`[ProviderRegistry] Registered provider: ${name}`);
+    return this;
+  }
+
+  /**
+   * 注册模型
+   * @param {string} modelId - 模型 ID
+   * @param {string} provider - Provider 名称
+   * @param {Object} [options] - 模型选项
+   */
+  registerModel(modelId, provider, options = {}) {
+    this._models.set(modelId, { provider, ...options });
+    return this;
+  }
+
+  /**
+   * 获取 Provider 配置
+   */
+  getProvider(name) {
+    return this._providers.get(name);
+  }
+
+  /**
+   * 获取模型配置
+   */
+  getModel(modelId) {
+    return this._models.get(modelId);
+  }
+
+  /**
+   * 获取所有已注册的 Provider 名称
+   */
+  getProviderNames() {
+    return Array.from(this._providers.keys());
+  }
+
+  /**
+   * 检查 Provider 是否已注册
+   */
+  hasProvider(name) {
+    return this._providers.has(name);
+  }
+
+  /**
+   * 创建 AI 客户端
+   * @param {string} providerName - Provider 名称
+   * @param {string} model - 模型 ID
+   * @param {string} [apiKey] - API key (可选，会使用注册时提供的)
+   * @param {string} [baseURL] - Base URL (可选，会使用注册时提供的)
+   */
+  createClient(providerName, model, apiKey, baseURL) {
+    const provider = this._providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Provider '${providerName}' not registered. Use framework.registerProvider() first.`);
+    }
+
+    const finalApiKey = apiKey || provider.apiKey;
+    const finalBaseURL = baseURL || provider.baseURL;
+    const finalModel = model || provider.defaultModel;
+
+    if (!finalApiKey) {
+      throw new Error(`No API key provided for provider '${providerName}'`);
+    }
+
+    const client = createOpenAICompatible({
+      baseURL: finalBaseURL,
+      apiKey: finalApiKey,
+    });
+
+    return client(finalModel);
+  }
+
+  /**
+   * 移除 Provider
+   */
+  unregisterProvider(name) {
+    this._providers.delete(name);
+    // 同时移除该 provider 的所有模型
+    for (const [modelId, modelConfig] of this._models) {
+      if (modelConfig.provider === name) {
+        this._models.delete(modelId);
+      }
+    }
+    return this;
+  }
+}
+
+// 单例
+const _registry = new ProviderRegistry();
+
+/**
+ * 获取 Provider Registry 实例
+ */
+function getProviderRegistry() {
+  return _registry;
+}
+
+/**
+ * 注册默认的 Providers
+ */
+function registerDefaultProviders() {
+  const { DEFAULT_PROVIDERS } = require('./provider');
+
+  for (const [key, config] of Object.entries(DEFAULT_PROVIDERS)) {
+    _registry.registerProvider(key, {
+      name: config.name,
+      baseURL: config.baseURL,
+      defaultModel: config.defaultModel,
+    });
+  }
+}
+
+// 初始化时注册默认 providers
+registerDefaultProviders();
+
+module.exports = {
+  ProviderRegistry,
+  getProviderRegistry,
+};

package/src/core/provider.js

@@ -151,4 +151,6 @@ module.exports = {
   getAvailableProviders,
   DEFAULT_PROVIDERS,
   isThinkingModel,
+  getProviderRegistry: () => require('./provider-registry').getProviderRegistry(),
+  registerProvider: (name, config) => require('./provider-registry').getProviderRegistry().registerProvider(name, config),
 };