flowmind 1.0.1 → 1.2.2

package/dashboard/app.jsx

@@ -0,0 +1,29 @@
+const React = require('react');
+const { Box, useApp, useInput } = require('ink');
+const ActivityFeed = require('./components/ActivityFeed.jsx');
+const StatsRow = require('./components/StatsRow.jsx');
+const DragonPanel = require('./components/DragonPanel.jsx');
+const McpStatusBar = require('./components/McpStatusBar.jsx');
+
+function DashboardApp({ flowmind, eventBus }) {
+  const { exit } = useApp();
+
+  useInput((input, key) => {
+    if (key.ctrl && input === 'c') exit();
+  });
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' },
+      React.createElement(Box, { flexDirection: 'row', flexGrow: 1 },
+        React.createElement(ActivityFeed, { eventBus: eventBus }),
+        React.createElement(Box, { flexDirection: 'column', width: '60%', flexGrow: 1 },
+          React.createElement(StatsRow, { flowmind: flowmind }),
+          React.createElement(DragonPanel, { flowmind: flowmind })
+        )
+      ),
+      React.createElement(McpStatusBar, { eventBus: eventBus })
+    )
+  );
+}
+
+module.exports = DashboardApp;

package/dashboard/components/ActivityFeed.jsx

@@ -0,0 +1,86 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+const EVENT_COLORS = {
+  'skill:executed': 'green',
+  'honor:awarded': 'yellow',
+  'learning:recorded': 'cyan',
+  'mcp:tool_called': 'magenta',
+  'process:start': 'blue',
+  'process:complete': 'green',
+  'process:error': 'red',
+};
+
+function formatTime(timestamp) {
+  if (!timestamp) return '??:??';
+  return new Date(timestamp).toTimeString().substring(0, 8);
+}
+
+function formatEvent(event) {
+  switch (event.type) {
+    case 'skill:executed':
+      return 'skill:' + (event.data?.name || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717');
+    case 'honor:awarded':
+      return 'honor +' + (event.data?.points || 0) + ' (' + (event.data?.description || '') + ')';
+    case 'learning:recorded':
+      return 'learning:' + (event.data?.type || '?') + ' ' + (event.data?.skill || '');
+    case 'mcp:tool_called':
+      return 'MCP:' + (event.data?.tool || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717') + ' ' + (event.data?.duration || 0) + 'ms';
+    case 'process:start':
+      return 'process: ' + (event.data?.input?.substring(0, 30) || '?') + '...';
+    case 'process:complete':
+      return 'done:' + (event.data?.skill || '?') + ' ' + (event.data?.duration || 0) + 'ms';
+    case 'process:error':
+      return 'error: ' + (event.data?.error?.substring(0, 40) || '?');
+    default:
+      return event.type || 'unknown';
+  }
+}
+
+function ActivityFeed({ eventBus }) {
+  const [events, setEvents] = React.useState([]);
+
+  React.useEffect(() => {
+    if (!eventBus) return;
+
+    const handler = (eventType) => (data) => {
+      setEvents(prev => {
+        const next = [...prev, { type: eventType, data, timestamp: data.timestamp || new Date().toISOString() }];
+        if (next.length > 100) next.shift();
+        return next;
+      });
+    };
+
+    const eventTypes = ['skill:executed', 'honor:awarded', 'learning:recorded', 'mcp:tool_called', 'process:start', 'process:complete', 'process:error'];
+    const handlers = eventTypes.map(type => {
+      const h = handler(type);
+      eventBus.on(type, h);
+      return { type, handler: h };
+    });
+
+    return () => {
+      for (const { type, handler: h } of handlers) {
+        eventBus.removeListener(type, h);
+      }
+    };
+  }, [eventBus]);
+
+  const displayEvents = events.slice(-30);
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'green', paddingX: 1, width: '40%' },
+      React.createElement(Text, { bold: true, color: 'green' }, 'Activity Feed'),
+      React.createElement(Box, { flexDirection: 'column', marginTop: 1, overflow: 'hidden' },
+        displayEvents.length === 0 && React.createElement(Text, { color: 'gray' }, 'Waiting for events...'),
+        displayEvents.map((event, i) =>
+          React.createElement(Text, { key: i },
+            React.createElement(Text, { color: 'gray' }, formatTime(event.timestamp) + ' '),
+            React.createElement(Text, { color: EVENT_COLORS[event.type] || 'white' }, formatEvent(event))
+          )
+        )
+      )
+    )
+  );
+}
+
+module.exports = ActivityFeed;

