@salesforce/mcp 0.18.0 → 0.19.1-dev.0

package/lib/index.js

@@ -20,7 +20,6 @@ import { Command, Flags, ux } from '@oclif/core';
 import Cache from './utils/cache.js';
 import { Telemetry } from './telemetry.js';
 import { SfMcpServer } from './sf-mcp-server.js';
-import { maybeBuildIndex } from './utils/assets.js';
 import { registerToolsets } from './utils/registry-utils.js';
 import { Services } from './services.js';
 /**
@@ -140,7 +139,6 @@ You can also use special values to control access to orgs:
         }, {
             telemetry: this.telemetry,
         });
-        await maybeBuildIndex(this.config.dataDir);
         const services = new Services({ telemetry: this.telemetry, dataDir: this.config.dataDir });
         await registerToolsets(flags.toolsets ?? ['all'], flags['dynamic-tools'] ?? false, flags['allow-non-ga-tools'] ?? false, server, services);
         const transport = new StdioServerTransport();

package/lib/main-server-provider.d.ts

@@ -1,7 +1,3 @@
-import { McpProvider, McpTool, Services } from '@salesforce/mcp-provider-api';
+import { McpTool } from '@salesforce/mcp-provider-api';
 import { SfMcpServer } from './sf-mcp-server.js';
 export declare function createDynamicServerTools(server: SfMcpServer): McpTool[];
-export declare class MainServerProvider extends McpProvider {
-    getName(): string;
-    provideTools(services: Services): Promise<McpTool[]>;
-}

package/lib/main-server-provider.js

@@ -13,19 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { McpProvider } from '@salesforce/mcp-provider-api';
 import { EnableToolsMcpTool } from './tools/sf-enable-tools.js';
 import { ListToolsMcpTool } from './tools/sf-list-tools.js';
-import { SuggestCliCommandMcpTool } from './tools/sf-suggest-cli-command.js';
 export function createDynamicServerTools(server) {
     return [new EnableToolsMcpTool(server), new ListToolsMcpTool()];
 }
-export class MainServerProvider extends McpProvider {
-    getName() {
-        return 'MainServerProvider';
-    }
-    async provideTools(services) {
-        return Promise.resolve([new SuggestCliCommandMcpTool(services)]);
-    }
-}
 //# sourceMappingURL=main-server-provider.js.map

package/lib/registry.js

@@ -15,10 +15,8 @@
  */
 import { DxCoreMcpProvider } from '@salesforce/mcp-provider-dx-core';
 import { CodeAnalyzerMcpProvider } from '@salesforce/mcp-provider-code-analyzer';
