flowmind 1.5.2 → 1.5.4

package/core/sdd-agent-sync.js

@@ -2,10 +2,14 @@ const fs = require('fs-extra');
 const os = require('os');
 const path = require('path');
 
-const MCP_SERVER_ALIASES = Object.freeze({
-  'aomi-yapi-mcp': 'yapi-mcp',
-  'aomi-yuque-mcp': 'yuque-mcp'
-});
+const SDD_SOURCE_SYNC_FILES = Object.freeze([
+  'RESOURCE_INDEX.md',
+  'project-db-configs.json',
+  'project-git-map.json',
+  'feign-link-map.json',
+  'auto-flow-apis.md',
+  'auto-flow-pipeline-map.json'
+]);
 
 const RESOURCE_BINDING_SPECS = Object.freeze({
   yapi: { componentType: 'apiDoc', provider: 'yapi' },
@@ -23,7 +27,9 @@ function getHomeDir() {
 
 function normalizeMcpServer(name) {
   if (!name) return null;
-  return MCP_SERVER_ALIASES[name] || name;
+  if (/^[^-]+-yapi-mcp$/i.test(name)) return 'yapi-mcp';
+  if (/^[^-]+-yuque-mcp$/i.test(name)) return 'yuque-mcp';
+  return name;
 }
 
 function deepMerge(target, source) {
@@ -204,7 +210,81 @@ function buildWorkflowResource(skillBindingData = {}) {
   };
 }
 
-function buildWorkflowBindings(skillBindingData = {}) {
+function normalizeWorkflowTransport(transport) {
+  if (!transport || !transport.url) return null;
+
+  const headers = transport.headers || {};
+  const normalizedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined || value === null || value === '') continue;
+    normalizedHeaders[key] = value;
+  }
+
+  return {
+    url: transport.url,
+    type: transport.type || 'http',
+    headers: normalizedHeaders,
+    description: transport.description || 'Workflow MCP server'
+  };
+}
+
+async function discoverWorkflowTransport(options = {}) {
+  const direct = normalizeWorkflowTransport(options.workflowTransport);
+  if (direct) return direct;
+
+  const envUrl = process.env.FLOWMIND_AUTO_FLOW_MCP_URL;
+  if (envUrl) {
+    return normalizeWorkflowTransport({
+      url: envUrl,
+      type: 'http',
+      headers: process.env.FLOWMIND_AUTO_FLOW_MCP_TOKEN
+        ? { mcp_token: process.env.FLOWMIND_AUTO_FLOW_MCP_TOKEN }
+        : {},
+      description: 'Workflow MCP server from environment'
+    });
+  }
+
+  const debugDir = path.join(os.homedir(), '.claude', 'debug');
+  if (!await fs.pathExists(debugDir)) return null;
+
+  const entries = await fs.readdir(debugDir);
+  const candidates = [];
+  for (const entry of entries) {
+    const filePath = path.join(debugDir, entry);
+    try {
+      const stat = await fs.stat(filePath);
+      if (stat.isFile()) {
+        candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+      }
+    } catch (error) {
+      // skip unreadable files
+    }
+  }
+
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+  for (const { filePath } of candidates.slice(0, 10)) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const match = content.match(/MCP server "friday-auto-flow": HTTP transport options: (\{[^\n]+\})/);
+      if (!match) continue;
+
+      const parsed = JSON.parse(match[1]);
+      return normalizeWorkflowTransport({
+        url: parsed.url,
+        type: parsed.type || 'http',
+        headers: parsed.headers || {},
+        description: 'Workflow MCP server discovered from Claude debug logs'
+      });
+    } catch (error) {
+      // continue scanning other files
+    }
+  }
+
+  return null;
+}
+
+function buildWorkflowBindings(skillBindingData = {}, workflowTransport = null) {
   const workflowBinding = skillBindingData.bindings?.['auto-flow'];
   if (!workflowBinding) return [];
 
@@ -249,7 +329,11 @@ function buildWorkflowBindings(skillBindingData = {}) {
       learningCount: workflowBinding.learningCount || 0,
       lastLearning: workflowBinding.lastLearning || null,
       records: workflowBinding.records || [],
-      rules: workflowBinding.rules || []
+      rules: workflowBinding.rules || [],
+      transport: workflowTransport ? {
+        url: workflowTransport.url,
+        type: workflowTransport.type
+      } : undefined
     },
     metadata: {
       source: 'sdd-agent',
@@ -263,7 +347,7 @@ function buildWorkflowBindings(skillBindingData = {}) {
   }];
 }
 
