aui-agent-builder 0.1.8 → 0.1.11

package/README.md

@@ -71,9 +71,10 @@ Session is invalidated server-side and cleared locally.
 |---------|-------------|
 | `aui login` | Sign in (email OTP or access token) |
 | `aui list-agents` | List all agents in your account |
-| `aui create-agent` | Create a new agent on the backend |
 | `aui import [agent-id]` | Download an agent as local `.aui.json` files |
 | `aui init [directory]` | Scaffold a new agent project with examples |
+| `aui add-integration` | Add an integration (API, RAG, or MCP) |
+| `aui rag` | List and manage RAG knowledge bases and files |
 | `aui validate [path]` | Validate `.aui.json` files for errors |
 | `aui push` | Upload local changes to the backend |
 | `aui status` | Show session, linked agent, and file summary |
@@ -160,6 +161,31 @@ my-agent/
 
 **`rules.aui.json`** — Global rules that apply across tools. Define conditions (when) and actions (then) to control agent behavior like blocking certain actions, requiring confirmation, or activating other tools.
 
+## Adding Integrations
+
+Add API, RAG, or MCP integrations to your project:
+
+```bash
+aui add-integration
+```
+
+Select the integration type, provide a code name, and the command scaffolds the JSON config with the correct structure and placeholder values. Edit the generated `integrations.aui.json` in your editor to fill in the details.
+
+- **API** — generates endpoint URL, method, authentication, request schema, and test curl
+- **RAG** — prompts for knowledge hub (new or existing) and scope (organization, account, or network)
+- **MCP** — generates a minimal config to fill in
+
+## RAG Knowledge Bases
+
+Manage RAG knowledge bases and their files:
+
+```bash
+aui rag                  # List knowledge bases and files by scope
+aui rag --add-file       # Add a file or URL to a knowledge hub
+```
+
+After adding a RAG integration, use `aui rag --add-file` to attach local files (PDF, TXT, etc.) or URLs for scraping. Files are tracked locally and will be uploaded when push endpoints are ready. On push, only changed files are re-embedded (diff-based).
+
 ## Validating Changes
 
 Check your configuration files for errors before pushing:

package/dist/commands/add-integration.d.ts

@@ -1,26 +1,20 @@
 /**
- * add-integration command - Import integrations from OpenAPI specs or manually
+ * add-integration command - Scaffold integration config files
  *
- * Interactive flow:
- * 1. Choose source: URL, JSON file, or manual entry
- * 2. For OpenAPI: fetch, parse, select endpoints
- * 3. For each endpoint: collect curl for testing
- * 4. Generate integration configuration
- * 5. Save to integrations.aui.json
+ * Asks only the essentials (type, code, scope for RAG), then generates
+ * the .aui.json file with the correct structure and placeholder values
+ * for the user to edit in their editor.
+ *
+ * For RAG, also supports adding files/URLs to the knowledge hub.
  *
  * Usage: aui add-integration
- * Options:
- *   --url <url>      URL to OpenAPI spec
- *   --file <path>    Path to OpenAPI JSON file
- *   --manual         Manual integration entry
  */
 export interface AddIntegrationOptions {
     url?: string;
     file?: string;
-    manual?: boolean;
 }
 /**
- * Main add-integration command
+ * Scaffold an integration config file
  */
-export declare function addIntegration(options?: AddIntegrationOptions): Promise<void>;
+export declare function addIntegration(_options?: AddIntegrationOptions): Promise<void>;
 //# sourceMappingURL=add-integration.d.ts.map

