@memnexus-ai/cli 0.1.0

package/src/commands/facts.ts

@@ -0,0 +1,320 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import {
+  listFacts,
+  getFactById,
+  createFact,
+  updateFact,
+  deleteFact,
+  searchFacts,
+} 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 semantic facts management commands
+ * @param program - Commander program instance
+ */
+export function registerFactsCommands(program: Command): void {
+  const facts = program.command('facts').description('Manage semantic facts');
+
+  /**
+   * mx facts list [options]
+   * List facts with pagination
+   */
+  facts
+    .command('list')
+    .description('List facts')
+    .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 page = parseInt(options.page, 10);
+        const limit = parseInt(options.limit, 10);
+        const offset = page * limit;
+
+        const result = await listFacts({
+          ...getApiOptions(),
+          query: { limit, offset },
+        });
+
+        // Format for table display
+        if (options.format === 'table' || !options.format) {
+          const tableData = (result.data?.data || []).map((f: any) => ({
+            id: f.id,
+            subject: f.subject?.substring(0, 20) + (f.subject?.length > 20 ? '...' : ''),
+            predicate: f.predicate,
+            object: f.object?.substring(0, 20) + (f.object?.length > 20 ? '...' : ''),
+            confidence: f.confidence?.toFixed(2) || 'N/A',
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'subject', 'predicate', 'object', 'confidence'],
+            maxColumnWidth: 25,
+          });
+
+          console.log(
+            chalk.gray(
+              `\nShowing ${offset + 1}-${offset + (result.data?.data?.length || 0)} of ${
+                result.data?.count || 0
+              } (Page ${page + 1})`
+            )
+          );
+        } else {
+          printOutput(result.data, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx facts get <id>
+   * Get a specific fact by ID
+   */
+  facts
+    .command('get <id>')
+    .description('Get a specific fact')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getFactById({
+          ...getApiOptions(),
+          path: { id },
+        });
+        printOutput(result.data?.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx facts create [options]
+   * Create a new fact
+   */
+  facts
+    .command('create')
+    .description('Create a new fact')
+    .option('--subject <text>', 'Fact subject (entity name)')
+    .option('--predicate <text>', 'Relationship type')
+    .option('--object <text>', 'Fact object (related entity)')
+    .option('--confidence <number>', 'Confidence score (0-1)', '1.0')
+    .option('--memory-id <id>', 'Associated memory ID')
+    .option('--interactive', 'Interactive mode')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        let factData: any = {};
+
+        if (options.interactive || !options.subject || !options.predicate || !options.object) {
+          // Interactive mode
+          const answers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'subject',
+              message: 'Subject (entity name):',
+              default: options.subject,
+              validate: (input: string) => input.trim().length > 0 || 'Subject is required',
+            },
+            {
+              type: 'input',
+              name: 'predicate',
+              message: 'Predicate (relationship):',
+              default: options.predicate,
+              validate: (input: string) => input.trim().length > 0 || 'Predicate is required',
+            },
+            {
+              type: 'input',
+              name: 'object',
+              message: 'Object (related entity):',
+              default: options.object,
+              validate: (input: string) => input.trim().length > 0 || 'Object is required',
+            },
+            {
+              type: 'number',
+              name: 'confidence',
+              message: 'Confidence (0-1):',
+              default: parseFloat(options.confidence) || 1.0,
+              validate: (input: number) => {
+                if (input < 0 || input > 1) return 'Confidence must be between 0 and 1';
+                return true;
+              },
+            },
+            {
+              type: 'input',
+              name: 'memoryId',
+              message: 'Memory ID (optional):',
+              default: options.memoryId,
+            },
+          ]);
+
+          factData = {
+            subject: answers.subject,
+            predicate: answers.predicate,
+            object: answers.object,
+            confidence: answers.confidence,
+            memoryId: answers.memoryId || undefined,
+          };
+        } else {
+          // Direct mode
+          factData = {
+            subject: options.subject,
+            predicate: options.predicate,
+            object: options.object,
+            confidence: parseFloat(options.confidence),
+            memoryId: options.memoryId,
+          };
+        }
+
+        const result = await createFact({
+          ...getApiOptions(),
+          body: factData,
+        });
+
+        const fact = result.data?.data;
+        console.log(chalk.green(`✓ Fact created with ID: ${fact?.id}`));
+        printOutput(fact, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx facts update <id> [options]
+   * Update an existing fact
+   */
+  facts
+    .command('update <id>')
+    .description('Update an existing fact')
+    .option('--subject <text>', 'Updated subject')
+    .option('--predicate <text>', 'Updated predicate')
+    .option('--object <text>', 'Updated object')
+    .option('--confidence <number>', 'Updated confidence (0-1)')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const updates: any = {};
+
+        if (options.subject) updates.subject = options.subject;
+        if (options.predicate) updates.predicate = options.predicate;
+        if (options.object) updates.object = options.object;
+        if (options.confidence) {
+          const conf = parseFloat(options.confidence);
+          if (conf < 0 || conf > 1) {
+            console.log(chalk.red('Error: Confidence must be between 0 and 1'));
+            return;
+          }
+          updates.confidence = conf;
+        }
+
+        if (Object.keys(updates).length === 0) {
+          console.log(chalk.yellow('No updates provided. Use --help to see available options.'));
+          return;
+        }
+
+        const result = await updateFact({
+          ...getApiOptions(),
+          path: { id },
+          body: updates,
+        });
+
+        const fact = result.data?.data;
+        console.log(chalk.green(`✓ Fact ${id} updated successfully`));
+        printOutput(fact, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx facts delete <id>
+   * Delete a fact
+   */
+  facts
+    .command('delete <id>')
+    .description('Delete a fact')
+    .option('--force', 'Skip confirmation prompt')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.force) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Are you sure you want to delete fact ${id}?`,
+              default: false,
+            },
+          ]);
+
+          if (!answers.confirm) {
+            console.log(chalk.yellow('Delete cancelled'));
+            return;
+          }
+        }
+
+        await deleteFact({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        console.log(chalk.green(`✓ Fact ${id} deleted successfully`));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx facts search [options]
+   * Search facts
+   */
+  facts
+    .command('search')
+    .description('Search facts')
+    .option('--query <text>', 'Search query')
+    .option('--limit <number>', 'Maximum results', '20')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.query) {
+          console.log(chalk.red('Error: --query is required'));
+          return;
+        }
+
+        const result = await searchFacts({
+          ...getApiOptions(),
+          body: {
+            query: options.query,
+            limit: parseInt(options.limit, 10),
+          },
+        });
+
+        const searchData = result.data;
+
+        // Format for table display
+        if (options.format === 'table' || !options.format) {
+          const tableData = (searchData?.data || []).map((f: any) => ({
+            id: f.id || 'N/A',
+            subject: f.subject?.substring(0, 20) + (f.subject?.length > 20 ? '...' : ''),
+            predicate: f.predicate,
+            object: f.object?.substring(0, 20) + (f.object?.length > 20 ? '...' : ''),
+            confidence: f.confidence?.toFixed(2) || 'N/A',
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'subject', 'predicate', 'object', 'confidence'],
+            maxColumnWidth: 25,
+          });
+
+          console.log(chalk.gray(`\nFound ${searchData?.count || 0} results`));
+        } else {
+          printOutput(searchData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/graphrag.ts

@@ -0,0 +1,149 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  executeGraphRagQuery,
+  explainGraphRagQuery,
+  queryCommunities,
+} 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 GraphRAG query commands
+ * @param program - Commander program instance
+ */
+export function registerGraphragCommands(program: Command): void {
+  const graphrag = program.command('graphrag').description('Execute GraphRAG queries');
+
+  /**
+   * mx graphrag query [options]
+   * Execute a GraphRAG query
+   */
+  graphrag
+    .command('query')
+    .description('Execute GraphRAG query')
+    .option('--query <text>', 'Query text (required)')
+    .option('--context-id <id>', 'Context ID')
+    .option('--mode <mode>', 'Query mode (local|global|hybrid)', 'hybrid')
+    .option('--max-depth <number>', 'Graph traversal depth', '3')
+    .option('--limit <number>', 'Max results', '20')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.query) {
+          console.log(chalk.red('Error: --query is required'));
+          return;
+        }
+
+        const spinner = ora('Executing GraphRAG query...').start();
+
+        const result = await executeGraphRagQuery({
+          ...getApiOptions(),
+          body: {
+            query: options.query,
+            maxDepth: parseInt(options.maxDepth, 10),
+            limit: parseInt(options.limit, 10),
+          },
+        });
+
+        spinner.succeed('Query executed successfully');
+
+        const responseData = result.data as any;
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((r: any) => ({
+            id: r.id,
+            answer: r.answer?.substring(0, 50) + (r.answer?.length > 50 ? '...' : ''),
+            sources: r.sources?.length || 0,
+            confidence: r.confidence || 0,
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'answer', 'sources', 'confidence'],
+            maxColumnWidth: 25,
+          });
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx graphrag explain <result-id>
+   * Explain a query result
+   */
+  graphrag
+    .command('explain <result-id>')
+    .description('Explain query result')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (resultId: string, options) => {
+      try {
+        const spinner = ora('Generating explanation...').start();
+
+        const result = await explainGraphRagQuery({
+          ...getApiOptions(),
+          query: { queryId: resultId },
+        });
+
+        spinner.succeed('Explanation generated');
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx graphrag query-communities [options]
+   * Query at community level
+   */
+  graphrag
+    .command('query-communities')
+    .description('Query communities')
+    .option('--query <text>', 'Query text (required)')
+    .option('--context-id <id>', 'Context ID')
+    .option('--limit <number>', 'Max communities', '10')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.query) {
+          console.log(chalk.red('Error: --query is required'));
+          return;
+        }
+
+        const spinner = ora('Querying communities...').start();
+
+        const result = await queryCommunities({
+          ...getApiOptions(),
+          body: {
+            query: options.query,
+            limit: parseInt(options.limit, 10),
+          },
+        });
+
+        spinner.succeed('Community query completed');
+
+        const responseData = result.data as any;
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((c: any) => ({
+            communityId: c.communityId,
+            communityName: c.communityName || 'N/A',
+            answer: c.answer?.substring(0, 40) + (c.answer?.length > 40 ? '...' : ''),
+            confidence: c.confidence || 0,
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['communityId', 'communityName', 'answer', 'confidence'],
+            maxColumnWidth: 20,
+          });
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}