@moxxy/cli 0.0.12 → 0.1.1

package/src/tui/mcp-wizard.js

@@ -0,0 +1,136 @@
+export function createMcpAddWizard(transport) {
+  return {
+    transport,
+    step: transport === 'stdio' ? 'command' : 'url',
+    values: {},
+  };
+}
+
+export function parseMcpCommandInput(rawValue) {
+  const input = String(rawValue || '').trim();
+  if (!input) {
+    return { command: '', args: [] };
+  }
+
+  const parts = [];
+  let current = '';
+  let quote = null;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === '\'') {
+      quote = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        parts.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    parts.push(current);
+  }
+
+  return {
+    command: parts[0] || '',
+    args: parts.slice(1),
+  };
+}
+
+export function getMcpAddWizardPrompt(wizard) {
+  switch (wizard.step) {
+    case 'command':
+      return {
+        title: 'Add MCP Server',
+        label: 'Command',
+        placeholder: 'npx -y @modelcontextprotocol/server-filesystem',
+      };
+    case 'url':
+      return {
+        title: 'Add MCP Server',
+        label: 'Server URL',
+        placeholder: wizard.transport === 'streamable_http'
+          ? 'https://mcp.exa.ai/mcp'
+          : 'http://localhost:8080/sse',
+      };
+    case 'server_id':
+      return {
+        title: 'Add MCP Server',
+        label: 'Server ID',
+        placeholder: 'my-mcp-server',
+      };
+    default:
+      return {
+        title: 'Add MCP Server',
+        label: 'Value',
+        placeholder: '',
+      };
+  }
+}
+
+export function submitMcpAddWizardValue(wizard, rawValue) {
+  const value = String(rawValue || '').trim();
+  if (!value) {
+    return {
+      done: false,
+      wizard,
+      error: 'Value cannot be empty.',
+    };
+  }
+
+  if (wizard.step === 'command') {
+    const parsed = parseMcpCommandInput(value);
+    return {
+      done: false,
+      wizard: {
+        ...wizard,
+        step: 'server_id',
+        values: {
+          ...wizard.values,
+          command: parsed.command,
+          ...(parsed.args.length > 0 ? { args: parsed.args } : {}),
+        },
+      },
+      error: null,
+    };
+  }
+
+  if (wizard.step === 'url') {
+    return {
+      done: false,
+      wizard: {
+        ...wizard,
+        step: 'server_id',
+        values: { ...wizard.values, url: value },
+      },
+      error: null,
+    };
+  }
+
+  return {
+    done: true,
+    payload: {
+      transport: wizard.transport,
+      ...wizard.values,
+      id: value,
+    },
+    error: null,
+  };
+}

package/src/tui/model-picker.js

