nexusforge-cli 1.0.0

package/src/index.ts

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+/**
+ * NexusForge CLI
+ *
+ * AI-powered development companion for your terminal.
+ * Like Claude Code, but for NexusForge.
+ *
+ * Usage:
+ *   nexusforge              - Start interactive chat
+ *   nexusforge login        - Authenticate with browser
+ *   nexusforge logout       - Clear credentials
+ *   nexusforge status       - Check connection status
+ *   nexusforge --session X  - Sync with web session
+ *   nexusforge --help       - Show help
+ */
+
+import { Command } from 'commander';
+import * as readline from 'readline';
+import * as config from './utils/config.js';
+import { displayWelcome, displayUserMessage, displayAssistantMessage, displaySystemMessage, style } from './utils/theme.js';
+import { startDeviceAuth, logout, checkAuth, getCurrentUser } from './services/auth.js';
+import * as api from './services/api.js';
+import * as executor from './services/executor.js';
+import type { ChatMessage } from './types/index.js';
+
+const VERSION = '1.0.0';
+
+// Current conversation state
+let conversationId: string | undefined;
+let messages: ChatMessage[] = [];
+
+// Create CLI program
+const program = new Command();
+
+program
+  .name('nexusforge')
+  .description('NexusForge CLI - AI-powered development companion')
+  .version(VERSION);
+
+// Login command
+program
+  .command('login')
+  .description('Authenticate with NexusForge via browser')
+  .action(async () => {
+    const success = await startDeviceAuth();
+    process.exit(success ? 0 : 1);
+  });
+
+// Logout command
+program
+  .command('logout')
+  .description('Clear saved credentials')
+  .action(() => {
+    logout();
+    process.exit(0);
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Check connection and authentication status')
+  .action(async () => {
+    console.log('');
+    console.log(style.assistant('NexusForge CLI Status'));
+    console.log(style.divider());
+    console.log('');
+
+    // Check auth
+    const isAuth = await checkAuth();
+    const user = getCurrentUser();
+
+    if (isAuth && user) {
+      displaySystemMessage(`Authenticated as: ${user.username}`, 'success');
+    } else if (config.isAuthenticated()) {
+      displaySystemMessage('Token may be expired. Run "nexusforge login" to re-authenticate.', 'warning');
+    } else {
+      displaySystemMessage('Not authenticated. Run "nexusforge login" to authenticate.', 'warning');
+    }
+
+    // Check API health
+    const isHealthy = await api.checkHealth();
+    if (isHealthy) {
+      displaySystemMessage(`API: ${config.getApiUrl()} (healthy)`, 'success');
+    } else {
+      displaySystemMessage(`API: ${config.getApiUrl()} (unreachable)`, 'error');
+    }
+
+    console.log('');
+    console.log(style.muted(`Config file: ${config.getConfigPath()}`));
+    console.log('');
+    process.exit(0);
+  });
+
+// Main command (interactive chat)
+program
+  .option('-s, --session <token>', 'Sync with a web session token')
+  .option('-m, --model <name>', 'Use a specific model')
+  .option('--cwd <path>', 'Set working directory')
+  .action(async (options) => {
+    // Change working directory if specified
+    if (options.cwd) {
+      if (!executor.changeCwd(options.cwd)) {
+        displaySystemMessage(`Cannot change to directory: ${options.cwd}`, 'error');
+        process.exit(1);
+      }
+    }
+
+    // Check authentication
+    if (!config.isAuthenticated()) {
+      displaySystemMessage('Not authenticated. Starting login...', 'info');
+      const success = await startDeviceAuth();
+      if (!success) {
+        process.exit(1);
+      }
+    }
+
+    // Sync with web session if provided
+    if (options.session) {
+      try {
+        displaySystemMessage('Syncing with web session...', 'info');
+        const session = await api.getSessionStatus(options.session);
+        conversationId = session.conversation_id;
+        displaySystemMessage(`Synced with conversation: ${conversationId}`, 'success');
+      } catch (error) {
+        displaySystemMessage('Failed to sync with session. Starting fresh.', 'warning');
+      }
+    }
+
+    // Display welcome screen
+    const user = getCurrentUser();
+    displayWelcome(
+      VERSION,
+      config.getApiUrl(),
+      options.model || config.get('defaultModel') || 'NexusForge',
+    );
+
+    if (user?.username) {
+      displaySystemMessage(`Logged in as ${user.username}`, 'success');
+    }
+
+    // Start interactive loop
+    await startInteractiveChat(options.model);
+  });
+
+// Parse arguments
+program.parse();
+
+/**
+ * Start the interactive chat loop
+ */
+async function startInteractiveChat(model?: string): Promise<void> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const promptUser = (): void => {
+    rl.question(`${style.userLabel('You')} ${style.prompt('❯')} `, async (input) => {
+      const trimmedInput = input.trim();
+
+      if (!trimmedInput) {
+        promptUser();
+        return;
+      }
+
+      // Handle slash commands
+      if (trimmedInput.startsWith('/')) {
+        await handleSlashCommand(trimmedInput, rl);
+        promptUser();
+        return;
+      }
+
+      // Send message to AI
+      try {
+        console.log('');
+        process.stdout.write(`${style.assistantLabel('NexusForge')} ${style.prompt('❯')} `);
+
+        // Stream response
+        let fullResponse = '';
+        for await (const chunk of api.streamMessage(trimmedInput, conversationId, model)) {
+          process.stdout.write(style.assistant(chunk));
+          fullResponse += chunk;
+        }
+        console.log('\n');
+
+        // Store messages
+        messages.push({ role: 'user', content: trimmedInput });
+        messages.push({ role: 'assistant', content: fullResponse });
+
+        // Check for executable commands in response
+        const commands = executor.parseCommandsFromResponse(fullResponse);
+        if (commands.length > 0 && config.get('autoExecute')) {
+          await promptToExecuteCommands(commands, rl);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        displaySystemMessage(`Error: ${errorMessage}`, 'error');
+      }
+
+      promptUser();
+    });
+  };
+
+  promptUser();
+}
+
+/**
+ * Handle slash commands
+ */
+async function handleSlashCommand(input: string, rl: readline.Interface): Promise<void> {
+  const parts = input.slice(1).split(/\s+/);
+  const command = parts[0].toLowerCase();
+  const args = parts.slice(1);
+
+  switch (command) {
+    case 'help':
+    case 'h':
+      displayHelp();
+      break;
+
+    case 'exit':
+    case 'quit':
+    case 'q':
+      console.log('');
+      displaySystemMessage('Goodbye!', 'info');
+      rl.close();
+      process.exit(0);
+
+    case 'clear':
+    case 'c':
+      console.clear();
+      displayWelcome(VERSION, config.getApiUrl(), config.get('defaultModel') || 'NexusForge');
+      break;
+
+    case 'history':
+      displayHistory();
+      break;
+
+    case 'resume':
+      await resumeConversation(args[0]);
+      break;
+
+    case 'model':
+      if (args[0]) {
+        config.set('defaultModel', args[0]);
+        displaySystemMessage(`Model set to: ${args[0]}`, 'success');
+      } else {
+        displaySystemMessage(`Current model: ${config.get('defaultModel')}`, 'info');
+      }
+      break;
+
+    case 'status':
+      await displayStatus();
+      break;
+
+    case 'read':
+      if (args[0]) {
+        await readFile(args[0]);
+      } else {
+        displaySystemMessage('Usage: /read <file_path>', 'warning');
+      }
+      break;
+
+    case 'exec':
+    case 'run':
+      if (args.length > 0) {
+        const cmd = args.join(' ');
+        const result = await executor.executeCommandStream(cmd, undefined,
+          (data) => process.stdout.write(data),
+          (data) => process.stderr.write(style.error(data))
+        );
+        executor.displayCommandResult(result);
+      } else {
+        displaySystemMessage('Usage: /exec <command>', 'warning');
+      }
+      break;
+
+    default:
+      displaySystemMessage(`Unknown command: /${command}. Type /help for available commands.`, 'warning');
+  }
+}
+
+/**
+ * Display help
+ */
+function displayHelp(): void {
+  console.log('');
+  console.log(style.assistant('Available Commands:'));
+  console.log(style.divider());
+  console.log('');
+  console.log(`  ${style.prompt('/help, /h')}       - Show this help`);
+  console.log(`  ${style.prompt('/exit, /q')}       - Exit CLI`);
+  console.log(`  ${style.prompt('/clear, /c')}      - Clear screen`);
+  console.log(`  ${style.prompt('/history')}        - Show conversation history`);
+  console.log(`  ${style.prompt('/resume [id]')}    - Resume a previous conversation`);
+  console.log(`  ${style.prompt('/model [name]')}   - Get or set the model`);
+  console.log(`  ${style.prompt('/status')}         - Show connection status`);
+  console.log(`  ${style.prompt('/read <path>')}    - Read a file into context`);
+  console.log(`  ${style.prompt('/exec <cmd>')}     - Execute a shell command`);
+  console.log('');
+  console.log(style.muted('Just type your message to chat with NexusForge!'));
+  console.log('');
+}
+
+/**
+ * Display conversation history
+ */
+function displayHistory(): void {
+  console.log('');
+  if (messages.length === 0) {
+    displaySystemMessage('No messages in current conversation.', 'info');
+    return;
+  }
+
+  console.log(style.assistant('Conversation History:'));
+  console.log(style.divider());
+  console.log('');
+
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      displayUserMessage(msg.content);
+    } else {
+      displayAssistantMessage(msg.content.substring(0, 200) + (msg.content.length > 200 ? '...' : ''));
+    }
+  }
+}
+
+/**
+ * Resume a previous conversation
+ */
+async function resumeConversation(id?: string): Promise<void> {
+  displaySystemMessage('Resume functionality coming soon!', 'info');
+}
+
+/**
+ * Display current status
+ */
+async function displayStatus(): Promise<void> {
+  console.log('');
+  const user = getCurrentUser();
+  displaySystemMessage(`User: ${user?.username || 'Unknown'}`, 'info');
+  displaySystemMessage(`API: ${config.getApiUrl()}`, 'info');
+  displaySystemMessage(`Model: ${config.get('defaultModel')}`, 'info');
+  displaySystemMessage(`Conversation: ${conversationId || 'New'}`, 'info');
+  displaySystemMessage(`Messages: ${messages.length}`, 'info');
+  displaySystemMessage(`CWD: ${executor.getCwd()}`, 'info');
+  console.log('');
+}
+
+/**
+ * Read a file and display it
+ */
+async function readFile(path: string): Promise<void> {
+  const fs = await import('fs/promises');
+  try {
+    const content = await fs.readFile(path, 'utf-8');
+    console.log('');
+    console.log(style.muted(`--- ${path} ---`));
+    console.log(style.code(content));
+    console.log(style.muted(`--- end ${path} ---`));
+    console.log('');
+    displaySystemMessage(`File "${path}" added to context.`, 'success');
+  } catch (error) {
+    displaySystemMessage(`Cannot read file: ${path}`, 'error');
+  }
+}
+
+/**
+ * Prompt user to execute detected commands
+ */
+async function promptToExecuteCommands(
+  commands: string[],
+  rl: readline.Interface,
+): Promise<void> {
+  console.log('');
+  displaySystemMessage(`Found ${commands.length} command(s) in response:`, 'info');
+
+  for (let i = 0; i < commands.length; i++) {
+    console.log(style.muted(`  ${i + 1}. ${commands[i]}`));
+  }
+
+  console.log('');
+
+  return new Promise((resolve) => {
+    rl.question(
+      `${style.prompt('Execute these commands? [y/N/1-n]: ')}`,
+      async (answer) => {
+        const trimmed = answer.trim().toLowerCase();
+
+        if (trimmed === 'y' || trimmed === 'yes') {
+          // Execute all commands
+          for (const cmd of commands) {
+            if (executor.isDangerous(cmd)) {
+              displaySystemMessage(`Skipping dangerous command: ${cmd}`, 'warning');
+              continue;
+            }
+            const result = await executor.executeCommandStream(cmd, undefined,
+              (data) => process.stdout.write(data),
+              (data) => process.stderr.write(style.error(data))
+            );
+            if (result.exitCode !== 0) {
+              displaySystemMessage(`Command failed with exit code ${result.exitCode}`, 'error');
+              break;
+            }
+          }
+        } else if (/^\d+$/.test(trimmed)) {
+          // Execute specific command
+          const index = parseInt(trimmed, 10) - 1;
+          if (index >= 0 && index < commands.length) {
+            const cmd = commands[index];
+            if (executor.isDangerous(cmd)) {
+              displaySystemMessage(`Cannot execute dangerous command`, 'error');
+            } else {
+              const result = await executor.executeCommandStream(cmd, undefined,
+                (data) => process.stdout.write(data),
+                (data) => process.stderr.write(style.error(data))
+              );
+              executor.displayCommandResult(result);
+            }
+          }
+        }
+
+        resolve();
+      },
+    );
+  });
+}

