agentvault 1.0.1 → 1.0.2

package/src/packaging/parsers/clawdbot.ts

@@ -1,278 +0,0 @@
-/**
- * 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 type {
-  ClawdbotConfig,
-  ConfigLocation,
-  ConfigValidationResult,
-} from '../config-schemas.js';
-import {
-  DEFAULT_CLAWDBOT_SETTINGS,
-  type ClawdbotProject,
-  type ClawdbotTask,
-  type ClawdbotSettings,
-} from '../config-schemas.js';
-
-/**
- * Find Clawdbot directory or configuration file
- */
-function findClawdbotConfig(sourcePath: string): ConfigLocation | null {
-  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: string): ClawdbotConfig {
-  try {
-    // Read projects
-    const projectsPath = path.join(dirPath, 'projects.json');
-    let projects: ClawdbotProject[] = [];
-    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: ClawdbotTask[] = [];
-    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: Record<string, unknown> = {};
-    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: ClawdbotSettings = { ...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: ClawdbotConfig = {
-      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: ClawdbotConfig): ConfigValidationResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  // 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: string,
-  verbose: boolean = false
-): Promise<ClawdbotConfig> {
-  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: ClawdbotConfig;
-
-  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: string): Promise<string[]> {
-  const results: string[] = [];
-
-  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;
-}

package/src/packaging/parsers/cline.ts

@@ -1,223 +0,0 @@
-/**
- * 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 type {
-  ClineConfig,
-  ConfigLocation,
-  ConfigValidationResult,
-} from '../config-schemas.js';
-import {
-  DEFAULT_CLINE_CONFIG,
-} from '../config-schemas.js';
-
-/**
- * Find Cline configuration file
- */
-function findClineConfig(sourcePath: string): ConfigLocation | null {
-  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: ClineConfig): ConfigValidationResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  // 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: string,
-  verbose: boolean = false
-): Promise<ClineConfig> {
-  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: ClineConfig;
-
-  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: string): string[] {
-  const configs: string[] = [];
-
-  function searchDirectory(dirPath: string): void {
-    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;
-}