@@ -0,0 +1,174 @@
+function normalizeQuery(query) {
+  return String(query || '').trim().toLowerCase();
+}
+
+function inferProviderLabel(provider) {
+  return provider.display_name || provider.provider_name || provider.id || provider.provider_id || 'Provider';
+}
+
+function inferProviderId(provider) {
+  return provider.id || provider.provider_id || '';
+}
+
+function inferDeployment(model) {
+  if (typeof model.deployment === 'string' && model.deployment.trim()) {
+    return model.deployment.trim().toLowerCase();
+  }
+
+  const metadataDeployment = model.metadata?.deployment;
+  if (typeof metadataDeployment === 'string' && metadataDeployment.trim()) {
+    return metadataDeployment.trim().toLowerCase();
+  }
+
+  if (model.provider_id === 'ollama') {
+    const id = String(model.model_id || '').toLowerCase();
+    if (id.includes(':cloud') || id.includes('-cloud')) {
+      return 'cloud';
+    }
+    return 'local';
+  }
+
+  return null;
+}
+
+function isModelMatch(model, query) {
+  if (!query) return true;
+
+  return [
+    model.provider_name,
+    model.provider_id,
+    model.model_name,
+    model.model_id,
+    model.deployment,
+  ]
+    .filter(Boolean)
+    .some(value => String(value).toLowerCase().includes(query));
+}
+
+function isProviderMatch(provider, query) {
+  if (!query) return true;
+
+  return [
+    provider.provider_name,
+    provider.provider_id,
+    'custom model',
+  ]
+    .some(value => String(value).toLowerCase().includes(query));
+}
+
+export function buildModelPickerEntries(providers, models, query = '', currentCustom = null) {
+  const normalizedQuery = normalizeQuery(query);
+  const grouped = new Map();
+
+  for (const provider of providers || []) {
+    const providerId = inferProviderId(provider);
+    if (!providerId) continue;
+    grouped.set(providerId, {
+      provider_id: providerId,
+      provider_name: inferProviderLabel(provider),
+      models: [],
+    });
+  }
+
+  for (const model of models || []) {
+    const providerId = model.provider_id;
+    if (!providerId) continue;
+    if (!grouped.has(providerId)) {
+      grouped.set(providerId, {
+        provider_id: providerId,
+        provider_name: model.provider_name || providerId,
+        models: [],
+      });
+    }
+    grouped.get(providerId).models.push({
+      ...model,
+      provider_name: model.provider_name || grouped.get(providerId).provider_name,
+      deployment: inferDeployment(model),
+    });
+  }
+
+  const providerGroups = Array.from(grouped.values()).sort((left, right) =>
+    left.provider_name.toLowerCase().localeCompare(right.provider_name.toLowerCase())
+  );
+
+  const entries = [];
+  for (const provider of providerGroups) {
+    const visibleModels = provider.models
+      .filter(model => isModelMatch(model, normalizedQuery))
+      .sort((left, right) => {
+        const leftRank = left.deployment === 'local' ? 0 : left.deployment === 'cloud' ? 1 : 2;
+        const rightRank = right.deployment === 'local' ? 0 : right.deployment === 'cloud' ? 1 : 2;
+        return leftRank - rightRank
+          || left.model_name.toLowerCase().localeCompare(right.model_name.toLowerCase());
+      });
+
+    const providerMatches = isProviderMatch(provider, normalizedQuery);
+    if (visibleModels.length === 0 && !providerMatches) continue;
+
+    const currentCustomModelId = currentCustom?.provider_id === provider.provider_id
+      ? currentCustom.model_id
+      : null;
+
+    entries.push({
+      type: 'section',
+      label: provider.provider_name,
+      provider_id: provider.provider_id,
+    });
+
+    for (const model of visibleModels) {
+      entries.push({
+        type: 'model',
+        ...model,
+      });
+    }
+
+    entries.push({
+      type: 'custom',
+      provider_id: provider.provider_id,
+      provider_name: provider.provider_name,
+      is_current: Boolean(currentCustomModelId),
+      current_model_id: currentCustomModelId,
+    });
+  }
+
+  return entries;
+}
+
+function isSelectable(entry) {
+  return entry && entry.type !== 'section';
+}
+
+export function movePickerSelection(entries, currentIndex, direction) {
+  if (!Array.isArray(entries) || entries.length === 0) return 0;
+
+  let index = Number.isInteger(currentIndex) ? currentIndex : 0;
+  while (true) {
+    const nextIndex = index + direction;
+    if (nextIndex < 0 || nextIndex >= entries.length) {
+      return index;
+    }
+    index = nextIndex;
+    if (isSelectable(entries[index])) {
+      return index;
+    }
+  }
+}
+
+export function findFirstSelectableIndex(entries) {
+  if (!Array.isArray(entries)) return 0;
+  const index = entries.findIndex(isSelectable);
+  return index >= 0 ? index : 0;
+}
+
+export function clampPickerScroll(selectedIndex, scrollOffset, visibleRows) {
+  if (!visibleRows || visibleRows <= 0) return 0;
+
+  const selected = Math.max(0, Number(selectedIndex) || 0);
+  const scroll = Math.max(0, Number(scrollOffset) || 0);
+  const viewport = Math.max(1, Number(visibleRows) || 1);
+  const end = scroll + viewport - 1;
+
+  if (selected < scroll) return selected;
+  if (selected > end) return selected - viewport + 1;
+  return scroll;
+}

package/src/tui/slash-commands.js

@@ -0,0 +1,26 @@
+export const SLASH_COMMANDS = [
+  { name: '/exit',         description: 'Exit the TUI',                aliases: [] },
+  { name: '/stop',         description: 'Stop the running agent',      aliases: [] },
+  { name: '/new',          description: 'Reset session and start fresh', aliases: ['/reset'] },
+  { name: '/clear',        description: 'Clear chat history',          aliases: [] },
+  { name: '/help',         description: 'Show available commands',     aliases: [] },
+  { name: '/status',       description: 'Show agent status',           aliases: [] },
+  { name: '/model',        description: 'Open model picker',           aliases: [] },
+  { name: '/vault',        description: 'Open vault actions',          aliases: ['/vault delete'] },
+  { name: '/mcp',          description: 'Open MCP actions',            aliases: [] },
+  { name: '/template',     description: 'Open template actions',       aliases: [] },
+];
+
+export function matchCommands(input) {
+  if (!input.startsWith('/')) return [];
+  const lower = input.toLowerCase();
+  return SLASH_COMMANDS.filter(cmd =>
+    cmd.name.startsWith(lower) ||
+    lower.startsWith(cmd.name) ||
+    cmd.aliases.some(a => a.startsWith(lower) || lower.startsWith(a))
+  );
+}
+
+export function isSlashCommand(input) {
+  return input.startsWith('/');
+}

