@toothfairyai/cli 1.1.5 → 1.4.0

package/bin/toothfairy.js

@@ -7,6 +7,7 @@ const { table } = require('table');
 require('dotenv').config();
 const path = require('path');
 
+const fs = require('fs');
 const ToothFairyAPI = require('../src/api');
 const {
   loadConfig,
@@ -17,6 +18,128 @@ const {
   validateDocumentConfiguration,
 } = require('../src/config');
 
+/**
+ * Determines the best way to handle a local file based on its type and size.
+ * Text files under a certain size are read as text content.
+ * Binary files or large text files should be uploaded.
+ *
+ * @param {string} filePath - Path to the local file
+ * @returns {Object} - { strategy: 'text'|'upload', content?: string, mimeType: string, size: number }
+ */
+function analyzeLocalFile(filePath) {
+  const absolutePath = path.resolve(filePath);
+
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const stats = fs.statSync(absolutePath);
+  const ext = path.extname(filePath).toLowerCase().slice(1);
+  const sizeInMB = stats.size / (1024 * 1024);
+
+  // Text-based file extensions that can be read as content
+  const textExtensions = [
+    'txt', 'md', 'markdown', 'json', 'jsonl', 'yaml', 'yml',
+    'js', 'ts', 'jsx', 'tsx', 'py', 'java', 'c', 'cpp', 'h', 'hpp',
+    'cs', 'rb', 'go', 'rs', 'php', 'swift', 'kt', 'scala',
+    'html', 'htm', 'css', 'scss', 'sass', 'less',
+    'xml', 'svg', 'sql', 'sh', 'bash', 'zsh', 'ps1',
+    'env', 'ini', 'cfg', 'conf', 'toml', 'properties',
+    'csv', 'log', 'gitignore', 'dockerignore', 'editorconfig'
+  ];
+
+  // Binary file extensions that must be uploaded
+  const binaryExtensions = [
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp', 'ico', 'tiff',
+    'mp3', 'wav', 'aac', 'ogg', 'flac', 'm4a',
+    'mp4', 'avi', 'mov', 'wmv', 'flv', 'webm', 'mkv',
+    'zip', 'tar', 'gz', 'rar', '7z',
+    'exe', 'dll', 'so', 'dylib',
+    'woff', 'woff2', 'ttf', 'otf', 'eot'
+  ];
+
+  const isTextFile = textExtensions.includes(ext) || ext === '';
+  const isBinaryFile = binaryExtensions.includes(ext);
+
+  // Max size for reading as text (500KB)
+  const maxTextSize = 0.5;
+
+  // Determine strategy
+  let strategy;
+  let content = null;
+
+  if (isBinaryFile) {
+    strategy = 'upload';
+  } else if (isTextFile && sizeInMB <= maxTextSize) {
+    strategy = 'text';
+    content = fs.readFileSync(absolutePath, 'utf-8');
+  } else if (sizeInMB > 15) {
+    throw new Error(`File size (${sizeInMB.toFixed(2)}MB) exceeds 15MB limit`);
+  } else {
+    // Large text file or unknown extension - upload it
+    strategy = 'upload';
+  }
+
+  return {
+    strategy,
+    content,
+    absolutePath,
+    fileName: path.basename(filePath),
+    extension: ext,
+    size: stats.size,
+    sizeInMB
+  };
+}
+
+/**
+ * Processes local files and prepares them for sending to an agent.
+ * Returns message text with file contents embedded and/or attachments for upload.
+ *
+ * @param {string[]} localFiles - Array of local file paths
+ * @param {string} originalMessage - The original message from the user
+ * @param {Object} existingAttachments - Existing attachment object
+ * @returns {Object} - { message: string, attachments: Object }
+ */
+function processLocalFiles(localFiles, originalMessage, existingAttachments = {}) {
+  const textContents = [];
+  const attachments = { ...existingAttachments };
+
+  for (const filePath of localFiles) {
+    const analysis = analyzeLocalFile(filePath);
+
+    if (analysis.strategy === 'text') {
+      // Add file content as text
+      textContents.push({
+        fileName: analysis.fileName,
+        content: analysis.content
+      });
+    } else {
+      // Add to attachments for upload
+      if (!attachments.files) {
+        attachments.files = [];
+      }
+      attachments.files.push(analysis.absolutePath);
+    }
+  }
+
+  // Build enhanced message with text file contents
+  let enhancedMessage = originalMessage;
+
+  if (textContents.length > 0) {
+    const fileSection = textContents.map(file =>
+      `\n\n--- File: ${file.fileName} ---\n${file.content}\n--- End of ${file.fileName} ---`
+    ).join('');
+
+    enhancedMessage = `${originalMessage}${fileSection}`;
+  }
+
+  return {
+    message: enhancedMessage,
+    attachments
+  };
+}
+
 const program = new Command();
 
 program
@@ -48,6 +171,7 @@ program
   .option('--api-key <key>', 'API key')
   .option('--workspace-id <id>', 'Workspace ID')
   .option('--user-id <id>', 'User ID')
+  .option('--default-agent-id <id>', 'Default agent ID for send/chat commands')
   .option('--config-path <path>', 'Path to save config file')
   .action(async (options) => {
     try {
@@ -57,7 +181,7 @@ program
         existingConfig = loadConfig(options.configPath);
       } catch (error) {
         // No existing config, use empty defaults
-        existingConfig = new ToothFairyConfig('', '', '', '', '', '');
+        existingConfig = new ToothFairyConfig('', '', '', '', '', '', '');
       }
 
       // Merge provided options with existing config
@@ -71,7 +195,8 @@ program
           'https://ais.toothfairyai.com',
         options.apiKey || existingConfig.apiKey || '',
         options.workspaceId || existingConfig.workspaceId || '',
-        options.userId || existingConfig.userId || ''
+        options.userId || existingConfig.userId || '',
+        options.defaultAgentId || existingConfig.defaultAgentId || ''
       );
 
       // Validate that at least API key and workspace ID are set
@@ -109,7 +234,7 @@ program
   .command('send')
   .description('Send a message to a ToothFairyAI agent')
   .argument('<message>', 'message to send')
-  .requiredOption('--agent-id <id>', 'Agent ID to send message to')
+  .option('--agent-id <id>', 'Agent ID to send message to (uses default if configured)')
   .option('--chat-id <id>', 'Chat ID to use existing conversation (optional)')
   .option('--phone-number <number>', 'Phone number for SMS channel')
   .option('--customer-id <id>', 'Customer ID')
@@ -119,6 +244,7 @@ program
   .option('--audio <path>', 'Path to audio file (wav, mp3, aac, ogg, flac)')
   .option('--video <path>', 'Path to video file (mp4, avi, mov, wmv, flv, webm)')
   .option('--file <path...>', 'Path to document files (max 5)')
+  .option('--local-file <path...>', 'Path to local files to include (text files embedded in message, binary files uploaded)')
   .option('-o, --output <format>', 'Output format (json|text)', 'text')
   .option('-v, --verbose', 'Show detailed response information')
   .action(async (message, options, command) => {
@@ -127,6 +253,15 @@ program
       const config = loadConfig(globalOptions.config);
       validateConfiguration(config);
 
+      // Use provided agent-id or fall back to default from config
+      const agentId = options.agentId || config.defaultAgentId;
+      if (!agentId) {
+        console.error(chalk.red('Error: --agent-id is required'));
+        console.error(chalk.yellow('Either provide --agent-id or set a default with:'));
+        console.error(chalk.dim('  tf configure --default-agent-id YOUR_AGENT_ID'));
+        process.exit(1);
+      }
+
       const api = new ToothFairyAPI(
         config.baseUrl,
         config.aiUrl,
@@ -148,7 +283,7 @@ program
       }
 
       // Process file attachments if provided
-      const attachments = {};
+      let attachments = {};
       if (options.image) {
         attachments.images = [options.image];
       }
@@ -162,11 +297,28 @@ program
         attachments.files = Array.isArray(options.file) ? options.file : [options.file];
       }
 
+      // Process local files - text files are embedded in message, binary files are uploaded
+      let finalMessage = message;
+      if (options.localFile) {
+        const localFiles = Array.isArray(options.localFile) ? options.localFile : [options.localFile];
+        const processed = processLocalFiles(localFiles, message, attachments);
+        finalMessage = processed.message;
+        attachments = processed.attachments;
+
+        if (globalOptions.verbose || options.verbose) {
+          console.log(chalk.dim(`Processing ${localFiles.length} local file(s)...`));
+          for (const filePath of localFiles) {
+            const analysis = analyzeLocalFile(filePath);
+            console.log(chalk.dim(`  - ${analysis.fileName}: ${analysis.strategy} (${analysis.sizeInMB.toFixed(2)}MB)`));
+          }
+        }
+      }
+
       const spinner = ora('Sending message to agent...').start();
 
       const response = await api.sendMessageToAgent(
-        message,
-        options.agentId,
+        finalMessage,
+        agentId,
         options.phoneNumber,
         options.customerId,
         options.providerId,
@@ -238,7 +390,7 @@ program
     'Send a message to a ToothFairyAI agent with real-time streaming response'
   )
   .argument('<message>', 'message to send')
-  .requiredOption('--agent-id <id>', 'Agent ID to send message to')
+  .option('--agent-id <id>', 'Agent ID to send message to (uses default if configured)')
   .option('--chat-id <id>', 'Chat ID to use existing conversation (optional)')
   .option('--phone-number <number>', 'Phone number for SMS channel')
   .option('--customer-id <id>', 'Customer ID')
@@ -248,6 +400,7 @@ program
   .option('--audio <path>', 'Path to audio file (WAV, max 1)')
   .option('--video <path>', 'Path to video file (MP4, max 1)')
   .option('--file <path>', 'Path to file (max 5, can be used multiple times)', (value, previous) => previous.concat([value]), [])
+  .option('--local-file <path...>', 'Path to local files to include (text files embedded in message, binary files uploaded)')
   .option('-o, --output <format>', 'Output format (json|text)', 'text')
   .option('-v, --verbose', 'Show detailed streaming information')
   .option('--show-progress', 'Show agent processing status updates')
@@ -277,6 +430,15 @@ program
       const config = loadConfig(globalOptions.config);
       validateConfiguration(config);
 
+      // Use provided agent-id or fall back to default from config
+      const agentId = options.agentId || config.defaultAgentId;
+      if (!agentId) {
+        console.error(chalk.red('Error: --agent-id is required'));
+        console.error(chalk.yellow('Either provide --agent-id or set a default with:'));
+        console.error(chalk.dim('  tf configure --default-agent-id YOUR_AGENT_ID'));
+        process.exit(1);
+      }
+
       const api = new ToothFairyAPI(
         config.baseUrl,
         config.aiUrl,
@@ -298,7 +460,7 @@ program
       }
 
       // Process file attachments if provided
-      const attachments = {};
+      let attachments = {};
       if (options.image) {
         attachments.images = [options.image];
       }
@@ -312,18 +474,34 @@ program
         attachments.files = Array.isArray(options.file) ? options.file : [options.file];
       }
 
+      // Process local files - text files are embedded in message, binary files are uploaded
+      let finalMessage = message;
+      if (options.localFile) {
+        const localFiles = Array.isArray(options.localFile) ? options.localFile : [options.localFile];
+        const processed = processLocalFiles(localFiles, message, attachments);
+        finalMessage = processed.message;
+        attachments = processed.attachments;
+
+        if (globalOptions.verbose || options.verbose) {
+          console.log(chalk.dim(`Processing ${localFiles.length} local file(s)...`));
+          for (const filePath of localFiles) {
+            const analysis = analyzeLocalFile(filePath);
+            console.log(chalk.dim(`  - ${analysis.fileName}: ${analysis.strategy} (${analysis.sizeInMB.toFixed(2)}MB)`));
+          }
+        }
+      }
+
       console.log(
-        chalk.cyan(`Streaming message to agent ${options.agentId}...`)
+        chalk.cyan(`Streaming message to agent ${agentId}...`)
       );
-      console.log(chalk.dim(`Message: ${message}`));
+      console.log(chalk.dim(`Message: ${options.localFile ? '(with local files) ' : ''}${message}`));
       console.log();
 
       // Initialize variables for streaming
-      let currentText = '';
       let finalResponse = null;
       let processingStatus = null;
-      let lastUpdateTime = 0;
       let hasStartedResponse = false;
+      let hasCompletedResponse = false;
 
       const mapStateWithLabel = (state) => {
         switch (state) {
@@ -377,8 +555,8 @@ program
         const allEvents = [];
 
         await api.sendMessageToAgentStream(
-          message,
-          options.agentId,
+          finalMessage,
+          agentId,
           options.phoneNumber,
           options.customerId,
           options.providerId,
@@ -396,7 +574,8 @@ program
           },
           attachments,
           options.showProgress,
-          options.chatId
+          options.chatId,
+          true // rawStream - enable chunk-by-chunk streaming
         );
 
         console.log(JSON.stringify(allEvents, null, 2));
@@ -404,42 +583,10 @@ program
         // Text mode: show live streaming
         let currentSpinner = null;
 
-        // Function to update display with status filtering
-        const updateDisplay = (text, agentStatus, type = 'response') => {
-          if (currentSpinner) {
-            currentSpinner.stop();
-            currentSpinner = null;
-          }
-
-          // Only show text when agent is actually replying
-          if (text && type === 'response' && agentStatus === 'replying') {
-            const trimmedText = text.trim();
-            const now = Date.now();
-
-            // Only update if the text is actually different and enough time has passed
-            // This prevents rapid duplicate updates
-            if (
-              trimmedText !== currentText &&
-              trimmedText?.length > currentText?.length &&
-              now - lastUpdateTime > 50
-            ) {
-              if (!hasStartedResponse) {
-                // First time showing response - print header on new line
-                console.log(chalk.green('🧚 Responding'));
-                hasStartedResponse = true;
-              }
-              // Stream new text content on new line
-              console.log(trimmedText);
-              currentText = trimmedText;
-              lastUpdateTime = now;
-            }
-          }
-        };
-
         try {
           await api.sendMessageToAgentStream(
-            message,
-            options.agentId,
+            finalMessage,
+            agentId,
             options.phoneNumber,
             options.customerId,
             options.providerId,
@@ -480,19 +627,71 @@ program
                 return;
               }
 
-              // Handle message events
+              // Handle streaming data events (tokens from raw_stream mode)
+              if (eventType === 'data' && eventData.text) {
+                // Stop spinner when text starts streaming
+                if (currentSpinner) {
+                  currentSpinner.stop();
+                  currentSpinner = null;
+                }
+
+                if (!hasStartedResponse) {
+                  console.log(chalk.green('🧚 Responding'));
+                  hasStartedResponse = true;
+                }
+
+                // Stream chunk directly to output
+                process.stdout.write(eventData.text);
+              }
+
+              // Handle progress events (from raw_stream mode)
+              if (eventType === 'progress') {
+                const status = eventData.processing_status || eventData.metadata_parsed?.agent_processing_status;
+                if (status && status !== processingStatus) {
+                  processingStatus = status;
+                  if (options.showProgress) {
+                    const statusMsg = mapStateWithLabel(processingStatus);
+                    if (currentSpinner) {
+                      currentSpinner.stop();
+                    }
+                    currentSpinner = ora(chalk.yellow(statusMsg)).start();
+                  }
+                }
+              }
+
+              // Handle chat_created events
+              if (eventType === 'chat_created' && eventData.chatId) {
+                if (options.verbose) {
+                  console.log(chalk.dim(`\n📝 Chat created: ${eventData.chatId}`));
+                }
+              }
+
+              // Handle complete events
+              if (eventType === 'complete') {
+                finalResponse = eventData;
+                if (currentSpinner) {
+                  currentSpinner.stop();
+                  currentSpinner = null;
+                }
+              }
+
+              // Handle message events (legacy format / additional metadata)
               if (eventData.type === 'message') {
                 let metadata = {};
                 let agentStatus = null;
 
                 // Parse metadata if available
                 if (eventData.metadata) {
-                  try {
-                    metadata = JSON.parse(eventData.metadata);
-                    agentStatus = metadata.agent_processing_status;
-                  } catch (e) {
-                    // Metadata parsing failed, continue without it
+                  if (typeof eventData.metadata === 'object') {
+                    metadata = eventData.metadata;
+                  } else {
+                    try {
+                      metadata = JSON.parse(eventData.metadata);
+                    } catch (e) {
+                      // Metadata parsing failed, continue without it
+                    }
                   }
+                  agentStatus = metadata.agent_processing_status;
                 }
 
                 // Handle status changes
@@ -507,22 +706,15 @@ program
                   }
                 }
 
-                // Handle progressive text streaming
-                if (eventData.text && agentStatus === 'replying') {
-                  updateDisplay(eventData.text, agentStatus, 'response');
-                }
-
                 // Handle fulfilled status (final response)
-                if (eventData.status === 'fulfilled') {
+                if (eventData.status === 'fulfilled' && !hasCompletedResponse) {
                   finalResponse = eventData;
-                  if (currentText) {
-                    // Clean final display with magic wand emoji
-                    if (currentSpinner) {
-                      currentSpinner.stop();
-                      currentSpinner = null;
-                    }
-                    console.log(chalk.blue('🪄 Response complete'));
+                  hasCompletedResponse = true;
+                  if (currentSpinner) {
+                    currentSpinner.stop();
+                    currentSpinner = null;
                   }
+                  console.log(chalk.blue('\n🪄 Response complete'));
                 }
 
                 // Handle additional metadata events (images, files, callback metadata)
@@ -530,14 +722,12 @@ program
                   eventData.images !== undefined ||
                   eventData.files !== undefined
                 ) {
-                  // These are attachment events - could show notification if needed
                   if (options.verbose) {
                     console.log(chalk.dim('\n📎 Attachments processed'));
                   }
                 }
 
                 if (eventData.callbackMetadata) {
-                  // Function execution metadata
                   if (options.verbose) {
                     console.log(
                       chalk.dim('\n⚙️ Function execution metadata received')
@@ -558,7 +748,8 @@ program
             },
             attachments,
             options.showProgress,
-            options.chatId
+            options.chatId,
+            true // rawStream - enable chunk-by-chunk streaming
           );
 
           // Clean up spinner after streaming completes
@@ -610,7 +801,7 @@ program
             console.log('─'.repeat(50));
           }
 
-          if (!currentText) {
+          if (!hasStartedResponse) {
             console.log(chalk.yellow('No text response received from agent.'));
           }
         } catch (streamError) {
@@ -626,6 +817,378 @@ program
     }
   });
 
+// Interactive Chat command
+program
+  .command('chat')
+  .description('Start an interactive chat session with a ToothFairyAI agent (use @ to reference local files)')
+  .option('--agent-id <id>', 'Agent ID to chat with (uses default if configured)')
+  .option('--chat-id <id>', 'Resume an existing chat conversation')
+  .option('-v, --verbose', 'Show detailed information')
+  .option('--show-progress', 'Show agent processing status updates')
+  .action(async (options, command) => {
+    const readline = require('readline');
+    const glob = require('glob');
+
+    try {
+      const globalOptions = command.parent.opts();
+      const config = loadConfig(globalOptions.config);
+      validateConfiguration(config);
+
+      // Use provided agent-id or fall back to default from config
+      const agentId = options.agentId || config.defaultAgentId;
+      if (!agentId) {
+        console.error(chalk.red('Error: --agent-id is required'));
+        console.error(chalk.yellow('Either provide --agent-id or set a default with:'));
+        console.error(chalk.dim('  tf configure --default-agent-id YOUR_AGENT_ID'));
+        process.exit(1);
+      }
+
+      const api = new ToothFairyAPI(
+        config.baseUrl,
+        config.aiUrl,
+        config.aiStreamUrl,
+        config.apiKey,
+        config.workspaceId,
+        globalOptions.verbose || options.verbose
+      );
+
+      // Track current chat ID for conversation continuity
+      let currentChatId = options.chatId || null;
+      const workingDir = process.cwd();
+
+      // Helper to get files matching a pattern
+      const getMatchingFiles = (pattern) => {
+        try {
+          // Remove @ prefix if present
+          const cleanPattern = pattern.startsWith('@') ? pattern.slice(1) : pattern;
+
+          // If it's a directory, list its contents
+          if (fs.existsSync(cleanPattern) && fs.statSync(cleanPattern).isDirectory()) {
+            return fs.readdirSync(cleanPattern).map(f => path.join(cleanPattern, f));
+          }
+
+          // Try glob pattern
+          const matches = glob.sync(cleanPattern, {
+            cwd: workingDir,
+            nodir: false,
+            dot: false
+          });
+          return matches;
+        } catch (e) {
+          return [];
+        }
+      };
+
+      // Helper to list files for autocomplete
+      const listFilesForCompletion = (partial) => {
+        const cleanPartial = partial.startsWith('@') ? partial.slice(1) : partial;
+        const dir = path.dirname(cleanPartial) || '.';
+        const prefix = path.basename(cleanPartial);
+
+        try {
+          let searchDir = dir === '.' ? workingDir : path.resolve(workingDir, dir);
+          if (!fs.existsSync(searchDir)) {
+            searchDir = workingDir;
+          }
+
+          const files = fs.readdirSync(searchDir);
+          const matches = files
+            .filter(f => f.startsWith(prefix) || prefix === '')
+            .map(f => {
+              const fullPath = path.join(dir === '.' ? '' : dir, f);
+              const isDir = fs.statSync(path.join(searchDir, f)).isDirectory();
+              return isDir ? fullPath + '/' : fullPath;
+            });
+          return matches;
+        } catch (e) {
+          return [];
+        }
+      };
+
+      // Parse @ references from message
+      const parseFileReferences = (message) => {
+        const fileRefs = [];
+        // Match @path/to/file or @"path with spaces/file" or @./relative/path
+        const regex = /@(?:"([^"]+)"|([^\s@]+))/g;
+        let match;
+
+        while ((match = regex.exec(message)) !== null) {
+          const filePath = match[1] || match[2];
+          fileRefs.push(filePath);
+        }
+
+        return fileRefs;
+      };
+
+      // Remove @ references from message for cleaner prompt
+      const cleanMessage = (message) => {
+        return message.replace(/@(?:"[^"]+"|[^\s@]+)/g, '').trim();
+      };
+
+      // Print welcome banner
+      console.log(chalk.cyan.bold('\n🧚 ToothFairy Interactive Chat'));
+      console.log(chalk.dim('─'.repeat(50)));
+      console.log(chalk.white(`Agent: ${agentId}`));
+      console.log(chalk.white(`Working directory: ${workingDir}`));
+      if (currentChatId) {
+        console.log(chalk.white(`Resuming chat: ${currentChatId}`));
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+      console.log(chalk.yellow('\nTips:'));
+      console.log(chalk.dim('  • Use @filename to include a file in your message'));
+      console.log(chalk.dim('  • Use @path/to/file or @./relative/path for paths'));
+      console.log(chalk.dim('  • Use @"path with spaces/file.txt" for paths with spaces'));
+      console.log(chalk.dim('  • Use @*.js or @src/**/*.ts for glob patterns'));
+      console.log(chalk.dim('  • Type /files to list files in current directory'));
+      console.log(chalk.dim('  • Type /cd <path> to change directory'));
+      console.log(chalk.dim('  • Type /chat to see current chat ID'));
+      console.log(chalk.dim('  • Type /clear to start a new chat'));
+      console.log(chalk.dim('  • Type /exit or Ctrl+C to quit'));
+      console.log(chalk.dim('─'.repeat(50)));
+      console.log();
+
+      // Create readline interface with custom completer
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer: (line) => {
+          // Check if we're completing a file reference
+          const atMatch = line.match(/@([^\s]*)$/);
+          if (atMatch) {
+            const partial = atMatch[1];
+            const completions = listFilesForCompletion(partial);
+            const hits = completions.map(c => '@' + c);
+            return [hits.length ? hits : [], line];
+          }
+          return [[], line];
+        },
+        prompt: chalk.green('You: ')
+      });
+
+      rl.prompt();
+
+      rl.on('line', async (input) => {
+        const trimmedInput = input.trim();
+
+        if (!trimmedInput) {
+          rl.prompt();
+          return;
+        }
+
+        // Handle special commands
+        if (trimmedInput.startsWith('/')) {
+          const [cmd, ...args] = trimmedInput.slice(1).split(' ');
+
+          switch (cmd.toLowerCase()) {
+            case 'exit':
+            case 'quit':
+            case 'q':
+              console.log(chalk.cyan('\nGoodbye! 👋'));
+              rl.close();
+              process.exit(0);
+              break;
+
+            case 'files':
+            case 'ls': {
+              const targetDir = args[0] || '.';
+              try {
+                const files = fs.readdirSync(path.resolve(workingDir, targetDir));
+                console.log(chalk.cyan(`\nFiles in ${targetDir}:`));
+                files.forEach(f => {
+                  const fullPath = path.join(workingDir, targetDir, f);
+                  const isDir = fs.statSync(fullPath).isDirectory();
+                  console.log(chalk.dim(`  ${isDir ? '📁' : '📄'} ${f}${isDir ? '/' : ''}`));
+                });
+                console.log();
+              } catch (e) {
+                console.log(chalk.red(`Cannot list directory: ${e.message}`));
+              }
+              break;
+            }
+
+            case 'cd': {
+              if (args[0]) {
+                const newDir = path.resolve(workingDir, args[0]);
+                if (fs.existsSync(newDir) && fs.statSync(newDir).isDirectory()) {
+                  process.chdir(newDir);
+                  console.log(chalk.cyan(`\nChanged directory to: ${newDir}\n`));
+                } else {
+                  console.log(chalk.red(`Directory not found: ${args[0]}`));
+                }
+              } else {
+                console.log(chalk.yellow('Usage: /cd <path>'));
+              }
+              break;
+            }
+
+            case 'chat':
+              console.log(chalk.cyan(`\nCurrent chat ID: ${currentChatId || '(new chat)'}\n`));
+              break;
+
+            case 'clear':
+            case 'new':
+              currentChatId = null;
+              console.log(chalk.cyan('\nStarting new chat session.\n'));
+              break;
+
+            case 'help':
+              console.log(chalk.yellow('\nCommands:'));
+              console.log(chalk.dim('  /files [path]  - List files in directory'));
+              console.log(chalk.dim('  /cd <path>     - Change directory'));
+              console.log(chalk.dim('  /chat          - Show current chat ID'));
+              console.log(chalk.dim('  /clear         - Start new chat'));
+              console.log(chalk.dim('  /exit          - Quit'));
+              console.log();
+              break;
+
+            default:
+              console.log(chalk.yellow(`Unknown command: /${cmd}. Type /help for available commands.`));
+          }
+
+          rl.prompt();
+          return;
+        }
+
+        // Parse file references from the message
+        const fileRefs = parseFileReferences(trimmedInput);
+        let messageText = trimmedInput;
+        let attachments = {};
+
+        // Process file references
+        if (fileRefs.length > 0) {
+          const allFiles = [];
+
+          for (const ref of fileRefs) {
+            const matches = getMatchingFiles(ref);
+            if (matches.length === 0) {
+              // Check if it's a direct file path
+              const directPath = path.resolve(workingDir, ref);
+              if (fs.existsSync(directPath)) {
+                allFiles.push(directPath);
+              } else {
+                console.log(chalk.yellow(`Warning: No files found matching @${ref}`));
+              }
+            } else {
+              allFiles.push(...matches.map(m => path.resolve(workingDir, m)));
+            }
+          }
+
+          if (allFiles.length > 0) {
+            // Filter out directories
+            const validFiles = allFiles.filter(f => {
+              try {
+                return fs.existsSync(f) && fs.statSync(f).isFile();
+              } catch {
+                return false;
+              }
+            });
+
+            if (validFiles.length > 0) {
+              console.log(chalk.dim(`\nIncluding ${validFiles.length} file(s):`));
+              validFiles.forEach(f => console.log(chalk.dim(`  📄 ${path.relative(workingDir, f)}`)));
+              console.log();
+
+              // Process the files
+              const cleanedMessage = cleanMessage(messageText);
+              const processed = processLocalFiles(validFiles, cleanedMessage || 'Please review these files:', attachments);
+              messageText = processed.message;
+              attachments = processed.attachments;
+            }
+          }
+        }
+
+        // Send message to agent with streaming
+        console.log(chalk.blue('\n🧚 Agent: '));
+
+        let processingStatus = null;
+        let currentSpinner = null;
+
+        try {
+          await api.sendMessageToAgentStream(
+            messageText,
+            agentId,
+            null, // phoneNumber
+            null, // customerId
+            null, // providerId
+            {}, // customerInfo
+            (eventType, eventData) => {
+              // Handle chat creation event
+              if (eventData.type === 'chat_created' || eventData.event === 'chat_created') {
+                if (eventData.chatId) {
+                  currentChatId = eventData.chatId;
+                }
+              }
+
+              // Update chat ID from response
+              if (eventData.chatId && !currentChatId) {
+                currentChatId = eventData.chatId;
+              }
+
+              // Handle status events
+              if (eventData.status === 'connected' && options.showProgress) {
+                console.log(chalk.dim('Connected...'));
+              }
+
+              // Handle progress events
+              if (eventType === 'progress' && options.showProgress) {
+                const status = eventData.processing_status || eventData.status;
+                if (status && status !== processingStatus) {
+                  processingStatus = status;
+                  if (currentSpinner) currentSpinner.stop();
+                  currentSpinner = ora(chalk.dim(status)).start();
+                }
+              }
+
+              // Handle streaming text (raw_stream tokens come as 'data' events with chunk in text)
+              if (eventType === 'data' && eventData.text) {
+                if (currentSpinner) {
+                  currentSpinner.stop();
+                  currentSpinner = null;
+                }
+                // Print chunk directly (raw_stream sends individual chunks, not cumulative)
+                process.stdout.write(eventData.text);
+              }
+
+              // Handle completion
+              if (eventData.status === 'fulfilled' || eventType === 'complete') {
+                if (currentSpinner) {
+                  currentSpinner.stop();
+                  currentSpinner = null;
+                }
+              }
+
+              // Handle errors
+              if (eventType === 'error') {
+                if (currentSpinner) currentSpinner.stop();
+                console.log(chalk.red(`\nError: ${eventData.message || 'Unknown error'}`));
+              }
+            },
+            attachments,
+            options.showProgress,
+            currentChatId,
+            true // rawStream - enable chunk-by-chunk streaming
+          );
+
+          console.log('\n');
+        } catch (error) {
+          if (currentSpinner) currentSpinner.stop();
+          console.log(chalk.red(`\nError: ${error.message}\n`));
+        }
+
+        rl.prompt();
+      });
+
+      rl.on('close', () => {
+        console.log(chalk.cyan('\nGoodbye! 👋\n'));
+        process.exit(0);
+      });
+
+    } catch (error) {
+      console.error(chalk.red(`Error starting chat: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 // Search command
 program
   .command('search')
@@ -963,6 +1526,7 @@ program
         ],
         ['Workspace ID', config.workspaceId],
         ['User ID', config.userId ? config.userId : 'Not set'],
+        ['Default Agent ID', config.defaultAgentId ? config.defaultAgentId : 'Not set'],
       ];
 
       console.log(