@runflow-ai/cli 0.2.20 → 0.2.22

package/dist/commands/kb/kb.command.js

@@ -0,0 +1,627 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeBaseCommand = void 0;
+const nest_commander_1 = require("nest-commander");
+const prompts_1 = require("@clack/prompts");
+const config_1 = require("../../common/config");
+const api_client_1 = require("../../common/api-client");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const axios_1 = __importDefault(require("axios"));
+const config_2 = require("../../common/config");
+let KnowledgeBaseCommand = class KnowledgeBaseCommand extends nest_commander_1.CommandRunner {
+    async run(inputs, options) {
+        const [action, name, filePath] = inputs;
+        const actions = ['list', 'create', 'upload', 'status', 'delete', 'docs', 'remove-doc', 'search'];
+        if (!action) {
+            this.showHelp();
+            return;
+        }
+        if (!actions.includes(action)) {
+            console.log(chalk_1.default.red(`Unknown action: ${action}`));
+            this.showHelp();
+            return;
+        }
+        try {
+            const apiClient = (0, api_client_1.createApiClient)(options.api);
+            switch (action) {
+                case 'list':
+                    await this.listKnowledgeBases(apiClient);
+                    break;
+                case 'create':
+                    await this.createKnowledgeBase(apiClient, name, options);
+                    break;
+                case 'upload':
+                    if (!name || !filePath) {
+                        console.log(chalk_1.default.red('Usage: rf kb upload <kb-name> <file-or-directory>'));
+                        return;
+                    }
+                    await this.upload(apiClient, name, filePath, options);
+                    break;
+                case 'status':
+                    if (!name) {
+                        console.log(chalk_1.default.red('Usage: rf kb status <kb-name>'));
+                        return;
+                    }
+                    await this.getStatus(apiClient, name);
+                    break;
+                case 'delete':
+                    if (!name) {
+                        console.log(chalk_1.default.red('Usage: rf kb delete <kb-name>'));
+                        return;
+                    }
+                    await this.deleteKnowledgeBase(apiClient, name, options);
+                    break;
+                case 'docs':
+                    if (!name) {
+                        console.log(chalk_1.default.red('Usage: rf kb docs <kb-name>'));
+                        return;
+                    }
+                    await this.listDocuments(apiClient, name);
+                    break;
+                case 'remove-doc':
+                    if (!name || !filePath) {
+                        console.log(chalk_1.default.red('Usage: rf kb remove-doc <kb-name> <doc-id>'));
+                        return;
+                    }
+                    await this.removeDocument(apiClient, name, filePath, options);
+                    break;
+                case 'search':
+                    if (!name || !filePath) {
+                        console.log(chalk_1.default.red('Usage: rf kb search <kb-name> "<query>"'));
+                        return;
+                    }
+                    await this.search(apiClient, name, filePath);
+                    break;
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('Error: ' + (error.response?.data?.message || error.message)));
+        }
+    }
+    async interactiveMode(options) {
+        console.log('');
+        (0, prompts_1.intro)(chalk_1.default.cyan.bold('📚 Runflow Knowledge Bases'));
+        const s = (0, prompts_1.spinner)();
+        s.start('Fetching knowledge bases...');
+        const apiClient = (0, api_client_1.createApiClient)(options.api);
+        const res = await apiClient.get('/vector-stores');
+        const kbs = res.data.data || [];
+        s.stop(chalk_1.default.green(`✓ Found ${kbs.length} knowledge bases`));
+        if (kbs.length === 0) {
+            const createNew = await (0, prompts_1.confirm)({
+                message: 'No knowledge bases found. Create one now?',
+                initialValue: true,
+            });
+            if (createNew) {
+                await this.createKnowledgeBase(apiClient);
+            }
+            (0, prompts_1.outro)(chalk_1.default.gray('Done'));
+            return;
+        }
+        const choices = [
+            ...kbs.map((kb) => ({
+                value: kb.id,
+                label: kb.name,
+                hint: `${kb.documentCount || 0} documents`,
+            })),
+            { value: '__create__', label: '+ Create new', hint: 'Create a knowledge base' },
+        ];
+        const selectedId = await (0, prompts_1.select)({
+            message: 'Select a knowledge base:',
+            options: choices,
+        });
+        if (typeof selectedId === 'symbol') {
+            (0, prompts_1.outro)(chalk_1.default.gray('Cancelled'));
+            return;
+        }
+        if (selectedId === '__create__') {
+            await this.createKnowledgeBase(apiClient);
+            (0, prompts_1.outro)(chalk_1.default.green('✓ Knowledge base created'));
+            return;
+        }
+        const selectedKb = kbs.find((kb) => kb.id === selectedId);
+        const actionChoice = await (0, prompts_1.select)({
+            message: `What would you like to do with "${selectedKb.name}"?`,
+            options: [
+                { value: 'status', label: '📊 View stats' },
+                { value: 'upload-file', label: '📤 Upload file' },
+                { value: 'upload-dir', label: '📂 Upload directory' },
+                { value: 'docs', label: '📄 List documents' },
+                { value: 'search', label: '🔍 Search' },
+                { value: 'delete', label: '🗑️  Delete' },
+                { value: 'cancel', label: '❌ Cancel' },
+            ],
+        });
+        if (typeof actionChoice === 'symbol' || actionChoice === 'cancel') {
+            (0, prompts_1.outro)(chalk_1.default.gray('Cancelled'));
+            return;
+        }
+        switch (actionChoice) {
+            case 'status':
+                await this.getStatus(apiClient, selectedKb.name);
+                break;
+            case 'upload-file':
+                const filePath = await (0, prompts_1.text)({
+                    message: 'File path:',
+                    placeholder: './document.pdf',
+                    validate: (value) => {
+                        if (!value)
+                            return 'File path required';
+                        if (!fs.existsSync(value))
+                            return 'File not found';
+                        return undefined;
+                    },
+                });
+                if (typeof filePath === 'string') {
+                    await this.upload(apiClient, selectedKb.name, filePath);
+                }
+                break;
+            case 'upload-dir':
+                const dirPath = await (0, prompts_1.text)({
+                    message: 'Directory path:',
+                    placeholder: './docs',
+                    validate: (value) => {
+                        if (!value)
+                            return 'Directory path required';
+                        if (!fs.existsSync(value))
+                            return 'Directory not found';
+                        if (!fs.statSync(value).isDirectory())
+                            return 'Not a directory';
+                        return undefined;
+                    },
+                });
+                if (typeof dirPath === 'string') {
+                    await this.upload(apiClient, selectedKb.name, dirPath);
+                }
+                break;
+            case 'docs':
+                await this.listDocuments(apiClient, selectedKb.name);
+                break;
+            case 'search':
+                const query = await (0, prompts_1.text)({
+                    message: 'Search query:',
+                    placeholder: 'How to configure authentication?',
+                });
+                if (typeof query === 'string') {
+                    await this.search(apiClient, selectedKb.name, query);
+                }
+                break;
+            case 'delete':
+                await this.deleteKnowledgeBase(apiClient, selectedKb.name);
+                break;
+        }
+        (0, prompts_1.outro)(chalk_1.default.green('✓ Done'));
+    }
+    async listKnowledgeBases(apiClient) {
+        const res = await apiClient.get('/vector-stores');
+        const kbs = res.data.data || [];
+        console.log(chalk_1.default.cyan.bold(`\n📚 Knowledge Bases (${kbs.length} total)\n`));
+        if (kbs.length === 0) {
+            console.log(chalk_1.default.gray('  No knowledge bases found'));
+            console.log(chalk_1.default.gray('  Create one with: rf kb create\n'));
+            return;
+        }
+        kbs.forEach((kb) => {
+            console.log(chalk_1.default.white(`  ${kb.name}`));
+            console.log(chalk_1.default.gray(`    Documents: ${kb.documentCount || 0}`));
+            console.log(chalk_1.default.gray(`    Embedding: ${kb.embeddingConfig?.name || 'Unknown'}`));
+            console.log('');
+        });
+    }
+    async createKnowledgeBase(apiClient, name, options) {
+        let kbName = name;
+        if (options?.embedding && !kbName) {
+            console.log(chalk_1.default.red('Name required with --embedding'));
+            console.log(chalk_1.default.gray('Usage: rf kb create <name> --embedding <config-id-or-name>'));
+            return;
+        }
+        if (!kbName) {
+            const nameInput = await (0, prompts_1.text)({
+                message: 'Knowledge base name:',
+                placeholder: 'product-docs',
+                validate: (value) => {
+                    if (!value || !value.trim())
+                        return 'Name is required';
+                    if (!/^[a-z0-9-_]+$/i.test(value.trim())) {
+                        return 'Use only letters, numbers, hyphens, and underscores';
+                    }
+                    return undefined;
+                },
+            });
+            if (typeof nameInput === 'symbol')
+                return;
+            kbName = nameInput.trim();
+        }
+        console.log(chalk_1.default.gray('Fetching embedding configurations...'));
+        const configsRes = await apiClient.get('/vector-stores/embedding-configs');
+        const configs = configsRes.data.data || [];
+        if (configs.length === 0) {
+            console.log(chalk_1.default.red('No embedding configurations available'));
+            return;
+        }
+        let embeddingConfigId;
+        if (options?.embedding) {
+            const matchedConfig = configs.find((c) => c.id === options.embedding ||
+                c.name.toLowerCase() === options.embedding?.toLowerCase() ||
+                c.name.toLowerCase().includes(options.embedding?.toLowerCase() || ''));
+            if (!matchedConfig) {
+                console.log(chalk_1.default.red(`Embedding config not found: ${options.embedding}`));
+                console.log(chalk_1.default.gray('Available configs:'));
+                configs.forEach((c) => {
+                    console.log(chalk_1.default.gray(`  - ${c.name} (${c.id})`));
+                });
+                return;
+            }
+            embeddingConfigId = matchedConfig.id;
+            console.log(chalk_1.default.gray(`Using embedding: ${matchedConfig.name}`));
+        }
+        else {
+            const selectedConfigId = await (0, prompts_1.select)({
+                message: 'Choose embedding configuration:',
+                options: configs.map((c) => ({
+                    value: c.id,
+                    label: c.name,
+                    hint: `${c.provider} - ${c.model}`,
+                })),
+            });
+            if (typeof selectedConfigId === 'symbol')
+                return;
+            embeddingConfigId = selectedConfigId;
+        }
+        console.log(chalk_1.default.gray('Creating knowledge base...'));
+        await apiClient.post('/vector-stores', {
+            name: kbName,
+            embeddingConfigId,
+            type: 'KNOWLEDGE',
+            chunkSize: 1000,
+            chunkOverlap: 200,
+            chunkStrategy: 'recursive',
+        });
+        console.log(chalk_1.default.green('✓ Knowledge base created: ' + kbName));
+        console.log('');
+        console.log(chalk_1.default.cyan.bold('Use in your agent:'));
+        console.log(chalk_1.default.white(`  rag: {`));
+        console.log(chalk_1.default.white(`    vectorStore: '${kbName}',`));
+        console.log(chalk_1.default.white(`    autoSearch: true,`));
+        console.log(chalk_1.default.white(`  }`));
+        console.log('');
+    }
+    async upload(apiClient, kbName, targetPath, options) {
+        const stats = fs.statSync(targetPath);
+        if (stats.isDirectory()) {
+            await this.uploadDirectory(apiClient, kbName, targetPath, options);
+        }
+        else {
+            await this.uploadFile(apiClient, kbName, targetPath);
+        }
+    }
+    async uploadFile(apiClient, kbName, filePath) {
+        const s = (0, prompts_1.spinner)();
+        s.start(`Uploading ${path.basename(filePath)}...`);
+        try {
+            const { config } = (0, config_2.getValidatedConfig)();
+            const apiUrl = config.api || config_1.DEFAULT_API_URL;
+            const formData = new form_data_1.default();
+            formData.append('file', fs.createReadStream(filePath));
+            formData.append('vectorStore', kbName);
+            formData.append('title', path.basename(filePath));
+            await axios_1.default.post(`${apiUrl}/runtime/v1/vectors/upload`, formData, {
+                headers: {
+                    ...formData.getHeaders(),
+                    'x-api-key': config.apiKey,
+                },
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+            });
+            s.stop(chalk_1.default.green('✓ File uploaded and processed'));
+        }
+        catch (error) {
+            s.stop(chalk_1.default.red('✗ Upload failed'));
+            throw error;
+        }
+    }
+    async uploadDirectory(apiClient, kbName, dirPath, options) {
+        const files = this.findFiles(dirPath);
+        if (files.length === 0) {
+            console.log(chalk_1.default.yellow('No files found in directory'));
+            return;
+        }
+        console.log(chalk_1.default.blue(`\nFound ${files.length} files`));
+        if (!options?.yes) {
+            const shouldContinue = await (0, prompts_1.confirm)({
+                message: `Upload ${files.length} files to "${kbName}"?`,
+                initialValue: true,
+            });
+            if (typeof shouldContinue !== 'boolean' || !shouldContinue) {
+                console.log(chalk_1.default.gray('Cancelled'));
+                return;
+            }
+        }
+        let uploaded = 0;
+        let failed = 0;
+        for (const file of files) {
+            const relativePath = path.relative(dirPath, file);
+            console.log(chalk_1.default.gray(`[${uploaded + failed + 1}/${files.length}] ${relativePath}`));
+            try {
+                const { config } = (0, config_2.getValidatedConfig)();
+                const apiUrl = config.api || config_1.DEFAULT_API_URL;
+                const formData = new form_data_1.default();
+                formData.append('file', fs.createReadStream(file));
+                formData.append('vectorStore', kbName);
+                formData.append('title', relativePath);
+                await axios_1.default.post(`${apiUrl}/runtime/v1/vectors/upload`, formData, {
+                    headers: {
+                        ...formData.getHeaders(),
+                        'x-api-key': config.apiKey,
+                    },
+                    maxBodyLength: Infinity,
+                    maxContentLength: Infinity,
+                });
+                uploaded++;
+                console.log(chalk_1.default.green('  ✓ Uploaded'));
+            }
+            catch (error) {
+                failed++;
+                console.log(chalk_1.default.red('  ✗ Failed'));
+            }
+        }
+        console.log('');
+        console.log(chalk_1.default.green(`✓ Uploaded: ${uploaded}`));
+        if (failed > 0) {
+            console.log(chalk_1.default.red(`✗ Failed: ${failed}`));
+        }
+        console.log('');
+    }
+    async getStatus(apiClient, name) {
+        const res = await apiClient.get(`/vector-stores/${name}`);
+        const kb = res.data.data;
+        console.log(chalk_1.default.cyan.bold('\n📚 Knowledge Base Stats\n'));
+        console.log(chalk_1.default.gray('Name:       ') + chalk_1.default.white(kb.name));
+        console.log(chalk_1.default.gray('ID:         ') + chalk_1.default.white(kb.id));
+        console.log(chalk_1.default.gray('Documents:  ') + chalk_1.default.white(kb.documentCount || 0));
+        console.log(chalk_1.default.gray('Embedding:  ') + chalk_1.default.white(`${kb.embeddingConfig.provider} - ${kb.embeddingConfig.model}`));
+        console.log(chalk_1.default.gray('Dimensions: ') + chalk_1.default.white(kb.embeddingConfig.dimensions));
+        console.log(chalk_1.default.gray('Chunk size: ') + chalk_1.default.white(kb.chunkSize || 1000));
+        console.log('');
+    }
+    async deleteKnowledgeBase(apiClient, name, options) {
+        const res = await apiClient.get(`/vector-stores/${name}`);
+        const kb = res.data.data;
+        if (!options?.yes) {
+            const shouldDelete = await (0, prompts_1.confirm)({
+                message: `Delete "${kb.name}" (${kb.documentCount || 0} documents)?`,
+                initialValue: false,
+            });
+            if (typeof shouldDelete !== 'boolean' || !shouldDelete) {
+                console.log(chalk_1.default.gray('Cancelled'));
+                return;
+            }
+        }
+        console.log(chalk_1.default.gray('Deleting knowledge base...'));
+        await apiClient.delete(`/vector-stores/${name}`);
+        console.log(chalk_1.default.green('✓ Knowledge base deleted'));
+    }
+    async listDocuments(apiClient, kbName) {
+        const s = (0, prompts_1.spinner)();
+        s.start('Fetching documents...');
+        const res = await apiClient.get(`/vector-stores/${kbName}/documents`);
+        const docs = res.data.data?.documents || [];
+        s.stop(chalk_1.default.green(`✓ Found ${docs.length} documents`));
+        console.log(chalk_1.default.cyan.bold(`\n📄 Documents in "${kbName}"\n`));
+        if (docs.length === 0) {
+            console.log(chalk_1.default.gray('  No documents found'));
+            console.log(chalk_1.default.gray(`  Upload with: rf kb upload ${kbName} <file>\n`));
+            return;
+        }
+        docs.forEach((doc, index) => {
+            const title = doc.metadata?.title || doc.metadata?.fileName || 'Untitled';
+            console.log(chalk_1.default.white(`  ${index + 1}. ${title}`));
+            console.log(chalk_1.default.gray(`     ID: ${doc.id}`));
+            if (doc.metadata?.fileSize) {
+                const sizeMB = (doc.metadata.fileSize / 1024 / 1024).toFixed(2);
+                console.log(chalk_1.default.gray(`     Size: ${sizeMB} MB`));
+            }
+            console.log('');
+        });
+    }
+    async removeDocument(apiClient, kbName, docId, options) {
+        if (!options?.yes) {
+            const shouldDelete = await (0, prompts_1.confirm)({
+                message: `Delete document ${docId}?`,
+                initialValue: false,
+            });
+            if (typeof shouldDelete !== 'boolean' || !shouldDelete) {
+                console.log(chalk_1.default.gray('Cancelled'));
+                return;
+            }
+        }
+        console.log(chalk_1.default.gray('Deleting document...'));
+        await apiClient.delete(`/vector-stores/${kbName}/documents/${docId}`);
+        console.log(chalk_1.default.green('✓ Document deleted'));
+    }
+    async search(apiClient, kbName, query) {
+        const s = (0, prompts_1.spinner)();
+        s.start('Searching...');
+        const res = await apiClient.post(`/vector-stores/${kbName}/search`, {
+            query,
+            k: 5,
+            threshold: 0.7,
+        });
+        const results = res.data.data || [];
+        s.stop(chalk_1.default.green(`✓ Found ${results.length} results`));
+        console.log(chalk_1.default.cyan.bold(`\n🔍 Search Results for "${query}"\n`));
+        if (results.length === 0) {
+            console.log(chalk_1.default.gray('  No results found\n'));
+            return;
+        }
+        results.forEach((result, index) => {
+            const score = (result.score * 100).toFixed(1);
+            console.log(chalk_1.default.white(`  ${index + 1}. Score: ${score}%`));
+            if (result.metadata?.title) {
+                console.log(chalk_1.default.gray(`     Source: ${result.metadata.title}`));
+            }
+            const preview = result.content.substring(0, 150);
+            console.log(chalk_1.default.gray(`     ${preview}${result.content.length > 150 ? '...' : ''}`));
+            console.log('');
+        });
+    }
+    findFiles(dirPath, extensions = ['.pdf', '.txt', '.md', '.docx', '.doc']) {
+        const files = [];
+        const traverse = (currentPath) => {
+            const items = fs.readdirSync(currentPath);
+            for (const item of items) {
+                const fullPath = path.join(currentPath, item);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (!['node_modules', '.git', 'dist', 'build'].includes(item)) {
+                        traverse(fullPath);
+                    }
+                }
+                else if (stat.isFile()) {
+                    const ext = path.extname(item).toLowerCase();
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        };
+        traverse(dirPath);
+        return files;
+    }
+    showHelp() {
+        console.log('');
+        console.log(chalk_1.default.cyan.bold('📚 Knowledge Base Management'));
+        console.log(chalk_1.default.gray('Manage vector stores for RAG (Retrieval Augmented Generation)\n'));
+        console.log(chalk_1.default.white.bold('Usage:'));
+        console.log(chalk_1.default.gray('  rf kb <action> [name] [path]\n'));
+        console.log(chalk_1.default.white.bold('Actions:'));
+        console.log(chalk_1.default.cyan('  list                    ') + chalk_1.default.gray('List all knowledge bases'));
+        console.log(chalk_1.default.cyan('  create <name>           ') + chalk_1.default.gray('Create new knowledge base'));
+        console.log(chalk_1.default.cyan('  status <name>           ') + chalk_1.default.gray('Show KB stats and info'));
+        console.log(chalk_1.default.cyan('  upload <name> <path>    ') + chalk_1.default.gray('Upload file or directory'));
+        console.log(chalk_1.default.cyan('  docs <name>             ') + chalk_1.default.gray('List documents in KB'));
+        console.log(chalk_1.default.cyan('  search <name> <query>   ') + chalk_1.default.gray('Semantic search in KB'));
+        console.log(chalk_1.default.cyan('  remove-doc <name> <id>  ') + chalk_1.default.gray('Remove document from KB'));
+        console.log(chalk_1.default.cyan('  delete <name>           ') + chalk_1.default.gray('Delete knowledge base'));
+        console.log('');
+        console.log(chalk_1.default.white.bold('Options:'));
+        console.log(chalk_1.default.cyan('  -e, --embedding <config>  ') + chalk_1.default.gray('Embedding config (non-interactive)'));
+        console.log(chalk_1.default.cyan('  -y, --yes                 ') + chalk_1.default.gray('Skip confirmation prompts'));
+        console.log('');
+        console.log(chalk_1.default.white.bold('Examples:'));
+        console.log(chalk_1.default.gray('  rf kb list'));
+        console.log(chalk_1.default.gray('  rf kb create product-docs'));
+        console.log(chalk_1.default.gray('  rf kb create docs --embedding "OpenAI Small"'));
+        console.log(chalk_1.default.gray('  rf kb upload product-docs ./manual.pdf'));
+        console.log(chalk_1.default.gray('  rf kb upload docs ./folder --yes'));
+        console.log(chalk_1.default.gray('  rf kb search product-docs "how to reset password"'));
+        console.log(chalk_1.default.gray('  rf kb delete old-kb --yes'));
+        console.log('');
+    }
+    parseApiKey(val) {
+        return val;
+    }
+    parseApi(val) {
+        return val;
+    }
+    parseEmbedding(val) {
+        return val;
+    }
+    parseYes() {
+        return true;
+    }
+};
+exports.KnowledgeBaseCommand = KnowledgeBaseCommand;
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '--api-key <key>',
+        description: 'API key override',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], KnowledgeBaseCommand.prototype, "parseApiKey", null);
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '--api <url>',
+        description: `API URL override (default: ${config_1.DEFAULT_API_URL})`,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], KnowledgeBaseCommand.prototype, "parseApi", null);
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '-e, --embedding <config>',
+        description: 'Embedding config ID or name (non-interactive mode)',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], KnowledgeBaseCommand.prototype, "parseEmbedding", null);
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '-y, --yes',
+        description: 'Skip confirmation prompts',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Boolean)
+], KnowledgeBaseCommand.prototype, "parseYes", null);
+exports.KnowledgeBaseCommand = KnowledgeBaseCommand = __decorate([
+    (0, nest_commander_1.Command)({
+        name: 'kb',
+        aliases: ['knowledge'],
+        arguments: '[action] [name] [path]',
+        description: 'Manage knowledge bases for RAG (Retrieval Augmented Generation)',
+    })
+], KnowledgeBaseCommand);
+//# sourceMappingURL=kb.command.js.map