package/dist/commands/add-integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-integration.d.ts","sourceRoot":"","sources":["../../src/commands/add-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CA4DvF"}
+{"version":3,"file":"add-integration.d.ts","sourceRoot":"","sources":["../../src/commands/add-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,QAAQ,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAuDxF"}

package/dist/commands/add-integration.js

@@ -1,19 +1,14 @@
 "use strict";
 /**
- * add-integration command - Import integrations from OpenAPI specs or manually
+ * add-integration command - Scaffold integration config files
  *
- * Interactive flow:
- * 1. Choose source: URL, JSON file, or manual entry
- * 2. For OpenAPI: fetch, parse, select endpoints
- * 3. For each endpoint: collect curl for testing
- * 4. Generate integration configuration
- * 5. Save to integrations.aui.json
+ * Asks only the essentials (type, code, scope for RAG), then generates
+ * the .aui.json file with the correct structure and placeholder values
+ * for the user to edit in their editor.
+ *
+ * For RAG, also supports adding files/URLs to the knowledge hub.
  *
  * Usage: aui add-integration
- * Options:
- *   --url <url>      URL to OpenAPI spec
- *   --file <path>    Path to OpenAPI JSON file
- *   --manual         Manual integration entry
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -56,381 +51,173 @@ exports.addIntegration = addIntegration;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../config");
 /**
- * Main add-integration command
+ * Scaffold an integration config file
  */
-async function addIntegration(options = {}) {
-    console.log(chalk_1.default.blue('\n  ┌─────────────────────────────────────────┐'));
-    console.log(chalk_1.default.blue('  │     Add Integration to Agent            │'));
-    console.log(chalk_1.default.blue('  └─────────────────────────────────────────┘\n'));
-    const projectRoot = (0, config_1.findProjectRoot)();
-    if (!projectRoot) {
-        console.log(chalk_1.default.yellow('  Note: No AUI project found. Integration will be saved to current directory.'));
-    }
-    try {
-        // Choose source type
-        const { sourceType } = await inquirer_1.default.prompt([{
-                type: 'list',
-                name: 'sourceType',
-                message: 'How would you like to add the integration?',
-                choices: [
-                    { name: 'Manual entry - Define integration fields step by step', value: 'manual' },
-                    { name: 'OpenAPI URL - Import from OpenAPI spec URL', value: 'url' },
-                    { name: 'OpenAPI File - Import from local OpenAPI JSON file', value: 'file' }
-                ]
-            }]);
-        let integration;
-        if (sourceType === 'manual') {
-            integration = await createManualIntegration();
-        }
-        else if (sourceType === 'url') {
-            integration = await createFromOpenAPIUrl(options.url);
-        }
-        else {
-            integration = await createFromOpenAPIFile(options.file);
-        }
-        // Preview
-        console.log(chalk_1.default.blue('\n  ─── Integration Preview ───\n'));
-        console.log(chalk_1.default.white(`    Type: ${integration.type}`));
-        console.log(chalk_1.default.white(`    Code: ${integration.code}`));
-        if (integration.settings && 'endpoint' in integration.settings && integration.settings.endpoint) {
-            console.log(chalk_1.default.white(`    Endpoint: ${integration.settings.endpoint.method} ${integration.settings.endpoint.url}`));
-        }
-        // Confirm and save
-        const { confirm } = await inquirer_1.default.prompt([{
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Add this integration to your project?',
-                default: true
-            }]);
-        if (!confirm) {
-            console.log(chalk_1.default.gray('\n  Cancelled.\n'));
-            return;
-        }
-        await saveIntegration(integration, projectRoot);
-        console.log(chalk_1.default.green(`\n  ✓ Integration "${integration.code}" added successfully!\n`));
-    }
-    catch (error) {
-        console.error(chalk_1.default.red(`\n  Error: ${error instanceof Error ? error.message : error}`));
-    }
-}
-/**
- * Create integration manually step by step
- */
-async function createManualIntegration() {
-    const answers = await inquirer_1.default.prompt([
-        {
+async function addIntegration(_options = {}) {
+    console.log(chalk_1.default.dim('\n  ╭──────────────────────────────────────────────╮'));
+    console.log(chalk_1.default.dim('  │') + chalk_1.default.white.bold('  Add Integration') + chalk_1.default.dim('                             │'));
+    console.log(chalk_1.default.dim('  ╰──────────────────────────────────────────────╯\n'));
+    const projectRoot = (0, config_1.findProjectRoot)() || process.cwd();
+    // Step 1: Integration type
+    const { integrationType } = await inquirer_1.default.prompt([{
             type: 'list',
-            name: 'type',
+            name: 'integrationType',
             message: 'Integration type:',
             choices: [
-                { name: 'API - REST API endpoint', value: 'API' },
-                { name: 'RAG - Knowledge base retrieval', value: 'RAG' },
-                { name: 'MCP - Model Context Protocol', value: 'MCP' }
+                { name: 'API — REST API endpoint', value: 'API' },
+                { name: 'RAG — Knowledge base (files / URLs)', value: 'RAG' },
+                { name: 'MCP — Model Context Protocol', value: 'MCP' }
             ]
-        },
-        {
+        }]);
+    // Step 2: Code
+    const { code } = await inquirer_1.default.prompt([{
             type: 'input',
             name: 'code',
             message: 'Integration code (kebab-case):',
             validate: (input) => /^[a-z][a-z0-9-]*$/.test(input) || 'Use lowercase letters, numbers, and hyphens'
-        },
-        {
-            type: 'input',
-            name: 'description',
-            message: 'Description (optional):'
-        }
-    ]);
-    if (answers.type === 'API') {
-        return await createAPIIntegration(answers.code, answers.description);
+        }]);
+    // Step 3: Build the integration based on type
+    let integration;
+    if (integrationType === 'API') {
+        integration = scaffoldAPI(code);
+    }
+    else if (integrationType === 'RAG') {
+        integration = await scaffoldRAG(code);
+    }
+    else {
+        integration = scaffoldMCP(code);
     }
-    if (answers.type === 'RAG') {
-        return await createRAGIntegration(answers.code, answers.description);
+    // Step 4: Save to integrations.aui.json
+    await saveIntegration(integration, projectRoot);
+    const filePath = path.join(projectRoot, 'integrations.aui.json');
+    console.log(chalk_1.default.green(`\n  ✓ ${integrationType} integration "${code}" created`));
+    console.log(chalk_1.default.dim(`\n  Edit the configuration:`));
+    console.log(chalk_1.default.cyan(`    ${filePath}`));
+    if (integrationType === 'RAG') {
+        console.log(chalk_1.default.dim(`\n  Add files to the knowledge hub:`));
+        console.log(chalk_1.default.cyan(`    aui rag --add-file`));
     }
-    // MCP or other
+    console.log(chalk_1.default.dim(`\n  Then validate and push:`));
+    console.log(chalk_1.default.cyan(`    aui validate`));
+    console.log(chalk_1.default.cyan(`    aui push\n`));
+}
+// ─── Scaffolders ───
+function scaffoldAPI(code) {
     return {
-        type: answers.type,
-        code: answers.code,
-        description: answers.description || undefined,
-        settings: undefined
+        type: 'API',
+        code,
+        description: '',
+        settings: {
+            endpoint: {
+                url: 'https://api.example.com/endpoint',
+                method: 'GET',
+                authentication: {
+                    type: 'API_KEY',
+                    apiKey: `$${code.toUpperCase().replace(/-/g, '_')}_API_KEY`
+                }
+            },
+            request_schema: [
+                {
+                    key: 'query',
+                    required: true,
+                    description: 'Search query or input parameter',
+                    type: 'STRING',
+                    value_source: 'dynamic',
+                    params: [],
+                    entities: [],
+                    values: [],
+                    default_value: ''
+                }
+            ],
+            response_mapping: {},
+            test_curl: `curl "https://api.example.com/endpoint?query=test" -H "X-API-Key: YOUR_KEY"`
+        }
     };
 }
-/**
- * Create an API integration with endpoint details
- */
-async function createAPIIntegration(code, description) {
-    const endpointAnswers = await inquirer_1.default.prompt([
-        {
-            type: 'input',
-            name: 'url',
-            message: 'Endpoint URL (supports {{param}} placeholders):',
-            validate: (input) => input.length > 0 || 'URL is required'
-        },
-        {
-            type: 'list',
-            name: 'method',
-            message: 'HTTP Method:',
-            choices: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
-        },
-        {
+async function scaffoldRAG(code) {
+    // RAG needs a few extra questions for the knowledge hub
+    const { khSource } = await inquirer_1.default.prompt([{
             type: 'list',
-            name: 'authType',
-            message: 'Authentication:',
+            name: 'khSource',
+            message: 'Knowledge hub:',
             choices: [
-                { name: 'None', value: 'NONE' },
-                { name: 'API Key', value: 'API_KEY' },
-                { name: 'Bearer Token', value: 'BEARER_TOKEN' },
-                { name: 'Basic Auth', value: 'BASIC' }
+                { name: 'Create a new knowledge hub', value: 'new' },
+                { name: 'Use an existing knowledge hub (enter ID)', value: 'existing' }
             ]
-        }
-    ]);
-    const endpoint = {
-        url: endpointAnswers.url,
-        method: endpointAnswers.method,
-    };
-    if (endpointAnswers.authType !== 'NONE') {
-        if (endpointAnswers.authType === 'API_KEY') {
-            const { envVar } = await inquirer_1.default.prompt([{
-                    type: 'input',
-                    name: 'envVar',
-                    message: 'Environment variable name for API key:',
-                    default: `${code.toUpperCase().replace(/-/g, '_')}_API_KEY`
-                }]);
-            endpoint.authentication = { type: 'API_KEY', apiKey: `$${envVar}` };
-        }
-        else if (endpointAnswers.authType === 'BEARER_TOKEN') {
-            const { envVar } = await inquirer_1.default.prompt([{
-                    type: 'input',
-                    name: 'envVar',
-                    message: 'Environment variable name for token:',
-                    default: `${code.toUpperCase().replace(/-/g, '_')}_TOKEN`
-                }]);
-            endpoint.authentication = { type: 'BEARER_TOKEN', token: `$${envVar}` };
-        }
-    }
-    // Request schema fields
-    const requestSchema = [];
-    let addMore = true;
-    console.log(chalk_1.default.gray('\n  Define request schema fields (the data this API needs):\n'));
-    while (addMore) {
-        const { wantField } = await inquirer_1.default.prompt([{
-                type: 'confirm',
-                name: 'wantField',
-                message: requestSchema.length === 0 ? 'Add a request field?' : 'Add another request field?',
-                default: requestSchema.length === 0
-            }]);
-        if (!wantField) {
-            addMore = false;
-            continue;
-        }
-        const fieldAnswers = await inquirer_1.default.prompt([
-            {
+        }]);
+    let knowledgeHub;
+    let knowledgeBaseId = '';
+    if (khSource === 'existing') {
+        const { id } = await inquirer_1.default.prompt([{
                 type: 'input',
-                name: 'key',
-                message: 'Field name:',
-                validate: (input) => input.length > 0 || 'Field name is required'
-            },
-            {
-                type: 'confirm',
-                name: 'required',
-                message: 'Required?',
-                default: true
-            },
+                name: 'id',
+                message: 'Knowledge hub ID:',
+                validate: (input) => input.trim().length > 0 || 'ID is required'
+            }]);
+        knowledgeBaseId = id.trim();
+        knowledgeHub = { id: knowledgeBaseId, name: '', scope: 'organization' };
+    }
+    else {
+        const khAnswers = await inquirer_1.default.prompt([
             {
                 type: 'input',
-                name: 'description',
-                message: 'Description:'
+                name: 'name',
+                message: 'Knowledge hub name:',
+                validate: (input) => input.trim().length > 0 || 'Name is required'
             },
             {
                 type: 'list',
-                name: 'type',
-                message: 'Type:',
-                choices: ['STRING', 'NUMBER', 'BOOLEAN', 'ENUM', 'OBJECT', 'ARRAY']
-            },
-            {
-                type: 'list',
-                name: 'valueSource',
-                message: 'Value source:',
+                name: 'scope',
+                message: 'Scope:',
                 choices: [
-                    { name: 'Dynamic - LLM determines value', value: 'dynamic' },
-                    { name: 'Default - Fixed value', value: 'default' },
-                    { name: 'User Profile - From user context', value: 'user_profile' },
-                    { name: 'Context - From conversation context', value: 'context' },
-                    { name: 'Entities - From entity data', value: 'entities' }
+                    { name: 'Organization — shared across all accounts and agents', value: 'organization' },
+                    { name: 'Account — shared within this account', value: 'account' },
+                    { name: 'Network — specific to this agent only', value: 'network' }
                 ]
             }
         ]);
-        requestSchema.push({
-            key: fieldAnswers.key,
-            required: fieldAnswers.required,
-            description: fieldAnswers.description,
-            type: fieldAnswers.type,
-            value_source: fieldAnswers.valueSource,
-            params: [],
-            entities: [],
-            values: [],
-            default_value: ''
-        });
+        knowledgeHub = {
+            name: khAnswers.name.trim(),
+            scope: khAnswers.scope,
+            files: []
+        };
+        // TODO: When knowledge hub creation endpoint is ready:
+        //   POST /knowledge-hub with { name, scope }
+        //   Response includes the knowledge_base_id
+        knowledgeBaseId = `kh-${code}-pending`;
     }
-    // Test curl
-    const { testCurl } = await inquirer_1.default.prompt([{
-            type: 'input',
-            name: 'testCurl',
-            message: 'Test curl command (optional - used to generate response mapping):'
-        }]);
-    return {
-        type: 'API',
-        code,
-        description: description || undefined,
-        settings: {
-            endpoint,
-            request_schema: requestSchema,
-            response_mapping: {},
-            test_curl: testCurl || undefined
-        }
-    };
-}
-/**
- * Create a RAG integration
- */
-async function createRAGIntegration(code, description) {
-    const answers = await inquirer_1.default.prompt([
-        {
-            type: 'input',
-            name: 'knowledgeBaseId',
-            message: 'Knowledge base ID:',
-            validate: (input) => input.length > 0 || 'Knowledge base ID is required'
-        },
-        {
-            type: 'number',
-            name: 'searchTopK',
-            message: 'Search top-k results:',
-            default: 7
-        },
-        {
-            type: 'number',
-            name: 'rankerTopK',
-            message: 'Ranker top-k results:',
-            default: 3
-        },
-        {
-            type: 'number',
-            name: 'confidenceThreshold',
-            message: 'Confidence threshold (0-1):',
-            default: 0.3
-        }
-    ]);
     return {
         type: 'RAG',
         code,
-        description: description || undefined,
+        description: '',
         settings: {
-            search_top_k: answers.searchTopK,
-            ranker_top_k: answers.rankerTopK,
+            search_top_k: 7,
+            ranker_top_k: 3,
             ranker_model: null,
-            confidence_threshold: answers.confidenceThreshold,
-            knowledge_base_id: answers.knowledgeBaseId,
+            confidence_threshold: 0.3,
+            knowledge_base_id: knowledgeBaseId,
             parent_knowledge_base_ids: [],
             allow_multiple_calls: false,
-            placeholders: []
+            placeholders: [],
+            knowledge_hub: knowledgeHub
         }
     };
 }
-/**
- * Create integration from OpenAPI URL
- */
-async function createFromOpenAPIUrl(url) {
-    if (!url) {
-        const answers = await inquirer_1.default.prompt([{
-                type: 'input',
-                name: 'url',
-                message: 'OpenAPI spec URL:',
-                validate: (input) => {
-                    if (!input.startsWith('http://') && !input.startsWith('https://')) {
-                        return 'URL must start with http:// or https://';
-                    }
-                    return true;
-                }
-            }]);
-        url = answers.url;
-    }
-    const spinner = (0, ora_1.default)('Fetching OpenAPI spec...').start();
-    try {
-        // Note: In production, this would fetch and parse the OpenAPI spec
-        // For now, we create a placeholder integration
-        spinner.succeed('OpenAPI spec loaded');
-        console.log(chalk_1.default.yellow('\n  OpenAPI import is a work in progress.'));
-        console.log(chalk_1.default.yellow('  Creating a placeholder integration from the URL.\n'));
-        const { code } = await inquirer_1.default.prompt([{
-                type: 'input',
-                name: 'code',
-                message: 'Integration code:',
-                validate: (input) => /^[a-z][a-z0-9-]*$/.test(input) || 'Use kebab-case'
-            }]);
-        return {
-            type: 'API',
-            code,
-            settings: {
-                endpoint: {
-                    url: url,
-                    method: 'GET'
-                },
-                request_schema: [],
-                response_mapping: {}
-            }
-        };
-    }
-    catch (error) {
-        spinner.fail('Failed to fetch OpenAPI spec');
-        throw error;
-    }
-}
-/**
- * Create integration from OpenAPI file
- */
-async function createFromOpenAPIFile(filePath) {
-    if (!filePath) {
-        const answers = await inquirer_1.default.prompt([{
-                type: 'input',
-                name: 'filePath',
-                message: 'Path to OpenAPI JSON file:',
-                validate: (input) => {
-                    if (!fs.existsSync(input))
-                        return `File not found: ${input}`;
-                    return true;
-                }
-            }]);
-        filePath = answers.filePath;
-    }
-    console.log(chalk_1.default.yellow('\n  OpenAPI file import is a work in progress.'));
-    console.log(chalk_1.default.yellow('  Creating a placeholder integration.\n'));
-    const { code } = await inquirer_1.default.prompt([{
-            type: 'input',
-            name: 'code',
-            message: 'Integration code:',
-            validate: (input) => /^[a-z][a-z0-9-]*$/.test(input) || 'Use kebab-case'
-        }]);
+function scaffoldMCP(code) {
     return {
-        type: 'API',
+        type: 'MCP',
         code,
-        settings: {
-            endpoint: null,
-            request_schema: [],
-            response_mapping: {}
-        }
+        description: '',
+        settings: undefined
     };
 }
-/**
- * Save integration to integrations.aui.json
- */
+// ─── Save ───
 async function saveIntegration(integration, projectRoot) {
-    const targetDir = projectRoot || process.cwd();
-    const integrationsPath = path.join(targetDir, 'integrations.aui.json');
+    const integrationsPath = path.join(projectRoot, 'integrations.aui.json');
     let existingIntegrations = [];
-    // Load existing file
     if (fs.existsSync(integrationsPath)) {
         try {
             const content = fs.readFileSync(integrationsPath, 'utf-8');
@@ -438,7 +225,7 @@ async function saveIntegration(integration, projectRoot) {
             existingIntegrations = parsed.integrations || [];
         }
         catch {
-            // File exists but couldn't be parsed
+            // Start fresh if file is invalid
         }
     }
     // Check for duplicate
@@ -447,38 +234,21 @@ async function saveIntegration(integration, projectRoot) {
         const { action } = await inquirer_1.default.prompt([{
                 type: 'list',
                 name: 'action',
-                message: `Integration "${integration.code}" already exists. What would you like to do?`,
+                message: `Integration "${integration.code}" already exists.`,
                 choices: [
-                    { name: 'Replace existing', value: 'replace' },
-                    { name: 'Rename new integration', value: 'rename' },
+                    { name: 'Replace it', value: 'replace' },
                     { name: 'Cancel', value: 'cancel' }
                 ]
             }]);
         if (action === 'cancel') {
-            throw new Error('Cancelled by user');
-        }
-        if (action === 'replace') {
-            existingIntegrations[existingIdx] = integration;
-        }
-        else {
-            const { newCode } = await inquirer_1.default.prompt([{
-                    type: 'input',
-                    name: 'newCode',
-                    message: 'New integration code:',
-                    validate: (input) => /^[a-z][a-z0-9-]*$/.test(input) || 'Use kebab-case'
-                }]);
-            integration.code = newCode;
-            existingIntegrations.push(integration);
+            console.log(chalk_1.default.gray('\n  Cancelled.\n'));
+            return;
         }
+        existingIntegrations[existingIdx] = integration;
     }
     else {
         existingIntegrations.push(integration);
     }
-    // Save
-    const fileContent = {
-        integrations: existingIntegrations
-    };
-    fs.writeFileSync(integrationsPath, JSON.stringify(fileContent, null, 2) + '\n');
-    console.log(chalk_1.default.gray(`  Saved to: ${integrationsPath}`));
+    fs.writeFileSync(integrationsPath, JSON.stringify({ integrations: existingIntegrations }, null, 2) + '\n');
 }
 //# sourceMappingURL=add-integration.js.map