@ebowwa/crm 0.1.0

package/src/cli/commands/search.ts

@@ -0,0 +1,426 @@
+/**
+ * Search Commands
+ *
+ * CLI commands for searching across CRM entities.
+ */
+
+import { Command } from 'commander';
+import {
+  printSuccess,
+  printError,
+  printWarning,
+  printTable,
+  printJSON,
+  printHeader,
+  printDivider,
+  formatStatus,
+  formatCurrency,
+  formatRelativeTime,
+  truncate,
+  output,
+} from '../utils/output.js';
+import { Spinner } from '../utils/prompt.js';
+import { CRMStorageClient } from '../../mcp/storage/client.js';
+import type { Contact, Deal, Activity } from '../../core/types.js';
+
+/**
+ * Search result type
+ */
+interface SearchResult {
+  type: 'contact' | 'deal' | 'activity';
+  id: string;
+  title: string;
+  subtitle: string;
+  matchField?: string;
+  matchValue?: string;
+}
+
+// Storage client singleton
+let _storage: CRMStorageClient | null = null;
+
+/**
+ * Get storage client (lazy initialization)
+ */
+async function getStorage(): Promise<CRMStorageClient> {
+  if (!_storage) {
+    _storage = new CRMStorageClient({
+      path: process.env.CRM_DB_PATH || './data/crm-cli',
+      mapSize: 256 * 1024 * 1024, // 256MB
+      maxDbs: 20,
+    });
+    await _storage.initialize();
+  }
+  return _storage;
+}
+
+/**
+ * Get all contacts
+ */
+async function getContacts(): Promise<Contact[]> {
+  const storage = await getStorage();
+  return storage.list('contacts');
+}
+
+/**
+ * Get all deals
+ */
+async function getDeals(): Promise<Deal[]> {
+  const storage = await getStorage();
+  return storage.list('deals');
+}
+
+/**
+ * Get all activities
+ */
+async function getActivities(): Promise<Activity[]> {
+  const storage = await getStorage();
+  return storage.list('activities');
+}
+
+/**
+ * Register search commands
+ */
+export function registerSearchCommands(program: Command): void {
+  const search = program.command('search').description('Search across all entities');
+
+  // Global search
+  search
+    .command('<query>')
+    .description('Search contacts, deals, and activities')
+    .option('-t, --type <type>', 'Filter by entity type (contact, deal, activity)')
+    .option('--json', 'Output as JSON')
+    .option('--limit <number>', 'Limit results per type', '10')
+    .action(async (query, options) => {
+      if (!query || query.length < 2) {
+        printError('Search query must be at least 2 characters');
+        process.exit(1);
+      }
+
+      const spinner = new Spinner(`Searching for "${query}"...`).start();
+      await new Promise((r) => setTimeout(r, 300));
+
+      const results: SearchResult[] = [];
+      const q = query.toLowerCase();
+      const limit = parseInt(options.limit);
+
+      // Search contacts
+      if (!options.type || options.type === 'contact') {
+        const contacts = await getContacts();
+        for (const contact of contacts) {
+          const matches: { field: string; value: string }[] = [];
+
+          // Check name
+          if (contact.name.toLowerCase().includes(q)) {
+            matches.push({ field: 'name', value: contact.name });
+          }
+
+          // Check emails
+          for (const email of contact.emails) {
+            if (email.email.toLowerCase().includes(q)) {
+              matches.push({ field: 'email', value: email.email });
+            }
+          }
+
+          // Check company
+          if (contact.company?.toLowerCase().includes(q)) {
+            matches.push({ field: 'company', value: contact.company });
+          }
+
+          // Check tags
+          for (const tag of contact.tags) {
+            if (tag.toLowerCase().includes(q)) {
+              matches.push({ field: 'tag', value: tag });
+            }
+          }
+
+          if (matches.length > 0) {
+            results.push({
+              type: 'contact',
+              id: contact.id,
+              title: contact.name,
+              subtitle: contact.company || contact.emails[0]?.email || 'No details',
+              matchField: matches[0].field,
+              matchValue: matches[0].value,
+            });
+          }
+
+          if (results.filter((r) => r.type === 'contact').length >= limit) break;
+        }
+      }
+
+      // Search deals
+      if (!options.type || options.type === 'deal') {
+        const deals = await getDeals();
+        for (const deal of deals) {
+          const matches: { field: string; value: string }[] = [];
+
+          // Check title
+          if (deal.title.toLowerCase().includes(q)) {
+            matches.push({ field: 'title', value: deal.title });
+          }
+
+          // Check notes
+          if (deal.notes?.toLowerCase().includes(q)) {
+            matches.push({ field: 'notes', value: truncate(deal.notes, 50) });
+          }
+
+          // Check tags
+          for (const tag of deal.tags) {
+            if (tag.toLowerCase().includes(q)) {
+              matches.push({ field: 'tag', value: tag });
+            }
+          }
+
+          if (matches.length > 0) {
+            results.push({
+              type: 'deal',
+              id: deal.id,
+              title: deal.title,
+              subtitle: `${formatCurrency(deal.value, deal.currency)} - ${deal.stage}`,
+              matchField: matches[0].field,
+              matchValue: matches[0].value,
+            });
+          }
+
+          if (results.filter((r) => r.type === 'deal').length >= limit) break;
+        }
+      }
+
+      // Search activities
+      if (!options.type || options.type === 'activity') {
+        const activities = await getActivities();
+        for (const activity of activities) {
+          const matches: { field: string; value: string }[] = [];
+
+          // Check title
+          if (activity.title.toLowerCase().includes(q)) {
+            matches.push({ field: 'title', value: activity.title });
+          }
+
+          // Check description
+          if (activity.description?.toLowerCase().includes(q)) {
+            matches.push({ field: 'description', value: truncate(activity.description, 50) });
+          }
+
+          if (matches.length > 0) {
+            results.push({
+              type: 'activity',
+              id: activity.id,
+              title: activity.title,
+              subtitle: `${activity.type} - ${formatRelativeTime(activity.timestamp)}`,
+              matchField: matches[0].field,
+              matchValue: matches[0].value,
+            });
+          }
+
+          if (results.filter((r) => r.type === 'activity').length >= limit) break;
+        }
+      }
+
+      spinner.succeed(`Found ${results.length} results`);
+
+      if (options.json) {
+        printJSON(results);
+        return;
+      }
+
+      if (results.length === 0) {
+        printWarning(`No results found for "${query}"`);
+        return;
+      }
+
+      // Group by type
+      const byType = results.reduce(
+        (acc, r) => {
+          if (!acc[r.type]) acc[r.type] = [];
+          acc[r.type].push(r);
+          return acc;
+        },
+        {} as Record<string, SearchResult[]>
+      );
+
+      // Display contacts
+      if (byType.contact?.length) {
+        console.log();
+        console.log(output.bold(`\u{1F464} Contacts (${byType.contact.length})`));
+        printDivider('-');
+
+        printTable(byType.contact, [
+          { key: 'id', header: 'ID', width: 8, format: (v) => truncate(String(v), 8) },
+          { key: 'title', header: 'Name', width: 25 },
+          { key: 'subtitle', header: 'Details', width: 30, format: (v) => truncate(String(v), 30) },
+          {
+            key: 'matchField',
+            header: 'Match',
+            format: (v, row) => `${v}: ${(row as SearchResult).matchValue}`,
+          },
+        ]);
+      }
+
+      // Display deals
+      if (byType.deal?.length) {
+        console.log();
+        console.log(output.bold(`\u{1F4B0} Deals (${byType.deal.length})`));
+        printDivider('-');
+
+        printTable(byType.deal, [
+          { key: 'id', header: 'ID', width: 8, format: (v) => truncate(String(v), 8) },
+          { key: 'title', header: 'Title', width: 25, format: (v) => truncate(String(v), 25) },
+          { key: 'subtitle', header: 'Value/Stage', width: 30, format: (v) => truncate(String(v), 30) },
+          {
+            key: 'matchField',
+            header: 'Match',
+            format: (v, row) => `${v}: ${(row as SearchResult).matchValue}`,
+          },
+        ]);
+      }
+
+      // Display activities
+      if (byType.activity?.length) {
+        console.log();
+        console.log(output.bold(`\u{1F4DD} Activities (${byType.activity.length})`));
+        printDivider('-');
+
+        printTable(byType.activity, [
+          { key: 'id', header: 'ID', width: 8, format: (v) => truncate(String(v), 8) },
+          { key: 'title', header: 'Title', width: 30, format: (v) => truncate(String(v), 30) },
+          { key: 'subtitle', header: 'When', width: 20 },
+          {
+            key: 'matchField',
+            header: 'Match',
+            format: (v, row) => `${v}: ${(row as SearchResult).matchValue}`,
+          },
+        ]);
+      }
+
+      console.log();
+    });
+
+  // Quick search (alias)
+  search
+    .command('quick <query>')
+    .description('Quick search with minimal output')
+    .action(async (query) => {
+      const results: SearchResult[] = [];
+      const q = query.toLowerCase();
+
+      // Quick contact search
+      const contacts = await getContacts();
+      for (const contact of contacts) {
+        if (contact.name.toLowerCase().includes(q)) {
+          results.push({
+            type: 'contact',
+            id: contact.id,
+            title: contact.name,
+            subtitle: contact.emails[0]?.email || '',
+          });
+          if (results.length >= 5) break;
+        }
+      }
+
+      // Quick deal search
+      const deals = await getDeals();
+      for (const deal of deals) {
+        if (deal.title.toLowerCase().includes(q)) {
+          results.push({
+            type: 'deal',
+            id: deal.id,
+            title: deal.title,
+            subtitle: formatCurrency(deal.value, deal.currency),
+          });
+          if (results.length >= 10) break;
+        }
+      }
+
+      if (results.length === 0) {
+        printWarning('No quick results');
+        return;
+      }
+
+      for (const r of results) {
+        const icon = r.type === 'contact' ? '\u{1F464}' : '\u{1F4B0}';
+        console.log(`${icon} ${output.bold(r.id.slice(0, 8))} ${r.title} ${output.dim(r.subtitle)}`);
+      }
+    });
+
+  // Recent items
+  search
+    .command('recent')
+    .description('Show recent items')
+    .option('-t, --type <type>', 'Filter by type (contact, deal, activity)')
+    .option('--limit <number>', 'Limit results', '10')
+    .action(async (options) => {
+      const limit = parseInt(options.limit);
+      const results: SearchResult[] = [];
+
+      // Get recent contacts
+      if (!options.type || options.type === 'contact') {
+        const contacts = (await getContacts())
+          .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+          .slice(0, limit);
+
+        for (const c of contacts) {
+          results.push({
+            type: 'contact',
+            id: c.id,
+            title: c.name,
+            subtitle: `Updated ${formatRelativeTime(c.updatedAt)}`,
+          });
+        }
+      }
+
+      // Get recent deals
+      if (!options.type || options.type === 'deal') {
+        const deals = (await getDeals())
+          .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+          .slice(0, limit);
+
+        for (const d of deals) {
+          results.push({
+            type: 'deal',
+            id: d.id,
+            title: d.title,
+            subtitle: `${formatStatus(d.stage)} - Updated ${formatRelativeTime(d.updatedAt)}`,
+          });
+        }
+      }
+
+      // Get recent activities
+      if (!options.type || options.type === 'activity') {
+        const activities = (await getActivities())
+          .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+          .slice(0, limit);
+
+        for (const a of activities) {
+          results.push({
+            type: 'activity',
+            id: a.id,
+            title: a.title,
+            subtitle: `${a.type} - ${formatRelativeTime(a.timestamp)}`,
+          });
+        }
+      }
+
+      if (results.length === 0) {
+        printWarning('No recent items');
+        return;
+      }
+
+      printHeader('Recent Items');
+
+      for (const r of results) {
+        const icons: Record<string, string> = {
+          contact: '\u{1F464}',
+          deal: '\u{1F4B0}',
+          activity: '\u{1F4DD}',
+        };
+        const icon = icons[r.type];
+        console.log(
+          `${icon} ${output.dim(r.type.padEnd(8))} ${output.bold(truncate(r.id, 8))} ${r.title}`
+        );
+        console.log(`  ${output.dim(r.subtitle)}`);
+      }
+
+      console.log();
+    });
+}