package/dashboard/components/DragonPanel.jsx

@@ -0,0 +1,67 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+const DRAGON_ARTS = {
+  0: ['        ╭─────╮        ','       ╱  ╭─╮  ╲       ','      │  │   │  │      ','      │  │ ◎ │  │      ','      │   ╰─╯   │      ','       ╲       ╱       ','        ╰─────╯        '],
+  1: ['           ╭──╮            ','      ╭────╯  ╰───╮        ','     ╱  ◎    ╰─╯   ╲      ','    ╱    ▽           ╲     ','    ╲    ╱╲   ╱╲     ╱     ','     ╲╱╱  ╲╱╱  ╲╱╲╱       '],
+  2: ['        ╭─╮  ╭─╮             ','   ╭────╯ ╰──╯ ╰───╮         ','  ╱  ◎      ╰──╯     ╲       ',' ╱      ╭────────╮     ╲     ',' ╲     ╱ ╱╱╱╱╱╱╱╱ ╲    ╱     ','  ╲───╯ ╱╱╱╱╱╱╱╱╱╱ ╰──╱      ','   ╰─╯            ╰─╯       '],
+  3: ['      ╭───╮  ╭───╮               ','  ╭───╯   ╰──╯   ╰───╮           ',' ╱  ◎        ╰───╯     ╲         ','│     ╭──────────╮      │        ','│    ╱ ╱╱╱╱╱╱╱╱╱╱ ╲     │        ',' ╲──╯ ╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯        ','  ╲  ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╱         ','   ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱          ','    ╰───╯       ╰───╯            '],
+  4: ['    ╭───╮      ╭───╮                 ','╭───╯   ╰──────╯   ╰───╮             ','│  ◎           ╰───╯     │           ','│      ╭────────────╮    │           ','│     ╱ ╱╱╱╱╱╱╱╱╱╱╱╱ ╲   │           ',' ╲───╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰──╯          ','  ╲   ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╲          ','   ╲─╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰─╲         ','    ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱         ','     ╰───╯         ╰───╯             '],
+  5: ['  ★  ╭───╮          ╭───╮  ★           ','╭─╯   ╰──╯          ╰──╯   ╰─╮         ','│  ◎            ╰───╯         │         ','│       ╭──────────────╮      │         ','│      ╱ ★╱╱╱╱╱╱╱╱╱╱★╱╱ ╲     │         ',' ╲────╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯         ','  ╲    ╱╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱  ╲          ','   ╲──╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰──╲         ','    ╲─╯╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱╰──╲         ','  ★  ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ★       ','       ╰───╯           ╰───╯            '],
+};
+
+const LEVEL_NAMES = ['Egg', 'Hatchling', 'Juvenile', 'Adult', 'Elder', 'Ascended'];
+const LEVEL_STATES = ['dormant', 'awakening', 'growing', 'soaring', 'wise', 'transcendent'];
+const LEVEL_COLORS = ['gray', 'cyan', 'cyan', 'cyanBright', 'cyanBright', 'cyanBright'];
+
+function DragonPanel({ flowmind }) {
+  const [honorData, setHonorData] = React.useState({ points: 0, level: 0, stats: {} });
+
+  React.useEffect(() => {
+    if (!flowmind) return;
+    const refresh = () => {
+      try { setHonorData(flowmind.getHonorData()); } catch (e) { /* ignore */ }
+    };
+    refresh();
+    const interval = setInterval(refresh, 5000);
+    return () => clearInterval(interval);
+  }, [flowmind]);
+
+  const level = honorData.level || 0;
+  const art = DRAGON_ARTS[level] || DRAGON_ARTS[0];
+  const color = LEVEL_COLORS[level] || 'gray';
+  const levelName = LEVEL_NAMES[level] || 'Unknown';
+  const state = LEVEL_STATES[level] || 'unknown';
+  const nextLevelPoints = [1, 10, 30, 60, 100];
+  const nextPoints = nextLevelPoints[level] || null;
+  const pointsToNext = nextPoints !== null ? nextPoints - honorData.points : 0;
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'cyan', paddingX: 1, flexGrow: 1 },
+      React.createElement(Text, { bold: true, color: 'cyan' }, 'Dragon Totem'),
+      React.createElement(Box, { flexDirection: 'row', marginTop: 1 },
+        React.createElement(Box, { flexDirection: 'column' },
+          art.map((line, i) => React.createElement(Text, { key: i, color: color }, line))
+        ),
+        React.createElement(Box, { flexDirection: 'column', marginLeft: 3, justifyContent: 'center' },
+          React.createElement(Text, null,
+            React.createElement(Text, { color: 'yellow', bold: true }, 'Lv' + level),
+            React.createElement(Text, { color: 'white' }, ' ' + levelName)
+          ),
+          React.createElement(Text, { color: 'gray' }, 'State: ' + state),
+          React.createElement(Text, null,
+            React.createElement(Text, { color: 'yellow' }, '' + honorData.points),
+            React.createElement(Text, { color: 'gray' }, ' points')
+          ),
+          pointsToNext > 0 && React.createElement(Text, { color: 'gray' }, pointsToNext + ' to next'),
+          React.createElement(Box, { flexDirection: 'column', marginTop: 1 },
+            React.createElement(Text, { color: 'gray' }, 'Skills: ' + (honorData.stats?.skillUseCount || 0)),
+            React.createElement(Text, { color: 'gray' }, 'Learnings: ' + (honorData.stats?.learningCount || 0))
+          )
+        )
+      )
+    )
+  );
+}
+
+module.exports = DragonPanel;

