@closedloop-ai/cli 0.2.0

package/src/commands/list.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { table } from 'table';
+import { listFeedbacks } from '../api/feedback';
+import { CommandOptions, FeedbackData, ListResponse } from '../types';
+import { CONFIG, MESSAGES } from '../config/constants';
+
+export const listCommand = new Command('list')
+  .description('List customer inputs and generated AI feedback')
+  .option('-p, --page <number>', 'Page number to show', '1')
+  .option('-l, --limit <number>', 'How many items to show per page', '20')
+  .option('-s, --status <status>', 'Show only items with this status (processing, completed, failed)')
+  .option('--new', 'Show only inputs that are still being processed')
+  .option('--json', 'Output in JSON format')
+  .action(async (options: CommandOptions) => {
+    try {
+      const params: CommandOptions = {
+        page: options.page || 1,
+        limit: options.limit || CONFIG.DEFAULT_PAGE_SIZE
+      };
+
+      if (options.status) {
+        params.status = options.status;
+      }
+
+      const result = options.new 
+        ? await listFeedbacks(params, true) // new feedbacks
+        : await listFeedbacks(params, false); // processed feedbacks
+
+      const feedbacks = result.feedbacks || result.data || [];
+      if (feedbacks.length === 0) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: [], pagination: result.pagination || {} }, null, 2));
+        } else {
+          console.log(chalk.yellow('No customer inputs found.'));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: feedbacks, pagination: result.pagination || {} }, null, 2));
+        return;
+      }
+
+      // Create table data
+      const tableData = [
+        ['ID', 'Title', 'Status', 'AI Feedback', 'Credits Used', 'Submitted']
+      ];
+
+      feedbacks.forEach((item: any) => {
+        const statusColor = item.status === 'completed' ? 'green' : 
+                           item.status === 'processing' ? 'yellow' : 
+                           item.status === 'pending_step2' ? 'yellow' :
+                           item.status === 'failed' ? 'red' :
+                           item.status === 'new' ? 'blue' :
+                           item.status === 'in_review' ? 'yellow' :
+                           item.status === 'addressed' ? 'green' :
+                           item.status === 'archived' ? 'gray' : 'red';
+        
+        tableData.push([
+          item.id,
+          item.title || 'Untitled',
+          chalk[statusColor](item.status || 'unknown'),
+          (item.feedbackCount || 0).toString(),
+          (item.creditsConsumed || 0).toString(),
+          item.timestamp ? new Date(item.timestamp).toLocaleString() : 'Unknown'
+        ]);
+      });
+
+      console.log(chalk.blue('\n📋 Customer Inputs & AI Feedback:'));
+      console.log(table(tableData));
+
+      // Pagination info
+      const pagination = result.pagination || {};
+      if (pagination.pages > 1) {
+        console.log(chalk.gray(`\nPage ${pagination.page} of ${pagination.pages} (${pagination.total} total items)`));
+        console.log(chalk.gray('Use --page <number> to see more'));
+      }
+
+    } catch (error: any) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });

package/src/commands/status.ts

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getFeedbackStatus } from '../api/feedback';
+import { CommandOptions, FeedbackData } from '../types';
+import { CONFIG, MESSAGES } from '../config/constants';
+
+export const statusCommand = new Command('status')
+  .description('Check processing status of a feedback submission')
+  .argument('<id>', 'Feedback submission ID')
+  .option('-w, --watch', 'Watch for status changes')
+  .option('--json', 'Output in JSON format')
+  .action(async (id, options: CommandOptions) => {
+    try {
+      if (options.watch) {
+        // Watch mode - check status every few seconds
+        const spinner = ora('Watching for status changes...').start();
+        
+        const checkStatus = async () => {
+          try {
+            const result = await getFeedbackStatus(id);
+            
+            if (result.status === 'completed') {
+              spinner.succeed(chalk.green(`✅ Processing completed! Generated ${result.feedbackCount} insights`));
+              process.exit(0);
+            } else if (result.status === 'failed') {
+              spinner.fail(chalk.red('❌ Processing failed'));
+              process.exit(1);
+            } else {
+              spinner.text = `Processing... (${result.status})`;
+            }
+          } catch (error: any) {
+            spinner.fail(chalk.red('Error checking status:') + ' ' + error.message);
+            process.exit(1);
+          }
+        };
+
+        // Check immediately
+        await checkStatus();
+        
+        // Then check every few seconds
+        const interval = setInterval(checkStatus, CONFIG.POLL_INTERVAL_MS);
+        
+        // Stop watching on Ctrl+C
+        process.on('SIGINT', () => {
+          clearInterval(interval);
+          spinner.stop();
+          console.log(chalk.yellow('\nStopped watching.'));
+          process.exit(0);
+        });
+        
+      } else {
+        // Single check
+        const spinner = ora('Checking status...').start();
+        
+        const result = await getFeedbackStatus(id);
+        
+        spinner.stop();
+        
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: result }, null, 2));
+          return;
+        }
+        
+        console.log(chalk.blue('\n📊 Status Information:'));
+        console.log(chalk.gray('─'.repeat(40)));
+        console.log(chalk.blue('ID:'), result.id);
+        console.log(chalk.blue('Title:'), result.signal_title || result.title);
+        console.log(chalk.blue('Status:'), 
+          result.status === 'completed' ? chalk.green(result.status) :
+          result.status === 'processing' ? chalk.yellow(result.status) :
+          result.status === 'pending_step2' ? chalk.yellow('pending') :
+          result.status === 'failed' ? chalk.red(result.status) :
+          result.status === 'new' ? chalk.blue(result.status) :
+          result.status === 'in_review' ? chalk.yellow(result.status) :
+          result.status === 'addressed' ? chalk.green(result.status) :
+          result.status === 'archived' ? chalk.gray(result.status) :
+          chalk.red(result.status)
+        );
+        console.log(chalk.blue('Created:'), result.created_at ? new Date(result.created_at).toLocaleString() : 'Unknown');
+        console.log(chalk.blue('Updated:'), result.updated_at ? new Date(result.updated_at).toLocaleString() : 'Unknown');
+        console.log(chalk.blue('Credits Used:'), result.creditsConsumed || 'Unknown');
+        console.log(chalk.blue('AI Feedback Generated:'), result.feedbackCount || 0);
+        
+        if (result.status === 'completed' && (result.feedbackCount || 0) > 0) {
+          console.log(chalk.green('\n🎯 Use "cl list" to see the generated AI feedback!'));
+        } else if (result.status === 'processing') {
+          console.log(chalk.yellow('\n⏳ Still processing... Use "cl status <id> --watch" to monitor'));
+        }
+      }
+
+    } catch (error: any) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });

package/src/commands/submit.ts

