@closedloop-ai/cli 0.2.0 → 0.2.1

package/src/commands/submit.ts

@@ -1,214 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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;
-}

package/src/utils/errors.ts

@@ -1,98 +0,0 @@
-export class CliError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public exitCode: number = 1
-  ) {
-    super(message);
-    this.name = 'CliError';
-  }
-}
-
-export const ERROR_CODES = {
-  NO_API_KEY: 'NO_API_KEY',
-  INVALID_API_KEY: 'INVALID_API_KEY',
-  INVALID_INPUT: 'INVALID_INPUT',
-  API_ERROR: 'API_ERROR',
-  VALIDATION_ERROR: 'VALIDATION_ERROR',
-  CONNECTION_ERROR: 'CONNECTION_ERROR',
-  PROCESSING_ERROR: 'PROCESSING_ERROR',
-  NOT_FOUND: 'NOT_FOUND',
-  UNAUTHORIZED: 'UNAUTHORIZED',
-  RATE_LIMITED: 'RATE_LIMITED',
-  SERVER_ERROR: 'SERVER_ERROR',
-  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
-} as const;
-
-export function handleApiError(error: any): CliError {
-  if (error.response) {
-    const status = error.response.status;
-    const data = error.response.data;
-    
-    switch (status) {
-      case 401:
-        return new CliError(
-          'Invalid API key. Please check your configuration.',
-          ERROR_CODES.UNAUTHORIZED,
-          1
-        );
-      case 404:
-        return new CliError(
-          'Resource not found. Please check the ID and try again.',
-          ERROR_CODES.NOT_FOUND,
-          1
-        );
-      case 429:
-        return new CliError(
-          'Rate limit exceeded. Please wait a moment and try again.',
-          ERROR_CODES.RATE_LIMITED,
-          1
-        );
-      case 500:
-      case 502:
-      case 503:
-      case 504:
-        return new CliError(
-          'Server error. Please try again later.',
-          ERROR_CODES.SERVER_ERROR,
-          1
-        );
-      default:
-        return new CliError(
-          data?.message || `API error (${status})`,
-          ERROR_CODES.API_ERROR,
-          1
-        );
-    }
-  } else if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
-    return new CliError(
-      'Cannot connect to ClosedLoop AI servers. Please check your internet connection.',
-      ERROR_CODES.CONNECTION_ERROR,
-      1
-    );
-  } else if (error.code === 'ETIMEDOUT') {
-    return new CliError(
-      'Request timed out. Please try again.',
-      ERROR_CODES.CONNECTION_ERROR,
-      1
-    );
-  } else {
-    return new CliError(
-      error.message || 'An unknown error occurred',
-      ERROR_CODES.UNKNOWN_ERROR,
-      1
-    );
-  }
-}
-
-export function handleValidationError(message: string): CliError {
-  return new CliError(message, ERROR_CODES.VALIDATION_ERROR, 1);
-}
-
-export function handleInputError(message: string): CliError {
-  return new CliError(message, ERROR_CODES.INVALID_INPUT, 1);
-}
-
-export function handleProcessingError(message: string): CliError {
-  return new CliError(message, ERROR_CODES.PROCESSING_ERROR, 1);
-}

package/src/utils/validation.ts