package/dashboard/components/McpStatusBar.jsx

@@ -0,0 +1,43 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+function McpStatusBar({ eventBus }) {
+  const [toolCount, setToolCount] = React.useState(0);
+  const [lastCall, setLastCall] = React.useState(null);
+  const [serverState, setServerState] = React.useState('running');
+
+  React.useEffect(() => {
+    if (!eventBus) return;
+    const handler = (data) => {
+      setToolCount(prev => prev + 1);
+      setLastCall(data.timestamp || new Date().toISOString());
+    };
+    eventBus.on('mcp:tool_called', handler);
+    return () => { eventBus.removeListener('mcp:tool_called', handler); };
+  }, [eventBus]);
+
+  const formatTime = (ts) => ts ? new Date(ts).toTimeString().substring(0, 8) : 'none';
+
+  return (
+    React.createElement(Box, { borderStyle: 'single', borderColor: 'gray', paddingX: 1, justifyContent: 'space-between' },
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'MCP Server: '),
+        React.createElement(Text, { color: 'green' }, serverState)
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Port: '),
+        React.createElement(Text, { color: 'white' }, 'stdin/stdout')
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Tool calls: '),
+        React.createElement(Text, { color: 'white' }, '' + toolCount)
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Last call: '),
+        React.createElement(Text, { color: 'white' }, formatTime(lastCall))
+      )
+    )
+  );
+}
+
+module.exports = McpStatusBar;

package/dashboard/components/StatsRow.jsx

@@ -0,0 +1,65 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+const LEVEL_NAMES = ['Egg', 'Hatchling', 'Juvenile', 'Adult', 'Elder', 'Ascended'];
+
+function StatsRow({ flowmind }) {
+  const [honorData, setHonorData] = React.useState({ points: 0, level: 0, stats: {} });
+  const [learningStats, setLearningStats] = React.useState({ totalRecords: 0, byType: {} });
+  const [aiStatus, setAiStatus] = React.useState({ initialized: false, defaultProvider: 'none' });
+
+  React.useEffect(() => {
+    if (!flowmind) return;
+    const refresh = () => {
+      try { setHonorData(flowmind.getHonorData()); } catch (e) { /* ignore */ }
+      try { flowmind.getStats().then(s => setLearningStats(s)); } catch (e) { /* ignore */ }
+      try { setAiStatus(flowmind.getAIStatus()); } catch (e) { /* ignore */ }
+    };
+    refresh();
+    const interval = setInterval(refresh, 5000);
+    return () => clearInterval(interval);
+  }, [flowmind]);
+
+  const barWidth = 16;
+  const progress = honorData.points > 0 ? Math.min(1, honorData.points / 100) : 0;
+  const filled = Math.round(progress * barWidth);
+  const progressBar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
+
+  return (
+    React.createElement(Box, { flexDirection: 'row' },
+      React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'yellow', paddingX: 1, width: '33%' },
+        React.createElement(Text, { bold: true, color: 'yellow' }, 'Honor'),
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'yellow' }, LEVEL_NAMES[honorData.level] || 'Egg'),
+          React.createElement(Text, { color: 'gray' }, ' Lv' + honorData.level)
+        ),
+        React.createElement(Text, { color: 'green' }, progressBar),
+        React.createElement(Text, { color: 'gray' }, honorData.points + '/100 pts')
+      ),
+      React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'cyan', paddingX: 1, width: '33%' },
+        React.createElement(Text, { bold: true, color: 'cyan' }, 'Learning'),
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'white' }, '' + (learningStats.totalRecords || 0)),
+          React.createElement(Text, { color: 'gray' }, ' records')
+        ),
+        Object.entries(learningStats.byType || {}).map(([type, count]) =>
+          React.createElement(Text, { key: type, color: 'gray' }, '  ' + type + ': ' + count)
+        ),
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'gray' }, 'AI: '),
+          React.createElement(Text, { color: aiStatus.initialized ? 'green' : 'red' }, aiStatus.initialized ? 'ok' : 'off')
+        )
+      ),
+      React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'blue', paddingX: 1, width: '33%' },
+        React.createElement(Text, { bold: true, color: 'blue' }, 'Components'),
+        React.createElement(Text, { color: 'gray' }, 'Registry loaded'),
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'gray' }, 'Provider: '),
+          React.createElement(Text, { color: aiStatus.initialized ? 'green' : 'red' }, aiStatus.defaultProvider || 'none')
+        )
+      )
+    )
+  );
+}
+
+module.exports = StatsRow;