package/src/cli/index.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env bun
+/**
+ * CRM CLI Entry Point
+ *
+ * Terminal-based CLI for CRM operations.
+ */
+
+import { Command } from 'commander';
+import {
+  printError,
+  printHeader,
+  output,
+} from './utils/output.js';
+import { loadConfig, applyEnvOverrides, initConfig } from './utils/config.js';
+import { registerContactCommands } from './commands/contacts.js';
+import { registerDealCommands } from './commands/deals.js';
+import { registerActivityCommands } from './commands/activities.js';
+import { registerMediaCommands } from './commands/media.js';
+import { registerSearchCommands } from './commands/search.js';
+import { registerREPLCommand } from './repl.js';
+
+// Package version (would be read from package.json in production)
+const VERSION = '1.0.0';
+
+/**
+ * Create and configure the CLI program
+ */
+function createProgram(): Command {
+  const program = new Command();
+
+  // Program metadata
+  program
+    .name('crm')
+    .description('Terminal-based CRM CLI')
+    .version(VERSION, '-v, --version', 'Show version')
+    .helpOption('-h, --help', 'Show help');
+
+  // Global options
+  program
+    .option('--json', 'Output as JSON')
+    .option('--no-color', 'Disable colored output')
+    .option('--api <url>', 'API endpoint URL');
+
+  // Register command modules
+  registerContactCommands(program);
+  registerDealCommands(program);
+  registerActivityCommands(program);
+  registerMediaCommands(program);
+  registerSearchCommands(program);
+  registerREPLCommand(program);
+
+  // Config command
+  program
+    .command('config')
+    .description('Manage CLI configuration')
+    .argument('[action]', 'Action (show, init, location)')
+    .action(async (action = 'show') => {
+      const { displayConfig, initConfig, getConfigLocation } = await import(
+        './utils/config.js'
+      );
+
+      switch (action) {
+        case 'init':
+          await initConfig();
+          break;
+        case 'location':
+          console.log(`\nConfig file: ${getConfigLocation()}\n`);
+          break;
+        case 'show':
+        default:
+          displayConfig();
+      }
+    });
+
+  // Init command (alias)
+  program
+    .command('init')
+    .description('Initialize CLI configuration')
+    .action(async () => {
+      const { initConfig } = await import('./utils/config.js');
+      await initConfig();
+    });
+
+  // Status command
+  program
+    .command('status')
+    .description('Show CRM status overview')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const { printTable, printJSON, formatCurrency } = await import(
+        './utils/output.js'
+      );
+
+      // Mock data (would come from API)
+      const status = {
+        contacts: { total: 156, leads: 45, customers: 89 },
+        deals: {
+          total: 34,
+          pipeline: 245000,
+          won: 89000,
+          weighted: 156000,
+        },
+        activities: { today: 12, thisWeek: 67 },
+      };
+
+      if (options.json) {
+        printJSON(status);
+        return;
+      }
+
+      printHeader('CRM Status');
+
+      console.log(output.bold('\u{1F464} Contacts'));
+      console.log(`  Total: ${status.contacts.total}`);
+      console.log(`  Leads: ${status.contacts.leads}`);
+      console.log(`  Customers: ${status.contacts.customers}`);
+      console.log();
+
+      console.log(output.bold('\u{1F4B0} Deals'));
+      console.log(`  Total: ${status.deals.total}`);
+      console.log(`  Pipeline Value: ${formatCurrency(status.deals.pipeline)}`);
+      console.log(`  Won This Month: ${formatCurrency(status.deals.won)}`);
+      console.log(`  Weighted Pipeline: ${formatCurrency(status.deals.weighted)}`);
+      console.log();
+
+      console.log(output.bold('\u{1F4DD} Activities'));
+      console.log(`  Today: ${status.activities.today}`);
+      console.log(`  This Week: ${status.activities.thisWeek}`);
+      console.log();
+    });
+
+  // Quick commands
+  program
+    .command('ls')
+    .description('List contacts (alias for contacts list)')
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(process.argv.indexOf('ls') + 1);
+      await program.parseAsync(['contacts', 'list', ...args], { from: 'user' });
+    });
+
+  program
+    .command('new')
+    .description('Create new entity')
+    .argument('<type>', 'Entity type (contact, deal, activity)')
+    .action(async (type) => {
+      switch (type) {
+        case 'contact':
+          await program.parseAsync(['contacts', 'create'], { from: 'user' });
+          break;
+        case 'deal':
+          await program.parseAsync(['deals', 'create'], { from: 'user' });
+          break;
+        case 'activity':
+          await program.parseAsync(['activities', 'create'], { from: 'user' });
+          break;
+        default:
+          printError(`Unknown entity type: ${type}`);
+          console.log('Valid types: contact, deal, activity');
+      }
+    });
+
+  return program;
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+  // Load and apply configuration
+  let config = loadConfig();
+  config = applyEnvOverrides(config);
+
+  // Create program
+  const program = createProgram();
+
+  // Handle unknown commands
+  program.on('command:*', (operands) => {
+    printError(`Unknown command: ${operands[0]}`);
+    console.log(`Run ${output.info('crm --help')} for available commands.`);
+    process.exit(1);
+  });
+
+  // Parse arguments
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('An unexpected error occurred');
+    }
+    process.exit(1);
+  }
+}
+
+// Run main
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});
+
+export { createProgram };