@indemn/cli 1.0.0

package/src/cli/functions.ts

@@ -0,0 +1,330 @@
+import { Command } from 'commander';
+import ora from 'ora';
+import { IndemnClient } from '../sdk/client.js';
+import { FunctionsSDK } from '../sdk/functions.js';
+import { formatTable, printJson, printError, printSuccess, confirm } from './utils/output.js';
+
+export function registerFunctionCommands(program: Command): void {
+  const functions = program.command('functions').description('Manage agent functions/tools');
+
+  functions
+    .command('list')
+    .argument('<agent-id>', 'Agent ID')
+    .description('List functions for an agent')
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', 'Limit number of results')
+    .option('--page <n>', 'Page number (use with --limit)')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Fetching functions...').start();
+
+        let funcs = await sdk.listFunctions(agentId);
+        spinner.stop();
+
+        if (options.page && options.limit) {
+          const page = parseInt(options.page, 10);
+          const limit = parseInt(options.limit, 10);
+          funcs = funcs.slice((page - 1) * limit, page * limit);
+        } else if (options.limit) {
+          funcs = funcs.slice(0, parseInt(options.limit, 10));
+        }
+
+        if (options.json) {
+          printJson(funcs);
+          return;
+        }
+
+        if (funcs.length === 0) {
+          console.log('No functions found for this agent.');
+          return;
+        }
+
+        const rows = funcs.map((f) => [
+          f._id,
+          f.name || '',
+          f.type || '',
+          f.description || '',
+        ]);
+
+        console.log(formatTable(['ID', 'Name', 'Type', 'Description'], rows));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('create')
+    .argument('<agent-id>', 'Agent ID')
+    .description('Create a function for an agent')
+    .requiredOption('--type <type>', 'Function type')
+    .option('--name <name>', 'Function name')
+    .option('--description <description>', 'Function description')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Creating function...').start();
+
+        const func = await sdk.createFunction(agentId, {
+          type: options.type,
+          name: options.name,
+          description: options.description,
+        });
+        spinner.stop();
+
+        printSuccess(`Function created: ${func._id}`);
+        console.log(`  Name: ${func.name || '(none)'}`);
+        console.log(`  Type: ${func.type}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('update')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .description('Update a function')
+    .option('--name <name>', 'Function name')
+    .option('--description <description>', 'Function description')
+    .action(async (agentId: string, funcId: string, options) => {
+      try {
+        const input: Record<string, unknown> = {};
+        if (options.name) input.name = options.name;
+        if (options.description) input.description = options.description;
+
+        if (Object.keys(input).length === 0) {
+          printError('No update options provided. Use --name or --description.');
+          process.exit(1);
+        }
+
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Updating function...').start();
+
+        await sdk.updateFunction(agentId, funcId, input);
+        spinner.stop();
+
+        printSuccess(`Function ${funcId} updated.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('delete')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .description('Delete a function')
+    .action(async (agentId: string, funcId: string) => {
+      try {
+        const confirmed = await confirm(`Delete function ${funcId}? This cannot be undone.`);
+        if (!confirmed) {
+          console.log('Cancelled.');
+          return;
+        }
+
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Deleting function...').start();
+
+        await sdk.deleteFunction(agentId, funcId);
+        spinner.stop();
+
+        printSuccess(`Function ${funcId} deleted.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('test')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .description('Test a function')
+    .option('--json', 'Output as JSON')
+    .action(async (agentId: string, funcId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Testing function...').start();
+
+        const result = await sdk.testFunction(agentId, funcId);
+        spinner.stop();
+
+        if (options.json) {
+          printJson(result);
+        } else {
+          printSuccess('Function test completed:');
+          printJson(result);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('export')
+    .argument('<agent-id>', 'Agent ID')
+    .description('Export all functions for an agent')
+    .option('--json', 'Output as JSON')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Exporting functions...').start();
+
+        const result = await sdk.exportFunctions(agentId);
+        spinner.stop();
+
+        if (options.json) {
+          printJson(result);
+        } else {
+          printSuccess('Functions exported:');
+          printJson(result);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  functions
+    .command('import')
+    .argument('<agent-id>', 'Agent ID')
+    .description('Import functions from a URL')
+    .requiredOption('--url <url>', 'URL to import from')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Importing functions...').start();
+
+        const result = await sdk.importFunctions(agentId, options.url);
+        spinner.stop();
+
+        printSuccess('Functions imported successfully.');
+        printJson(result);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  const params = functions.command('params').description('Manage function parameters');
+
+  params
+    .command('list')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .description('List parameters for a function')
+    .option('--json', 'Output as JSON')
+    .action(async (agentId: string, funcId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Fetching parameters...').start();
+        const parameters = await sdk.listParameters(agentId, funcId);
+        spinner.stop();
+        if (options.json) { printJson(parameters); return; }
+        if (parameters.length === 0) { console.log('No parameters found.'); return; }
+        const rows = parameters.map((p) => [p._id || '', p.name, p.type, p.description || '', String(p.required || false)]);
+        console.log(formatTable(['ID', 'Name', 'Type', 'Description', 'Required'], rows));
+      } catch (err) { printError(err); process.exit(1); }
+    });
+
+  params
+    .command('add')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .description('Add a parameter to a function')
+    .requiredOption('--name <name>', 'Parameter name')
+    .requiredOption('--type <type>', 'Parameter type (e.g. string, number, boolean)')
+    .option('--description <desc>', 'Parameter description')
+    .option('--required', 'Mark as required')
+    .action(async (agentId: string, funcId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Adding parameter...').start();
+        const result = await sdk.addParameter(agentId, funcId, {
+          name: options.name, type: options.type,
+          description: options.description, required: options.required || false,
+        });
+        spinner.stop();
+        // Server returns array of upserted params; extract the first one
+        const param = Array.isArray(result) ? result[0] : result;
+        printSuccess(`Parameter added: ${param._id || param.name}`);
+      } catch (err) { printError(err); process.exit(1); }
+    });
+
+  params
+    .command('update')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .argument('<param-id>', 'Parameter ID')
+    .description('Update a function parameter')
+    .option('--name <name>', 'Parameter name')
+    .option('--type <type>', 'Parameter type')
+    .option('--description <desc>', 'Parameter description')
+    .option('--required', 'Mark as required')
+    .action(async (agentId: string, funcId: string, paramId: string, options) => {
+      try {
+        const input: Record<string, unknown> = {};
+        if (options.name) input.name = options.name;
+        if (options.type) input.type = options.type;
+        if (options.description) input.description = options.description;
+        if (options.required !== undefined) input.required = options.required;
+        if (Object.keys(input).length === 0) { printError('No options provided.'); process.exit(1); }
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Updating parameter...').start();
+        await sdk.updateParameter(agentId, funcId, paramId, input);
+        spinner.stop();
+        printSuccess(`Parameter ${paramId} updated.`);
+      } catch (err) { printError(err); process.exit(1); }
+    });
+
+  params
+    .command('delete')
+    .argument('<agent-id>', 'Agent ID')
+    .argument('<func-id>', 'Function ID')
+    .argument('<param-id>', 'Parameter ID')
+    .description('Delete a function parameter')
+    .action(async (agentId: string, funcId: string, paramId: string) => {
+      try {
+        const confirmed = await confirm(`Delete parameter ${paramId}?`);
+        if (!confirmed) { console.log('Cancelled.'); return; }
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Deleting parameter...').start();
+        await sdk.deleteParameter(agentId, funcId, paramId);
+        spinner.stop();
+        printSuccess(`Parameter ${paramId} deleted.`);
+      } catch (err) { printError(err); process.exit(1); }
+    });
+
+  // Master functions
+  functions
+    .command('master-list')
+    .description('List available master function templates')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new FunctionsSDK(client);
+        const spinner = ora('Fetching master functions...').start();
+        const result = await sdk.listMasterFunctions();
+        spinner.stop();
+        if (options.json) { printJson(result); return; }
+        printJson(result);
+      } catch (err) { printError(err); process.exit(1); }
+    });
+}

package/src/cli/index.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerAuthCommands } from './auth.js';
+import { registerAgentCommands } from './agents.js';
+import { registerConfigCommands } from './config.js';
+import { registerFunctionCommands } from './functions.js';
+import { registerKBCommands } from './kb.js';
+import { registerEvalCommands } from './eval.js';
+import { registerChatCommand } from './chat.js';
+
+const program = new Command();
+
+program
+  .name('indemn')
+  .description('CLI for managing Indemn AI agents')
+  .version('1.0.0');
+
+program.option('--env <environment>', 'Environment (dev or production)');
+
+// Hook to set environment before any command runs
+program.hook('preAction', (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.env) {
+    process.env.INDEMN_ENV = opts.env;
+  }
+});
+
+// Register all command groups
+registerAuthCommands(program);
+registerAgentCommands(program);
+registerConfigCommands(program);
+registerFunctionCommands(program);
+registerKBCommands(program);
+registerEvalCommands(program);
+registerChatCommand(program);
+
+// MCP serve command
+const mcp = program.command('mcp').description('MCP server commands');
+
+mcp
+  .command('serve')
+  .description('Start MCP server')
+  .action(async () => {
+    const { startServer } = await import('../mcp/server.js');
+    await startServer();
+  });
+
+// Models command
+program
+  .command('models')
+  .description('List available LLM models')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    const { IndemnClient } = await import('../sdk/client.js');
+    const { FunctionsSDK } = await import('../sdk/functions.js');
+    const ora = (await import('ora')).default;
+    const { printJson, printError } = await import('./utils/output.js');
+    try {
+      const client = new IndemnClient();
+      const sdk = new FunctionsSDK(client);
+      const spinner = ora('Fetching models...').start();
+      const models = await sdk.listLLMModels();
+      spinner.stop();
+      printJson(models);
+    } catch (err) { printError(err); process.exit(1); }
+  });
+
+program.parse();