flowmind 1.0.0

package/core/config-manager.js

@@ -0,0 +1,360 @@
+/**
+ * FlowMind Configuration Manager
+ * Manages configuration loading and access
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class ConfigManager {
+  constructor(configPath = null) {
+    this.configPath = configPath;
+    this.config = {};
+    this.defaults = this.getDefaults();
+    this.initialized = false;
+  }
+
+  /**
+   * Load configuration
+   */
+  async load() {
+    // Try to load from specified path
+    if (this.configPath) {
+      await this.loadFromFile(this.configPath);
+    }
+
+    // Try to load from default locations
+    const defaultPaths = [
+      path.join(process.cwd(), 'flowmind.config.js'),
+      path.join(process.cwd(), 'flowmind.config.json'),
+      path.join(this.getHomeDir(), '.flowmind', 'config.json'),
+      path.join(this.getHomeDir(), '.flowmindrc')
+    ];
+
+    for (const configPath of defaultPaths) {
+      if (await fs.pathExists(configPath)) {
+        await this.loadFromFile(configPath);
+        break;
+      }
+    }
+
+    // Load resource config
+    await this.loadResourceConfig();
+
+    // Load learning config
+    await this.loadLearningConfig();
+
+    // Load component config
+    await this.loadComponentConfig();
+
+    this.initialized = true;
+    return this.config;
+  }
+
+  /**
+   * Load configuration from file
+   */
+  async loadFromFile(filePath) {
+    try {
+      const ext = path.extname(filePath).toLowerCase();
+
+      if (ext === '.js') {
+        const module = require(filePath);
+        this.mergeConfig(module);
+      } else if (ext === '.json') {
+        const data = await fs.readJson(filePath);
+        this.mergeConfig(data);
+      }
+    } catch (error) {
+      console.warn(`Failed to load config from ${filePath}:`, error.message);
+    }
+  }
+
+  /**
+   * Load resource configuration
+   */
+  async loadResourceConfig() {
+    const resourceConfigPath = path.join(this.getHomeDir(), '.flowmind', 'resource-config.json');
+
+    if (await fs.pathExists(resourceConfigPath)) {
+      try {
+        const resourceConfig = await fs.readJson(resourceConfigPath);
+        this.mergeConfig({ resources: resourceConfig.resources || {} });
+      } catch (error) {
+        console.warn('Failed to load resource config:', error.message);
+      }
+    }
+  }
+
+  /**
+   * Load learning configuration
+   */
+  async loadLearningConfig() {
+    const learningConfigPath = path.join(this.getHomeDir(), '.flowmind', 'learning-config.json');
+
+    if (await fs.pathExists(learningConfigPath)) {
+      try {
+        const learningConfig = await fs.readJson(learningConfigPath);
+        this.mergeConfig({ learning: learningConfig });
+      } catch (error) {
+        console.warn('Failed to load learning config:', error.message);
+      }
+    }
+  }
+
+  /**
+   * Load component configuration
+   * Supports loading from:
+   *   - ~/.flowmind/component-config.json (dedicated component config)
+   *   - flowmind.config.json (as part of main config under "components" key)
+   */
+  async loadComponentConfig() {
+    const componentConfigPaths = [
+      path.join(this.getHomeDir(), '.flowmind', 'component-config.json'),
+      path.join(process.cwd(), 'component-config.json')
+    ];
+
+    for (const configPath of componentConfigPaths) {
+      if (await fs.pathExists(configPath)) {
+        try {
+          const componentConfig = await fs.readJson(configPath);
+          if (componentConfig.components) {
+            this.mergeConfig({ components: componentConfig.components });
+          }
+        } catch (error) {
+          console.warn(`Failed to load component config from ${configPath}:`, error.message);
+        }
+      }
+    }
+  }
+
+  /**
+   * Get component configuration for a specific type.
+   * @param {string} componentType
+   * @returns {object|null}
+   */
+  getComponentConfig(componentType) {
+    const components = this.get('components', {});
+    return components[componentType] || null;
+  }
+
+  /**
+   * Get the default provider for a component type.
+   * @param {string} componentType
+   * @returns {string|null}
+   */
+  getDefaultProvider(componentType) {
+    const typeConfig = this.getComponentConfig(componentType);
+    return typeConfig ? typeConfig.default : null;
+  }
+
+  /**
+   * Get provider configuration.
+   * @param {string} componentType
+   * @param {string} providerName
+   * @returns {object|null}
+   */
+  getProviderConfig(componentType, providerName) {
+    const typeConfig = this.getComponentConfig(componentType);
+    if (!typeConfig || !typeConfig.providers) return null;
+    return typeConfig.providers[providerName] || null;
+  }
+
+  /**
+   * Get default configuration
+   */
+  getDefaults() {
+    return {
+      // Core settings
+      version: '1.0.0',
+      name: 'FlowMind',
+
+      // Paths
+      skills: {
+        path: path.join(__dirname, '..', 'skills')
+      },
+
+      // Learning settings
+      learning: {
+        enabled: true,
+        autoApply: true,
+        confidenceThreshold: 0.7,
+        maxRecordsPerSkill: 100,
+        storagePath: path.join(this.getHomeDir(), '.flowmind', 'learning')
+      },
+
+      // Scene mapping settings
+      sceneMapping: {
+        enabled: true,
+        matchAlgorithm: 'weighted',
+        weights: {
+          keywordMatch: 0.4,
+          patternMatch: 0.3,
+          historyScore: 0.2,
+          confidence: 0.1
+        }
+      },
+
+      // Output settings
+      output: {
+        format: 'text',
+        language: 'auto',
+        verbose: false
+      },
+
+      // Resource settings
+      resources: {
+        database: { enabled: false },
+        redis: { enabled: false },
+        logs: { enabled: false },
+        apiDocs: { enabled: false }
+      }
+    };
+  }
+
+  /**
+   * Merge configuration
+   */
+  mergeConfig(newConfig) {
+    this.config = this.deepMerge(this.config, newConfig);
+  }
+
+  /**
+   * Deep merge objects
+   */
+  deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        if (this.isObject(source[key]) && this.isObject(target[key])) {
+          result[key] = this.deepMerge(target[key], source[key]);
+        } else {
+          result[key] = source[key];
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if value is object
+   */
+  isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+  }
+
+  /**
+   * Get configuration value
+   */
+  get(keyPath, defaultValue = undefined) {
+    const keys = keyPath.split('.');
+    let value = this.config;
+
+    for (const key of keys) {
+      if (value === undefined || value === null) {
+        return defaultValue;
+      }
+      value = value[key];
+    }
+
+    return value !== undefined ? value : defaultValue;
+  }
+
+  /**
+   * Set configuration value
+   */
+  set(keyPath, value) {
+    const keys = keyPath.split('.');
+    let current = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key] || !this.isObject(current[key])) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+
+    current[keys[keys.length - 1]] = value;
+    return true;
+  }
+
+  /**
+   * Check if key exists
+   */
+  has(keyPath) {
+    return this.get(keyPath) !== undefined;
+  }
+
+  /**
+   * Get all configuration
+   */
+  getAll() {
+    return { ...this.config };
+  }
+
+  /**
+   * Save configuration
+   */
+  async save() {
+    const configPath = path.join(this.getHomeDir(), '.flowmind', 'config.json');
+
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeJson(configPath, this.config, { spaces: 2 });
+
+    return configPath;
+  }
+
+  /**
+   * Get home directory
+   */
+  getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+  }
+
+  /**
+   * Reload configuration
+   */
+  async reload() {
+    this.config = {};
+    this.initialized = false;
+    return await this.load();
+  }
+
+  /**
+   * Validate configuration
+   */
+  validate() {
+    const errors = [];
+
+    // Check required fields
+    if (!this.config.version) {
+      errors.push('Missing required field: version');
+    }
+
+    // Validate learning settings
+    if (this.config.learning) {
+      if (this.config.learning.confidenceThreshold < 0 || this.config.learning.confidenceThreshold > 1) {
+        errors.push('Invalid confidenceThreshold: must be between 0 and 1');
+      }
+    }
+
+    // Validate scene mapping weights
+    if (this.config.sceneMapping?.weights) {
+      const weights = this.config.sceneMapping.weights;
+      const sum = Object.values(weights).reduce((a, b) => a + b, 0);
+      if (Math.abs(sum - 1) > 0.01) {
+        errors.push('Scene mapping weights must sum to 1');
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors: errors
+    };
+  }
+}
+
+module.exports = ConfigManager;

