flowmind 1.4.2 → 1.4.4

package/README_CN.md

@@ -319,6 +319,16 @@ Claude：我来使用 FlowMind 的代码审查技能...
 通过 JSON 输出与 Codex 集成。
 
 ```bash
+# 推荐：使用 Codex 包装命令
+flowmind-codex "查询最近1小时的错误日志"
+flowmind-codex skills
+flowmind-codex skill log-audit
+flowmind-codex doctor
+
+# 默认使用当前工作区的 .flowmind-codex/
+# 也可以自定义目录
+# FLOWMIND_CODEX_HOME=/your/path flowmind-codex skills
+
 # 获取技能列表 (JSON 格式)
 flowmind skills --json
 

package/bin/flowmind-codex.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const fs = require('fs-extra');
+const path = require('path');
+const FlowMind = require('../core');
+const { version } = require('../package.json');
+
+function printJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+function fail(message, extra = {}) {
+  printJson({
+    ok: false,
+    error: {
+      message,
+      ...extra
+    }
+  });
+  process.exitCode = 1;
+}
+
+async function createFlowMind() {
+  const codexHome = process.env.FLOWMIND_CODEX_HOME || path.join(process.cwd(), '.flowmind-codex');
+  process.env.FLOWMIND_HOME = process.env.FLOWMIND_HOME || codexHome;
+
+  const configPath = path.join(codexHome, 'config.json');
+  await fs.ensureDir(codexHome);
+
+  if (!await fs.pathExists(configPath)) {
+    await fs.writeJson(configPath, {
+      version: '1.0.0',
+      name: 'FlowMind Codex Workspace',
+      storagePath: codexHome,
+      learning: {
+        storagePath: path.join(codexHome, 'learning')
+      }
+    }, { spaces: 2 });
+  }
+
+  const flowmind = new FlowMind({ configPath });
+  await flowmind.init();
+  return flowmind;
+}
+
+program
+  .name('flowmind-codex')
+  .description('Codex-friendly JSON wrapper for FlowMind')
+  .version(version);
+
+program
+  .argument('[input...]', 'Process a FlowMind request directly')
+  .option('-s, --skill <skill>', 'Use a specific skill')
+  .action(async (inputParts, options) => {
+    if (!inputParts.length) {
+      return;
+    }
+
+    try {
+      const flowmind = await createFlowMind();
+      const input = inputParts.join(' ');
+      const result = await flowmind.process(input, {
+        skill: options.skill
+      });
+
+      printJson({
+        ok: result.type !== 'error',
+        command: 'ask',
+        input,
+        result
+      });
+
+      if (result.type === 'error') {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'ask' });
+    }
+  });
+
+program
+  .command('ask')
+  .description('Process a request and emit JSON')
+  .argument('<input...>', 'Input to process')
+  .option('-s, --skill <skill>', 'Use a specific skill')
+  .action(async (inputParts, options) => {
+    try {
+      const flowmind = await createFlowMind();
+      const input = inputParts.join(' ');
+      const result = await flowmind.process(input, {
+        skill: options.skill
+      });
+
+      printJson({
+        ok: result.type !== 'error',
+        command: 'ask',
+        input,
+        result
+      });
+
+      if (result.type === 'error') {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'ask' });
+    }
+  });
+
+program
+  .command('skills')
+  .description('List skills as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      printJson({
+        ok: true,
+        command: 'skills',
+        skills: flowmind.skills.list()
+      });
+    } catch (error) {
+      fail(error.message, { command: 'skills' });
+    }
+  });
+
+program
+  .command('skill')
+  .description('Get one skill as JSON')
+  .argument('<name>', 'Skill name')
+  .action(async (name) => {
+    try {
+      const flowmind = await createFlowMind();
+      const skill = flowmind.skills.get(name);
+
+      if (!skill) {
+        fail(`Skill not found: ${name}`, { command: 'skill', skill: name });
+        return;
+      }
+
+      printJson({
+        ok: true,
+        command: 'skill',
+        skill: {
+          name: skill.name,
+          description: skill.definition?.description,
+          category: skill.definition?.category || skill.definition?.metadata?.category,
+          version: skill.definition?.version || skill.definition?.metadata?.version,
+          author: skill.definition?.author || skill.definition?.metadata?.author,
+          triggers: skill.definition?.triggers || [],
+          componentDependencies: skill.definition?.componentDependencies || []
+        }
+      });
+    } catch (error) {
+      fail(error.message, { command: 'skill', skill: name });
+    }
+  });
+
+program
+  .command('doctor')
+  .description('Run health checks as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      const result = await flowmind.doctor();
+      printJson({
+        ok: result.summary?.errors === 0,
+        command: 'doctor',
+        result
+      });
+
+      if (result.summary?.errors > 0) {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'doctor' });
+    }
+  });
+
+program
+  .command('ai-status')
+  .description('Show AI status as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      printJson({
+        ok: true,
+        command: 'ai-status',
+        result: flowmind.getAIStatus()
+      });
+    } catch (error) {
+      fail(error.message, { command: 'ai-status' });
+    }
+  });
+
+program.parseAsync(process.argv).catch((error) => {
+  fail(error.message);
+});

package/bin/flowmind.js

@@ -15,23 +15,45 @@ const { execSync } = require('child_process');
 const FlowMind = require('../core');
 const HonorEngine = require('../core/honor-engine');
 
+/**
+ * Restore terminal to sane state (cancel raw mode, show cursor, reset colors)
+ */
+function restoreTerminal() {
+  try {
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+      process.stdin.setRawMode(false);
+    }
+  } catch (e) { /* ignore */ }
+  if (process.stdout.isTTY) {
+    // Show cursor, reset colors, clear scroll region
+    process.stdout.write('\x1b[?25h\x1b[0m\x1b[r');
+  }
+}
+
 // Global error handlers to prevent silent CLI crashes
 process.on('uncaughtException', (err) => {
   console.error(chalk.red('\nUncaught Exception:'), err.message);
-  if (process.stdin.isTTY && process.stdin.isRaw) {
-    process.stdin.setRawMode(false);
-  }
+  restoreTerminal();
   process.exit(1);
 });
 
 process.on('unhandledRejection', (reason) => {
   console.error(chalk.red('\nUnhandled Rejection:'), reason?.message || reason);
-  if (process.stdin.isTTY && process.stdin.isRaw) {
-    process.stdin.setRawMode(false);
-  }
+  restoreTerminal();
   process.exit(1);
 });
 
+// Handle SIGINT (Ctrl+C) to restore terminal state
+process.on('SIGINT', () => {
+  restoreTerminal();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  restoreTerminal();
+  process.exit(0);
+});
+
 // Package info
 const packageJson = require('../package.json');
 
@@ -483,6 +505,7 @@ program
   .alias('p')
   .description('Process a request')
   .argument('[input]', 'Input to process')
+  .option('-j, --json', 'Output as JSON (for tool integration)')
   .option('-s, --skill <skill>', 'Use specific skill')
   .option('-v, --verbose', 'Verbose output')
   .action(async (input, options) => {
@@ -494,18 +517,38 @@ program
         await runInteractiveMode(fm);
       } else {
         // Single command mode
-        const spinner = ora('Processing...').start();
+        const spinner = options.json ? null : ora('Processing...').start();
 
         const result = await fm.process(input, {
           skill: options.skill,
           verbose: options.verbose
         });
 
-        spinner.stop();
-        displayResult(result);
+        if (spinner) {
+          spinner.stop();
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          if (result.type === 'error') {
+            process.exitCode = 1;
+          }
+        } else {
+          displayResult(result);
+        }
       }
     } catch (error) {
-      console.error(chalk.red('Error:'), error.message);
+      if (options.json) {
+        console.log(JSON.stringify({
+          type: 'error',
+          message: error.message
+        }, null, 2));
+        process.exitCode = 1;
+      } else {
+        console.error(chalk.red('Error:'), error.message);
+      }
+    } finally {
+      restoreTerminal();
     }
   });
 
@@ -889,35 +932,47 @@ async function runInteractiveMode(fm) {
   showBanner();
   console.log(chalk.cyan('Interactive mode started. Type "exit" to quit.\n'));
 
-  while (true) {
-    const { input } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'input',
-        message: chalk.green('You:'),
-        prefix: ''
+  try {
+    while (true) {
+      let input;
+      try {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'input',
+            message: chalk.green('You:'),
+            prefix: ''
+          }
+        ]);
+        input = answers.input;
+      } catch (promptErr) {
+        // inquirer throws on SIGINT (Ctrl+C)
+        console.log(chalk.cyan('\nGoodbye! 👋\n'));
+        break;
       }
-    ]);
 
-    if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
-      console.log(chalk.cyan('\nGoodbye! FlowMind will remember your preferences. 👋\n'));
-      break;
-    }
+      if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+        console.log(chalk.cyan('\nGoodbye! FlowMind will remember your preferences. 👋\n'));
+        break;
+      }
 
-    if (!input.trim()) continue;
+      if (!input.trim()) continue;
 
-    const spinner = ora('Thinking...').start();
+      const spinner = ora('Thinking...').start();
 
-    try {
-      const result = await fm.process(input);
-      spinner.stop();
-      displayResult(result);
-    } catch (error) {
-      spinner.stop();
-      console.error(chalk.red('Error:'), error.message);
-    }
+      try {
+        const result = await fm.process(input);
+        spinner.stop();
+        displayResult(result);
+      } catch (error) {
+        spinner.stop();
+        console.error(chalk.red('Error:'), error.message);
+      }
 
-    console.log(''); // Empty line for spacing
+      console.log(''); // Empty line for spacing
+    }
+  } finally {
+    restoreTerminal();
   }
 }
 
@@ -1409,15 +1464,10 @@ program
       if (stdinForwarder) {
         process.stdin.removeListener('data', stdinForwarder);
       }
-      // Restore stdin to normal mode
-      try {
-        if (process.stdin.isTTY && process.stdin.setRawMode) {
-          process.stdin.setRawMode(false);
-        }
-      } catch (e) { /* ignore */ }
       if (stdinWrapper && !stdinWrapper.destroyed) {
         stdinWrapper.destroy();
       }
+      restoreTerminal();
     }
   });
 
@@ -1481,14 +1531,10 @@ program
       if (stdinForwarder) {
         process.stdin.removeListener('data', stdinForwarder);
       }
-      try {
-        if (process.stdin.isTTY && process.stdin.setRawMode) {
-          process.stdin.setRawMode(false);
-        }
-      } catch (e) { /* ignore */ }
       if (stdinWrapper && !stdinWrapper.destroyed) {
         stdinWrapper.destroy();
       }
+      restoreTerminal();
     }
   });
 
@@ -1624,6 +1670,8 @@ if (!process.argv.slice(2).length) {
       await runInteractiveMode(fm);
     } catch (error) {
       console.error(chalk.red('Error:'), error.message);
+    } finally {
+      restoreTerminal();
     }
   })();
 }

package/core/config-manager.js

@@ -312,7 +312,7 @@ class ConfigManager {
    * Get home directory
    */
   getHomeDir() {
-    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
   }
 
   /**

package/core/honor-engine.js

@@ -26,20 +26,26 @@ const DRAGON_LEVELS = [
 class HonorEngine {
   constructor(config) {
     this.config = config;
-    this.honorPath = path.join(
-      config.get('storagePath') || path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind'),
-      'honor.json'
-    );
+    this.honorPath = null;
     this.skillsPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
     this.data = null;
     this.initialized = false;
   }
 
+  resolveHonorPath() {
+    const storagePath = this.config.get('storagePath')
+      || process.env.FLOWMIND_HOME
+      || path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind');
+    return path.join(storagePath, 'honor.json');
+  }
+
   /**
    * Initialize honor engine
    */
   async init() {
     try {
+      this.honorPath = this.resolveHonorPath();
+
       if (await fs.pathExists(this.honorPath)) {
         this.data = await fs.readJson(this.honorPath);
       } else {

package/core/index.js

@@ -116,9 +116,16 @@ class FlowMind {
 
       // 4. Select skill (AI-assisted if available)
       let skill = null;
+      if (context.skill) {
+        skill = this.skills.get(context.skill);
+        if (!skill) {
+          return this.formatError(`Skill not found: ${context.skill}`, input);
+        }
+      }
+
       const candidates = await this.skills.getCandidates(input, context);
 
-      if (candidates.length > 0) {
+      if (!skill && candidates.length > 0) {
         // Use AI to select skill if available
         const aiSelection = await this.ai.selectSkill(input, candidates);
         if (aiSelection && aiSelection.selectedSkill) {

package/core/learning-engine.js

@@ -32,7 +32,7 @@ class LearningEngine {
   constructor(config, honorEngine = null) {
     this.config = config;
     this.honorEngine = honorEngine;
-    this.learningPath = config.get('learning.storagePath', '~/.flowmind/learning');
+    this.learningPath = null;
     this.writeQueue = new WriteQueue();
     this.records = {};
     this.skillBindings = {};
@@ -44,6 +44,11 @@ class LearningEngine {
    * Initialize learning engine
    */
   async init() {
+    this.learningPath = this.config.get(
+      'learning.storagePath',
+      path.join(process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || '', '.flowmind', 'learning')
+    );
+
     // Ensure directories exist
     await fs.ensureDir(this.expandPath(this.learningPath));
     await fs.ensureDir(path.join(this.expandPath(this.learningPath), 'records'));

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "flowmind",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "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-codex": "./bin/flowmind-codex.js",
     "flowmind-mcp": "./mcp/server.js"
   },
   "scripts": {