flowmind 1.5.4 → 1.5.6

package/core/update-notifier.js

@@ -0,0 +1,74 @@
+const { execSync } = require('child_process');
+
+function compareVersions(currentVersion, latestVersion) {
+  const current = parseVersion(currentVersion);
+  const latest = parseVersion(latestVersion);
+
+  for (let index = 0; index < 3; index += 1) {
+    if (latest[index] > current[index]) return -1;
+    if (latest[index] < current[index]) return 1;
+  }
+
+  return 0;
+}
+
+function parseVersion(version) {
+  return String(version || '0.0.0')
+    .split('.')
+    .slice(0, 3)
+    .map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function getLatestVersion(packageName = 'flowmind') {
+  return execSync(`npm view ${packageName} version`, { encoding: 'utf-8' }).trim();
+}
+
+function isGlobalInstall(packageJsonPath, packageName = 'flowmind') {
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+    return String(packageJsonPath || '').startsWith(globalRoot) || String(packageJsonPath || '').includes(`${globalRoot}/${packageName}`);
+  } catch {
+    return false;
+  }
+}
+
+function buildInstallCommand({ packageName = 'flowmind', version, globalInstall = false }) {
+  if (!version) {
+    return globalInstall ? `npm install -g ${packageName}@latest` : `npm install ${packageName}@latest`;
+  }
+
+  return globalInstall
+    ? `npm install -g ${packageName}@${version}`
+    : `npm install ${packageName}@${version}`;
+}
+
+function getUpdateStatus({
+  packageName = 'flowmind',
+  currentVersion = '0.0.0',
+  packageJsonPath = ''
+} = {}) {
+  const latestVersion = getLatestVersion(packageName);
+  const comparison = compareVersions(currentVersion, latestVersion);
+  const globalInstall = isGlobalInstall(packageJsonPath, packageName);
+
+  return {
+    packageName,
+    currentVersion,
+    latestVersion,
+    comparison,
+    globalInstall,
+    installCommand: buildInstallCommand({
+      packageName,
+      version: latestVersion,
+      globalInstall
+    })
+  };
+}
+
+module.exports = {
+  buildInstallCommand,
+  compareVersions,
+  getLatestVersion,
+  getUpdateStatus,
+  isGlobalInstall
+};

package/dashboard/app.jsx

@@ -1,27 +1,86 @@
 const React = require('react');
-const { Box, useApp, useInput } = require('ink');
+const { Box, Text, 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');
+const { getTuiLayout, MIN_COLUMNS, MIN_ROWS } = require('../tui/layout');
+
+class DashboardErrorBoundary extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: null };
+  }
+
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+
+  render() {
+    if (this.state.error) {
+      return React.createElement(
+        Box,
+        { flexDirection: 'column', borderStyle: 'single', borderColor: 'red', paddingX: 1, paddingY: 1 },
+        React.createElement(Text, { bold: true, color: 'red' }, 'Dashboard render error'),
+        React.createElement(Text, { color: 'gray' }, this.state.error.message || 'Unknown render failure'),
+        React.createElement(Text, { color: 'gray' }, 'Resize the terminal or restart FlowMind.')
+      );
+    }
+    return this.props.children;
+  }
+}
 
 function DashboardApp({ flowmind, eventBus, asciiMode = false }) {
   const { exit } = useApp();
+  const [terminalSize, setTerminalSize] = React.useState(() => ({
+    columns: Number(process.stdout?.columns) || 0,
+    rows: Number(process.stdout?.rows) || 0
+  }));
+
+  React.useEffect(() => {
+    const updateSize = () => {
+      setTerminalSize({
+        columns: Number(process.stdout?.columns) || 0,
+        rows: Number(process.stdout?.rows) || 0
+      });
+    };
+
+    updateSize();
+    process.stdout?.on?.('resize', updateSize);
+
+    return () => {
+      process.stdout?.removeListener?.('resize', updateSize);
+    };
+  }, []);
 
   useInput((input, key) => {
     if (key.ctrl && input === 'c') exit();
   });
 
+  const layout = getTuiLayout(terminalSize.columns, terminalSize.rows);
+
+  if (layout.tooSmall) {
+    return (
+      React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'red', paddingX: 1, paddingY: 1 },
+        React.createElement(Text, { bold: true, color: 'red' }, 'Terminal too small'),
+        React.createElement(Text, { color: 'gray' }, `Need at least ${MIN_COLUMNS}x${MIN_ROWS}. Current size: ${layout.columns}x${layout.rows}.`),
+        React.createElement(Text, { color: 'gray' }, 'Resize the terminal to keep the dashboard stable.')
+      )
+    );
+  }
+
   return (
-    React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' },
-      React.createElement(Box, { flexDirection: 'row', flexGrow: 1 },
-        React.createElement(ActivityFeed, { eventBus: eventBus, asciiMode: asciiMode }),
-        React.createElement(Box, { flexDirection: 'column', width: '60%', flexGrow: 1 },
-          React.createElement(StatsRow, { flowmind: flowmind, asciiMode: asciiMode }),
-          React.createElement(DragonPanel, { flowmind: flowmind, asciiMode: asciiMode })
-        )
-      ),
-      React.createElement(McpStatusBar, { eventBus: eventBus, asciiMode: asciiMode })
+    React.createElement(DashboardErrorBoundary, null,
+      React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' },
+        React.createElement(Box, { flexDirection: layout.columns < 120 ? 'column' : 'row', flexGrow: 1 },
+          React.createElement(ActivityFeed, { eventBus: eventBus, asciiMode: asciiMode, width: layout.columns, compact: layout.columns < 120 }),
+          React.createElement(Box, { flexDirection: 'column', width: layout.columns < 120 ? '100%' : '60%', flexGrow: 1 },
+            React.createElement(StatsRow, { flowmind: flowmind, asciiMode: asciiMode, width: layout.columns, compact: layout.columns < 120 }),
+            React.createElement(DragonPanel, { flowmind: flowmind, asciiMode: asciiMode, width: layout.columns, compact: layout.columns < 120 })
+          )
+        ),
+        React.createElement(McpStatusBar, { eventBus: eventBus, asciiMode: asciiMode, width: layout.columns, compact: layout.columns < 120 })
+      )
     )
   );
 }