-import { MainServerProvider } from './main-server-provider.js';
 /** -------- ADD McpProvider INSTANCES HERE ------------------------------------------------------------------------- */
 export const MCP_PROVIDER_REGISTRY = [
-    new MainServerProvider(),
     new DxCoreMcpProvider(),
     new CodeAnalyzerMcpProvider(),
     // Add new instances here

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/mcp",
-  "version": "0.18.0",
+  "version": "0.19.1-dev.0",
   "description": "MCP Server for interacting with Salesforce instances",
   "bin": {
     "sf-mcp-server": "bin/run.js"
@@ -42,7 +42,6 @@
     "package.json"
   ],
   "dependencies": {
-    "@huggingface/transformers": "^3.7.0",
     "@modelcontextprotocol/sdk": "^1.16.0",
     "@oclif/core": "^4.5.1",
     "@salesforce/agents": "^0.15.4",
@@ -50,13 +49,12 @@
     "@salesforce/core": "^8.18.0",
     "@salesforce/kit": "^3.1.6",
     "@salesforce/mcp-provider-api": "0.2.0",
-    "@salesforce/mcp-provider-dx-core": "0.2.0",
+    "@salesforce/mcp-provider-dx-core": "0.2.2",
     "@salesforce/mcp-provider-code-analyzer": "0.0.2",
     "@salesforce/source-deploy-retrieve": "^12.22.0",
     "@salesforce/source-tracking": "^7.4.8",
     "@salesforce/telemetry": "^6.1.0",
     "@salesforce/ts-types": "^2.0.11",
-    "faiss-node": "^0.5.1",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package/lib/scripts/build-index.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/scripts/build-index.js

@@ -1,124 +0,0 @@
-/*
- * Copyright 2025, Salesforce, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Args, Parser, ux } from '@oclif/core';
-import { pipeline } from '@huggingface/transformers';
-import faiss from 'faiss-node';
-import { createWeightedEmbeddingText } from './create-embedding-text.js';
-const normalizeCommandName = (command) => (command ?? '').split(':').join(' ');
-const main = async () => {
-    const { args: { outputDir }, } = await Parser.parse(process.argv.slice(2), {
-        args: {
-            outputDir: Args.string({
-                description: 'Directory to save the output files',
-                required: true,
-            }),
-        },
-    });
-    if (!outputDir) {
-        ux.stderr('Output directory not specified. Please provide a path as the first argument.');
-        process.exit(1);
-    }
-    // Define the output file paths
-    const commandsPath = path.join(outputDir, 'sf-commands.json');
-    const faissIndexPath = path.join(outputDir, 'commands-index.bin');
-    ux.stderr('Starting offline data preparation...');
-    // 1. Ensure output directory exists
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir);
-    }
-    // 2. Get Command Data from Salesforce CLI
-    ux.stderr('Fetching commands from sf CLI...');
-    const rawCommandsJson = execSync('sf commands --json').toString();
-    const rawCommands = JSON.parse(rawCommandsJson);
-    // 3. Process and Clean the Data
-    ux.stderr('Processing and cleaning command data...');
-    const commandsData = rawCommands.map((cmd, index) => ({
-        id: index, // Use our own sequential ID for FAISS
-        command: normalizeCommandName(cmd.id),
-        summary: cmd.summary ?? 'No summary available.',
-        description: cmd.description ?? 'No description available.',
-        examples: cmd.examples ?? [],
-        flags: Object.values(cmd.flags ?? {})
-            .filter((flag) => !flag.hidden)
-            .map((flag) => ({
-            name: flag.name,
-            summary: flag.summary ?? 'No summary available.',
-            description: flag.description ?? 'No description available.',
-            type: flag.type ?? 'string',
-            required: flag.required ?? false,
-            // @ts-expect-error because options doesn't exist on boolean flags
-            options: (flag.options ?? []),
-            // @ts-expect-error because multiple doesn't exist on boolean flags
-            multiple: !!flag.multiple,
-            dependsOn: flag.dependsOn,
-            exclusive: flag.exclusive,
-            atLeastOne: flag.atLeastOne,
-            exactlyOne: flag.exactlyOne,
-            relationships: flag.relationships,
-            default: flag.default,
-        })),
-        // Create a more descriptive text for better embedding quality
-        // This will be stripped from the final output sent to the LLM to save token count
-        embeddingText: createWeightedEmbeddingText({
-            command: normalizeCommandName(cmd.id),
-            summary: cmd.summary ?? '',
-            description: cmd.description ?? '',
-            examples: cmd.examples ?? [],
-        }),
-    }));
-    if (commandsData.length === 0) {
-        ux.stderr('No command data could be processed. Is `sf` CLI installed and working?');
-        return;
-    }
-    ux.stderr(`Processed ${commandsData.length} commands.`);
-    // 4. Generate Embeddings
-    ux.stderr('Loading embedding model... (This may take a moment)');
-    const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
-        dtype: 'fp32',
-    });
-    ux.stderr('Generating embeddings for all commands...');
-    const embeddings = await Promise.all(commandsData.map((cmd) => embedder(cmd.embeddingText, { pooling: 'mean', normalize: true })));
-    // The output tensor needs to be converted to a flat Float32Array for FAISS
-    const embeddingDimension = embeddings[0].dims[1];
-    const flattenedEmbeddings = new Float32Array(commandsData.length * embeddingDimension);
-    embeddings.forEach((tensor, i) => {
-        flattenedEmbeddings.set(tensor.data, i * embeddingDimension);
-    });
-    ux.stderr(`Generated embeddings with dimension: ${embeddingDimension}`);
-    // 5. Build and Save the FAISS Index
-    ux.stderr('Building FAISS index...');
-    const index = new faiss.IndexFlatL2(embeddingDimension);
-    // Convert Float32Array to regular array for faiss-node
-    const embeddingsArray = Array.from(flattenedEmbeddings);
-    index.add(embeddingsArray);
-    const vectorCount = index.ntotal();
-    ux.stderr(`FAISS index built with ${String(vectorCount)} vectors.`);
-    // Use the correct method name for faiss-node
-    index.write(faissIndexPath);
-    ux.stderr(`FAISS index saved to: ${faissIndexPath}`);
-    // 6. Save the Processed Command Data
-    fs.writeFileSync(commandsPath, JSON.stringify(commandsData, null, 2));
-    ux.stderr(`Command data saved to: ${commandsPath}`);
-    ux.stderr('Offline preparation complete!');
-};
-main().catch((error) => {
-    // eslint-disable-next-line no-console
-    console.error(error);
-});
-//# sourceMappingURL=build-index.js.map

package/lib/scripts/create-embedding-text.d.ts

@@ -1,29 +0,0 @@
-/**
- * Action words - verbs that describe what a command does
- * These should get the highest weight (3x) in embedding text
- */
-export declare const SF_ACTION_WORDS: readonly string[];
-/**
- * Domain words - nouns that represent Salesforce concepts and objects
- * These should get medium weight (2x) in embedding text
- */
-export declare const SF_DOMAIN_WORDS: readonly string[];
-/**
- * Modifier words - adjectives and adverbs that modify actions
- * These should get light weight (1.5x) in embedding text
- */
-export declare const SF_MODIFIER_WORDS: readonly string[];
-/**
- * Context words - structural terms that provide context
- * These should get normal weight (1x) in embedding text
- */
-export declare const SF_CONTEXT_WORDS: readonly string[];
-/**
- * Create weighted embedding text for a command
- */
-export declare function createWeightedEmbeddingText({ command, summary, description, examples, }: {
-    command: string;
-    summary: string;
-    description: string;
-    examples: string[];
-}): string;

package/lib/scripts/create-embedding-text.js

@@ -1,468 +0,0 @@
-/*
- * Copyright 2025, Salesforce, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Action words - verbs that describe what a command does
- * These should get the highest weight (3x) in embedding text
- */
-export const SF_ACTION_WORDS = [
-    // Core CRUD operations
-    'create',
-    'generate',
-    'delete',
-    'update',
-    'upsert',
-    'get',
-    'set',
-    'unset',
-    // Deployment & sync operations
-    'deploy',
-    'retrieve',
-    'push',
-    'pull',
-    'sync',
-    'convert',
-    'validate',
-    'preview',
-    // Execution operations
-    'run',
-    'execute',
-    'test',
-    'start',
-    'stop',
-    'resume',
-    'cancel',
-    'quick',
-    // Information operations
-    'list',
-    'display',
-    'show',
-    'describe',
-    'query',
-    'search',
-    'audit',
-    'check',
-    // Management operations
-    'assign',
-    'open',
-    'login',
-    'logout',
-    'install',
-    'uninstall',
-    'enable',
-    'disable',
-    'publish',
-    'report',
-    // Data operations
-    'import',
-    'export',
-    'bulk',
-    'tree',
-    'results',
-    // Package operations
-    'promote',
-    'demote',
-    'version',
-];
-/**
- * Domain words - nouns that represent Salesforce concepts and objects
- * These should get medium weight (2x) in embedding text
- */
-export const SF_DOMAIN_WORDS = [
-    // Core Salesforce concepts
-    'org',
-    'metadata',
-    'project',
-    'package',
-    'source',
-    'data',
-    'user',
-    'permission',
-    'permset',
-    'permsetlicense',
-    // Development concepts
-    'apex',
-    'flow',
-    'trigger',
-    'class',
-    'component',
-    'lwc',
-    'aura',
-    'lightning',
-    'visualforce',
-    'app',
-    'tab',
-    'field',
-    'object',
-    'record',
-    'sobject',
-    // Org types
-    'scratch',
-    'sandbox',
-    'production',
-    'devhub',
-    'shape',
-    'snapshot',
-    // Metadata types
-    'layout',
-    'workflow',
-    'validation',
-    'rule',
-    'profile',
-    'role',
-    'queue',
-    'group',
-    'territory',
-    'sharing',
-    // Testing & analysis
-    'test',
-    'coverage',
-    'log',
-    'debug',
-    'trace',
-    'analyzer',
-    'doctor',
-    // AI & Agents
-    'agent',
-    'bot',
-    'template',
-    'spec',
-    'topic',
-    'action',
-    'evaluation',
-    // Data management
-    'bulk',
-    'tree',
-    'query',
-    'soql',
-    'sosl',
-    'csv',
-    'json',
-    'xml',
-    // Package management
-    'managed',
-    'unlocked',
-    'unmanaged',
-    'installed',
-    'subscriber',
-    // Community & Experience
-    'community',
-    'experience',
-    'site',
-    'portal',
-    // Custom metadata
-    'cmdt',
-    'custom',
-    'standard',
-    // Development tools
-    'plugin',
-    'command',
-    'flag',
-    'config',
-    'alias',
-    'autocomplete',
-    'help',
-    'interactive',
-    // API & Integration
-    'api',
-    'rest',
-    'graphql',
-    'soap',
-    'request',
-    'response',
-    'endpoint',
-    // Analytics
-    'analytics',
-    'dashboard',
-    'report',
-    'dataset',
-    // DevOps & Pipeline
-    'pipeline',
-    'devops',
-    'branch',
-    'git',
-    'repository',
-    'manifest',
-    // File types
-    'file',
-    'directory',
-    'path',
-    'zip',
-    'archive',
-];
-/**
- * Modifier words - adjectives and adverbs that modify actions
- * These should get light weight (1.5x) in embedding text
- */
-export const SF_MODIFIER_WORDS = [
-    // Action modifiers
-    'quick',
-    'async',
-    'sync',
-    'force',
-    'dry',
-    'preview',
-    'validate',
-    'check',
-    'watch',
-    'tail',
-    'poll',
-    // Scope modifiers
-    'all',
-    'local',
-    'remote',
-    'global',
-    'default',
-    'target',
-    'source',
-    'current',
-    'recent',
-    'latest',
-    'specific',
-    // State modifiers
-    'active',
-    'inactive',
-    'enabled',
-    'disabled',
-    'tracked',
-    'untracked',
-    'deployed',
-    'pending',
-    'failed',
-    'successful',
-    // Type modifiers
-    'managed',
-    'unmanaged',
-    'unlocked',
-    'locked',
-    'protected',
-    'public',
-    'private',
-    'shared',
-    // Format modifiers
-    'formatted',
-    'raw',
-    'pretty',
-    'compact',
-    'verbose',
-    'concise',
-    'detailed',
-    'summary',
-];
-/**
- * Context words - structural terms that provide context
- * These should get normal weight (1x) in embedding text
- */
-export const SF_CONTEXT_WORDS = [
-    // Structural
-    'force',
-    'sf',
-    'sfdx',
-    'cli',
-    'salesforce',
-    // Directories
-    'app',
-    'main',
-    'default',
-    'classes',
-    'objects',
-    'layouts',
-    'tabs',
-    'flows',
-    'triggers',
-    'components',
-    'static',
-    'resources',
-    // File extensions (without dots)
-    'cls',
-    'trigger',
-    'page',
-    'component',
-    'app',
-    'evt',
-    'intf',
-    'cmp',
-    'design',
-    'svg',
-    'css',
-    'js',
-    'xml',
-    'meta',
-    // Common patterns
-    'scratch',
-    'def',
-    'definition',
-    'configuration',
-    'settings',
-    'preferences',
-    'options',
-    'parameters',
-    'arguments',
-    'flags',
-    'values',
-];
-/**
- * Synonym mappings for expanding keywords with related terms
- * This helps match user queries that use different but related terminology
- */
-const SYNONYM_MAP = {
-    // Action synonyms
-    deploy: ['deployment', 'deploying', 'push', 'upload', 'send'],
-    retrieve: ['pull', 'download', 'fetch', 'get', 'sync'],
-    list: ['show', 'display', 'enumerate', 'ls', 'view'],
-    create: ['make', 'generate', 'new', 'add', 'build'],
-    delete: ['remove', 'destroy', 'rm', 'drop', 'erase'],
-    update: ['modify', 'change', 'edit', 'alter', 'refresh'],
-    run: ['execute', 'start', 'launch', 'invoke'],
-    query: ['search', 'find', 'select', 'lookup'],
-    open: ['launch', 'start', 'view', 'access'],
-    login: ['authenticate', 'auth', 'signin', 'connect'],
-    logout: ['disconnect', 'signout', 'unauthenticate'],
-    install: ['add', 'setup', 'configure'],
-    uninstall: ['remove', 'delete', 'unsetup'],
-    convert: ['transform', 'migrate', 'change', 'translate'],
-    validate: ['verify', 'check', 'confirm', 'test'],
-    preview: ['view', 'show', 'display', 'check'],
-    report: ['status', 'info', 'summary', 'details'],
-    resume: ['continue', 'restart', 'proceed'],
-    cancel: ['stop', 'abort', 'terminate', 'halt'],
-    // Domain synonyms
-    org: ['organization', 'environment', 'instance', 'tenant'],
-    metadata: ['meta', 'components', 'definitions', 'config'],
-    scratch: ['dev', 'development', 'temp', 'temporary', 'trial'],
-    sandbox: ['test', 'staging', 'non-prod', 'development'],
-    production: ['prod', 'live', 'main', 'release'],
-    apex: ['code', 'classes', 'triggers', 'programming'],
-    flow: ['workflow', 'process', 'automation'],
-    component: ['comp', 'lwc', 'aura', 'element'],
-    lightning: ['lwc', 'aura', 'web-component'],
-    object: ['sobject', 'entity', 'table', 'record-type'],
-    field: ['column', 'attribute', 'property'],
-    record: ['row', 'data', 'entry', 'item'],
-    user: ['person', 'account', 'profile', 'identity'],
-    permission: ['access', 'rights', 'privileges', 'security'],
-    permset: ['permission-set', 'permissions', 'access-set'],
-    package: ['app', 'bundle', 'module', 'extension'],
-    source: ['code', 'files', 'project-files'],
-    data: ['records', 'information', 'content'],
-    test: ['testing', 'tests', 'verification', 'validation'],
-    log: ['logs', 'debug', 'trace', 'output'],
-    agent: ['bot', 'assistant', 'ai', 'chatbot'],
-    template: ['spec', 'blueprint', 'pattern', 'example'],
-    manifest: ['package-xml', 'config', 'definition'],
-    bulk: ['batch', 'mass', 'multiple', 'many'],
-    api: ['service', 'endpoint', 'interface', 'web-service'],
-    devhub: ['dev-hub', 'development-hub', 'hub'],
-    // Format synonyms
-    json: ['javascript-object-notation', 'data'],
-    xml: ['markup', 'config', 'meta'],
-    csv: ['comma-separated', 'spreadsheet', 'data'],
-    // Common user terms
-    setup: ['configure', 'install', 'create', 'initialize'],
-    config: ['configuration', 'settings', 'preferences'],
-    info: ['information', 'details', 'data', 'summary'],
-    help: ['assistance', 'documentation', 'guide', 'support'],
-};
-/**
- * Expand a list of keywords with their synonyms
- */
-function expandWithSynonyms(keywords) {
-    const expanded = new Set(keywords);
-    keywords.forEach((keyword) => {
-        const synonyms = SYNONYM_MAP[keyword];
-        if (synonyms) {
-            synonyms.forEach((synonym) => expanded.add(synonym));
-        }
-    });
-    return Array.from(expanded);
-}
-/**
- * Extract keywords from a command string and categorize them
- */
-function extractKeywords(command) {
-    const words = command
-        .toLowerCase()
-        .split(/[\s:-]+/)
-        .filter((word) => word.length > 0);
-    return {
-        actions: words.filter((word) => SF_ACTION_WORDS.includes(word)),
-        domains: words.filter((word) => SF_DOMAIN_WORDS.includes(word)),
-        modifiers: words.filter((word) => SF_MODIFIER_WORDS.includes(word)),
-        context: words.filter((word) => SF_CONTEXT_WORDS.includes(word)),
-    };
-}
-/**
- * Create weighted embedding text for a command
- */
-export function createWeightedEmbeddingText({ command, summary, description, examples, }) {
-    const keywords = extractKeywords(command);
-    // Expand keywords with synonyms for better matching
-    const expandedActions = expandWithSynonyms(keywords.actions);
-    const expandedDomains = expandWithSynonyms(keywords.domains);
-    const expandedModifiers = expandWithSynonyms(keywords.modifiers);
-    // Build weighted sections with cleaner formatting
-    const weightedSections = [];
-    // Primary actions (3x weight) - space-separated repetitions
-    if (keywords.actions.length > 0) {
-        const actionWords = keywords.actions.join(' ');
-        weightedSections.push(`${actionWords} ${actionWords} ${actionWords}`);
-        // Add synonyms (2x weight)
-        const synonyms = expandedActions.filter((word) => !keywords.actions.includes(word));
-        if (synonyms.length > 0) {
-            const synonymText = synonyms.join(' ');
-            weightedSections.push(`${synonymText} ${synonymText}`);
-        }
-    }
-    // Domain objects (2x weight) - space-separated repetitions
-    if (keywords.domains.length > 0) {
-        const domainWords = keywords.domains.join(' ');
-        weightedSections.push(`${domainWords} ${domainWords}`);
-        // Add synonyms (1x weight)
-        const synonyms = expandedDomains.filter((word) => !keywords.domains.includes(word));
-        if (synonyms.length > 0) {
-            weightedSections.push(synonyms.join(' '));
-        }
-    }
-    // Modifiers (1.5x weight - approximate with 1.5 repetitions)
-    if (keywords.modifiers.length > 0) {
-        const modifierWords = keywords.modifiers.join(' ');
-        weightedSections.push(`${modifierWords} ${modifierWords}`);
-        // Add modifier synonyms
-        const synonyms = expandedModifiers.filter((word) => !keywords.modifiers.includes(word));
-        if (synonyms.length > 0) {
-            weightedSections.push(synonyms.join(' '));
-        }
-    }
-    // Natural language expansion
-    if (keywords.actions.length > 0 && keywords.domains.length > 0) {
-        const primaryAction = keywords.actions[0];
-        const primaryDomain = keywords.domains[0];
-        // Core action-domain pairs
-        weightedSections.push(`${primaryAction} ${primaryDomain}`);
-        weightedSections.push(`how to ${primaryAction} ${primaryDomain}`);
-        // Add top synonym variations for better natural language matching
-        const actionSynonyms = SYNONYM_MAP[primaryAction];
-        const domainSynonyms = SYNONYM_MAP[primaryDomain];
-        if (actionSynonyms && actionSynonyms.length > 0) {
-            weightedSections.push(`${actionSynonyms[0]} ${primaryDomain}`);
-        }
-        if (domainSynonyms && domainSynonyms.length > 0) {
-            weightedSections.push(`${primaryAction} ${domainSynonyms[0]}`);
-        }
-    }
-    // Include natural content for semantic understanding
-    return `${weightedSections.join(' ')}\n\nCommand: ${command}\nSummary: ${summary}\n\nDescription: ${description}\n\nExamples:\n${examples?.join('\n') ?? 'No examples available'}`;
-}
-//# sourceMappingURL=create-embedding-text.js.map

package/lib/tools/sf-suggest-cli-command.d.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { McpTool, McpToolConfig, Toolset, Services, ReleaseState } from '@salesforce/mcp-provider-api';
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-/**
- * Suggest a Salesforce CLI (sf) command based on user input.
- */
-declare const suggestCliCommandParamsSchema: z.ZodObject<{
-    query: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-}, {
-    query: string;
-}>;
-type InputArgs = z.infer<typeof suggestCliCommandParamsSchema>;
-type InputArgsShape = typeof suggestCliCommandParamsSchema.shape;
-type OutputArgsShape = z.ZodRawShape;
-export declare class SuggestCliCommandMcpTool extends McpTool<InputArgsShape, OutputArgsShape> {
-    private readonly services;
-    constructor(services: Services);
-    getReleaseState(): ReleaseState;
-    getToolsets(): Toolset[];
-    getName(): string;
-    getConfig(): McpToolConfig<InputArgsShape, OutputArgsShape>;
-    exec(input: InputArgs): Promise<CallToolResult>;
-}
-export {};

package/lib/tools/sf-suggest-cli-command.js

@@ -1,120 +0,0 @@
-/*
- * Copyright 2025, Salesforce, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { z } from 'zod';
-import { McpTool, Toolset, ReleaseState } from '@salesforce/mcp-provider-api';
-import { getAssets } from '../utils/assets.js';
-/**
- * Suggest a Salesforce CLI (sf) command based on user input.
- */
-const suggestCliCommandParamsSchema = z.object({
-    query: z.string().describe('The natural language query to suggest an `sf` command'),
-});
-export class SuggestCliCommandMcpTool extends McpTool {
-    services;
-    constructor(services) {
-        super();
-        this.services = services;
-    }
-    getReleaseState() {
-        return ReleaseState.GA;
-    }
-    getToolsets() {
-        return [Toolset.CORE];
-    }
-    getName() {
-        return 'sf-suggest-cli-command';
-    }
-    getConfig() {
-        return {
-            title: 'Suggest CLI Command',
-            description: `Suggests an \`sf\` CLI command based on a natural language query. It finds relevant commands from a local index and uses an LLM to construct the final, precise command to fulfill the user's request.
-
-AGENT INSTRUCTIONS:
-Use this tool whenever a user:
-  - asks for guidance on how to use the Salesforce CLI (sf or sfdx)
-  - needs help with Salesforce CLI (sf or sfdx) command syntax
-  - wants to know what Salesforce CLI (sf or sfdx) command to run for a specific task
-  - asks questions like 'how do I...', 'what command...', or 'how to...' related to Salesforce development operations.
-NEVER use this tool for enabling Salesforce MCP tools (use sf-enable-tools instead).
-NEVER use this tool for listing available Salesforce MCP tools (use sf-list-tools instead).
-NEVER use this tool for understanding the Salesforce MCP server's capabilities.
-NEVER use this tool for understanding the input schema of a Salesforce MCP tool.`,
-            inputSchema: suggestCliCommandParamsSchema.shape,
-            outputSchema: undefined,
-            annotations: {
-                readOnlyHint: true,
-            },
-        };
-    }
-    async exec(input) {
-        const assets = await getAssets(this.services.getConfigService().getDataDir(), 'sf-commands.json', 'commands-index.bin');
-        // Embed the user query
-        const queryEmbedding = await assets.embedder(input.query, {
-            pooling: 'mean',
-            normalize: true,
-        });
-        // Perform Semantic Search (FAISS)
-        const searchResults = assets.index.search(
-        // Convert the embedding tensor data to a flat array of numbers
-        Array.from(queryEmbedding.data), 5);
-        const topCandidateIds = searchResults.labels.slice(0, 5);
-        const contextCommands = topCandidateIds.map((id) => {
-            const command = assets.data.find((c) => c.id === id);
-            // Remove the embedding text to avoid sending it to the LLM
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { embeddingText, ...commandWithoutEmbeddingText } = command;
-            return commandWithoutEmbeddingText;
-        });
-        contextCommands.forEach((command, index) => {
-            // eslint-disable-next-line no-console
-            console.error(`Command: ${command.command}, Score: ${searchResults.distances[index]}`);
-        });
-        const prompt = `System: You are a precise expert on the Salesforce CLI (sf). Your sole purpose is to construct a single, valid sf command based on the user's request and the Command Reference provided.
-- Base your answer STRICTLY on the user's request and the Command Reference.
-- If there is no command that matches the user's request, tell the user that you cannot find a command.
-- Do not use any flags or commands not listed in the reference.
-
-User Request:
-"${input.query}"
-
-Command Reference:
-${JSON.stringify(contextCommands, null, 2)}
-
-Notes about Flag Properties:
-- multiple: Flags that support multiple values should be specified with the '--flag value1 --flag value2' syntax.
-- dependsOn: If a flag depends on another flag, ensure that the dependent flag is included in the command.
-- atLeastOne: If a flag requires at least one of a set of flags, ensure that at least one of those flags is included in the command.
-- exactlyOne: If a flag requires exactly one of a set of flags, ensure that exactly one of those flags is included in the command.
-- exclusive: If a flag is exclusive with another flag, ensure that only one of those flags is included in the command.
-- required: If a flag is required, ensure that it is included in the command unless it has a default value.
-- relationships: If a flag has relationships with other flags, ensure that those relationships are respected in the command.
-- options: If a flag has options, ensure that one of those options is used
-
-
-Synthesize the single "sf" command that best fulfills the user's request.
-`;
-        return {
-            isError: false,
-            content: [
-                {
-                    type: 'text',
-                    text: prompt,
-                },
-            ],
-        };
-    }
-}
-//# sourceMappingURL=sf-suggest-cli-command.js.map

package/lib/utils/assets.d.ts

@@ -1,21 +0,0 @@
-import { FeatureExtractionPipeline } from '@huggingface/transformers';
-import faiss from 'faiss-node';
-type Assets<T> = {
-    data: T;
-    embedder: FeatureExtractionPipeline;
-    index: faiss.IndexFlatL2;
-};
-/**
- * Conditionally builds or rebuilds a FAISS index based on its existence and age.
- *
- * This function checks if a FAISS index file exists in the specified output directory.
- * If the index exists but is older than one week, it triggers a rebuild. If the index
- * doesn't exist, it initiates the initial build process. The build process can run as a
- * detached child process or in the same process depending on the detached parameter.
- *
- * @param indexPath - The path to the FAISS index file.
- * @param detached - Whether to run the build process detached (default: true)
- */
-export declare function maybeBuildIndex(indexPath: string, detached?: boolean): Promise<void>;
-export declare function getAssets<T>(dataDir: string, dataPath: string, indexPath: string): Promise<Assets<T>>;
-export {};

package/lib/utils/assets.js

@@ -1,116 +0,0 @@
-/*
- * Copyright 2025, Salesforce, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import fs from 'node:fs';
-import { resolve, join } from 'node:path';
-import { spawn } from 'node:child_process';
-import faiss from 'faiss-node';
-import { pipeline } from '@huggingface/transformers';
-import { ux } from '@oclif/core';
-/**
- * Conditionally builds or rebuilds a FAISS index based on its existence and age.
- *
- * This function checks if a FAISS index file exists in the specified output directory.
- * If the index exists but is older than one week, it triggers a rebuild. If the index
- * doesn't exist, it initiates the initial build process. The build process can run as a
- * detached child process or in the same process depending on the detached parameter.
- *
- * @param indexPath - The path to the FAISS index file.
- * @param detached - Whether to run the build process detached (default: true)
- */
-export async function maybeBuildIndex(indexPath, detached = true) {
-    try {
-        const stats = fs.statSync(indexPath);
-        const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
-        ux.stderr(`Checking FAISS index in ${indexPath}...`);
-        ux.stderr(`Last modified: ${stats.mtime.toString()}`);
-        if (stats.mtime < oneWeekAgo) {
-            ux.stderr(`FAISS index is more than 1 week old - rebuilding in ${indexPath}...`);
-            await spawnBuildScript(indexPath, detached);
-        }
-        else {
-            ux.stderr(`FAISS index is up to date in ${indexPath}. No rebuild needed.`);
-        }
-    }
-    catch (error) {
-        // File doesn't exist, so build the index
-        ux.stderr(`Building FAISS index in ${indexPath}...`);
-        await spawnBuildScript(indexPath, detached);
-    }
-}
-function spawnBuildScript(outputDir, detached) {
-    const scriptPath = resolve(import.meta.dirname, '..', 'scripts', 'build-index.js');
-    const args = [scriptPath, outputDir];
-    if (detached) {
-        spawn('node', args, {
-            detached: true,
-            stdio: 'ignore',
-        }).unref();
-        return Promise.resolve();
-    }
-    else {
-        return new Promise((res, reject) => {
-            const childProcess = spawn('node', args, {
-                stdio: 'inherit',
-            });
-            childProcess.on('close', (code) => {
-                if (code === 0) {
-                    res();
-                }
-                else {
-                    reject(new Error(`Build script exited with code ${code ?? 'UNKNOWN'}`));
-                }
-            });
-            childProcess.on('error', (error) => {
-                reject(error);
-            });
-        });
-    }
-}
-export async function getAssets(dataDir, dataPath, indexPath) {
-    const fullDataPath = join(dataDir, dataPath);
-    const fullIndexPath = join(dataDir, indexPath);
-    // Ensure the index is built or rebuilt if necessary
-    await maybeBuildIndex(fullIndexPath, false);
-    try {
-        await fs.promises.access(fullDataPath);
-    }
-    catch {
-        throw new Error(`Commands file not found at ${fullDataPath}. Please run maybeBuildIndex to build the index.`);
-    }
-    try {
-        await fs.promises.access(fullIndexPath);
-    }
-    catch {
-        throw new Error(`FAISS index not found at ${fullIndexPath}. Please run maybeBuildIndex to build the index.`);
-    }
-    try {
-        const dataRaw = await fs.promises.readFile(fullDataPath, 'utf-8');
-        const data = JSON.parse(dataRaw);
-        const index = faiss.IndexFlatL2.read(fullIndexPath);
-        const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
-            dtype: 'fp32',
-        });
-        return {
-            data,
-            index,
-            embedder,
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to load assets: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-//# sourceMappingURL=assets.js.map