@@ -0,0 +1,214 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { submitFeedback, getFeedbackStatus } from '../api/feedback';
+import { CommandOptions, InputData } from '../types';
+import { CONFIG, MESSAGES } from '../config/constants';
+
+export const submitCommand = new Command('submit')
+  .description('Submit customer input for AI analysis and insight generation')
+  .argument('[content]', 'Customer input content to analyze')
+  .option('-t, --title <title>', 'Title for this customer input')
+  .option('-u, --url <url>', 'Where this input came from (support ticket, survey, etc.)')
+  .option('-c, --customer <id>', 'Customer identifier')
+  .option('-n, --name <name>', 'Name of person who provided the input')
+  .option('-e, --email <email>', 'Email of person who provided the input')
+  .option('--interactive', 'Fill in details step by step')
+  .option('-w, --wait', 'Wait until processing is completed')
+  .option('--json', 'Output in JSON format')
+  .action(async (content, options: CommandOptions) => {
+    try {
+      let feedbackData: Partial<InputData> = {};
+
+      if (options.interactive || !content) {
+        // Interactive mode
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'content',
+            message: 'What customer input would you like to analyze?',
+            validate: (input) => input.length >= 10 || 'Input must be at least 10 characters',
+            default: content
+          },
+          {
+            type: 'input',
+            name: 'title',
+            message: 'What should we call this input? (optional):',
+            default: options.title
+          },
+          {
+            type: 'input',
+            name: 'sourceUrl',
+            message: 'Where did this come from? (support ticket, survey, etc.) (optional):',
+            default: options.url
+          },
+          {
+            type: 'input',
+            name: 'customerId',
+            message: 'Customer identifier (optional):',
+            default: options.customer
+          },
+          {
+            type: 'input',
+            name: 'reporterName',
+            message: 'Who provided this input? (optional):',
+            default: options.name
+          },
+          {
+            type: 'input',
+            name: 'reporterEmail',
+            message: 'Their email address (optional):',
+            default: options.email
+          }
+        ]);
+
+        feedbackData = {
+          content: answers.content,
+          title: answers.title,
+          source_url: answers.sourceUrl,
+          customer_id: answers.customerId,
+          reporter_name: answers.reporterName,
+          reporter_email: answers.reporterEmail
+        };
+      } else {
+        // Command line mode
+        feedbackData = {
+          content,
+          title: options.title,
+          source_url: options.url,
+          customer_id: options.customer,
+          reporter_name: options.name,
+          reporter_email: options.email
+        };
+      }
+
+      const spinner = ora('Submitting customer input for AI analysis...').start();
+      
+      const result = await submitFeedback(feedbackData);
+      
+      if (options.wait) {
+        // Wait for processing to complete
+        if (options.json) {
+          // For JSON, we'll output the final result after waiting
+        } else {
+          console.log(chalk.green('✅ Customer input submitted successfully!'));
+          console.log(chalk.blue(`Submission ID: ${result.id}`));
+        }
+        
+        const waitSpinner = ora('Processing...').start();
+        let attempts = 0;
+        const maxAttempts = CONFIG.MAX_RETRY_ATTEMPTS;
+
+        while (attempts < maxAttempts) {
+          await new Promise(resolve => setTimeout(resolve, CONFIG.POLL_INTERVAL_MS));
+          
+          try {
+            const statusResult = await getFeedbackStatus(result.id);
+            
+            if (statusResult.status === 'completed') {
+              waitSpinner.succeed('Processing completed!');
+              
+              if (options.json) {
+                console.log(JSON.stringify({ success: true, data: statusResult }, null, 2));
+              } else {
+                console.log(chalk.blue(`Feedback generated: ${statusResult.feedbackCount || 0}`));
+                console.log(chalk.blue(`Credits used: ${statusResult.creditsConsumed || 0}`));
+                if ((statusResult.feedbackCount || 0) > 0) {
+                  console.log(chalk.gray('Run "cl list" to see all feedback'));
+                }
+              }
+              break;
+            } else if (statusResult.status === 'failed') {
+              waitSpinner.fail('Processing failed');
+              if (options.json) {
+                console.log(JSON.stringify({ success: false, error: 'Processing failed', data: statusResult }, null, 2));
+              } else {
+                console.log(chalk.red('\n❌ Processing failed. Check the status for more details.'));
+              }
+              break;
+            } else {
+              // Still processing
+              waitSpinner.text = `Processing... (${statusResult.status})`;
+            }
+          } catch (error) {
+            // Continue waiting on API errors
+            waitSpinner.text = 'Processing... (checking status)';
+          }
+          
+          attempts++;
+        }
+        
+        if (attempts >= maxAttempts) {
+          waitSpinner.warn('Processing is taking longer than expected');
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: 'Processing timeout', data: { id: result.id, message: 'Processing is taking longer than expected' } }, null, 2));
+          } else {
+            console.log(chalk.yellow('\n⏳ Processing is still in progress. You can check status manually:'));
+            console.log(chalk.gray(`   cl status ${result.id}`));
+          }
+        }
+      } else {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: result }, null, 2));
+        } else {
+          console.log(chalk.green('✅ Customer input submitted successfully!'));
+          console.log(chalk.blue(`Submission ID: ${result.id}`));
+          console.log(chalk.gray('Run "cl status ' + result.id + '" to check progress'));
+          console.log(chalk.gray('Or use "cl submit --wait" to wait for completion'));
+        }
+      }
+
+    } catch (error: any) {
+      if (options.json) {
+        console.log(JSON.stringify({ 
+          success: false, 
+          error: error.message,
+          details: error.response?.data || 'Unknown error occurred'
+        }, null, 2));
+      } else {
+        // User-friendly error messages
+        if (error.response?.status === 400) {
+          const errorData = error.response.data;
+          if (errorData?.code === 'VALIDATION_ERROR') {
+            console.error(chalk.red('❌ Validation Error:'), errorData.error);
+            console.log(chalk.gray('\n💡 Common issues:'));
+            console.log(chalk.gray('   • Content must be at least 10 characters'));
+            console.log(chalk.gray('   • Check that all required fields are provided'));
+            console.log(chalk.gray('   • Ensure API key is valid: cl config'));
+          } else if (errorData?.code === 'PROCESSING_ERROR') {
+            console.error(chalk.red('❌ Processing Error:'), errorData.error);
+            console.log(chalk.gray('\n💡 This usually means:'));
+            console.log(chalk.gray('   • The content could not be processed by our AI'));
+            console.log(chalk.gray('   • Try rephrasing your input'));
+            console.log(chalk.gray('   • Make sure the content is clear and meaningful'));
+            console.log(chalk.gray('   • Check API key: cl config'));
+          } else {
+            console.error(chalk.red('❌ Bad Request:'), errorData?.error || 'Invalid input provided');
+            console.log(chalk.gray('\n💡 Try:'));
+            console.log(chalk.gray('   • Check your input content'));
+            console.log(chalk.gray('   • Verify API key: cl config'));
+            console.log(chalk.gray('   • Get help: cl submit --help'));
+          }
+        } else if (error.response?.status === 401) {
+          console.error(chalk.red('❌ Authentication Error:'), 'Invalid API key');
+          console.log(chalk.gray('\n💡 To fix:'));
+          console.log(chalk.gray('   1. Get your free API key at: https://closedloop.sh'));
+          console.log(chalk.gray('   2. Run: cl config --set-api-key <your-key>'));
+        } else if (error.response?.status === 429) {
+          console.error(chalk.red('❌ Rate Limited:'), 'Too many requests');
+          console.log(chalk.gray('\n💡 Wait a moment and try again'));
+        } else if (error.response?.status >= 500) {
+          console.error(chalk.red('❌ Server Error:'), 'Our servers are having issues');
+          console.log(chalk.gray('\n💡 Try again in a few minutes'));
+        } else if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+          console.error(chalk.red('❌ Connection Error:'), 'Cannot connect to ClosedLoop servers');
+          console.log(chalk.gray('\n💡 Check your internet connection and try again'));
+        } else {
+          console.error(chalk.red('❌ Error:'), error.message);
+          console.log(chalk.gray('\n💡 Get help: cl --help'));
+        }
+      }
+      process.exit(1);
+    }
+  });

