@memnexus-ai/cli 0.1.0

package/src/commands/apikeys.ts

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { listApiKeys, createApiKey, deleteApiKey } from '@memnexus-ai/mx-typescript-sdk';
+import { getApiOptions } from '../lib/api-client';
+import { handleError } from '../lib/errors';
+import { printOutput } from '../lib/formatters';
+import { OutputFormat } from '../types';
+
+/**
+ * Register API key management commands
+ * @param program - Commander program instance
+ */
+export function registerApikeyCommands(program: Command): void {
+  const apikeys = program.command('apikeys').description('Manage API keys');
+
+  /**
+   * mx apikeys list [options]
+   * List API keys (metadata only, never show actual keys)
+   */
+  apikeys
+    .command('list')
+    .description('List API keys')
+    .option('--page <number>', 'Page number', '0')
+    .option('--limit <number>', 'Results per page', '20')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const result = await listApiKeys({
+          ...getApiOptions(),
+        });
+
+        const apiKeys = (result.data as any)?.data || (result.data as any) || [];
+
+        if (options.format === 'table' || !options.format) {
+          const tableData = (Array.isArray(apiKeys) ? apiKeys : []).map((k: any) => ({
+            id: k.id,
+            label: k.label || k.name || 'N/A',
+            status: k.status || 'active',
+            createdAt: k.createdAt ? new Date(k.createdAt).toLocaleDateString() : 'N/A',
+            lastUsed: k.lastUsed ? new Date(k.lastUsed).toLocaleDateString() : 'Never',
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'label', 'status', 'createdAt', 'lastUsed'],
+            maxColumnWidth: 20,
+          });
+
+          console.log(chalk.gray(`\nTotal: ${tableData.length} API keys`));
+        } else {
+          printOutput(result.data, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Note: There's no getApiKeyById endpoint in the API, only list
+  // Removed the 'get <id>' command as it's not supported by the API
+
+  /**
+   * mx apikeys create [options]
+   * Create a new API key (show value ONCE on creation)
+   */
+  apikeys
+    .command('create')
+    .description('Create API key')
+    .option('--label <label>', 'Key label (optional)')
+    .option('--expires-at <date>', 'Expiration date (ISO 8601 format, optional)')
+    .action(async (options) => {
+      try {
+        const spinner = ora('Creating API key...').start();
+
+        const result = await createApiKey({
+          ...getApiOptions(),
+          body: {
+            label: options.label,
+            expiresAt: options.expiresAt,
+          },
+        });
+
+        spinner.succeed('API key created successfully');
+
+        const apiKey = result.data as any;
+        if (apiKey) {
+          console.log(chalk.green(`✓ Created API key`));
+          console.log(
+            chalk.yellow(
+              '\n⚠️  IMPORTANT: Save this key securely. You will not be able to see it again.\n'
+            )
+          );
+          console.log(chalk.cyan(`Key: ${apiKey.key || apiKey.value || apiKey.id}`));
+          console.log(chalk.gray(`\nMetadata:`));
+          const metadata = { ...apiKey };
+          delete metadata.key;
+          delete metadata.value;
+          printOutput(metadata, 'json');
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx apikeys delete <id> [options]
+   * Delete an API key
+   */
+  apikeys
+    .command('delete <id>')
+    .description('Delete API key')
+    .option('--force', 'Skip confirmation')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.force) {
+          const answer = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: chalk.red(`Delete API key ${id}? This cannot be undone.`),
+              default: false,
+            },
+          ]);
+
+          if (!answer.confirm) {
+            console.log(chalk.gray('Delete cancelled'));
+            return;
+          }
+        }
+
+        const spinner = ora('Deleting API key...').start();
+
+        await deleteApiKey({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        spinner.succeed('API key deleted successfully');
+        console.log(chalk.green(`✓ Deleted API key: ${id}`));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/artifacts.ts

@@ -0,0 +1,296 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  listArtifacts,
+  getArtifactById,
+  createArtifact,
+  updateArtifact,
+  deleteArtifact,
+} from '@memnexus-ai/mx-typescript-sdk';
+import { getApiOptions } from '../lib/api-client';
+import { handleError } from '../lib/errors';
+import { printOutput } from '../lib/formatters';
+import { OutputFormat } from '../types';
+
+/**
+ * Register artifact management commands
+ * @param program - Commander program instance
+ */
+export function registerArtifactsCommands(program: Command): void {
+  const artifacts = program.command('artifacts').description('Manage artifacts');
+
+  /**
+   * mx artifacts list [options]
+   * List artifacts with pagination
+   */
+  artifacts
+    .command('list')
+    .description('List artifacts')
+    .option('--page <number>', 'Page number', '0')
+    .option('--limit <number>', 'Results per page', '20')
+    .option('--context-id <id>', 'Filter by context')
+    .option('--type <type>', 'Filter by artifact type')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const page = parseInt(options.page, 10);
+        const limit = parseInt(options.limit, 10);
+        const offset = page * limit;
+
+        const result = await listArtifacts({
+          ...getApiOptions(),
+          query: {
+            limit,
+            offset,
+            type: options.type,
+          },
+        });
+
+        const responseData = result.data as any;
+
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((a: any) => ({
+            id: a.id,
+            name: a.name || 'N/A',
+            type: a.type || 'N/A',
+            size: a.size || 0,
+            createdAt: new Date(a.createdAt).toLocaleDateString(),
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'name', 'type', 'size', 'createdAt'],
+            maxColumnWidth: 20,
+          });
+
+          const pagination = responseData?.pagination;
+          if (pagination) {
+            console.log(
+              chalk.gray(
+                `\nShowing ${pagination.offset + 1}-${
+                  pagination.offset + (responseData?.data?.length || 0)
+                } (Page ${page + 1})`
+              )
+            );
+          }
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx artifacts get <id>
+   * Get artifact details
+   */
+  artifacts
+    .command('get <id>')
+    .description('Get artifact details')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getArtifactById({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx artifacts create [options]
+   * Create a new artifact
+   */
+  artifacts
+    .command('create')
+    .description('Create artifact')
+    .option('--name <name>', 'Artifact name')
+    .option('--type <type>', 'Artifact type')
+    .option('--context-id <id>', 'Context ID')
+    .option('--data <json>', 'Artifact data as JSON')
+    .option('--metadata <json>', 'Artifact metadata as JSON')
+    .option('--interactive', 'Interactive mode')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        let payload: any = {};
+
+        if (options.interactive || !options.name || !options.type) {
+          // Interactive mode
+          const answers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'name',
+              message: 'Artifact name:',
+              default: options.name,
+              validate: (input: string) => input.trim().length > 0 || 'Name is required',
+            },
+            {
+              type: 'input',
+              name: 'type',
+              message: 'Artifact type:',
+              default: options.type,
+              validate: (input: string) => input.trim().length > 0 || 'Type is required',
+            },
+            {
+              type: 'input',
+              name: 'contextId',
+              message: 'Context ID (optional):',
+              default: options.contextId,
+            },
+            {
+              type: 'input',
+              name: 'data',
+              message: 'Artifact data as JSON (optional):',
+              default: options.data,
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) return true;
+                try {
+                  JSON.parse(input);
+                  return true;
+                } catch (e) {
+                  return 'Invalid JSON format';
+                }
+              },
+            },
+            {
+              type: 'input',
+              name: 'metadata',
+              message: 'Artifact metadata as JSON (optional):',
+              default: options.metadata,
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) return true;
+                try {
+                  JSON.parse(input);
+                  return true;
+                } catch (e) {
+                  return 'Invalid JSON format';
+                }
+              },
+            },
+          ]);
+
+          payload = {
+            name: answers.name,
+            type: answers.type,
+            contextId: answers.contextId || undefined,
+          };
+
+          if (answers.data && answers.data.trim().length > 0) {
+            payload.data = JSON.parse(answers.data);
+          }
+          if (answers.metadata && answers.metadata.trim().length > 0) {
+            payload.metadata = JSON.parse(answers.metadata);
+          }
+        } else {
+          // Direct mode
+          payload = {
+            name: options.name,
+            type: options.type,
+            contextId: options.contextId,
+          };
+
+          if (options.data) payload.data = JSON.parse(options.data);
+          if (options.metadata) payload.metadata = JSON.parse(options.metadata);
+        }
+
+        const spinner = ora('Creating artifact...').start();
+
+        const result = await createArtifact({
+          ...getApiOptions(),
+          body: payload,
+        });
+
+        spinner.succeed('Artifact created successfully');
+
+        const artifactData = result.data as any;
+        console.log(chalk.green(`✓ Created artifact: ${artifactData?.id}`));
+        printOutput(artifactData, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx artifacts update <id> [options]
+   * Update an artifact
+   */
+  artifacts
+    .command('update <id>')
+    .description('Update artifact')
+    .option('--name <name>', 'Updated name')
+    .option('--data <json>', 'Updated data')
+    .option('--metadata <json>', 'Updated metadata')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.name && !options.data && !options.metadata) {
+          console.log(chalk.red('Error: At least one option is required'));
+          return;
+        }
+
+        const updates: any = {};
+
+        if (options.name) updates.name = options.name;
+        if (options.data) updates.data = JSON.parse(options.data);
+        if (options.metadata) updates.metadata = JSON.parse(options.metadata);
+
+        const result = await updateArtifact({
+          ...getApiOptions(),
+          path: { id },
+          body: updates,
+        });
+
+        console.log(chalk.green('✓ Artifact updated successfully'));
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx artifacts delete <id> [options]
+   * Delete an artifact
+   */
+  artifacts
+    .command('delete <id>')
+    .description('Delete artifact')
+    .option('--force', 'Skip confirmation')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.force) {
+          const answer = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Delete artifact ${id}?`,
+              default: false,
+            },
+          ]);
+
+          if (!answer.confirm) {
+            console.log(chalk.gray('Delete cancelled'));
+            return;
+          }
+        }
+
+        const spinner = ora('Deleting artifact...').start();
+
+        await deleteArtifact({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        spinner.succeed('Artifact deleted successfully');
+        console.log(chalk.green(`✓ Deleted artifact: ${id}`));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/auth.ts

@@ -0,0 +1,122 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { storeApiKey, removeApiKey, getApiKeyStatus } from '../lib/auth';
+import { config } from '../lib/config';
+import { handleError } from '../lib/errors';
+
+/**
+ * Register authentication commands
+ * @param program - Commander program instance
+ */
+export function registerAuthCommands(program: Command): void {
+  const auth = program.command('auth').description('Manage authentication and API keys');
+
+  /**
+   * mx auth login
+   * Configure API key for authentication
+   */
+  auth
+    .command('login')
+    .description('Configure API key for authentication')
+    .option('--api-key <key>', 'API key to store')
+    .option('--interactive', 'Prompt for API key (mask input)')
+    .action(async (options) => {
+      try {
+        let apiKey: string;
+
+        if (options.apiKey) {
+          // Direct API key provided
+          apiKey = options.apiKey;
+        } else {
+          // Interactive mode - prompt for API key
+          const answers = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'apiKey',
+              message: 'Enter your API key:',
+              mask: '*',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'API key cannot be empty';
+                }
+                if (input.length < 10) {
+                  return 'API key seems too short. Please check and try again.';
+                }
+                return true;
+              },
+            },
+          ]);
+          apiKey = answers.apiKey;
+        }
+
+        // Store the API key
+        storeApiKey(apiKey);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx auth logout
+   * Remove stored credentials
+   */
+  auth
+    .command('logout')
+    .description('Remove stored credentials')
+    .action(async () => {
+      try {
+        removeApiKey();
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx auth status
+   * Show current authentication status
+   */
+  auth
+    .command('status')
+    .description('Show current authentication status')
+    .action(async () => {
+      try {
+        const status = getApiKeyStatus();
+        const apiUrl = config.getApiUrl();
+        const outputFormat = config.getFormat();
+
+        const table = new Table({
+          head: [chalk.cyan('Property'), chalk.cyan('Value')],
+          colWidths: [30, 70],
+          wordWrap: true,
+        });
+
+        // Authentication status
+        let authStatus: string;
+        if (status.configured) {
+          if (status.source === 'env') {
+            authStatus = chalk.green('✓ Configured (via environment)');
+          } else {
+            authStatus = chalk.green('✓ Configured (via config file)');
+          }
+        } else {
+          authStatus = chalk.red('✗ Not configured');
+        }
+
+        table.push(
+          ['Authentication', authStatus],
+          ['API URL', apiUrl],
+          ['Output Format', outputFormat]
+        );
+
+        console.log(table.toString());
+
+        if (!status.configured) {
+          console.log(chalk.yellow('\nTo configure authentication, run: mx auth login'));
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}