package/src/services/api.ts

@@ -0,0 +1,198 @@
+/**
+ * NexusForge CLI API Service
+ *
+ * Handles all API communication with NexusConnectBridge backend.
+ */
+
+import * as config from '../utils/config.js';
+import type {
+  ChatMessage,
+  ChatResponse,
+  CLISession,
+  FileContext,
+} from '../types/index.js';
+
+/**
+ * Make an authenticated API request
+ */
+async function apiRequest<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const apiUrl = config.getApiUrl();
+  const token = config.getAccessToken();
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...((options.headers as Record<string, string>) || {}),
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  const response = await fetch(`${apiUrl}${endpoint}`, {
+    ...options,
+    headers,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API error (${response.status}): ${errorText}`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+/**
+ * Send a chat message and get response
+ */
+export async function sendMessage(
+  message: string,
+  conversationId?: string,
+  model?: string,
+  fileContext?: FileContext[],
+): Promise<ChatResponse> {
+  return apiRequest<ChatResponse>('/cli/chat', {
+    method: 'POST',
+    body: JSON.stringify({
+      message,
+      conversation_id: conversationId,
+      model,
+      file_context: fileContext,
+    }),
+  });
+}
+
+/**
+ * Stream a chat message response
+ */
+export async function* streamMessage(
+  message: string,
+  conversationId?: string,
+  model?: string,
+  fileContext?: FileContext[],
+): AsyncGenerator<string, void, unknown> {
+  const apiUrl = config.getApiUrl();
+  const token = config.getAccessToken();
+
+  const response = await fetch(`${apiUrl}/ai/chat/stream`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: token ? `Bearer ${token}` : '',
+    },
+    body: JSON.stringify({
+      message,
+      conversation_id: conversationId,
+      model,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    yield chunk;
+  }
+}
+
+/**
+ * Create a new CLI session
+ */
+export async function createSession(
+  conversationId?: string,
+  workingDirectory?: string,
+): Promise<CLISession> {
+  return apiRequest<CLISession>('/cli/sessions', {
+    method: 'POST',
+    body: JSON.stringify({
+      conversation_id: conversationId,
+      working_directory: workingDirectory,
+    }),
+  });
+}
+
+/**
+ * Get session status
+ */
+export async function getSessionStatus(sessionToken: string): Promise<CLISession> {
+  return apiRequest<CLISession>(`/cli/sessions/${sessionToken}`);
+}
+
+/**
+ * Log a command execution
+ */
+export async function logCommandExecution(data: {
+  command: string;
+  workingDirectory: string;
+  exitCode?: number;
+  output?: string;
+  duration?: number;
+}): Promise<void> {
+  await apiRequest('/cli/execute', {
+    method: 'POST',
+    body: JSON.stringify({
+      command: data.command,
+      working_directory: data.workingDirectory,
+      exit_code: data.exitCode,
+      output: data.output,
+      duration_ms: data.duration,
+    }),
+  });
+}
+
+/**
+ * Sync conversation from web
+ */
+export async function syncConversation(
+  conversationId: string,
+  sinceMessageId?: string,
+): Promise<{
+  conversation_id: string;
+  title?: string;
+  model: string;
+  messages: ChatMessage[];
+  has_more: boolean;
+}> {
+  return apiRequest('/cli/sync', {
+    method: 'POST',
+    body: JSON.stringify({
+      conversation_id: conversationId,
+      since_message_id: sinceMessageId,
+    }),
+  });
+}
+
+/**
+ * Get available models
+ */
+export async function getModels(): Promise<string[]> {
+  const response = await apiRequest<{ models: Array<{ name: string }> }>('/ai/models');
+  return response.models.map((m) => m.name);
+}
+
+/**
+ * Check API health
+ */
+export async function checkHealth(): Promise<boolean> {
+  try {
+    const apiUrl = config.getApiUrl();
+    const response = await fetch(`${apiUrl.replace('/api/v1/bridge', '')}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}