package/src/config/constants.ts

@@ -0,0 +1,36 @@
+export const CONFIG = {
+  API_BASE_URL: process.env.CLOSEDLOOP_API_URL || 'https://mcp.closedloop.sh',
+  USER_AGENT: 'closedloop-cli/0.2.0',
+  MAX_RETRY_ATTEMPTS: 100,
+  POLL_INTERVAL_MS: 3000,
+  DEFAULT_PAGE_SIZE: 20,
+  MAX_PAGE_SIZE: 100,
+  MIN_API_KEY_LENGTH: 10,
+  MAX_CONTENT_LENGTH: 10000,
+  TIMEOUT_MS: 30000
+} as const;
+
+export const MESSAGES = {
+  NO_API_KEY: `🔑 No API key configured!
+
+To get started:
+1. Go to https://closedloop.sh
+2. Sign up for a free account
+3. Generate your API key
+4. Run: cl config --set-api-key <your-key>
+
+Get your free API key at: https://closedloop.sh`,
+  
+  INVALID_API_KEY: '❌ Invalid API key. Get your free API key at https://closedloop.sh',
+  CONNECTION_ERROR: '❌ Connection Error: Cannot connect to ClosedLoop AI servers',
+  CHECK_INTERNET: 'Check your internet connection and try again',
+  GET_HELP: 'Get help: cl --help',
+  PROCESSING_ERROR: '❌ Processing Error: Unable to process feedback',
+  VALIDATION_ERROR: '❌ Validation Error:',
+  UNKNOWN_ERROR: 'Unknown error occurred'
+} as const;
+
+export const URLS = {
+  CLOSEDLOOP_HOME: 'https://closedloop.sh',
+  GET_API_KEY: 'https://closedloop.sh'
+} as const;