package/src/tui/store.js

@@ -0,0 +1,12 @@
+import { useSyncExternalStore } from 'react';
+
+export function useEventsStore(handler) {
+  const snapshot = useSyncExternalStore(
+    (callback) => {
+      handler.onChange(callback);
+      return () => handler.onChange(null);
+    },
+    () => handler.getSnapshot(),
+  );
+  return snapshot;
+}

package/src/tui/theme.js

@@ -0,0 +1,17 @@
+export const THEME = {
+  primary: 'cyan',
+  accent: '#FF9500',
+  text: 'white',
+  dim: 'gray',
+  border: 'gray',
+  error: 'red',
+  warning: 'yellow',
+  success: 'green',
+  user: '#FF9500',
+  assistant: 'cyan',
+  tool: 'gray',
+  toolError: 'red',
+  contextLow: 'green',
+  contextMed: '#FF9500',
+  contextHigh: 'red',
+};

package/src/ui.js

@@ -0,0 +1,109 @@
+import * as p from '@clack/prompts';
+
+export function isInteractive() {
+  return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+
+export class CancelledError extends Error {
+  constructor() {
+    super('cancelled');
+    this.name = 'CancelledError';
+  }
+}
+
+export function handleCancel(value) {
+  if (p.isCancel(value)) {
+    throw new CancelledError();
+  }
+  return value;
+}
+
+export async function withSpinner(startMsg, fn, stopMsg) {
+  const s = p.spinner();
+  s.start(startMsg);
+  try {
+    const result = await fn();
+    s.stop(stopMsg || 'Done.');
+    return result;
+  } catch (err) {
+    s.stop(`Failed: ${err.message}`);
+    throw err;
+  }
+}
+
+export async function pickAgent(client, message = 'Select an agent') {
+  const agents = await withSpinner('Fetching agents...', () => client.listAgents(), 'Agents loaded.');
+  if (!agents || agents.length === 0) {
+    p.log.warn('No agents found. Create one first with: moxxy agent create');
+    process.exit(1);
+  }
+  const selected = await p.select({
+    message,
+    options: agents.map(a => ({
+      value: a.name,
+      label: a.name,
+      hint: `${a.provider_id}/${a.model_id} [${a.status}]`,
+    })),
+  });
+  return handleCancel(selected);
+}
+
+export async function pickProvider(client) {
+  const providers = await withSpinner('Fetching providers...', () => client.listProviders(), 'Providers loaded.');
+  if (!providers || providers.length === 0) {
+    p.log.warn('No providers available. Install one first.');
+    process.exit(1);
+  }
+  const selected = await p.select({
+    message: 'Select a provider',
+    options: providers.map(pr => ({
+      value: pr.id,
+      label: pr.display_name || pr.id,
+    })),
+  });
+  return handleCancel(selected);
+}
+
+export async function pickModel(client, providerId) {
+  const models = await withSpinner('Fetching models...', () => client.listModels(providerId), 'Models loaded.');
+  if (!models || models.length === 0) {
+    p.log.warn(`No models available for provider ${providerId}.`);
+    process.exit(1);
+  }
+  const selected = await p.select({
+    message: 'Select a model',
+    options: models.map(m => ({
+      value: m.model_id,
+      label: m.display_name || m.model_id,
+    })),
+  });
+  return handleCancel(selected);
+}
+
+export async function pickSkill(client, agentId, message = 'Select a skill') {
+  const skills = await withSpinner('Fetching skills...', () => client.listSkills(agentId), 'Skills loaded.');
+  if (!skills || skills.length === 0) {
+    p.log.warn('No skills found for this agent.');
+    process.exit(1);
+  }
+  const statusIcon = (s) => s === 'approved' ? '\u2705' : s === 'quarantined' ? '\u23f3' : '\u274c';
+  const selected = await p.select({
+    message,
+    options: skills.map(s => ({
+      value: s.id,
+      label: `${statusIcon(s.status)} ${s.name} v${s.version}`,
+      hint: `[${s.status}] ${s.id.slice(0, 12)}`,
+    })),
+  });
+  return handleCancel(selected);
+}
+
+export function showResult(title, data) {
+  const lines = Object.entries(data)
+    .filter(([, v]) => v !== undefined && v !== null)
+    .map(([k, v]) => `${k}: ${v}`)
+    .join('\n');
+  p.note(lines, title);
+}
+
+export { p };

package/bin/moxxy.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require('../dist/index.js').run();