package/core/index.js

@@ -0,0 +1,223 @@
+/**
+ * FlowMind - The AI Agent That Learns How You Work
+ * Core Engine Entry Point
+ */
+
+const SkillLoader = require('./skill-loader');
+const LearningEngine = require('./learning-engine');
+const SceneMatcher = require('./scene-matcher');
+const ConfigManager = require('./config-manager');
+const ComponentRegistry = require('./component-registry');
+
+class FlowMind {
+  constructor(options = {}) {
+    this.config = new ConfigManager(options.configPath);
+    this.learning = new LearningEngine(this.config);
+    this.matcher = new SceneMatcher(this.config, this.learning);
+    this.components = new ComponentRegistry(this.config);
+    this.skills = new SkillLoader(this.config, this.learning, this.components);
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize FlowMind
+   */
+  async init() {
+    if (this.initialized) return this;
+
+    await this.config.load();
+    await this.components.init();
+    await this.components.initAll();
+    await this.learning.init();
+    await this.skills.loadAll();
+    await this.matcher.loadScenes();
+
+    this.initialized = true;
+    return this;
+  }
+
+  /**
+   * Process a user request
+   */
+  async process(input, context = {}) {
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    const startTime = Date.now();
+
+    try {
+      // 1. Check for learning patterns (corrections, feedback)
+      const learningResult = await this.learning.detectLearning(input, context);
+      if (learningResult) {
+        return this.formatLearningResponse(learningResult);
+      }
+
+      // 2. Check scene mappings
+      const sceneMatch = await this.matcher.match(input);
+      if (sceneMatch && sceneMatch.confidence >= 0.7) {
+        return this.executeSceneWorkflow(sceneMatch, input, context);
+      }
+
+      // 3. Select and execute skill
+      const skill = await this.skills.select(input, context);
+      if (!skill) {
+        return this.formatError('No matching skill found', input);
+      }
+
+      // 4. Execute with learning applied
+      const result = await this.executeWithLearning(skill, input, context);
+
+      // 5. Format and return
+      return this.formatResult(result, {
+        skill: skill.name,
+        duration: Date.now() - startTime,
+        sceneMatch: sceneMatch
+      });
+
+    } catch (error) {
+      return this.formatError(error.message, input);
+    }
+  }
+
+  /**
+   * Execute skill with learning applied
+   */
+  async executeWithLearning(skill, input, context) {
+    // Get learning rules for this skill
+    const learnings = await this.learning.getSkillLearnings(skill.name);
+
+    // Apply learning rules to context
+    const enhancedContext = {
+      ...context,
+      learnings: learnings,
+      preferences: await this.learning.getPreferences(skill.name)
+    };
+
+    // Execute skill
+    const result = await skill.execute(input, enhancedContext);
+
+    return result;
+  }
+
+  /**
+   * Execute scene workflow
+   */
+  async executeSceneWorkflow(sceneMatch, input, context) {
+    const { scene, params } = sceneMatch;
+    const results = [];
+
+    for (const step of scene.workflow.skills) {
+      const skill = this.skills.get(step.skill);
+      if (!skill) continue;
+
+      const stepContext = {
+        ...context,
+        params: { ...step.params, ...params },
+        previousResults: results
+      };
+
+      const result = await this.executeWithLearning(skill, input, stepContext);
+      results.push({
+        skill: step.skill,
+        result: result
+      });
+    }
+
+    return {
+      type: 'scene_workflow',
+      scene: scene.name,
+      results: results,
+      preferences: scene.preferences
+    };
+  }
+
+  /**
+   * Format learning response
+   */
+  formatLearningResponse(learningResult) {
+    const { type, record, confirmation } = learningResult;
+
+    return {
+      type: 'learning',
+      learningType: type,
+      record: record,
+      message: confirmation,
+      success: true
+    };
+  }
+
+  /**
+   * Format result
+   */
+  formatResult(result, metadata) {
+    return {
+      type: 'result',
+      success: true,
+      data: result,
+      metadata: metadata,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Format error
+   */
+  formatError(message, input) {
+    return {
+      type: 'error',
+      success: false,
+      message: message,
+      input: input,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Get learning statistics
+   */
+  async getStats() {
+    return this.learning.getStats();
+  }
+
+  /**
+   * Get the component registry
+   * @returns {ComponentRegistry}
+   */
+  getComponentRegistry() {
+    return this.components;
+  }
+
+  /**
+   * Get the active adapter for a component type
+   * @param {string} componentType
+   * @returns {BaseAdapter|null}
+   */
+  getAdapter(componentType) {
+    return this.components.getAdapter(componentType);
+  }
+
+  /**
+   * Get component status summary
+   * @returns {object}
+   */
+  getComponentStatus() {
+    return this.components.getStatus();
+  }
+
+  /**
+   * Export learnings
+   */
+  async exportLearnings(options) {
+    return this.learning.export(options);
+  }
+
+  /**
+   * Import learnings
+   */
+  async importLearnings(data) {
+    return this.learning.import(data);
+  }
+}
+
+module.exports = FlowMind;