@@ -1,166 +0,0 @@
-import { CliError, handleValidationError, handleInputError, ERROR_CODES } from './errors';
-import { CONFIG } from '../config/constants';
-
-// UUID validation
-export function validateUuid(id: string): boolean {
-  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  return uuidRegex.test(id);
-}
-
-// Content validation
-export function validateInputContent(content: string): string {
-  if (!content || content.trim().length === 0) {
-    throw handleInputError('Content cannot be empty');
-  }
-  
-  if (content.length > CONFIG.MAX_CONTENT_LENGTH) {
-    throw handleInputError(`Content too long (max ${CONFIG.MAX_CONTENT_LENGTH} characters)`);
-  }
-  
-  return content.trim();
-}
-
-// API key validation
-export function validateApiKey(apiKey: string): string {
-  if (!apiKey || apiKey.trim().length === 0 || apiKey.length < CONFIG.MIN_API_KEY_LENGTH) {
-    throw handleValidationError('Invalid API key. Get your free API key at https://closedloop.sh');
-  }
-  
-  return apiKey.trim();
-}
-
-// Email validation
-export function validateEmail(email: string): string {
-  if (!email || email.trim().length === 0) {
-    throw handleValidationError('Email cannot be empty');
-  }
-  
-  const trimmedEmail = email.trim();
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(trimmedEmail)) {
-    throw handleValidationError('Invalid email format');
-  }
-  
-  return trimmedEmail.toLowerCase();
-}
-
-// URL validation
-export function validateUrl(url: string): string {
-  if (!url || url.trim().length === 0) {
-    throw handleValidationError('URL cannot be empty');
-  }
-  
-  try {
-    const urlObj = new URL(url);
-    if (!['http:', 'https:'].includes(urlObj.protocol)) {
-      throw handleValidationError('URL must use HTTP or HTTPS protocol');
-    }
-    return urlObj.toString();
-  } catch (error) {
-    throw handleValidationError('Invalid URL format');
-  }
-}
-
-// Pagination validation
-export function validatePagination(page?: number, limit?: number): { page: number; limit: number } {
-  const validatedPage = Math.max(1, page || 1);
-  const validatedLimit = Math.min(
-    Math.max(1, limit || CONFIG.DEFAULT_PAGE_SIZE),
-    CONFIG.MAX_PAGE_SIZE
-  );
-  
-  return { page: validatedPage, limit: validatedLimit };
-}
-
-// Title validation
-export function validateTitle(title: string): string {
-  if (!title || title.trim().length === 0) {
-    throw handleValidationError('Title cannot be empty');
-  }
-  
-  if (title.length > 200) {
-    throw handleValidationError('Title too long (max 200 characters)');
-  }
-  
-  return title.trim();
-}
-
-// Customer ID validation
-export function validateCustomerId(customerId: string): string {
-  if (!customerId || customerId.trim().length === 0) {
-    throw handleValidationError('Customer ID cannot be empty');
-  }
-  
-  if (customerId.length > 100) {
-    throw handleValidationError('Customer ID too long (max 100 characters)');
-  }
-  
-  return customerId.trim();
-}
-
-// Name validation
-export function validateName(name: string): string {
-  if (!name || name.trim().length === 0) {
-    throw handleValidationError('Name cannot be empty');
-  }
-  
-  if (name.length > 100) {
-    throw handleValidationError('Name too long (max 100 characters)');
-  }
-  
-  return name.trim();
-}
-
-// Sanitize input to prevent XSS
-export function sanitizeInput(input: string): string {
-  return input
-    .replace(/[<>]/g, '') // Remove < and >
-    .replace(/javascript:/gi, '') // Remove javascript: protocol
-    .replace(/on\w+=/gi, '') // Remove event handlers
-    .trim();
-}
-
-// Validate and sanitize all input data
-export function validateAndSanitizeInput(data: {
-  content: string;
-  title?: string;
-  source_url?: string;
-  customer_id?: string;
-  reporter_name?: string;
-  reporter_email?: string;
-}): {
-  content: string;
-  title?: string;
-  source_url?: string;
-  customer_id?: string;
-  reporter_name?: string;
-  reporter_email?: string;
-} {
-  const validated: any = {};
-  
-  // Required fields
-  validated.content = sanitizeInput(validateInputContent(data.content));
-  
-  // Optional fields
-  if (data.title) {
-    validated.title = sanitizeInput(validateTitle(data.title));
-  }
-  
-  if (data.source_url) {
-    validated.source_url = validateUrl(data.source_url);
-  }
-  
-  if (data.customer_id) {
-    validated.customer_id = sanitizeInput(validateCustomerId(data.customer_id));
-  }
-  
-  if (data.reporter_name) {
-    validated.reporter_name = sanitizeInput(validateName(data.reporter_name));
-  }
-  
-  if (data.reporter_email) {
-    validated.reporter_email = validateEmail(data.reporter_email);
-  }
-  
-  return validated;
-}