-function convertResourceBindings(sddConfig, skillBindingData = {}) {
+function convertResourceBindings(sddConfig, skillBindingData = {}, workflowTransport = null) {
   const resources = sddConfig.resources || {};
   const aliasIndex = buildAliasIndex(sddConfig.aliases);
   const bindings = [];
@@ -281,7 +365,7 @@ function convertResourceBindings(sddConfig, skillBindingData = {}) {
     }
   }
 
-  bindings.push(...buildWorkflowBindings(skillBindingData));
+  bindings.push(...buildWorkflowBindings(skillBindingData, workflowTransport));
 
   return bindings;
 }
@@ -317,10 +401,13 @@ function convertSceneMappings(sceneData = {}) {
   }));
 }
 
-function buildComponentConfig(sddConfig, skillBindingData = {}) {
+function buildComponentConfig(sddConfig, skillBindingData = {}, workflowTransport = null) {
   const resources = sddConfig.resources || {};
   const workflowResource = resources.workflow || buildWorkflowResource(skillBindingData);
   const components = {};
+  const directQueryServer = resources.database?.mcpServers?.directQuery
+    || resources.redis?.mcpServers?.directQuery
+    || null;
 
   if (resources.sls?.enabled) {
     const defaultEnv = resources.sls.defaultEnv || 'uat';
@@ -356,6 +443,18 @@ function buildComponentConfig(sddConfig, skillBindingData = {}) {
     };
   }
 
+  if ((resources.database?.enabled || resources.redis?.enabled) && directQueryServer) {
+    components.databaseQuery = {
+      default: 'aliyun-rds-query',
+      providers: {
+        'aliyun-rds-query': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(directQueryServer)
+        }
+      }
+    };
+  }
+
   if (resources.redis?.enabled && resources.redis.mcpServers?.monitor) {
     components.redisMonitor = {
       default: 'aliyun-redis',
@@ -398,7 +497,8 @@ function buildComponentConfig(sddConfig, skillBindingData = {}) {
       providers: {
         'friday-flow': {
           enabled: true,
-          mcpServer: normalizeMcpServer(workflowResource.mcpServer)
+          mcpServer: normalizeMcpServer(workflowResource.mcpServer),
+          ...(workflowTransport ? { transport: workflowTransport } : {})
         }
       }
     };
@@ -483,6 +583,118 @@ async function readJsonIfExists(filePath, fallback) {
   return fs.readJson(filePath);
 }
 
+async function statIfExists(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (error) {
+    return null;
+  }
+}
+
+async function copySelectedSourceFiles(sourceDir, targetDir) {
+  const sourceRoot = path.join(sourceDir, 'source');
+  const copied = [];
+
+  if (!(await fs.pathExists(sourceRoot))) {
+    return copied;
+  }
+
+  await fs.ensureDir(targetDir);
+
+  for (const fileName of SDD_SOURCE_SYNC_FILES) {
+    const sourcePath = path.join(sourceRoot, fileName);
+    if (!(await fs.pathExists(sourcePath))) {
+      continue;
+    }
+
+    const targetPath = path.join(targetDir, fileName);
+    await fs.copy(sourcePath, targetPath, { overwrite: true, dereference: true });
+    copied.push({
+      name: fileName,
+      sourcePath,
+      targetPath
+    });
+  }
+
+  return copied;
+}
+
+async function buildSyncSignature(sourceDir) {
+  const trackedFiles = [
+    path.join(sourceDir, 'resource-config.json'),
+    path.join(sourceDir, 'learning', 'scene-mappings.json'),
+    path.join(sourceDir, 'learning', 'skill-bindings.json'),
+    ...SDD_SOURCE_SYNC_FILES.map((fileName) => path.join(sourceDir, 'source', fileName))
+  ];
+
+  const entries = [];
+  for (const filePath of trackedFiles) {
+    const stat = await statIfExists(filePath);
+    if (!stat) continue;
+    entries.push({
+      path: filePath,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    });
+  }
+
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  return JSON.stringify(entries);
+}
+
+async function autoSyncSddAgentToFlowMind(options = {}) {
+  if (process.env.FLOWMIND_DISABLE_SDD_AGENT_AUTO_SYNC === '1') {
+    return { synced: false, skipped: true, reason: 'disabled' };
+  }
+
+  const sourceDir = options.sourceDir || path.join(os.homedir(), '.sdd-agent');
+  const targetHome = options.targetHome || getHomeDir();
+  const sourceConfigPath = path.join(sourceDir, 'resource-config.json');
+
+  if (!(await fs.pathExists(sourceConfigPath))) {
+    return { synced: false, skipped: true, reason: 'missing-source-config' };
+  }
+
+  const targetDir = path.join(targetHome, '.flowmind');
+  const statePath = path.join(targetDir, 'sdd-agent-sync-state.json');
+  const signature = await buildSyncSignature(sourceDir);
+  const previousState = await readJsonIfExists(statePath, null);
+
+  if (previousState?.signature === signature) {
+    return {
+      synced: false,
+      skipped: true,
+      reason: 'up-to-date',
+      sourceDir,
+      targetDir,
+      statePath
+    };
+  }
+
+  const summary = await syncSddAgentToFlowMind({
+    ...options,
+    sourceDir,
+    targetHome
+  });
+
+  await fs.ensureDir(targetDir);
+  await fs.writeJson(statePath, {
+    sourceDir,
+    targetDir,
+    signature,
+    syncedAt: new Date().toISOString(),
+    files: summary.files,
+    counts: summary.counts
+  }, { spaces: 2 });
+
+  return {
+    synced: true,
+    skipped: false,
+    statePath,
+    ...summary
+  };
+}
+
 async function syncSddAgentToFlowMind(options = {}) {
   const sourceDir = options.sourceDir || path.join(os.homedir(), '.sdd-agent');
   const targetHome = options.targetHome || getHomeDir();
@@ -500,11 +712,19 @@ async function syncSddAgentToFlowMind(options = {}) {
   const sddScenes = await readJsonIfExists(sourceScenesPath, { mappings: [] });
   const sddSkillBindings = await readJsonIfExists(sourceSkillBindingsPath, { version: '1.0', bindings: {} });
   sddConfig.skillBindings = sddSkillBindings;
+  const workflowTransport = await discoverWorkflowTransport(options);
+  if (workflowTransport) {
+    sddConfig.mcpServers = {
+      ...(sddConfig.mcpServers || {}),
+      'friday-auto-flow': workflowTransport
+    };
+  }
 
   const targetResourceConfigPath = path.join(targetDir, 'resource-config.json');
   const targetComponentConfigPath = path.join(targetDir, 'component-config.json');
   const targetBindingsPath = path.join(targetLearningDir, 'resource-bindings.json');
   const targetScenesPath = path.join(targetLearningDir, 'scenes.json');
+  const targetSourceDir = path.join(targetDir, 'source');
 
   const existingResourceConfig = await readJsonIfExists(targetResourceConfigPath, {});
   const existingComponentConfig = await readJsonIfExists(targetComponentConfigPath, { version: '1.0.0', components: {} });
@@ -512,8 +732,8 @@ async function syncSddAgentToFlowMind(options = {}) {
   const existingScenes = await readJsonIfExists(targetScenesPath, { version: '1.0', mappings: [] });
 
   const nextResourceConfig = deepMerge(existingResourceConfig, sanitizeResourceConfig(sddConfig, sddSkillBindings));
-  const nextComponentConfig = deepMerge(existingComponentConfig, buildComponentConfig(sddConfig, sddSkillBindings));
-  const importedBindings = convertResourceBindings(sddConfig, sddSkillBindings);
+  const nextComponentConfig = deepMerge(existingComponentConfig, buildComponentConfig(sddConfig, sddSkillBindings, workflowTransport));
+  const importedBindings = convertResourceBindings(sddConfig, sddSkillBindings, workflowTransport);
   const nextBindings = {
     version: existingBindings.version || '1.0',
     lastUpdated: new Date().toISOString(),
@@ -531,6 +751,7 @@ async function syncSddAgentToFlowMind(options = {}) {
   await fs.writeJson(targetComponentConfigPath, nextComponentConfig, { spaces: 2 });
   await fs.writeJson(targetBindingsPath, nextBindings, { spaces: 2 });
   await fs.writeJson(targetScenesPath, nextScenes, { spaces: 2 });
+  const copiedSourceFiles = await copySelectedSourceFiles(sourceDir, targetSourceDir);
 
   return {
     sourceDir,
@@ -539,14 +760,16 @@ async function syncSddAgentToFlowMind(options = {}) {
       resourceConfig: targetResourceConfigPath,
       componentConfig: targetComponentConfigPath,
       resourceBindings: targetBindingsPath,
-      scenes: targetScenesPath
+      scenes: targetScenesPath,
+      sourceFiles: copiedSourceFiles.map((item) => item.targetPath)
     },
     counts: {
       importedBindings: importedBindings.length,
       totalBindings: nextBindings.bindings.length,
       importedScenes: importedScenes.length,
       totalScenes: nextScenes.mappings.length,
-      components: Object.keys(nextComponentConfig.components || {}).length
+      components: Object.keys(nextComponentConfig.components || {}).length,
+      copiedSourceFiles: copiedSourceFiles.length
     }
   };
 }
@@ -563,5 +786,6 @@ module.exports = {
   buildWorkflowResource,
   normalizeMcpServer,
   sanitizeResourceConfig,
-  syncSddAgentToFlowMind
+  syncSddAgentToFlowMind,
+  autoSyncSddAgentToFlowMind
 };

package/core/source-inference.js

@@ -0,0 +1,324 @@
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+
+const ENV_PATTERNS = Object.freeze([
+  { env: 'prod', pattern: /\bprod\b|生产/iu },
+  { env: 'gray', pattern: /\bgray\b|灰度/iu },
+  { env: 'uat', pattern: /\buat\b|预发/iu },
+  { env: 'test', pattern: /\btest\b|测试/iu },
+  { env: 'dev', pattern: /\bdev\b|开发/iu }
+]);
+
+const DEFAULT_SCORE_LIMIT = 5;
+
+let cachedSignature = null;
+let cachedContext = null;
+
+function getFlowMindHome() {
+  return process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+function getSourceDir(options = {}) {
+  if (options.sourceDir) {
+    return options.sourceDir;
+  }
+  const flowmindHome = options.flowmindHome || getFlowMindHome();
+  return path.join(flowmindHome, '.flowmind', 'source');
+}
+
+async function readJsonIfExists(filePath, fallback) {
+  if (!(await fs.pathExists(filePath))) {
+    return fallback;
+  }
+  return fs.readJson(filePath);
+}
+
+async function buildSignature(sourceDir) {
+  const files = [
+    'RESOURCE_INDEX.md',
+    'project-db-configs.json',
+    'project-git-map.json'
+  ];
+  const entries = [];
+  for (const fileName of files) {
+    const filePath = path.join(sourceDir, fileName);
+    try {
+      const stat = await fs.stat(filePath);
+      entries.push(`${fileName}:${stat.size}:${stat.mtimeMs}`);
+    } catch (error) {
+      entries.push(`${fileName}:missing`);
+    }
+  }
+  return entries.join('|');
+}
+
+function parseList(value) {
+  if (!value) return [];
+  return String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseResourceIndex(markdown = '') {
+  const lines = String(markdown).split(/\r?\n/);
+  const entries = [];
+  let current = null;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    if (line.startsWith('### ')) {
+      current = {
+        title: line.slice(4).trim(),
+        path: null,
+        aliases: [],
+        domains: [],
+        modules: [],
+        tags: [],
+        note: null
+      };
+      entries.push(current);
+      continue;
+    }
+
+    if (!current || !line.startsWith('- ')) {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex < 0) continue;
+
+    const key = line.slice(2, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+
+    if (key === 'path') current.path = value;
+    if (key === 'aliases') current.aliases = parseList(value);
+    if (key === 'domains') current.domains = parseList(value);
+    if (key === 'modules') current.modules = parseList(value);
+    if (key === 'tags') current.tags = parseList(value);
+    if (key === 'note') current.note = value;
+  }
+
+  return entries;
+}
+
+function extractKeywords(input) {
+  return (String(input || '').match(/[\u4e00-\u9fa5A-Za-z0-9._-]+/g) || [])
+    .map((item) => item.toLowerCase());
+}
+
+function detectEnvironment(input) {
+  const normalized = String(input || '').toLowerCase();
+  const matched = ENV_PATTERNS.find(({ pattern }) => pattern.test(normalized));
+  return matched ? matched.env : null;
+}
+
+function normalizeProjectService(service = {}) {
+  return {
+    ...service,
+    databaseId: service.databaseId || service.dmsDatabaseId || null,
+    sourceId: service.sourceId || null
+  };
+}
+
+function buildProjectCatalog(projectConfigs = {}, gitMap = {}, resourceIndex = []) {
+  const catalog = new Map();
+  const serverProjects = gitMap.serverProjects || {};
+  const mobileProjects = gitMap.mobileProjects || {};
+
+  const ensureProject = (projectName) => {
+    if (!projectName) return null;
+    if (!catalog.has(projectName)) {
+      catalog.set(projectName, {
+        name: projectName,
+        config: projectConfigs[projectName] || null,
+        git: serverProjects[projectName] || mobileProjects[projectName] || null,
+        resourceEntries: []
+      });
+    }
+    return catalog.get(projectName);
+  };
+
+  for (const projectName of Object.keys(projectConfigs)) {
+    ensureProject(projectName);
+  }
+
+  for (const projectName of Object.keys(serverProjects)) {
+    ensureProject(projectName);
+  }
+
+  for (const projectName of Object.keys(mobileProjects)) {
+    ensureProject(projectName);
+  }
+
+  for (const entry of resourceIndex) {
+    for (const moduleName of entry.modules || []) {
+      const project = ensureProject(moduleName);
+      if (project) {
+        project.resourceEntries.push(entry);
+      }
+    }
+  }
+
+  return Array.from(catalog.values());
+}
+
+function scoreMatch(normalizedInput, value, score, reason) {
+  if (!value) return null;
+  const normalizedValue = String(value).toLowerCase();
+  if (!normalizedValue) return null;
+  if (!normalizedInput.includes(normalizedValue)) return null;
+  return { score, reason, match: value };
+}
+
+function scoreProjectCandidate(project, normalizedInput, keywords = []) {
+  let score = 0;
+  const reasons = [];
+
+  const directMatches = [
+    scoreMatch(normalizedInput, project.name, 18, 'project-name'),
+    scoreMatch(normalizedInput, stripEnvPrefix(project.name), 14, 'project-name-base'),
+    scoreMatch(normalizedInput, project.git?.description, 6, 'git-description')
+  ].filter(Boolean);
+
+  for (const match of directMatches) {
+    score += match.score;
+    reasons.push(match);
+  }
+
+  for (const entry of project.resourceEntries || []) {
+    const entryMatches = [
+      scoreMatch(normalizedInput, entry.title, 8, 'resource-title'),
+      ...entry.aliases.map((value) => scoreMatch(normalizedInput, value, 8, 'resource-alias')),
+      ...entry.modules.map((value) => scoreMatch(normalizedInput, value, 10, 'resource-module')),
+      ...entry.domains.map((value) => scoreMatch(normalizedInput, value, 3, 'resource-domain')),
+      ...entry.tags.map((value) => scoreMatch(normalizedInput, value, 2, 'resource-tag'))
+    ].filter(Boolean);
+
+    for (const match of entryMatches) {
+      score += match.score;
+      reasons.push({ ...match, entry: entry.title });
+    }
+  }
+
+  const description = String(project.git?.description || '').toLowerCase();
+  if (description) {
+    for (const keyword of keywords) {
+      if (keyword.length < 2) continue;
+      if (description.includes(keyword)) {
+        score += 1;
+        reasons.push({ score: 1, reason: 'git-description-keyword', match: keyword });
+      }
+    }
+  }
+
+  return {
+    name: project.name,
+    score,
+    reasons,
+    config: project.config,
+    git: project.git,
+    resourceEntries: project.resourceEntries || []
+  };
+}
+
+function stripEnvPrefix(projectName) {
+  return String(projectName || '').replace(/^(?:test|dev|uat|gray|prod)-/i, '');
+}
+
+async function loadSourceContext(options = {}) {
+  const sourceDir = getSourceDir(options);
+  const signature = await buildSignature(sourceDir);
+
+  if (cachedContext && cachedSignature === `${sourceDir}:${signature}`) {
+    return cachedContext;
+  }
+
+  const [projectDbConfigs, projectGitMap, resourceIndexContent] = await Promise.all([
+    readJsonIfExists(path.join(sourceDir, 'project-db-configs.json'), { configs: {} }),
+    readJsonIfExists(path.join(sourceDir, 'project-git-map.json'), { serverProjects: {}, mobileProjects: {} }),
+    fs.pathExists(path.join(sourceDir, 'RESOURCE_INDEX.md'))
+      ? fs.readFile(path.join(sourceDir, 'RESOURCE_INDEX.md'), 'utf8')
+      : Promise.resolve('')
+  ]);
+
+  const resourceIndex = parseResourceIndex(resourceIndexContent);
+  const projectConfigs = projectDbConfigs.configs || {};
+  const projectCatalog = buildProjectCatalog(projectConfigs, projectGitMap, resourceIndex);
+
+  cachedContext = {
+    sourceDir,
+    projectConfigs,
+    projectGitMap,
+    resourceIndex,
+    projectCatalog
+  };
+  cachedSignature = `${sourceDir}:${signature}`;
+  return cachedContext;
+}
+
+async function inferSourceContext(input, options = {}) {
+  const sourceContext = await loadSourceContext(options);
+  const normalizedInput = String(input || '').toLowerCase();
+  const keywords = extractKeywords(input);
+  const explicitEnv = detectEnvironment(input);
+  const candidates = sourceContext.projectCatalog
+    .map((project) => scoreProjectCandidate(project, normalizedInput, keywords))
+    .filter((candidate) => candidate.score > 0)
+    .sort((left, right) => right.score - left.score);
+
+  const topCandidates = candidates.slice(0, options.limit || DEFAULT_SCORE_LIMIT);
+  const selected = topCandidates[0] || null;
+
+  if (!selected) {
+    return {
+      matched: false,
+      sourceDir: sourceContext.sourceDir,
+      environment: explicitEnv,
+      candidates: []
+    };
+  }
+
+  const config = selected.config || {};
+  const mysql = config.services?.mysql ? normalizeProjectService(config.services.mysql) : null;
+  const redis = config.services?.redis ? normalizeProjectService(config.services.redis) : null;
+  const environment = explicitEnv
+    || config.environment
+    || mysql?.envType
+    || redis?.envType
+    || null;
+
+  return {
+    matched: true,
+    sourceDir: sourceContext.sourceDir,
+    project: selected.name,
+    environment,
+    gitProject: selected.git || null,
+    database: mysql,
+    redis,
+    cacheKeys: config.cacheKeys || {},
+    config,
+    matchedEntries: selected.resourceEntries.slice(0, 3).map((entry) => ({
+      title: entry.title,
+      aliases: entry.aliases,
+      modules: entry.modules,
+      tags: entry.tags
+    })),
+    candidates: topCandidates.map((candidate) => ({
+      project: candidate.name,
+      score: candidate.score,
+      reasons: candidate.reasons.slice(0, 8)
+    }))
+  };
+}
+
+module.exports = {
+  detectEnvironment,
+  getSourceDir,
+  inferSourceContext,
+  loadSourceContext,
+  parseResourceIndex
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "Memory and workflow automation for MCP, Codex, and Claude Code. Reuse repeatable developer operations through skills and explicit feedback.",
   "main": "core/index.js",
   "bin": {