@geminilight/mindos 0.6.40 → 0.6.41

package/bin/commands/agent.js

@@ -1,37 +1,132 @@
+/**
+ * mindos agent — AI Agent: interactive REPL (default) or one-shot (-p)
+ *
+ * Inspired by Claude Code: bare `mindos agent` enters interactive mode;
+ * `mindos agent -p "task"` prints the result and exits.
+ *
+ * Management subcommands (list/info/stats) are available as sub-routes.
+ */
+
 import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
 import { MCP_AGENTS, detectAgentPresence } from '../lib/mcp-agents.js';
 import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { homedir } from 'node:os';
+import { loadConfig } from '../lib/config.js';
 import { output, isJsonMode, EXIT } from '../lib/command.js';
+import { startRepl } from '../lib/repl.js';
+import { executeOneShot } from '../lib/one-shot.js';
+import { expandHome } from '../lib/path-expand.js';
 
-function expandHome(p) {
-  return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
-}
+const MANAGEMENT_SUBCOMMANDS = new Set(['list', 'ls', 'info', 'stats', 'help']);
 
 export const meta = {
   name: 'agent',
-  group: 'Knowledge',
-  summary: 'AI Agent management (list/info)',
-  usage: 'mindos agent <subcommand>',
+  group: 'AI',
+  summary: 'AI Agent: interactive REPL or one-shot (-p)',
+  usage: 'mindos agent [-p "<task>"]',
+  flags: {
+    '-p, --print': 'Non-interactive: run task and print result',
+    '--file <path>': 'Attach a file as context',
+    '--max-steps <n>': 'Max agent steps (default: 20)',
+    '--json': 'Output as JSON (implies -p)',
+    '--port <port>': 'MindOS web port (default: 3456)',
+  },
+  examples: [
+    'mindos agent                    # interactive REPL',
+    'mindos agent -p "Organize my inbox"',
+    'mindos agent "Summarize notes"  # also one-shot',
+    'mindos agent list               # list detected agents',
+  ],
 };
 
 export async function run(args, flags) {
   const sub = args[0];
-  if (!sub || flags.help || flags.h) {
-    console.log(bold('mindos agent') + ' — AI Agent management\n');
-    console.log('Subcommands:');
-    console.log('  list              List detected AI agents');
-    console.log('  info <agent-key>  Show agent details\n');
-    console.log('Keys: ' + Object.keys(MCP_AGENTS).join(', '));
+
+  // Management subcommands always take priority
+  if (sub && MANAGEMENT_SUBCOMMANDS.has(sub)) {
+    if (sub === 'help') { printHelp(); return; }
+    if (sub === 'list' || sub === 'ls') return agentList(flags);
+    if (sub === 'info') return agentInfo(args[1], flags);
+    if (sub === 'stats') return agentStats(flags);
     return;
   }
-  if (sub === 'list' || sub === 'ls') return agentList(flags);
-  if (sub === 'info') return agentInfo(args[1], flags);
-  console.error(red('Unknown subcommand: ' + sub));
-  process.exit(EXIT.ARGS);
+
+  // Determine mode: -p / --print / --json / bare task → print; otherwise interactive
+  const isPrintMode = flags.p || flags.print || isJsonMode(flags) || (sub != null);
+
+  if (isPrintMode) {
+    const task = args.join(' ');
+    if (!task) {
+      console.error(red('No task provided.'));
+      console.error(dim('Usage: mindos agent -p "<task>"'));
+      console.error(dim('       mindos agent    (interactive mode)'));
+      process.exit(EXIT.ARGS);
+    }
+    return agentExecute(task, flags);
+  }
+
+  // Interactive REPL (default)
+  return agentInteractive(flags);
+}
+
+// ---------------------------------------------------------------------------
+// Interactive REPL
+// ---------------------------------------------------------------------------
+
+async function agentInteractive(flags) {
+  loadConfig();
+  const port = flags.port || process.env.MINDOS_WEB_PORT || '3456';
+  const token = process.env.MINDOS_AUTH_TOKEN || '';
+  const baseUrl = `http://localhost:${port}`;
+
+  const maxSteps = (() => {
+    if (!flags['max-steps']) return undefined;
+    const n = parseInt(flags['max-steps'], 10);
+    return (!Number.isNaN(n) && n > 0) ? n : undefined;
+  })();
+
+  await startRepl({
+    baseUrl,
+    token,
+    mode: 'agent',
+    prompt: 'agent> ',
+    welcome: bold('MindOS Agent') + dim(' (interactive) — full tool access'),
+    showTools: true,
+    attachedFiles: flags.file ? [flags.file] : undefined,
+    maxSteps,
+  });
 }
 
+// ---------------------------------------------------------------------------
+// Print Mode — One-shot Task Execution
+// ---------------------------------------------------------------------------
+
+async function agentExecute(task, flags) {
+  loadConfig();
+  const port = flags.port || process.env.MINDOS_WEB_PORT || '3456';
+  const token = process.env.MINDOS_AUTH_TOKEN || '';
+
+  const maxSteps = (() => {
+    if (!flags['max-steps']) return undefined;
+    const n = parseInt(flags['max-steps'], 10);
+    return (!Number.isNaN(n) && n > 0) ? n : undefined;
+  })();
+
+  await executeOneShot({
+    baseUrl: `http://localhost:${port}`,
+    token,
+    message: task,
+    mode: 'agent',
+    showTools: true,
+    maxSteps,
+    attachedFiles: flags.file ? [flags.file] : undefined,
+    json: isJsonMode(flags),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Agent Management — List / Info / Stats
+// ---------------------------------------------------------------------------
+
 function hasMindosConfig(agent) {
   const paths = [agent.global, agent.project].filter(Boolean).map(expandHome);
   for (const p of paths) {
@@ -76,12 +171,13 @@ function agentList(flags) {
 function agentInfo(key, flags) {
   if (!key) {
     console.error(red('Usage: mindos agent info <agent-key>'));
-    process.exit(EXIT.ERROR);
+    process.exit(EXIT.ARGS);
   }
   const agent = MCP_AGENTS[key];
   if (!agent) {
     console.error(red('Unknown agent: ' + key));
-    process.exit(EXIT.ERROR);
+    console.error(dim('Available: ' + Object.keys(MCP_AGENTS).join(', ')));
+    process.exit(EXIT.NOT_FOUND);
   }
 
   const installed = detectAgentPresence(key);
@@ -108,3 +204,43 @@ function agentInfo(key, flags) {
   if (!connected && installed) console.log('\n  Connect: mindos mcp install ' + key);
   console.log('');
 }
+
+function agentStats(flags) {
+  if (isJsonMode(flags)) {
+    output({ message: 'Agent usage statistics are not yet available.' }, flags);
+    return;
+  }
+  console.log(dim('\n  Agent usage statistics are not yet available.'));
+  console.log(dim('  This feature will be added in a future release.\n'));
+}
+
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+
+export function printHelp() {
+  console.log(`
+${bold('mindos agent')} — AI Agent with full tool access
+
+${bold('Interactive (default):')}
+  ${cyan('mindos agent')}                         Enter multi-turn REPL
+  ${dim('Commands inside REPL: /clear, /exit')}
+
+${bold('Non-interactive (-p):')}
+  ${cyan('mindos agent -p "<task>"')}              Run task, print result, exit
+  ${cyan('mindos agent "<task>"')}                 Same (shorthand)
+
+${bold('Manage agents:')}
+  ${cyan('mindos agent list')}                    List detected AI agents
+  ${cyan('mindos agent info <agent-key>')}        Show agent details
+  ${cyan('mindos agent stats')}                   Usage statistics
+
+${bold('Options:')}
+  ${dim('-p, --print')}          Non-interactive mode
+  ${dim('--file <path>')}        Attach file as context
+  ${dim('--max-steps <n>')}      Max agent steps (default: 20)
+  ${dim('--json')}               JSON output (implies -p)
+
+${bold('Note:')} For lightweight Q&A (read-only), use ${cyan('mindos ask')}.
+`);
+}

package/bin/commands/api.js

@@ -1,23 +1,26 @@
 import { bold, dim, cyan, red } from '../lib/colors.js';
 import { loadConfig } from '../lib/config.js';
-import { EXIT } from '../lib/command.js';
+import { EXIT, printCommandHelp } from '../lib/command.js';
 
 export const meta = {
   name: 'api',
-  group: 'Knowledge',
-  summary: 'Raw API passthrough (GET/POST/PUT/DELETE any endpoint)',
+  group: 'Config',
+  summary: 'Raw API passthrough (GET/POST/PUT/DELETE)',
   usage: 'mindos api <METHOD> <path>',
+  flags: {
+    '--body <json>': 'Request body as JSON string',
+    '--port <port>': 'MindOS web port',
+  },
+  examples: [
+    'mindos api GET /api/health',
+    'mindos api GET /api/files',
+    'mindos api POST /api/ask --body \'{"messages":[...],"mode":"chat"}\'',
+  ],
 };
 
 export async function run(args, flags) {
-  if (args.length < 2 || flags.help || flags.h) {
-    console.log(bold('mindos api') + ' — Raw API passthrough\n');
-    console.log('Usage: mindos api <METHOD> <path> [--body <json>]');
-    console.log('Methods: GET, POST, PUT, PATCH, DELETE\n');
-    console.log('Examples:');
-    console.log('  mindos api GET /api/health');
-    console.log('  mindos api GET /api/files');
-    console.log('  mindos api POST /api/ask --body \'{"question":"..."}\'');
+  if (args.length < 2) {
+    printCommandHelp({ meta });
     return;
   }
 

package/bin/commands/ask.js

@@ -1,101 +1,112 @@
 /**
- * mindos ask — AI question answering via local MindOS API
+ * mindos ask — AI Chat: interactive REPL (default) or one-shot (-p)
+ *
+ * Uses 'chat' mode: read-only tools, lower step cap, smaller prompt.
+ * For full agent mode with tool execution, use `mindos agent`.
  */
 
-import { bold, dim, cyan, green, red } from '../lib/colors.js';
+import { bold, dim, cyan, red } from '../lib/colors.js';
 import { loadConfig } from '../lib/config.js';
-import { output, isJsonMode, EXIT } from '../lib/command.js';
+import { isJsonMode, EXIT } from '../lib/command.js';
+import { startRepl } from '../lib/repl.js';
+import { executeOneShot } from '../lib/one-shot.js';
 
 export const meta = {
   name: 'ask',
-  group: 'Knowledge',
-  summary: 'Ask AI a question using your knowledge base',
-  usage: 'mindos ask "<question>"',
+  group: 'AI',
+  summary: 'Chat with your knowledge base (read-only)',
+  usage: 'mindos ask [-p "<question>"]',
   flags: {
-    '--json': 'Output as JSON',
+    '-p, --print': 'Non-interactive: answer and exit',
+    '--file <path>': 'Attach a file as context',
+    '--json': 'Output as JSON (implies -p)',
     '--port <port>': 'MindOS web port (default: 3456)',
   },
   examples: [
-    'mindos ask "Summarize my meeting notes from today"',
-    'mindos ask "What are the key points in my RAG research?"',
-    'mindos ask "List all TODOs across my notes" --json',
+    'mindos ask                       # interactive chat',
+    'mindos ask -p "What is RAG?"',
+    'mindos ask "Summarize my notes"   # also one-shot',
   ],
 };
 
 export async function run(args, flags) {
-  const question = args.join(' ');
+  const isPrintMode = flags.p || flags.print || isJsonMode(flags) || (args.length > 0);
 
-  if (!question || flags.help || flags.h) {
-    console.log(`
-${bold('mindos ask')} — Ask AI using your knowledge base
-
-${bold('Usage:')}
-  ${cyan('mindos ask "<question>"')}
+  if (isPrintMode) {
+    const question = args.join(' ');
+    if (!question) {
+      console.error(red('No question provided. Usage: mindos ask -p "<question>"'));
+      process.exit(EXIT.ARGS);
+    }
+    return askExecute(question, flags);
+  }
 
-${bold('Examples:')}
-  ${dim('mindos ask "Summarize my meeting notes"')}
-  ${dim('mindos ask "What are the key insights from my research?" --json')}
+  // Interactive REPL (default)
+  return askInteractive(flags);
+}
 
-${bold('Note:')} MindOS must be running (mindos start).
-`);
-    return;
-  }
+// ---------------------------------------------------------------------------
+// Interactive REPL
+// ---------------------------------------------------------------------------
 
+async function askInteractive(flags) {
   loadConfig();
   const port = flags.port || process.env.MINDOS_WEB_PORT || '3456';
   const token = process.env.MINDOS_AUTH_TOKEN || '';
   const baseUrl = `http://localhost:${port}`;
 
-  // Check if MindOS is running
-  try {
-    const healthRes = await fetch(`${baseUrl}/api/health`);
-    if (!healthRes.ok) throw new Error();
-  } catch {
-    console.error(red('MindOS is not running. Start it with: mindos start'));
-    process.exit(EXIT.ERROR);
-  }
+  await startRepl({
+    baseUrl,
+    token,
+    mode: 'chat',
+    prompt: 'chat> ',
+    welcome: bold('MindOS Chat') + dim(' (interactive) — read-only knowledge access'),
+    showTools: false,
+    attachedFiles: flags.file ? [flags.file] : undefined,
+  });
+}
 
-  if (!isJsonMode(flags)) {
-    process.stdout.write(dim('Thinking...'));
-  }
+// ---------------------------------------------------------------------------
+// Print Mode — One-shot Q&A
+// ---------------------------------------------------------------------------
+
+async function askExecute(question, flags) {
+  loadConfig();
+  const port = flags.port || process.env.MINDOS_WEB_PORT || '3456';
+  const token = process.env.MINDOS_AUTH_TOKEN || '';
 
-  try {
-    const headers = { 'Content-Type': 'application/json' };
-    if (token) headers['Authorization'] = `Bearer ${token}`;
+  await executeOneShot({
+    baseUrl: `http://localhost:${port}`,
+    token,
+    message: question,
+    mode: 'chat',
+    attachedFiles: flags.file ? [flags.file] : undefined,
+    json: isJsonMode(flags),
+  });
+}
 
-    const res = await fetch(`${baseUrl}/api/ask`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ question }),
-    });
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
 
-    if (!res.ok) {
-      const errText = await res.text();
-      throw new Error(`API error (${res.status}): ${errText}`);
-    }
+export function printHelp() {
+  console.log(`
+${bold('mindos ask')} — Chat with your knowledge base (read-only)
 
-    const data = await res.json();
+${bold('Interactive (default):')}
+  ${cyan('mindos ask')}                          Enter multi-turn chat
+  ${dim('Commands inside REPL: /clear, /exit')}
 
-    if (isJsonMode(flags)) {
-      output(data, flags);
-      return;
-    }
+${bold('Non-interactive (-p):')}
+  ${cyan('mindos ask -p "<question>"')}           Answer and exit
+  ${cyan('mindos ask "<question>"')}              Same (shorthand)
 
-    // Clear "Thinking..." line
-    process.stdout.write('\r' + ' '.repeat(40) + '\r');
+${bold('Options:')}
+  ${dim('-p, --print')}          Non-interactive mode
+  ${dim('--file <path>')}        Attach file as context
+  ${dim('--json')}               JSON output (implies -p)
 
-    if (data.answer) {
-      console.log(data.answer);
-    } else if (data.text) {
-      console.log(data.text);
-    } else {
-      console.log(JSON.stringify(data, null, 2));
-    }
-  } catch (err) {
-    if (!isJsonMode(flags)) {
-      process.stdout.write('\r' + ' '.repeat(40) + '\r');
-    }
-    console.error(red(err.message));
-    process.exit(EXIT.ERROR);
-  }
+${bold('Note:')} Chat mode uses read-only tools for knowledge access.
+  For full agent mode with write tools, use ${cyan('mindos agent')}.
+`);
 }

package/bin/commands/build.js

@@ -0,0 +1,26 @@
+/**
+ * mindos build — Build for production
+ */
+
+import { resolve } from 'node:path';
+import { ROOT } from '../lib/constants.js';
+import { ensureAppDeps, cleanNextDir, writeBuildStamp } from '../lib/build.js';
+import { execInherited } from '../lib/shell.js';
+
+const NEXT_BIN = resolve(ROOT, 'app', 'node_modules', '.bin', 'next');
+
+export const meta = {
+  name: 'build',
+  group: 'Service',
+  summary: 'Build for production',
+  usage: 'mindos build',
+};
+
+export const run = (args) => {
+  const extra = args.join(' ');
+  ensureAppDeps({ force: true });
+  cleanNextDir();
+  execInherited('node scripts/gen-renderer-index.js', ROOT);
+  execInherited(`${NEXT_BIN} build --webpack ${extra}`, resolve(ROOT, 'app'));
+  writeBuildStamp();
+};

package/bin/commands/config.js

@@ -0,0 +1,170 @@
+/**
+ * mindos config — View and update MindOS configuration
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { CONFIG_PATH, ROOT } from '../lib/constants.js';
+import { bold, dim, cyan, green, red } from '../lib/colors.js';
+import { EXIT } from '../lib/command.js';
+
+export const meta = {
+  name: 'config',
+  group: 'Config',
+  summary: 'View or update configuration',
+  usage: 'mindos config <subcommand>',
+  flags: {
+    '--json': 'Output as JSON',
+  },
+  examples: [
+    'mindos config show',
+    'mindos config set startMode dev',
+    'mindos config unset sync.remote',
+    'mindos config validate',
+  ],
+};
+
+const maskKey = (val) => {
+  if (!val) return val;
+  if (val.length <= 8) return '****';
+  return val.slice(0, 6) + '****';
+};
+
+const readConfig = () => {
+  if (!existsSync(CONFIG_PATH)) {
+    console.error(red('No config found. Run `mindos onboard` first.'));
+    process.exit(EXIT.ERROR);
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    console.error(red('Failed to parse config file.'));
+    process.exit(EXIT.ERROR);
+  }
+};
+
+const coerceValue = (v) => {
+  if (v === 'true') return true;
+  if (v === 'false') return false;
+  if (v === 'null') return null;
+  if (v === '""' || v === "''") return '';
+  if (v.trim() !== '' && !isNaN(Number(v))) return Number(v);
+  return v;
+};
+
+export const run = (args, flags) => {
+  const sub = args[0];
+
+  if (sub === 'show') {
+    const config = readConfig();
+    const display = JSON.parse(JSON.stringify(config));
+    if (display.ai?.providers?.anthropic?.apiKey)
+      display.ai.providers.anthropic.apiKey = maskKey(display.ai.providers.anthropic.apiKey);
+    if (display.ai?.providers?.openai?.apiKey)
+      display.ai.providers.openai.apiKey = maskKey(display.ai.providers.openai.apiKey);
+    if (display.ai?.anthropicApiKey)
+      display.ai.anthropicApiKey = maskKey(display.ai.anthropicApiKey);
+    if (display.ai?.openaiApiKey)
+      display.ai.openaiApiKey = maskKey(display.ai.openaiApiKey);
+    if (display.authToken)
+      display.authToken = maskKey(display.authToken);
+    if (display.webPassword)
+      display.webPassword = maskKey(display.webPassword);
+
+    if (flags.json) {
+      console.log(JSON.stringify(display, null, 2));
+      return;
+    }
+    const pkgVersion = (() => { try { return JSON.parse(readFileSync(resolve(ROOT, 'package.json'), 'utf-8')).version; } catch { return '?'; } })();
+    console.log(`\n${bold('MindOS Config')}  ${dim(`v${pkgVersion}`)}  ${dim(CONFIG_PATH)}\n`);
+    console.log(JSON.stringify(display, null, 2));
+    console.log();
+    return;
+  }
+
+  if (sub === 'validate') {
+    const config = readConfig();
+    const issues = [];
+    if (!config.mindRoot) issues.push('missing required field: mindRoot');
+    if (!config.ai?.provider) issues.push('missing field: ai.provider');
+    if (config.ai?.provider === 'anthropic') {
+      const key = config.ai?.providers?.anthropic?.apiKey || config.ai?.anthropicApiKey;
+      if (!key) issues.push('ai.provider is "anthropic" but no API key found');
+    }
+    if (config.ai?.provider === 'openai') {
+      const key = config.ai?.providers?.openai?.apiKey || config.ai?.openaiApiKey;
+      if (!key) issues.push('ai.provider is "openai" but no API key found');
+    }
+    if (issues.length) {
+      console.error(`\n${red('✘ Config has issues:')}`);
+      issues.forEach(i => console.error(`  ${red('•')} ${i}`));
+      console.error(`\n  ${dim('Run `mindos onboard` to fix.\n')}`);
+      process.exit(EXIT.ERROR);
+    }
+    console.log(`\n${green('✔ Config is valid')}\n`);
+    return;
+  }
+
+  if (sub === 'set') {
+    const key = args[1];
+    const val = args[2];
+    if (!key || val === undefined) {
+      console.error(red('Usage: mindos config set <key> <value>'));
+      console.error(dim('  Examples:'));
+      console.error(dim('    mindos config set port 3002'));
+      console.error(dim('    mindos config set mcpPort 8788'));
+      console.error(dim('    mindos config set ai.provider openai'));
+      process.exit(EXIT.ARGS);
+    }
+    const config = readConfig();
+    const parts = key.split('.');
+    let obj = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (typeof obj[parts[i]] !== 'object' || !obj[parts[i]]) obj[parts[i]] = {};
+      obj = obj[parts[i]];
+    }
+    const coerced = coerceValue(val);
+    obj[parts[parts.length - 1]] = coerced;
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`${green('✔')} Set ${cyan(key)} = ${bold(String(coerced))}`);
+    return;
+  }
+
+  if (sub === 'unset') {
+    const key = args[1];
+    if (!key) {
+      console.error(red('Usage: mindos config unset <key>'));
+      process.exit(EXIT.ARGS);
+    }
+    const config = readConfig();
+    const parts = key.split('.');
+    let obj = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!obj[parts[i]]) { console.log(dim(`Key "${key}" not found`)); return; }
+      obj = obj[parts[i]];
+    }
+    if (!(parts[parts.length - 1] in obj)) { console.log(dim(`Key "${key}" not found`)); return; }
+    delete obj[parts[parts.length - 1]];
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`${green('✔')} Removed ${cyan(key)}`);
+    return;
+  }
+
+  // No subcommand → show help
+  const row = (c, d) => `  ${cyan(c.padEnd(32))}${dim(d)}`;
+  console.log(`
+${bold('mindos config')} — view and update MindOS configuration
+
+${bold('Subcommands:')}
+${row('mindos config show',          'Print current config (API keys masked)')}
+${row('mindos config validate',      'Validate config file')}
+${row('mindos config set <key> <v>', 'Update a single field (dot-notation supported)')}
+${row('mindos config unset <key>',   'Remove a config field')}
+
+${bold('Examples:')}
+  ${dim('mindos config set port 3002')}
+  ${dim('mindos config set ai.provider openai')}
+  ${dim('mindos config set setupPending false')}
+  ${dim('mindos config unset webPassword')}
+`);
+};