package/mcp/server.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+/**
+ * FlowMind MCP Server
+ * 让 Claude/Codex 可以直接调用 FlowMind 内部流程
+ */
+
+const FlowMind = require('../core');
+const eventBus = require('../core/event-bus');
+
+// MCP Server 实现
+class FlowMindMCPServer {
+  constructor() {
+    this.flowmind = null;
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    this.flowmind = new FlowMind();
+    await this.flowmind.init();
+    this.initialized = true;
+  }
+
+  /**
+   * 获取所有可用工具
+   */
+  getTools() {
+    const skills = this.flowmind.skills.list();
+    const tools = [];
+
+    // 添加核心工具
+    tools.push({
+      name: 'flowmind_process',
+      description: 'Process a request using FlowMind AI agent. This is the main entry point for using FlowMind.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          input: {
+            type: 'string',
+            description: 'The request to process'
+          },
+          context: {
+            type: 'object',
+            description: 'Optional context for the request'
+          }
+        },
+        required: ['input']
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_list_skills',
+      description: 'List all available FlowMind skills',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_get_skill',
+      description: 'Get detailed information about a specific skill',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Skill name'
+          }
+        },
+        required: ['name']
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_ai_status',
+      description: 'Get AI model status and configuration',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    tools.push({
+      name: 'flowmind_learning_stats',
+      description: 'Get learning statistics',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    });
+
+    // 添加每个技能作为独立工具
+    for (const skill of skills) {
+      tools.push({
+        name: `flowmind_skill_${skill.name}`,
+        description: skill.description || `Execute ${skill.name} skill`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            input: {
+              type: 'string',
+              description: 'Input for the skill'
+            },
+            context: {
+              type: 'object',
+              description: 'Optional context'
+            }
+          },
+          required: ['input']
+        }
+      });
+    }
+
+    return tools;
+  }
+
+  /**
+   * 调用工具
+   */
+  async callTool(name, args) {
+    await this.init();
+
+    const callStart = Date.now();
+    let result;
+
+    try {
+      // 核心工具
+      if (name === 'flowmind_process') {
+        const data = await this.flowmind.process(args.input, args.context || {});
+        result = {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(data, null, 2)
+          }]
+        };
+      } else if (name === 'flowmind_list_skills') {
+        const skills = this.flowmind.skills.list();
+        result = {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ skills }, null, 2)
+          }]
+        };
+      } else if (name === 'flowmind_get_skill') {
+        const skill = this.flowmind.skills.get(args.name);
+        if (!skill) {
+          result = {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: `Skill not found: ${args.name}` })
+            }],
+            isError: true
+          };
+        } else {
+          result = {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                name: skill.name,
+                description: skill.definition?.description,
+                category: skill.definition?.category,
+                triggers: skill.definition?.triggers,
+                componentDependencies: skill.definition?.componentDependencies
+              }, null, 2)
+            }]
+          };
+        }
+      } else if (name === 'flowmind_ai_status') {
+        const status = this.flowmind.getAIStatus();
+        result = {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(status, null, 2)
+          }]
+        };
+      } else if (name === 'flowmind_learning_stats') {
+        const stats = await this.flowmind.getStats();
+        result = {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(stats, null, 2)
+          }]
+        };
+      } else if (name.startsWith('flowmind_skill_')) {
+        // 技能工具
+        const skillName = name.replace('flowmind_skill_', '');
+        const skill = this.flowmind.skills.get(skillName);
+
+        if (!skill) {
+          result = {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: `Skill not found: ${skillName}` })
+            }],
+            isError: true
+          };
+        } else {
+          const data = await this.flowmind.executeWithLearning(skill, args.input, args.context || {});
+          result = {
+            content: [{
+              type: 'text',
+              text: JSON.stringify(data, null, 2)
+            }]
+          };
+        }
+      } else {
+        result = {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ error: `Unknown tool: ${name}` })
+          }],
+          isError: true
+        };
+      }
+
+      // Emit success event
+      eventBus.emit('mcp:tool_called', {
+        tool: name,
+        args,
+        duration: Date.now() - callStart,
+        success: !result.isError,
+        timestamp: new Date().toISOString()
+      });
+
+      return result;
+
+    } catch (error) {
+      eventBus.emit('mcp:tool_called', {
+        tool: name,
+        args,
+        duration: Date.now() - callStart,
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      });
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ error: error.message })
+        }],
+        isError: true
+      };
+    }
+  }
+}
+
+// 启动 MCP Server
+async function main() {
+  const server = new FlowMindMCPServer();
+
+  // 读取 stdin，写入 stdout
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+
+  rl.on('line', async (line) => {
+    try {
+      const request = JSON.parse(line);
+      let response;
+
+      if (request.method === 'initialize') {
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+              tools: {}
+            },
+            serverInfo: {
+              name: 'flowmind',
+              version: '1.0.1'
+            }
+          }
+        };
+      } else if (request.method === 'tools/list') {
+        await server.init();
+        const tools = server.getTools();
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: { tools }
+        };
+      } else if (request.method === 'tools/call') {
+        const result = await server.callTool(request.params.name, request.params.arguments || {});
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result
+        };
+      } else {
+        response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${request.method}`
+          }
+        };
+      }
+
+      process.stdout.write(JSON.stringify(response) + '\n');
+    } catch (error) {
+      const response = {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32700,
+          message: 'Parse error'
+        }
+      };
+      process.stdout.write(JSON.stringify(response) + '\n');
+    }
+  });
+
+  // 初始化
+  await server.init();
+  console.error('FlowMind MCP Server started');
+}
+
+main().catch(console.error);

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "flowmind",
-  "version": "1.0.1",
+  "version": "1.2.2",
   "description": "The AI Agent That Learns How You Work - Stop repeating yourself, FlowMind learns your workflows and applies them automatically.",
   "main": "core/index.js",
   "bin": {
-    "flowmind": "./bin/flowmind.js"
+    "flowmind": "./bin/flowmind.js",
+    "flowmind-mcp": "./mcp/server.js"
   },
   "scripts": {
     "start": "node core/index.js",
+    "mcp": "node mcp/server.js",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "lint": "eslint .",
@@ -21,7 +23,10 @@
     "learning-system",
     "code-review",
     "log-analysis",
-    "devops"
+    "devops",
+    "mcp-server",
+    "claude-integration",
+    "codex-integration"
   ],
   "author": "FlowMind Technologies",
   "license": "MIT",
@@ -36,7 +41,10 @@
   "files": [
     "bin/",
     "core/",
+    "mcp/",
     "skills/",
+    "tui/",
+    "dashboard/",
     "scripts/",
     "templates/",
     "config/",
@@ -50,16 +58,20 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "commander": "^11.0.0",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1",
-    "inquirer": "^8.2.6",
+    "commander": "^11.0.0",
     "fs-extra": "^11.1.1",
+    "ink": "^3.2.0",
+    "ink-spinner": "^4.0.3",
+    "ink-text-input": "^4.0.3",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "react": "^18.3.1",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "jest": "^29.7.0",
     "eslint": "^8.50.0",
+    "jest": "^29.7.0",
     "nodemon": "^3.0.1",
     "webpack": "^5.88.0",
     "webpack-cli": "^5.1.4"