agentvault 1.0.0 → 1.0.2

package/dist/src/packaging/parsers/clawdbot.js

@@ -0,0 +1,231 @@
+/**
+ * Clawdbot Configuration Parser
+ *
+ * Parses Clawdbot agent configuration from .clawdbot directory.
+ * Reads JSON files and constructs full configuration object.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DEFAULT_CLAWDBOT_SETTINGS, } from '../config-schemas.js';
+/**
+ * Find Clawdbot directory or configuration file
+ */
+function findClawdbotConfig(sourcePath) {
+    const absolutePath = path.resolve(sourcePath);
+    // Check for .clawdbot directory
+    const clawdbotDir = path.join(absolutePath, '.clawdbot');
+    if (fs.existsSync(clawdbotDir)) {
+        return {
+            path: clawdbotDir,
+            type: 'directory',
+        };
+    }
+    // Check for clawdbot.json or clawdbot.config.json
+    const configFiles = ['clawdbot.json', 'clawdbot.config.json'];
+    for (const file of configFiles) {
+        const filePath = path.join(absolutePath, file);
+        if (fs.existsSync(filePath)) {
+            return {
+                path: filePath,
+                type: 'json',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Read and parse .clawdbot directory structure
+ */
+function readClawdbotDirectory(dirPath) {
+    try {
+        // Read projects
+        const projectsPath = path.join(dirPath, 'projects.json');
+        let projects = [];
+        if (fs.existsSync(projectsPath)) {
+            const projectsContent = fs.readFileSync(projectsPath, 'utf-8');
+            projects = JSON.parse(projectsContent);
+        }
+        // Read tasks
+        const tasksPath = path.join(dirPath, 'tasks.json');
+        let tasks = [];
+        if (fs.existsSync(tasksPath)) {
+            const tasksContent = fs.readFileSync(tasksPath, 'utf-8');
+            tasks = JSON.parse(tasksContent);
+        }
+        // Read context
+        const contextPath = path.join(dirPath, 'context.json');
+        let context = {};
+        if (fs.existsSync(contextPath)) {
+            const contextContent = fs.readFileSync(contextPath, 'utf-8');
+            context = JSON.parse(contextContent);
+        }
+        // Read settings
+        const settingsPath = path.join(dirPath, 'settings.json');
+        let settings = { ...DEFAULT_CLAWDBOT_SETTINGS };
+        if (fs.existsSync(settingsPath)) {
+            const settingsContent = fs.readFileSync(settingsPath, 'utf-8');
+            const parsedSettings = JSON.parse(settingsContent);
+            settings = { ...DEFAULT_CLAWDBOT_SETTINGS, ...parsedSettings };
+        }
+        // Read main config file if exists
+        let name = 'clawdbot-agent';
+        let version = '1.0.0';
+        let description = '';
+        const configPath = path.join(dirPath, 'config.json');
+        if (fs.existsSync(configPath)) {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const configFile = JSON.parse(configContent);
+            name = configFile.name || name;
+            version = configFile.version || version;
+            description = configFile.description || description;
+        }
+        const parsedConfig = {
+            type: 'clawdbot',
+            name,
+            version,
+            description,
+            projects,
+            tasks,
+            context,
+            settings,
+        };
+        return parsedConfig;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse Clawdbot config: ${message}`);
+    }
+}
+/**
+ * Validate Clawdbot configuration
+ */
+function validateClawdbotConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate name
+    if (!config.name || config.name.trim() === '') {
+        errors.push('Agent name is required');
+    }
+    // Validate version format
+    if (config.version) {
+        const versionRegex = /^\d+\.\d+\.\d+$/;
+        if (!versionRegex.test(config.version)) {
+            errors.push(`Invalid version format: ${config.version}. Expected: X.Y.Z`);
+        }
+    }
+    // Validate settings
+    if (config.settings) {
+        // Validate temperature (must be between 0 and 2)
+        if (config.settings.temperature !== undefined) {
+            if (config.settings.temperature < 0 || config.settings.temperature > 2) {
+                errors.push(`Temperature must be between 0 and 2, got: ${config.settings.temperature}`);
+            }
+        }
+        // Validate maxTokens (must be positive)
+        if (config.settings.maxTokens !== undefined) {
+            if (config.settings.maxTokens <= 0) {
+                errors.push(`maxTokens must be positive, got: ${config.settings.maxTokens}`);
+            }
+        }
+    }
+    // Validate projects
+    if (config.projects && config.projects.length === 0) {
+        warnings.push('No projects defined in configuration');
+    }
+    // Validate tasks
+    if (config.tasks && config.tasks.length === 0) {
+        warnings.push('No tasks defined in configuration');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Parse Clawdbot agent configuration
+ *
+ * This function reads .clawdbot directory or clawdbot.json file
+ * and returns a fully validated configuration object.
+ */
+export async function parseClawdbotConfig(sourcePath, verbose = false) {
+    if (verbose) {
+        console.log(`[Clawdbot] Parsing configuration from: ${sourcePath}`);
+    }
+    const configLocation = findClawdbotConfig(sourcePath);
+    if (configLocation === null) {
+        throw new Error('No Clawdbot configuration found. ' +
+            'Expected .clawdbot directory or clawdbot.json file in the agent source path.');
+    }
+    let config;
+    if (configLocation.type === 'json') {
+        if (verbose) {
+            console.log(`[Clawdbot] Found JSON config: ${configLocation.path}`);
+        }
+        const content = fs.readFileSync(configLocation.path, 'utf-8');
+        const parsed = JSON.parse(content);
+        const settings = { ...DEFAULT_CLAWDBOT_SETTINGS, ...parsed.settings };
+        config = {
+            type: 'clawdbot',
+            name: parsed.name || 'clawdbot-agent',
+            version: parsed.version || '1.0.0',
+            description: parsed.description || '',
+            settings,
+            projects: parsed.projects || [],
+            tasks: parsed.tasks || [],
+            context: parsed.context || {},
+        };
+    }
+    else {
+        if (verbose) {
+            console.log(`[Clawdbot] Found directory: ${configLocation.path}`);
+        }
+        config = readClawdbotDirectory(configLocation.path);
+        if (verbose) {
+            console.log(`[Clawdbot] Parsed projects: ${config.projects?.length || 0}`);
+            console.log(`[Clawdbot] Parsed tasks: ${config.tasks?.length || 0}`);
+            console.log(`[Clawdbot] Parsed context keys: ${Object.keys(config.context || {}).length}`);
+            if (config.settings) {
+                console.log(`[Clawdbot] Model: ${config.settings.model}`);
+                console.log(`[Clawdbot] Temperature: ${config.settings.temperature}`);
+                console.log(`[Clawdbot] Max Tokens: ${config.settings.maxTokens}`);
+            }
+        }
+    }
+    const validation = validateClawdbotConfig(config);
+    if (verbose || !validation.valid) {
+        if (validation.errors.length > 0) {
+            console.error('[Clawdbot] Validation errors:');
+            validation.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+        if (validation.warnings.length > 0) {
+            console.warn('[Clawdbot] Warnings:');
+            validation.warnings.forEach((warning) => console.warn(`  - ${warning}`));
+        }
+    }
+    if (!validation.valid) {
+        throw new Error(`Clawdbot configuration validation failed: ${validation.errors.join('; ')}`);
+    }
+    return config;
+}
+/**
+ * Find all Clawdbot configurations in a directory
+ */
+export async function findClawdbotConfigs(dir) {
+    const results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            try {
+                await parseClawdbotConfig(entryPath);
+                results.push(entry.name);
+            }
+            catch {
+                // Skip directories that aren't valid Clawdbot configs
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=clawdbot.js.map

package/dist/src/packaging/parsers/cline.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cline Configuration Parser
+ *
+ * Parses Cline agent configuration from JSON files.
+ * Reads cline.json, cline.config.json, or .cline file and constructs configuration object.
+ */
+import type { ClineConfig } from '../config-schemas.js';
+/**
+ * Parse Cline agent configuration
+ *
+ * This function reads cline.json, cline.config.json, or .cline file
+ * and returns a fully validated configuration object.
+ *
+ * @param sourcePath - Path to agent source directory
+ * @param verbose - Enable verbose logging
+ * @returns Parsed and validated Cline configuration
+ */
+export declare function parseClineConfig(sourcePath: string, verbose?: boolean): Promise<ClineConfig>;
+/**
+ * Find all Cline configurations in a directory tree
+ *
+ * @param rootPath - Root directory to search
+ * @returns Array of paths to Cline configuration files
+ */
+export declare function findClineConfigs(rootPath: string): string[];
+//# sourceMappingURL=cline.d.ts.map

package/dist/src/packaging/parsers/cline.js

@@ -0,0 +1,185 @@
+/**
+ * Cline Configuration Parser
+ *
+ * Parses Cline agent configuration from JSON files.
+ * Reads cline.json, cline.config.json, or .cline file and constructs configuration object.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DEFAULT_CLINE_CONFIG, } from '../config-schemas.js';
+/**
+ * Find Cline configuration file
+ */
+function findClineConfig(sourcePath) {
+    const absolutePath = path.resolve(sourcePath);
+    // Check for JSON config files
+    const configFiles = ['cline.json', 'cline.config.json', '.cline'];
+    for (const file of configFiles) {
+        const filePath = path.join(absolutePath, file);
+        if (fs.existsSync(filePath)) {
+            return {
+                path: filePath,
+                type: 'json',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Validate Cline configuration
+ */
+function validateClineConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate name
+    if (!config.name || config.name.trim() === '') {
+        errors.push('Agent name is required');
+    }
+    // Validate mode
+    if (config.mode && !['auto', 'request'].includes(config.mode)) {
+        errors.push(`Invalid mode: ${config.mode}. Must be 'auto' or 'request'`);
+    }
+    // Validate claudeVersion format if specified
+    if (config.claudeVersion) {
+        // Basic version format validation
+        const versionRegex = /^\d+\.\d+/;
+        if (!versionRegex.test(config.claudeVersion)) {
+            warnings.push(`Unusual claudeVersion format: ${config.claudeVersion}`);
+        }
+    }
+    // Validate version format
+    if (config.version) {
+        const versionRegex = /^\d+\.\d+\.\d+$/;
+        if (!versionRegex.test(config.version)) {
+            errors.push(`Invalid version format: ${config.version}. Expected: X.Y.Z`);
+        }
+    }
+    // Validate working directory exists (if specified)
+    if (config.workingDirectory) {
+        const workingDirPath = path.resolve(process.cwd(), config.workingDirectory);
+        if (!fs.existsSync(workingDirPath)) {
+            warnings.push(`Working directory does not exist: ${config.workingDirectory}`);
+        }
+    }
+    // Validate allowedCommands format if specified
+    if (config.allowedCommands) {
+        if (!Array.isArray(config.allowedCommands)) {
+            errors.push('allowedCommands must be an array');
+        }
+        else {
+            for (const cmd of config.allowedCommands) {
+                if (typeof cmd !== 'string' || cmd.trim() === '') {
+                    errors.push(`Invalid command in allowedCommands: ${cmd}`);
+                }
+            }
+        }
+    }
+    // Warn if no allowedCommands defined in auto mode
+    if (config.mode === 'auto' && (!config.allowedCommands || config.allowedCommands.length === 0)) {
+        warnings.push('Auto mode without allowedCommands may execute dangerous commands');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Parse Cline agent configuration
+ *
+ * This function reads cline.json, cline.config.json, or .cline file
+ * and returns a fully validated configuration object.
+ *
+ * @param sourcePath - Path to agent source directory
+ * @param verbose - Enable verbose logging
+ * @returns Parsed and validated Cline configuration
+ */
+export async function parseClineConfig(sourcePath, verbose = false) {
+    if (verbose) {
+        console.log(`[Cline] Parsing configuration from: ${sourcePath}`);
+    }
+    const configLocation = findClineConfig(sourcePath);
+    if (configLocation === null) {
+        throw new Error('No Cline configuration found. ' +
+            'Expected cline.json, cline.config.json, or .cline file in the agent source path.');
+    }
+    if (verbose) {
+        console.log(`[Cline] Found JSON config: ${configLocation.path}`);
+    }
+    let config;
+    try {
+        const content = fs.readFileSync(configLocation.path, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Merge with defaults
+        config = {
+            type: 'cline',
+            name: parsed.name || DEFAULT_CLINE_CONFIG.name,
+            version: parsed.version || DEFAULT_CLINE_CONFIG.version,
+            description: parsed.description || DEFAULT_CLINE_CONFIG.description,
+            mode: parsed.mode || DEFAULT_CLINE_CONFIG.mode,
+            claudeVersion: parsed.claudeVersion,
+            workingDirectory: parsed.workingDirectory || DEFAULT_CLINE_CONFIG.workingDirectory,
+            autoConfirm: parsed.autoConfirm !== undefined ? parsed.autoConfirm : DEFAULT_CLINE_CONFIG.autoConfirm,
+            useReadline: parsed.useReadline !== undefined ? parsed.useReadline : DEFAULT_CLINE_CONFIG.useReadline,
+            allowedCommands: parsed.allowedCommands || [],
+        };
+        if (verbose) {
+            console.log(`[Cline] Parsed name: ${config.name}`);
+            console.log(`[Cline] Parsed version: ${config.version}`);
+            console.log(`[Cline] Parsed mode: ${config.mode}`);
+            console.log(`[Cline] Parsed claudeVersion: ${config.claudeVersion || 'default'}`);
+            console.log(`[Cline] Parsed workingDirectory: ${config.workingDirectory}`);
+            console.log(`[Cline] Parsed autoConfirm: ${config.autoConfirm}`);
+            console.log(`[Cline] Parsed useReadline: ${config.useReadline}`);
+            console.log(`[Cline] Parsed allowedCommands: ${config.allowedCommands?.length || 0}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse Cline config: ${message}`);
+    }
+    // Validate configuration
+    const validation = validateClineConfig(config);
+    if (!validation.valid) {
+        const errorMessage = `Cline configuration validation failed:\n${validation.errors.map(e => `  - ${e}`).join('\n')}`;
+        throw new Error(errorMessage);
+    }
+    // Display warnings if verbose
+    if (verbose && validation.warnings.length > 0) {
+        console.log(`[Cline] Warnings:`);
+        for (const warning of validation.warnings) {
+            console.log(`[Cline]   - ${warning}`);
+        }
+    }
+    return config;
+}
+/**
+ * Find all Cline configurations in a directory tree
+ *
+ * @param rootPath - Root directory to search
+ * @returns Array of paths to Cline configuration files
+ */
+export function findClineConfigs(rootPath) {
+    const configs = [];
+    function searchDirectory(dirPath) {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules and .git
+                if (entry.name !== 'node_modules' && entry.name !== '.git') {
+                    searchDirectory(fullPath);
+                }
+            }
+            else if (entry.isFile()) {
+                // Check for Cline config files
+                if (entry.name === 'cline.json' || entry.name === 'cline.config.json' || entry.name === '.cline') {
+                    configs.push(fullPath);
+                }
+            }
+        }
+    }
+    searchDirectory(rootPath);
+    return configs;
+}
+//# sourceMappingURL=cline.js.map

package/dist/src/packaging/parsers/generic.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Generic Configuration Parser
+ *
+ * Parses generic agent configuration from JSON or YAML files.
+ * Reads agent.json, agent.yaml, agent.yml, or .agentvault.json file
+ * and constructs configuration object.
+ */
+import type { GenericConfig } from '../config-schemas.js';
+/**
+ * Parse Generic agent configuration
+ *
+ * This function reads agent.json, agent.yaml, agent.yml, or .agentvault.json file
+ * and returns a fully validated configuration object.
+ *
+ * @param sourcePath - Path to agent source directory
+ * @param verbose - Enable verbose logging
+ * @returns Parsed and validated Generic configuration
+ */
+export declare function parseGenericConfig(sourcePath: string, verbose?: boolean): Promise<GenericConfig>;
+/**
+ * Find all Generic configurations in a directory tree
+ *
+ * @param rootPath - Root directory to search
+ * @returns Array of paths to Generic configuration files
+ */
+export declare function findGenericConfigs(rootPath: string): string[];
+//# sourceMappingURL=generic.d.ts.map

package/dist/src/packaging/parsers/generic.js

@@ -0,0 +1,228 @@
+/**
+ * Generic Configuration Parser
+ *
+ * Parses generic agent configuration from JSON or YAML files.
+ * Reads agent.json, agent.yaml, agent.yml, or .agentvault.json file
+ * and constructs configuration object.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+/**
+ * Find Generic configuration file
+ */
+function findGenericConfig(sourcePath) {
+    const absolutePath = path.resolve(sourcePath);
+    // Check for config files (priority order)
+    const configFiles = ['agent.json', 'agent.yaml', 'agent.yml', 'agentvault.json', '.agentvault.json'];
+    for (const file of configFiles) {
+        const filePath = path.join(absolutePath, file);
+        if (fs.existsSync(filePath)) {
+            // Determine type based on extension
+            const type = file.endsWith('.yaml') || file.endsWith('.yml') ? 'yaml' : 'json';
+            return {
+                path: filePath,
+                type,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Validate Generic configuration
+ */
+function validateGenericConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate name
+    if (!config.name || config.name.trim() === '') {
+        errors.push('Agent name is required');
+    }
+    // Validate version format
+    if (config.version) {
+        const versionRegex = /^\d+\.\d+\.\d+$/;
+        if (!versionRegex.test(config.version)) {
+            errors.push(`Invalid version format: ${config.version}. Expected: X.Y.Z`);
+        }
+    }
+    // Validate entry point exists (if specified)
+    if (config.entryPoint) {
+        const sourcePath = process.cwd();
+        const entryPath = path.join(sourcePath, config.entryPoint);
+        if (!fs.existsSync(entryPath)) {
+            warnings.push(`Entry point does not exist: ${config.entryPoint}`);
+        }
+    }
+    // Validate working directory exists (if specified)
+    if (config.workingDirectory) {
+        const workingDirPath = path.resolve(process.cwd(), config.workingDirectory);
+        if (!fs.existsSync(workingDirPath)) {
+            warnings.push(`Working directory does not exist: ${config.workingDirectory}`);
+        }
+    }
+    // Validate allowedFiles format if specified
+    if (config.allowedFiles) {
+        if (!Array.isArray(config.allowedFiles)) {
+            errors.push('allowedFiles must be an array');
+        }
+        else {
+            for (const pattern of config.allowedFiles) {
+                if (typeof pattern !== 'string' || pattern.trim() === '') {
+                    errors.push(`Invalid file pattern in allowedFiles: ${pattern}`);
+                }
+            }
+        }
+    }
+    // Validate maxFileSize if specified
+    if (config.maxFileSize !== undefined) {
+        if (typeof config.maxFileSize !== 'number' || config.maxFileSize <= 0) {
+            errors.push(`maxFileSize must be a positive number, got: ${config.maxFileSize}`);
+        }
+        else {
+            // Warn if maxFileSize is very large (> 100MB)
+            if (config.maxFileSize > 100 * 1024 * 1024) {
+                warnings.push(`maxFileSize is very large (${(config.maxFileSize / 1024 / 1024).toFixed(0)}MB)`);
+            }
+        }
+    }
+    // Validate environment variables if specified
+    if (config.environment) {
+        if (typeof config.environment !== 'object' || config.environment === null) {
+            errors.push('environment must be an object');
+        }
+        else {
+            for (const [key, value] of Object.entries(config.environment)) {
+                if (typeof value !== 'string') {
+                    errors.push(`Environment variable ${key} must be a string`);
+                }
+            }
+        }
+    }
+    // Warn if no entry point defined
+    if (!config.entryPoint) {
+        warnings.push('No entry point defined. Agent may not be executable.');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Parse Generic agent configuration
+ *
+ * This function reads agent.json, agent.yaml, agent.yml, or .agentvault.json file
+ * and returns a fully validated configuration object.
+ *
+ * @param sourcePath - Path to agent source directory
+ * @param verbose - Enable verbose logging
+ * @returns Parsed and validated Generic configuration
+ */
+export async function parseGenericConfig(sourcePath, verbose = false) {
+    if (verbose) {
+        console.log(`[Generic] Parsing configuration from: ${sourcePath}`);
+    }
+    const configLocation = findGenericConfig(sourcePath);
+    if (configLocation === null) {
+        throw new Error('No Generic agent configuration found. ' +
+            'Expected agent.json, agent.yaml, agent.yml, or .agentvault.json file in the agent source path.');
+    }
+    if (verbose) {
+        console.log(`[Generic] Found ${configLocation.type.toUpperCase()} config: ${configLocation.path}`);
+    }
+    let config;
+    try {
+        const content = fs.readFileSync(configLocation.path, 'utf-8');
+        // Parse based on file type
+        if (configLocation.type === 'json') {
+            const parsed = JSON.parse(content);
+            config = {
+                type: 'generic',
+                name: parsed.name || 'generic-agent',
+                version: parsed.version,
+                description: parsed.description,
+                entryPoint: parsed.entryPoint,
+                workingDirectory: parsed.workingDirectory,
+                environment: parsed.environment || {},
+                allowedFiles: parsed.allowedFiles,
+                maxFileSize: parsed.maxFileSize,
+            };
+        }
+        else {
+            // YAML
+            const parsed = yaml.parse(content);
+            config = {
+                type: 'generic',
+                name: parsed.name || 'generic-agent',
+                version: parsed.version,
+                description: parsed.description,
+                entryPoint: parsed.entryPoint,
+                workingDirectory: parsed.workingDirectory,
+                environment: parsed.environment || {},
+                allowedFiles: parsed.allowedFiles,
+                maxFileSize: parsed.maxFileSize,
+            };
+        }
+        if (verbose) {
+            console.log(`[Generic] Parsed name: ${config.name}`);
+            console.log(`[Generic] Parsed version: ${config.version}`);
+            console.log(`[Generic] Parsed entryPoint: ${config.entryPoint || 'none'}`);
+            console.log(`[Generic] Parsed workingDirectory: ${config.workingDirectory || 'none'}`);
+            console.log(`[Generic] Parsed environment keys: ${Object.keys(config.environment || {}).length}`);
+            console.log(`[Generic] Parsed allowedFiles: ${config.allowedFiles?.length || 0}`);
+            console.log(`[Generic] Parsed maxFileSize: ${config.maxFileSize || 'unlimited'}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse Generic config: ${message}`);
+    }
+    // Validate configuration
+    const validation = validateGenericConfig(config);
+    if (!validation.valid) {
+        const errorMessage = `Generic agent configuration validation failed:\n${validation.errors.map(e => `  - ${e}`).join('\n')}`;
+        throw new Error(errorMessage);
+    }
+    // Display warnings if verbose
+    if (verbose && validation.warnings.length > 0) {
+        console.log(`[Generic] Warnings:`);
+        for (const warning of validation.warnings) {
+            console.log(`[Generic]   - ${warning}`);
+        }
+    }
+    return config;
+}
+/**
+ * Find all Generic configurations in a directory tree
+ *
+ * @param rootPath - Root directory to search
+ * @returns Array of paths to Generic configuration files
+ */
+export function findGenericConfigs(rootPath) {
+    const configs = [];
+    function searchDirectory(dirPath) {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules and .git
+                if (entry.name !== 'node_modules' && entry.name !== '.git') {
+                    searchDirectory(fullPath);
+                }
+            }
+            else if (entry.isFile()) {
+                // Check for Generic config files
+                if (entry.name === 'agent.json' ||
+                    entry.name === 'agent.yaml' ||
+                    entry.name === 'agent.yml' ||
+                    entry.name === 'agentvault.json' ||
+                    entry.name === '.agentvault.json') {
+                    configs.push(fullPath);
+                }
+            }
+        }
+    }
+    searchDirectory(rootPath);
+    return configs;
+}
+//# sourceMappingURL=generic.js.map