package/src/config/index.ts

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface Config {
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+class ConfigManager {
+  private configPath: string;
+  private config: Config = {};
+
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.closedloop', 'config.json');
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf8');
+        this.config = JSON.parse(data);
+      }
+    } catch (error) {
+      // Ignore config load errors
+    }
+  }
+
+  private save(): void {
+    try {
+      const dir = path.dirname(this.configPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    } catch (error) {
+      throw new Error('Failed to save configuration');
+    }
+  }
+
+  get(key?: keyof Config): any {
+    if (key) {
+      return this.config[key];
+    }
+    return { ...this.config };
+  }
+
+  set(key: keyof Config, value: any): void {
+    this.config[key] = value;
+    this.save();
+  }
+
+  getConfigPath(): string {
+    return fs.existsSync(this.configPath) ? this.configPath : 'Not created yet';
+  }
+}
+
+export const config = new ConfigManager();

package/src/types/index.ts

@@ -0,0 +1,119 @@
+export interface CommandOptions {
+  page?: number;
+  limit?: number;
+  json?: boolean;
+  wait?: boolean;
+  interactive?: boolean;
+  // Config options
+  setApiKey?: string;
+  setTeam?: string;
+  apiKey?: string;
+  team?: string;
+  // Input options
+  title?: string;
+  url?: string;
+  customer?: string;
+  name?: string;
+  email?: string;
+  // Feedback options
+  status?: string;
+  search?: string;
+  new?: boolean;
+  watch?: boolean;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data: T;
+  error?: string;
+  pagination?: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}
+
+export interface InputData {
+  id: string;
+  title?: string;
+  content: string;
+  source_url?: string;
+  source_id?: string;
+  source_timestamp?: string;
+  customer_id?: string;
+  reporter_name?: string;
+  reporter_email?: string;
+  language?: string;
+  metadata?: any;
+  tags?: string[];
+  status: string;
+  created_at: string;
+  updated_at: string;
+  claimed_at?: string;
+  retry_count?: number;
+  error_message?: string;
+  feedback_count: number;
+  credits_consumed: number;
+}
+
+export interface FeedbackData {
+  id: string;
+  title?: string;
+  clarity?: string;
+  deal_blocker: boolean;
+  pain_point?: string;
+  workaround?: string;
+  competitor_gap?: string;
+  willingness_to_pay?: string;
+  use_case?: string;
+  feature_area?: string;
+  source_url?: string;
+  timestamp: string;
+  input_id?: string;
+  severity?: string;
+  status?: string;
+  source?: string;
+  // For backward compatibility
+  signal_title?: string;
+  created_at?: string;
+  updated_at?: string;
+  feedbackCount?: number;
+  creditsConsumed?: number;
+}
+
+export interface UsageData {
+  id: string;
+  input_id: string;
+  title?: string;
+  credits_consumed: number;
+  feedback_count: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ConfigData {
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+export interface PaginationData {
+  page: number;
+  limit: number;
+  total: number;
+  pages: number;
+}
+
+export interface ListResponse<T> {
+  data: T[];
+  pagination: PaginationData;
+  // For backward compatibility
+  inputs?: T[];
+  feedbacks?: T[];
+}
+
+export interface ErrorResponse {
+  success: false;
+  error: string;
+  details?: any;
+}