package/dashboard/components/ActivityFeed.jsx

@@ -38,7 +38,7 @@ function formatEvent(event, asciiMode) {
   }
 }
 
-function ActivityFeed({ eventBus, asciiMode = false }) {
+function ActivityFeed({ eventBus, asciiMode = false, width = 0, compact = false }) {
   const [events, setEvents] = React.useState([]);
 
   React.useEffect(() => {
@@ -66,13 +66,14 @@ function ActivityFeed({ eventBus, asciiMode = false }) {
     };
   }, [eventBus]);
 
-  const displayEvents = events.slice(-30);
+  const displayEvents = events.slice(-(compact ? 12 : 30));
+  const feedWidth = compact ? '100%' : '40%';
 
   return (
-    React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'green', paddingX: 1, width: '40%' },
+    React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'green', paddingX: 1, width: feedWidth },
       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.length === 0 && React.createElement(Text, { color: 'gray' }, compact ? 'Waiting...' : 'Waiting for events...'),
         displayEvents.map((event, i) =>
           React.createElement(Text, { key: i },
             React.createElement(Text, { color: 'gray' }, formatTime(event.timestamp) + ' '),

package/dashboard/components/DragonPanel.jsx

@@ -2,7 +2,7 @@ const React = require('react');
 const { Box, Text } = require('ink');
 const { LEVEL_COLORS, LEVEL_NAMES, LEVEL_STATES, getBorderStyle, getDragonArt } = require('../../tui/ui');
 
-function DragonPanel({ flowmind, asciiMode = false }) {
+function DragonPanel({ flowmind, asciiMode = false, width = 0, compact = false }) {
   const [honorData, setHonorData] = React.useState({ points: 0, level: 0, stats: {} });
 
   React.useEffect(() => {
@@ -23,6 +23,22 @@ function DragonPanel({ flowmind, asciiMode = false }) {
   const nextLevelPoints = [1, 10, 30, 60, 100];
   const nextPoints = nextLevelPoints[level] || null;
   const pointsToNext = nextPoints !== null ? nextPoints - honorData.points : 0;
+  const superCompact = compact || width < 120;
+
+  if (superCompact) {
+    return (
+      React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'cyan', paddingX: 1, flexGrow: 1 },
+        React.createElement(Text, { bold: true, color: 'cyan' }, 'Dragon Totem'),
+        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, { color: 'gray' }, honorData.points + ' pts'),
+        pointsToNext > 0 && React.createElement(Text, { color: 'gray' }, pointsToNext + ' to next')
+      )
+    );
+  }
 
   return (
     React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'cyan', paddingX: 1, flexGrow: 1 },

package/dashboard/components/McpStatusBar.jsx

@@ -2,10 +2,11 @@ const React = require('react');
 const { Box, Text } = require('ink');
 const { getBorderStyle } = require('../../tui/ui');
 
-function McpStatusBar({ eventBus, asciiMode = false }) {
+function McpStatusBar({ eventBus, asciiMode = false, width = 0, compact = false }) {
   const [toolCount, setToolCount] = React.useState(0);
   const [lastCall, setLastCall] = React.useState(null);
   const [serverState, setServerState] = React.useState('running');
+  const isCompact = compact || width < 120;
 
   React.useEffect(() => {
     if (!eventBus) return;
@@ -19,6 +20,23 @@ function McpStatusBar({ eventBus, asciiMode = false }) {
 
   const formatTime = (ts) => ts ? new Date(ts).toTimeString().substring(0, 8) : 'none';
 
+  if (isCompact) {
+    return (
+      React.createElement(Box, { borderStyle: getBorderStyle(asciiMode), borderColor: 'gray', paddingX: 1, flexDirection: 'column' },
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'gray' }, 'MCP: '),
+          React.createElement(Text, { color: 'green' }, serverState),
+          React.createElement(Text, { color: 'gray' }, ' | Tools: '),
+          React.createElement(Text, { color: 'white' }, '' + toolCount)
+        ),
+        React.createElement(Text, null,
+          React.createElement(Text, { color: 'gray' }, 'Last: '),
+          React.createElement(Text, { color: 'white' }, formatTime(lastCall))
+        )
+      )
+    );
+  }
+
   return (
     React.createElement(Box, { borderStyle: getBorderStyle(asciiMode), borderColor: 'gray', paddingX: 1, justifyContent: 'space-between' },
       React.createElement(Text, null,

package/dashboard/components/StatsRow.jsx

@@ -2,7 +2,7 @@ const React = require('react');
 const { Box, Text } = require('ink');
 const { LEVEL_NAMES, getBorderStyle, getProgressBar } = require('../../tui/ui');
 
-function StatsRow({ flowmind, asciiMode = false }) {
+function StatsRow({ flowmind, asciiMode = false, width = 0, compact = false }) {
   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' });
@@ -19,10 +19,35 @@ function StatsRow({ flowmind, asciiMode = false }) {
     return () => clearInterval(interval);
   }, [flowmind]);
 
-  const barWidth = 16;
+  const barWidth = compact ? Math.max(8, Math.floor(width / 10)) : 16;
   const progress = honorData.points > 0 ? Math.min(1, honorData.points / 100) : 0;
   const progressBar = getProgressBar(barWidth, progress, asciiMode);
 
+  if (compact) {
+    return (
+      React.createElement(Box, { flexDirection: 'column' },
+        React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'yellow', paddingX: 1, width: '100%' },
+          React.createElement(Text, { bold: true, color: 'yellow' }, 'Honor'),
+          React.createElement(Text, { color: 'yellow' }, LEVEL_NAMES[honorData.level] || 'Egg'),
+          React.createElement(Text, { color: 'green' }, progressBar),
+          React.createElement(Text, { color: 'gray' }, honorData.points + '/100 pts')
+        ),
+        React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'cyan', paddingX: 1, width: '100%', marginTop: 1 },
+          React.createElement(Text, { bold: true, color: 'cyan' }, 'Learning'),
+          React.createElement(Text, { color: 'white' }, '' + (learningStats.totalRecords || 0) + ' records'),
+          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: getBorderStyle(asciiMode), borderColor: 'blue', paddingX: 1, width: '100%', marginTop: 1 },
+          React.createElement(Text, { bold: true, color: 'blue' }, 'Components'),
+          React.createElement(Text, { color: 'gray' }, aiStatus.defaultProvider || 'none')
+        )
+      )
+    );
+  }
+
   return (
     React.createElement(Box, { flexDirection: 'row' },
       React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'yellow', paddingX: 1, width: '33%' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "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": {
@@ -11,6 +11,7 @@
   "scripts": {
     "start": "node core/index.js",
     "mcp": "node mcp/server.js",
+    "check:update": "node scripts/check-update.js",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "lint": "eslint .",

package/scripts/check-update.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const chalk = require('chalk');
+const packageJson = require('../package.json');
+const {
+  getUpdateStatus
+} = require('../core/update-notifier');
+
+function printStatus(status) {
+  console.log(chalk.cyan(`\nCurrent version: ${status.currentVersion}`));
+  console.log(chalk.cyan(`Latest version:  ${status.latestVersion}`));
+
+  if (status.comparison === 0) {
+    console.log(chalk.green('\n✓ You are already on the latest version!'));
+    return;
+  }
+
+  if (status.comparison > 0) {
+    console.log(chalk.green('\n✓ You are on a newer version than npm latest.'));
+    return;
+  }
+
+  console.log(chalk.yellow(`\n⬆ Update available: ${status.currentVersion} → ${status.latestVersion}`));
+  console.log(chalk.cyan('\nRun the following command to update:'));
+  console.log(chalk.white(`  ${status.installCommand}`));
+  console.log(chalk.gray('  Or run `flowmind update` for the guided upgrade flow.'));
+}
+
+async function main() {
+  try {
+    const status = getUpdateStatus({
+      packageName: packageJson.name,
+      currentVersion: packageJson.version,
+      packageJsonPath: require.resolve('../package.json')
+    });
+
+    printStatus(status);
+  } catch (error) {
+    console.error(chalk.red('Failed to check for updates:'), error.message);
+    console.log(chalk.yellow('\nYou can manually update with:'));
+    console.log(chalk.white(`  npm install -g ${packageJson.name}@latest`));
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  main
+};

package/skills/auto-flow/index.js

@@ -669,34 +669,8 @@ async function executeDeploy(workflow, params, input, context) {
     };
   }
 
-  const listParams = buildListPipelineParams(params);
-  const lookup = await workflow.client.listPipelines(listParams);
-  const batchParams = buildBatchRunParams(params);
-  const execution = await workflow.client.startBatchPipelineRun(batchParams);
-
-    return {
-      type: 'result',
-      skill: 'auto-flow',
-      message: 'Workflow status: deployment submitted',
-      data: {
-        action: 'deploy',
-        provider: workflow.provider,
-        binding: workflow.binding,
-        status: 'submitted',
-        mcpServer: getWorkflowMcpServer(workflow),
-        execution: summarizeDeployExecution(params, execution, {
-          source: 'batch-fallback',
-          lookup
-        }),
-        resolution: {
-          source: 'batch-fallback',
-          lookup
-        }
-      },
-      input,
-      timestamp: new Date().toISOString()
-    };
-  }
+  return buildUnresolvedDeployResult(workflow, params, input, context);
+}
 
 async function executeStatus(workflow, params, input) {
   let execution;
@@ -894,7 +868,7 @@ function resolveLocalPipelineForService(serviceName, environment, context) {
   const entry = pipelineMap[serviceName];
   if (!entry) return null;
 
-  const pipeline = selectPipelineFromEntry(entry, environment);
+  const pipeline = selectPipelineFromEntry(entry, environment, serviceName);
   if (!pipeline?.pipelineId) return null;
 
   return {
@@ -923,19 +897,13 @@ function readLocalPipelineMap(context) {
   return null;
 }
 
-function selectPipelineFromEntry(entry, environment) {
+function selectPipelineFromEntry(entry, environment, serviceName) {
   const preferredKeys = getEnvLookupOrder(environment);
   for (const key of preferredKeys) {
     const candidate = normalizePipelineCollection(entry?.[key]);
-    if (candidate.length > 0) {
-      return candidate[0];
-    }
-  }
-
-  for (const value of Object.values(entry || {})) {
-    const candidate = normalizePipelineCollection(value);
-    if (candidate.length > 0) {
-      return candidate[0];
+    const matched = candidate.find((item) => matchesPipelineName(item.pipelineName, environment, serviceName));
+    if (matched) {
+      return matched;
     }
   }
 
@@ -1094,49 +1062,12 @@ function matchesRemoteService(fields, serviceName, environment) {
 }
 
 function selectPipelineFromFields(fields, environment, serviceName) {
-  const indexedCandidate = selectIndexedPipelineForService(fields, environment, serviceName);
-  if (indexedCandidate?.pipelineId) {
-    return indexedCandidate;
-  }
-
   const candidates = collectFieldPipelineDescriptors(fields, environment);
-  if (candidates.length > 0) {
-    return candidates[0];
-  }
-
-  const pipelineIds = String(fields.pipelineId || '')
-    .split(',')
-    .map((item) => item.trim())
-    .filter(Boolean);
-
-  if (pipelineIds.length === 0) {
-    return null;
-  }
-
-  return {
-    pipelineName: buildPrefixedPipelineName(
-      Array.isArray(fields.service) ? fields.service[0] : null,
-      environment
-    ),
-    pipelineId: pipelineIds[0]
-  };
-}
-
-function selectIndexedPipelineForService(fields, environment, serviceName) {
-  if (!serviceName) return null;
-
-  const services = Array.isArray(fields.service) ? fields.service.map((item) => String(item).trim()) : [];
-  const serviceIndex = services.indexOf(serviceName);
-  if (serviceIndex < 0) return null;
-
-  for (const key of getFieldKeysForEnvironment(environment)) {
-    const values = Array.isArray(fields[key]) ? fields[key] : [];
-    const parsed = parsePipelineDescriptor(values[serviceIndex]);
-    if (parsed?.pipelineId) {
-      return parsed;
+  for (const candidate of candidates) {
+    if (candidate?.pipelineId && matchesPipelineName(candidate.pipelineName, environment, serviceName)) {
+      return candidate;
     }
   }
-
   return null;
 }
 
@@ -1177,10 +1108,11 @@ function parsePipelineDescriptor(value) {
 function getEnvLookupOrder(environment) {
   const normalized = normalizeEnvironment(environment || '');
   if (normalized === 'prod') return ['prod'];
-  if (normalized === 'gray') return ['gray', 'prod'];
+  if (normalized === 'gray') return ['gray'];
   if (normalized === 'uat') return ['uat'];
-  if (normalized === 'test') return ['test', 'dev', 'uat'];
-  return ['uat', 'test', 'dev', 'gray', 'prod'];
+  if (normalized === 'test') return ['test', 'dev'];
+  if (normalized === 'dev') return ['dev'];
+  return [];
 }
 
 function buildPrefixedPipelineName(serviceName, environment) {
@@ -1191,6 +1123,24 @@ function buildPrefixedPipelineName(serviceName, environment) {
   return `${prefix}-${serviceName}`;
 }
 
+function matchesPipelineName(pipelineName, environment, serviceName) {
+  if (!pipelineName || !serviceName) return false;
+
+  const normalized = String(pipelineName).toLowerCase();
+  const candidatePrefixes = getAllowedPipelinePrefixes(environment);
+  return candidatePrefixes.some((prefix) => normalized === `${prefix}-${serviceName}`.toLowerCase());
+}
+
+function getAllowedPipelinePrefixes(environment) {
+  const normalized = normalizeEnvironment(environment || '');
+  if (normalized === 'test') return ['test', 'dev'];
+  if (normalized === 'dev') return ['dev'];
+  if (normalized === 'uat') return ['uat'];
+  if (normalized === 'gray') return ['gray'];
+  if (normalized === 'prod') return ['prod'];
+  return [];
+}
+
 function inferEnvironmentFromPipelineName(pipelineName) {
   const match = String(pipelineName || '').match(/^(test|dev|uat|gray|prod)-/i);
   return match ? (ENV_PREFIX_TO_ENV[match[1].toLowerCase()] || normalizeEnvironment(match[1])) : null;
@@ -1219,6 +1169,32 @@ function collectNestedValues(payload, values = []) {
   return values;
 }
 
+function buildUnresolvedDeployResult(workflow, params, input, context) {
+  const target = buildWorkflowTargetLabel(params) || buildDeployTargetLabel(context) || 'deployment';
+  return {
+    type: 'error',
+    success: false,
+    skill: 'auto-flow',
+    message: `Unable to resolve deployment target for ${target}. Specify an exact environment or pipelineId.`,
+    data: {
+      action: 'deploy',
+      provider: workflow.provider,
+      binding: workflow.binding,
+      status: 'not_resolved',
+      mcpServer: getWorkflowMcpServer(workflow),
+      target,
+      environment: params.environment || null,
+      resolution: {
+        source: 'not-resolved',
+        serviceNames: params.serviceNames || [],
+        environment: params.environment || null
+      }
+    },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
 function compactObject(value) {
   return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null && item !== ''));
 }