@equinor/fusion-framework-cli-plugin-ai-index 2.0.1 → 2.1.0

package/src/create-command.ts

@@ -0,0 +1,218 @@
+import { type Command, createCommand, createOption } from 'commander';
+
+import { loadFusionAIConfig, setupFramework } from '@equinor/fusion-framework-cli-plugin-ai-base';
+import {
+  withOptions as withAiOptions,
+  type AiOptions,
+} from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+
+import type { FusionAIConfigWithIndex } from './config.js';
+import { zodToAzureFields } from './utils/zod-to-azure-fields.js';
+import { resolveEmbeddingDimensions } from './utils/embedding-dimensions.js';
+
+/**
+ * CLI command: `ai index create`
+ *
+ * Generate and preview the Azure AI Search index schema derived from the
+ * Zod-based schema definition in the fusion-ai config.
+ *
+ * Reads the `index.schema` configuration, converts the Zod shape into
+ * Azure AI Search field definitions, and combines them with the base
+ * fields (`id`, `content`, `content_vector`, `metadata`) to produce
+ * the full index schema.
+ *
+ * Usage:
+ *   $ ffc ai index create [options]
+ *
+ * Options:
+ *   --config <config>  Path to a config file (default: fusion-ai.config)
+ *   --dry-run          Preview the schema without creating the index
+ *
+ * Examples:
+ *   $ ffc ai index create --dry-run
+ *   $ ffc ai index create --config fusion-ai.config.eds.ts --dry-run
+ */
+const _command = createCommand('create')
+  .description('Create an Azure AI Search index from the config schema definition')
+  .addOption(createOption('--config <config>', 'Path to a config file').default('fusion-ai.config'))
+  .addOption(
+    createOption('--dry-run', 'Preview the index schema without creating it').default(false),
+  )
+  .action(async function (
+    this: Command,
+    commandOptions: AiOptions & { config: string; dryRun: boolean },
+  ) {
+    const config = await loadFusionAIConfig<FusionAIConfigWithIndex>(commandOptions.config, {
+      baseDir: process.cwd(),
+    });
+
+    const indexConfig = config.index;
+    if (!indexConfig?.schema) {
+      console.error(
+        '❌ No schema defined in config. Add a `schema` property to `index` using defineIndexSchema().',
+      );
+      process.exit(1);
+    }
+
+    // Resolve index name from config
+    const indexName = indexConfig.name;
+
+    if (!indexName) {
+      console.error('❌ Index name is required. Set `name` in the index config.');
+      process.exit(1);
+    }
+
+    // Convert Zod shape to Azure AI Search field definitions
+    const schemaFields = zodToAzureFields(indexConfig.schema.shape);
+
+    // Guard against schema fields that collide with reserved base-schema names
+    const reservedFieldNames = ['id', 'content', 'content_vector', 'metadata'] as const;
+    const conflictingSchemaFields = schemaFields
+      .map((field) => field.name)
+      .filter((name) => reservedFieldNames.includes(name as (typeof reservedFieldNames)[number]));
+
+    if (conflictingSchemaFields.length > 0) {
+      const conflicts = [...new Set(conflictingSchemaFields)].sort().join(', ');
+      console.error(
+        `❌ Schema fields use reserved names: ${conflicts}. Reserved field names are: ${reservedFieldNames.join(', ')}. Rename these fields in \`index.schema\`.`,
+      );
+      process.exit(1);
+    }
+
+    // Resolve embedding vector dimensions from the model name or explicit config
+    const model = indexConfig.model ?? 'text-embedding-3-large';
+    let dimensions: number;
+    try {
+      dimensions = resolveEmbeddingDimensions(model, indexConfig.embedding?.dimensions);
+    } catch (error) {
+      console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+
+    // Base Azure AI Search fields that every index requires
+    const baseFields = [
+      {
+        name: 'id',
+        type: 'Edm.String' as const,
+        key: true,
+        filterable: true,
+        sortable: false,
+        facetable: false,
+        searchable: false,
+      },
+      {
+        name: 'content',
+        type: 'Edm.String' as const,
+        filterable: false,
+        sortable: false,
+        facetable: false,
+        searchable: true,
+      },
+      {
+        name: 'content_vector',
+        type: 'Collection(Edm.Single)' as const,
+        filterable: false,
+        sortable: false,
+        facetable: false,
+        searchable: true,
+        dimensions,
+        vectorSearchProfile: 'default-vector-profile',
+      },
+      {
+        name: 'metadata',
+        type: 'Edm.ComplexType' as const,
+        fields: [
+          {
+            name: 'source',
+            type: 'Edm.String' as const,
+            filterable: true,
+            sortable: false,
+            facetable: false,
+            searchable: false,
+          },
+          {
+            name: 'attributes',
+            type: 'Collection(Edm.ComplexType)' as const,
+            fields: [
+              {
+                name: 'key',
+                type: 'Edm.String' as const,
+                filterable: true,
+                sortable: false,
+                facetable: false,
+                searchable: false,
+              },
+              {
+                name: 'value',
+                type: 'Edm.String' as const,
+                filterable: true,
+                sortable: false,
+                facetable: true,
+                searchable: false,
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const fullSchema = {
+      name: indexName,
+      fields: [...baseFields, ...schemaFields],
+      vectorSearch: {
+        algorithms: [{ name: 'default-hnsw', kind: 'hnsw' }],
+        profiles: [
+          {
+            name: 'default-vector-profile',
+            algorithm: 'default-hnsw',
+          },
+        ],
+      },
+    };
+
+    if (commandOptions.dryRun) {
+      console.log('📋 Index schema preview (dry-run):');
+      console.log(JSON.stringify(fullSchema, null, 2));
+      console.log(
+        `\n✅ Schema has ${baseFields.length} base fields + ${schemaFields.length} promoted fields`,
+      );
+      process.exit(0);
+    }
+
+    // Create or update the index via the Fusion AI proxy
+    const framework = await setupFramework(commandOptions);
+    const service = await framework.serviceDiscovery.resolveService('ai');
+    const baseUri = service.uri.replace(/\/+$/, '');
+    const scopes = service.scopes ?? service.defaultScopes ?? [];
+    const token = await framework.auth.acquireAccessToken({ request: { scopes } });
+
+    if (!token) {
+      console.error('❌ Failed to acquire access token for the AI service.');
+      process.exit(1);
+    }
+
+    const url = `${baseUri}/indexes/${encodeURIComponent(indexName)}?api-version=2024-07-01`;
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(fullSchema),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      console.error(`❌ Index creation failed (${response.status} ${response.statusText})`);
+      console.error(body);
+      process.exit(1);
+    }
+
+    console.log(`✅ Index "${indexName}" created/updated successfully.`);
+  });
+
+/**
+ * The `ai index create` command with inherited AI base options for
+ * authentication and service discovery.
+ */
+export const createIndexCommand: Command = withAiOptions(_command);

package/src/delete-command.options.ts

@@ -1,51 +1,21 @@
 import { z } from 'zod';
-
 import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
 
 /**
- * Zod schema for validating options of the `ai index remove` command.
- *
- * Extends the base AI options schema ({@link AiOptionsSchema}) to require
- * Azure Search credentials and the embedding deployment (needed to initialise
- * the vector store service for document removal).
+ * Zod schema for the `ai index remove` command.
  *
- * @example
- * ```ts
- * const validated = await DeleteOptionsSchema.parseAsync(rawOptions);
- * // validated.dryRun, validated.filter, validated.azureSearchEndpoint, etc.
- * ```
+ * Extends the base AI options schema making `indexName` required.
  */
 export const DeleteOptionsSchema = AiOptionsSchema.extend({
-  openaiEmbeddingDeployment: z
-    .string({ message: 'Embedding deployment name is required to initialise the vector store.' })
-    .min(1, 'Embedding deployment name must be a non-empty string.')
-    .describe('Azure OpenAI embedding deployment name'),
-  azureSearchEndpoint: z
-    .string({ message: 'Azure Search endpoint is required for deletion.' })
-    .url('Azure Search endpoint must be a valid URL.')
-    .min(1, 'Azure Search endpoint must be a non-empty string.')
-    .describe('Azure Search endpoint URL'),
-  azureSearchApiKey: z
-    .string({ message: 'Azure Search API key is required for deletion.' })
-    .min(1, 'Azure Search API key must be a non-empty string.')
-    .describe('Azure Search API key'),
-  azureSearchIndexName: z
-    .string({ message: 'Azure Search index name is required for deletion.' })
-    .min(1, 'Azure Search index name must be a non-empty string.')
-    .describe('Azure Search index name'),
-  dryRun: z
-    .boolean({ message: 'dryRun must be a boolean value.' })
-    .describe('Preview what would be deleted without making changes'),
+  indexName: z
+    .string({ message: 'Index name is required for deletion.' })
+    .min(1, 'Index name must be a non-empty string.'),
+  dryRun: z.boolean().describe('Preview what would be deleted without making changes'),
   filter: z
     .string()
-    .min(1, 'Filter expression must be a non-empty string.')
+    .min(1)
     .optional()
     .describe('Raw OData filter expression for selecting documents to delete'),
 }).describe('Command options for the delete command');
 
-/**
- * Validated options for the `ai index remove` command.
- *
- * Inferred from {@link DeleteOptionsSchema}.
- */
 export type DeleteOptions = z.infer<typeof DeleteOptionsSchema>;

package/src/delete-command.ts

@@ -1,7 +1,8 @@
 import { createCommand, createOption } from 'commander';
 
-import { setupFramework } from '@equinor/fusion-framework-cli-plugin-ai-base';
+import { loadFusionAIConfig, setupFramework } from '@equinor/fusion-framework-cli-plugin-ai-base';
 import { withOptions as withAiOptions } from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+import type { FusionAIConfigWithIndex } from './config.js';
 
 import { DeleteOptionsSchema, type DeleteOptions } from './delete-command.options.js';
 
@@ -59,6 +60,7 @@ function buildFilter(sources: string[], rawFilter?: string): string | undefined
  */
 const _command = createCommand('remove')
   .description('Remove documents from the search index by source path or OData filter')
+  .addOption(createOption('--config <config>', 'Path to a config file').default('fusion-ai.config'))
   .addOption(
     createOption('--dry-run', 'Preview matching documents without deleting them').default(false),
   )
@@ -69,6 +71,21 @@ const _command = createCommand('remove')
     ),
   )
   .argument('[source-paths...]', 'Relative file paths whose indexed chunks should be removed')
+  .hook('preAction', async (thisCommand) => {
+    const opts = thisCommand.opts();
+    const config = await loadFusionAIConfig<FusionAIConfigWithIndex>(
+      (opts.config as string) ?? 'fusion-ai.config',
+      { baseDir: process.cwd() },
+    );
+    const indexConfig = config.index ?? {};
+
+    if (indexConfig.name && !opts.indexName?.trim()) {
+      thisCommand.setOptionValue('indexName', indexConfig.name);
+    }
+    if (indexConfig.model && !opts.embedModel?.trim()) {
+      thisCommand.setOptionValue('embedModel', indexConfig.model);
+    }
+  })
   .action(async (sources: string[], commandOptions: DeleteOptions) => {
     const options = await DeleteOptionsSchema.parseAsync(commandOptions);
     const filterExpression = buildFilter(sources, options.filter);
@@ -95,7 +112,7 @@ const _command = createCommand('remove')
     }
 
     const framework = await setupFramework(options);
-    const vectorStoreService = framework.ai.getService('search', options.azureSearchIndexName);
+    const vectorStoreService = framework.ai.useIndex(options.indexName);
     await vectorStoreService.deleteDocuments({
       filter: { filterExpression },
     });

package/src/delete-index-command.ts

@@ -0,0 +1,121 @@
+import { type Command, createCommand, createOption } from 'commander';
+
+import { loadFusionAIConfig, setupFramework } from '@equinor/fusion-framework-cli-plugin-ai-base';
+import {
+  withOptions as withAiOptions,
+  type AiOptions,
+} from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+
+import type { FusionAIConfigWithIndex } from './config.js';
+
+/**
+ * CLI command: `ai index delete`
+ *
+ * Permanently deletes an Azure AI Search index and all its documents.
+ *
+ * This operation is irreversible — once deleted, the index definition and all
+ * indexed documents are permanently removed. Requires `Fusion.AI.Search.Manage`
+ * with a matching `index-name` scope, or the `Fusion.AI.Admin` role.
+ *
+ * Usage:
+ *   $ ffc ai index delete [options]
+ *
+ * Options:
+ *   --name <name>      Index name to delete (overrides config)
+ *   --config <config>  Path to a config file (default: fusion-ai.config)
+ *   --yes              Skip the confirmation prompt
+ *
+ * Examples:
+ *   $ ffc ai index delete
+ *   $ ffc ai index delete --name my-index --yes
+ *   $ ffc ai index delete --config fusion-ai.config.eds.ts
+ */
+const _command = createCommand('delete')
+  .description('Permanently delete an Azure AI Search index and all its documents')
+  .addOption(createOption('--name <name>', 'Index name to delete (overrides config)'))
+  .addOption(createOption('--config <config>', 'Path to a config file').default('fusion-ai.config'))
+  .addOption(createOption('--yes', 'Skip the confirmation prompt').default(false))
+  .hook('preAction', async (thisCommand) => {
+    const opts = thisCommand.opts();
+    const config = await loadFusionAIConfig<FusionAIConfigWithIndex>(
+      (opts.config as string) ?? 'fusion-ai.config',
+      { baseDir: process.cwd() },
+    );
+    const indexConfig = config.index ?? {};
+
+    // --name flag takes priority, then fall back to config
+    if (!opts.name?.trim() && indexConfig.name) {
+      thisCommand.setOptionValue('name', indexConfig.name);
+    }
+  })
+  .action(async function (
+    this: Command,
+    commandOptions: AiOptions & { config: string; yes: boolean; name?: string },
+  ) {
+    const indexName = commandOptions.name?.trim();
+
+    if (!indexName) {
+      console.error('❌ Index name is required. Set `name` in the index config or pass --name.');
+      process.exit(1);
+    }
+
+    console.log(`\n🗑️  Target index: ${indexName}`);
+
+    // Guard against accidental deletion — require explicit confirmation
+    if (!commandOptions.yes) {
+      const { createInterface } = await import('node:readline');
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise<string>((resolve) => {
+        rl.question(
+          `\n⚠️  This will permanently delete index "${indexName}" and ALL its documents.\n   Type the index name to confirm: `,
+          resolve,
+        );
+      });
+      rl.close();
+
+      if (answer.trim() !== indexName) {
+        console.log('❌ Confirmation did not match. Aborting.');
+        process.exit(1);
+      }
+    }
+
+    const framework = await setupFramework(commandOptions);
+    const service = await framework.serviceDiscovery.resolveService('ai');
+    const baseUri = service.uri.replace(/\/+$/, '');
+    const scopes = service.scopes ?? service.defaultScopes ?? [];
+    const token = await framework.auth.acquireAccessToken({ request: { scopes } });
+
+    if (!token) {
+      console.error('❌ Failed to acquire access token for the AI service.');
+      process.exit(1);
+    }
+
+    const url = `${baseUri}/indexes/${encodeURIComponent(indexName)}?api-version=2024-07-01`;
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    // 204 No Content = successful deletion, 404 = index doesn't exist
+    if (response.status === 404) {
+      console.error(`❌ Index "${indexName}" not found.`);
+      process.exit(1);
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      console.error(`❌ Index deletion failed (${response.status} ${response.statusText})`);
+      console.error(body);
+      process.exit(1);
+    }
+
+    console.log(`✅ Index "${indexName}" deleted successfully.`);
+  });
+
+/**
+ * The `ai index delete` command with inherited AI base options for
+ * authentication and service discovery.
+ */
+export const deleteIndexCommand: Command = withAiOptions(_command);

package/src/embed-command.ts

@@ -0,0 +1,44 @@
+import { createCommand } from 'commander';
+
+import { setupFramework } from '@equinor/fusion-framework-cli-plugin-ai-base';
+import {
+  withOptions as withAiOptions,
+  type AiOptions,
+} from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+
+type CommandOptions = AiOptions;
+
+/**
+ * CLI command: `ai index embed <text>`
+ *
+ * Embeds a single text string and prints the resulting vector.
+ * Useful for verifying the embeddings endpoint and model are reachable.
+ *
+ * @example
+ * ```sh
+ * ffc ai index embed "hello world"
+ * ```
+ */
+export const embedCommand = withAiOptions(
+  createCommand('embed')
+    .description('Embed a text string and print the resulting vector (for testing)')
+    .argument('<text>', 'Text to embed')
+    .action(async (text: string, options: CommandOptions) => {
+      const framework = await setupFramework(options);
+      const embedder = framework.ai.useEmbed(options.embedModel);
+
+      console.log(`Embedding model: ${options.embedModel ?? 'default'}`);
+      console.log(`Input: ${JSON.stringify(text)}`);
+
+      const vector = await embedder.embedQuery(text);
+
+      console.log(`Dimensions: ${vector.length}`);
+      console.log(
+        `Vector (first 8): [${vector
+          .slice(0, 8)
+          .map((v) => v.toFixed(6))
+          .join(', ')}, ...]`,
+      );
+    }),
+  { includeEmbedding: true },
+);

package/src/embeddings-command.options.ts

@@ -1,65 +1,27 @@
 import { z } from 'zod';
-
 import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
 
 /**
- * Zod schema for validating command options for the `ai index add` command.
- *
- * Extends the base AI options schema ({@link AiOptionsSchema}) with
- * add-specific options such as `--dry-run`, `--diff`, `--config`,
- * `--base-ref`, and `--clean`.
- *
- * Azure Search and embedding options that are optional in the base schema
- * become **required** because the add command always writes to a
- * vector store.
+ * Zod schema for the `ai index add` command.
  *
- * @example
- * ```ts
- * const validated = await CommandOptionsSchema.parseAsync(rawOptions);
- * // validated.dryRun, validated.azureSearchEndpoint, etc.
- * ```
+ * Extends the base AI options schema making `embedModel` and `indexName` required.
  */
 export const CommandOptionsSchema = AiOptionsSchema.extend({
-  // Override optional AI options to make them required for embeddings command
-  openaiEmbeddingDeployment: z
-    .string({ message: 'Embedding deployment name is required for embeddings command.' })
-    .min(1, 'Embedding deployment name must be a non-empty string.')
-    .describe('Azure OpenAI embedding deployment name'),
-  azureSearchEndpoint: z
-    .string({ message: 'Azure Search endpoint is required for embeddings command.' })
-    .url('Azure Search endpoint must be a valid URL.')
-    .min(1, 'Azure Search endpoint must be a non-empty string.')
-    .describe('Azure Search endpoint URL'),
-  azureSearchApiKey: z
-    .string({ message: 'Azure Search API key is required for embeddings command.' })
-    .min(1, 'Azure Search API key must be a non-empty string.')
-    .describe('Azure Search API key'),
-  azureSearchIndexName: z
-    .string({ message: 'Azure Search index name is required for embeddings command.' })
-    .min(1, 'Azure Search index name must be a non-empty string.')
-    .describe('Azure Search index name'),
+  embedModel: z
+    .string({ message: 'Embedding model name is required for the index add command.' })
+    .min(1, 'Embedding model name must be a non-empty string.'),
+  indexName: z
+    .string({ message: 'Index name is required for the index add command.' })
+    .min(1, 'Index name must be a non-empty string.'),
 
   // Embeddings-specific options
-  dryRun: z
-    .boolean({ message: 'dryRun must be a boolean value.' })
-    .describe('Show what would be processed without actually doing it'),
-  config: z
-    .string({ message: 'Config file path is required and must be a non-empty string.' })
-    .min(1, 'Config file path must be a non-empty string.')
-    .describe('Path to a config file'),
-  diff: z
-    .boolean({ message: 'diff must be a boolean value.' })
-    .describe('Process only changed files (workflow mode)'),
+  dryRun: z.boolean().describe('Show what would be processed without actually doing it'),
+  config: z.string().min(1).describe('Path to a config file'),
+  diff: z.boolean().describe('Process only changed files (workflow mode)'),
   baseRef: z.string().min(1).optional().describe('Git reference to compare against'),
   clean: z
-    .boolean({ message: 'clean must be a boolean value.' })
+    .boolean()
     .describe('Delete all existing documents from the vector store before processing'),
 }).describe('Command options for the embeddings command');
 
-/**
- * Validated options for the `ai index add` command.
- *
- * Inferred from {@link CommandOptionsSchema} and used as the single
- * source of truth for option types throughout the add/embeddings pipeline.
- */
 export type CommandOptions = z.infer<typeof CommandOptionsSchema>;

package/src/embeddings-command.ts

@@ -58,31 +58,31 @@ const _command = createCommand('add')
     ).default(false),
   )
   .argument('[glob-patterns...]', 'Glob patterns to match files (optional when using --diff)')
-  .action(async function (this: Command, patterns: string[], commandOptions: CommandOptions) {
-    // Load configuration before validation so config values can fill gaps
-    const preOptions = commandOptions as Record<string, unknown>;
+  .hook('preAction', async (thisCommand) => {
+    // Load config early so index name and embed model are available
+    // before the withOptions validation hook fires.
+    const opts = thisCommand.opts();
     const config = await loadFusionAIConfig<FusionAIConfigWithIndex>(
-      (preOptions.config as string) ?? 'fusion-ai.config',
+      (opts.config as string) ?? 'fusion-ai.config',
       { baseDir: process.cwd() },
     );
     const indexConfig = config.index ?? {};
 
-    // Config file values override env-var defaults but not explicit CLI flags.
-    // Commander merges env vars before the action runs, so we use
-    // getOptionValueSource to distinguish "user passed --flag" from "came from env".
-    const parentCommand = this.parent ?? this;
-    if (indexConfig.name) {
-      const source = parentCommand.getOptionValueSource('azureSearchIndexName');
-      if (source !== 'cli') {
-        preOptions.azureSearchIndexName = indexConfig.name;
-      }
+    if (indexConfig.name && !opts.indexName?.trim()) {
+      thisCommand.setOptionValue('indexName', indexConfig.name);
     }
-    if (indexConfig.model) {
-      const source = parentCommand.getOptionValueSource('openaiEmbeddingDeployment');
-      if (source !== 'cli') {
-        preOptions.openaiEmbeddingDeployment = indexConfig.model;
-      }
+    if (indexConfig.model && !opts.embedModel?.trim()) {
+      thisCommand.setOptionValue('embedModel', indexConfig.model);
     }
+  })
+  .action(async function (this: Command, patterns: string[], commandOptions: CommandOptions) {
+    // Config was already loaded in preAction; reload here for embed() usage.
+    const preOptions = commandOptions as Record<string, unknown>;
+    const config = await loadFusionAIConfig<FusionAIConfigWithIndex>(
+      (preOptions.config as string) ?? 'fusion-ai.config',
+      { baseDir: process.cwd() },
+    );
+    const indexConfig = config.index ?? {};
 
     const options = await CommandOptionsSchema.parseAsync(preOptions);
 

package/src/index.ts

@@ -4,22 +4,31 @@ import { registerAiPlugin as registerAiPluginBase } from '@equinor/fusion-framew
 import { command as addCommand } from './embeddings-command.js';
 import { deleteCommand as removeCommand } from './delete-command.js';
 import { searchCommand } from './search-command.js';
+import { embedCommand } from './embed-command.js';
+import { createIndexCommand } from './create-command.js';
+import { deleteIndexCommand } from './delete-index-command.js';
 
 export { FusionAIConfigWithIndex, IndexConfig } from './config.js';
+export { defineIndexSchema, IndexSchemaConfig } from './schema.js';
 
 /**
  * Parent command for the `ai index` group.
  *
- * Owns three subcommands:
+ * Owns subcommands:
  * - `add`    — index documents into the Azure AI Search vector store.
  * - `remove` — remove documents from the vector store.
  * - `search` — query the vector store for indexed documents.
+ * - `create` — create an index from the config schema definition.
+ * - `delete` — permanently delete an index and all its documents.
  */
 const indexCommand = createCommand('index')
-  .description('Manage the AI search index (add, search, remove)')
+  .description('Manage the AI search index (add, search, remove, create, delete)')
   .addCommand(addCommand)
   .addCommand(removeCommand)
-  .addCommand(searchCommand);
+  .addCommand(searchCommand)
+  .addCommand(embedCommand)
+  .addCommand(createIndexCommand)
+  .addCommand(deleteIndexCommand);
 
 /**
  * Registers the `ai index` command with the Fusion Framework CLI.