agentvault 1.0.1 → 1.0.5

package/src/packaging/config-persistence.ts

@@ -1,135 +0,0 @@
-/**
- * Config Persistence Module
- *
- * Manages agent configuration storage in ~/.agentvault/agents/<agent-id>/
- * Supports reading, writing, and listing agent configurations.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import type { ParsedAgentConfig } from './config-schemas.js';
-
-/**
- * Base agent vault directory
- */
-const AGENT_VAULT_DIR = path.join(os.homedir(), '.agentvault');
-
-/**
- * Agents directory within agent vault
- */
-const AGENTS_DIR = path.join(AGENT_VAULT_DIR, 'agents');
-
-/**
- * Get config file path for an agent
- *
- * @param agentId - Agent identifier
- * @param fileName - Name of the config file (default: 'agent.json')
- */
-export function getConfigPath(agentId: string, fileName: string = 'agent.json'): string {
-  const agentDir = path.join(AGENTS_DIR, agentId);
-  return path.join(agentDir, fileName);
-}
-
-/**
- * Ensure agent vault directories exist
- */
-export function ensureVaultStructure(): void {
-  if (!fs.existsSync(AGENT_VAULT_DIR)) {
-    fs.mkdirSync(AGENT_VAULT_DIR, { recursive: true, mode: 0o700 });
-  }
-  
-  if (!fs.existsSync(AGENTS_DIR)) {
-    fs.mkdirSync(AGENTS_DIR, { recursive: true, mode: 0o700 });
-  }
-}
-
-/**
- * Write agent configuration to vault
- *
- * @param agentId - Agent identifier
- * @param config - Parsed agent configuration
- * @param fileName - Name of the config file (default: 'agent.json')
- */
-export function writeAgentConfig(
-  agentId: string,
-  config: ParsedAgentConfig,
-  fileName: string = 'agent.json'
-): void {
-  ensureVaultStructure();
-  
-  const agentDir = path.join(AGENTS_DIR, agentId);
-  
-  if (!fs.existsSync(agentDir)) {
-    fs.mkdirSync(agentDir, { recursive: true, mode: 0o700 });
-  }
-  
-  const configPath = path.join(agentDir, fileName);
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-
-/**
- * Read agent configuration from vault
- *
- * @param agentId - Agent identifier
- * @param fileName - Name of the config file (default: 'agent.json')
- */
-export function readAgentConfig<T extends ParsedAgentConfig>(
-  agentId: string,
-  fileName: string = 'agent.json'
-): T | null {
-  ensureVaultStructure();
-  
-  const agentDir = path.join(AGENTS_DIR, agentId);
-  const configPath = path.join(agentDir, fileName);
-  
-  if (!fs.existsSync(configPath)) {
-    return null;
-  }
-  
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(content) as T;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * List all agents in vault
- *
- * @returns Array of agent IDs
- */
-export function listAgents(): string[] {
-  ensureVaultStructure();
-  
-  if (!fs.existsSync(AGENTS_DIR)) {
-    return [];
-  }
-  
-  const entries = fs.readdirSync(AGENTS_DIR, { withFileTypes: true });
-  const agentIds: string[] = [];
-  
-  for (const entry of entries) {
-    const entryPath = path.join(AGENTS_DIR, entry.name);
-    const stats = fs.statSync(entryPath);
-    if (stats.isDirectory() && fs.existsSync(path.join(entryPath, 'agent.json'))) {
-      agentIds.push(entry.name);
-    }
-  }
-  
-  return agentIds;
-}
-
-/**
- * Delete an agent's configuration from vault
- *
- * @param agentId - Agent identifier to remove
- */
-export function deleteAgentConfig(agentId: string): void {
-  const agentDir = path.join(AGENTS_DIR, agentId);
-  
-  if (fs.existsSync(agentDir)) {
-    fs.rmSync(agentDir, { recursive: true, force: true });
-  }
-}

package/src/packaging/config-schemas.ts

@@ -1,156 +0,0 @@
-/**
- * Agent Configuration Schemas
- *
- * Defines types and schemas for different agent configurations.
- * Supports Clawdbot, Goose, Cline, and Generic agents.
- */
-
-/**
- * Base agent configuration interface
- */
-export interface BaseAgentConfig {
-  name: string;
-  version?: string;
-  description?: string;
-}
-
-/**
- * Clawdbot configuration interface
- * Clawdbot uses a .clawdbot directory with JSON files
- */
-export interface ClawdbotConfig extends BaseAgentConfig {
-  type: 'clawdbot';
-  projects?: ClawdbotProject[];
-  tasks?: ClawdbotTask[];
-  context?: Record<string, unknown>;
-  settings?: ClawdbotSettings;
-}
-
-export interface ClawdbotProject {
-  id: string;
-  name: string;
-  path?: string;
-  description?: string;
-}
-
-export interface ClawdbotTask {
-  id: string;
-  name: string;
-  description?: string;
-  prompt?: string;
-  systemPrompt?: string;
-}
-
-export interface ClawdbotSettings {
-  model?: string;
-  temperature?: number;
-  maxTokens?: number;
-  systemPrompt?: string;
-  tools?: string[];
-}
-
-/**
- * Goose configuration interface
- * Goose uses YAML configuration files
- */
-export interface GooseConfig extends BaseAgentConfig {
-  type: 'goose';
-  model: string;
-  temperature?: number;
-  maxTokens?: number;
-  systemPrompt?: string;
-  tools?: string[];
-  workingDirectory?: string;
-}
-
-/**
- * Cline configuration interface
- * Cline uses JSON configuration
- */
-export interface ClineConfig extends BaseAgentConfig {
-  type: 'cline';
-  mode?: 'auto' | 'request';
-  claudeVersion?: string;
-  workingDirectory?: string;
-  autoConfirm?: boolean;
-  useReadline?: boolean;
-  allowedCommands?: string[];
-}
-
-/**
- * Generic agent configuration interface
- * Generic agents use agent.json or agent.yaml
- */
-export interface GenericConfig extends BaseAgentConfig {
-  type: 'generic';
-  entryPoint?: string;
-  workingDirectory?: string;
-  environment?: Record<string, string>;
-  allowedFiles?: string[];
-  maxFileSize?: number;
-}
-
-/**
- * Union type for all agent configurations
- */
-export type ParsedAgentConfig =
-  | ClawdbotConfig
-  | GooseConfig
-  | ClineConfig
-  | GenericConfig;
-
-/**
- * Validation result for agent configuration
- */
-export interface ConfigValidationResult {
-  valid: boolean;
-  errors: string[];
-  warnings: string[];
-}
-
-/**
- * Config file location
- */
-export interface ConfigLocation {
-  path: string;
-  type: 'json' | 'yaml' | 'directory';
-}
-
-/**
- * Default values for Clawdbot settings
- */
-export const DEFAULT_CLAWDBOT_SETTINGS: ClawdbotSettings = {
-  model: 'claude-3-5-sonnet-20240229',
-  temperature: 0.7,
-  maxTokens: 4096,
-  systemPrompt: '',
-  tools: [],
-};
-
-/**
- * Default values for Goose configuration
- */
-export const DEFAULT_GOOSE_CONFIG: Omit<GooseConfig, 'type'> = {
-  model: 'gpt-4',
-  temperature: 0.7,
-  maxTokens: 2048,
-  systemPrompt: '',
-  tools: [],
-  workingDirectory: '.',
-  name: 'Agent',
-  version: '1.0.0',
-  description: '',
-};
-
-/**
- * Default values for Cline configuration
- */
-export const DEFAULT_CLINE_CONFIG: Omit<ClineConfig, 'type'> = {
-  mode: 'auto',
-  autoConfirm: false,
-  useReadline: true,
-  workingDirectory: '.',
-  name: 'Agent',
-  version: '1.0.0',
-  description: '',
-};

package/src/packaging/detector.ts

@@ -1,220 +0,0 @@
-/**
- * Agent type detection logic
- *
- * Detects what type of agent is in a given directory based on
- * configuration files and directory structure.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as yaml from 'yaml';
-import type { AgentType, AgentConfig } from './types.js';
-
-/**
- * Configuration file patterns for each agent type
- */
-const AGENT_PATTERNS: Record<AgentType, { files: string[]; dirs: string[] }> = {
-  clawdbot: {
-    files: ['clawdbot.json', 'clawdbot.config.json', '.clawdbot'],
-    dirs: ['.clawdbot'],
-  },
-  goose: {
-    files: ['goose.yaml', 'goose.yml', 'goose.config.yaml', '.gooserc'],
-    dirs: ['.goose'],
-  },
-  cline: {
-    files: ['cline.json', 'cline.config.json', '.cline'],
-    dirs: ['.cline'],
-  },
-  generic: {
-    files: ['agent.json', 'agent.yaml', 'agent.yml', 'agentvault.json'],
-    dirs: [],
-  },
-};
-
-/**
- * Check if a file exists at the given path
- */
-function fileExists(filePath: string): boolean {
-  try {
-    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if a directory exists at the given path
- */
-function directoryExists(dirPath: string): boolean {
-  try {
-    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Detect agent type from a source directory
- */
-export function detectAgentType(sourcePath: string): AgentType {
-  const absolutePath = path.resolve(sourcePath);
-
-  for (const agentType of ['clawdbot', 'goose', 'cline'] as AgentType[]) {
-    const patterns = AGENT_PATTERNS[agentType];
-
-    for (const file of patterns.files) {
-      const filePath = path.join(absolutePath, file);
-      if (fileExists(filePath)) {
-        return agentType;
-      }
-    }
-
-    for (const dir of patterns.dirs) {
-      const dirPath = path.join(absolutePath, dir);
-      if (directoryExists(dirPath)) {
-        return agentType;
-      }
-    }
-  }
-
-  return 'generic';
-}
-
-/**
- * Extract agent name from the source path or config
- */
-function extractAgentName(sourcePath: string, config: Record<string, unknown> | null): string {
-  if (config && typeof config.name === 'string' && config.name.trim()) {
-    return config.name.trim();
-  }
-
-  const dirName = path.basename(path.resolve(sourcePath));
-
-  const sanitizedName = dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-
-  return sanitizedName;
-}
-
-/**
- * Find configuration file for a detected agent type
- */
-function findConfigFile(sourcePath: string, agentType: AgentType): string | null {
-  const absolutePath = path.resolve(sourcePath);
-  const patterns = AGENT_PATTERNS[agentType];
-
-  for (const file of patterns.files) {
-    const filePath = path.join(absolutePath, file);
-    if (fileExists(filePath)) {
-      return filePath;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Detect entry point for an agent
- */
-function detectEntryPoint(sourcePath: string, agentType: AgentType): string | undefined {
-  const absolutePath = path.resolve(sourcePath);
-
-  const entryPoints = [
-    'index.ts',
-    'index.js',
-    'main.ts',
-    'main.js',
-    'agent.ts',
-    'agent.js',
-    'src/index.ts',
-    'src/index.js',
-    'src/main.ts',
-    'src/main.js',
-  ];
-
-  if (agentType === 'clawdbot') {
-    entryPoints.unshift('clawdbot.ts', 'clawdbot.js');
-  } else if (agentType === 'goose') {
-    entryPoints.unshift('goose.ts', 'goose.js');
-  } else if (agentType === 'cline') {
-    entryPoints.unshift('cline.ts', 'cline.js');
-  }
-
-  for (const entry of entryPoints) {
-    const entryPath = path.join(absolutePath, entry);
-    if (fileExists(entryPath)) {
-      return entry;
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Detect agent configuration from a source directory
- *
- * @param sourcePath - Path to agent directory
- * @returns Agent configuration with basic detection
- */
-export function detectAgent(sourcePath: string): AgentConfig {
-  const absolutePath = path.resolve(sourcePath);
-
-  const agentType = detectAgentType(sourcePath);
-
-  const configFile = findConfigFile(sourcePath, agentType);
-  const config = configFile ? tryReadConfig(configFile) : null;
-
-  const name = extractAgentName(sourcePath, config);
-  const entryPoint = detectEntryPoint(sourcePath, agentType);
-
-    return {
-      name,
-      type: agentType,
-      sourcePath: absolutePath,
-      entryPoint,
-      version: (config?.version as string | undefined),
-    };
-}
-
-/**
- * Validate that the source path exists and is a directory
- */
-export function validateSourcePath(sourcePath: string): { valid: boolean; error?: string } {
-  const absolutePath = path.resolve(sourcePath);
-
-  if (!fs.existsSync(absolutePath)) {
-    return {
-      valid: false,
-      error: `Source path does not exist: ${absolutePath}`,
-    };
-  }
-
-  if (!fs.statSync(absolutePath).isDirectory()) {
-    return {
-      valid: false,
-      error: `Source path is not a directory: ${absolutePath}`,
-    };
-  }
-
-  return { valid: true };
-}
-
-/**
- * Try to read configuration file (JSON or YAML)
- */
-function tryReadConfig(filePath: string): Record<string, unknown> | null {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-
-    // Check file extension to determine format
-    if (filePath.endsWith('.json')) {
-      return JSON.parse(content) as Record<string, unknown>;
-    } else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml') || filePath.endsWith('.gooserc')) {
-      return yaml.parse(content) as Record<string, unknown>;
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}

package/src/packaging/index.ts

@@ -1,90 +0,0 @@
-/**
- * Agent Packaging Module
- *
- * Exports all packaging-related functionality.
- */
-
-// Types
-export type {
-  AgentType,
-  AgentConfig,
-  PackageOptions,
-  PackageResult,
-  ValidationError,
-  ValidationResult,
-} from './types.js';
-
-// Detection
-export { detectAgent, detectAgentType, validateSourcePath } from './detector.js';
-
-// Compilation
-export {
-  compileToWasm,
-  generateWasm,
-  generateWat,
-  generateStateJson,
-  validateWasmFile,
-} from './compiler.js';
-
-// WasmEdge Compiler
-export {
-  generateWasmEdgeWrapper,
-  validateWasmEdgeModule,
-  generateWasmEdgeConfig,
-  generateWasmEdgeManifest,
-  type WasmEdgeOptions,
-  DEFAULT_WASMEDGE_OPTIONS,
-} from './wasmedge-compiler.js';
-
-// Serialization
-export {
-  serializeState,
-  deserializeState,
-  writeStateFile,
-  readStateFile,
-  createEmptyState,
-  mergeStates,
-  validateState,
-} from './serializer.js';
-
-// Parsers
-export {
-  parseClawdbotConfig,
-  findClawdbotConfigs,
-  parseGooseConfig,
-  findGooseConfigs,
-  parseClineConfig,
-  findClineConfigs,
-  parseGenericConfig,
-  findGenericConfigs,
-} from './parsers/index.js';
-
-// Config Persistence
-export {
-  getConfigPath,
-  writeAgentConfig,
-  readAgentConfig,
-  listAgents,
-  deleteAgentConfig,
-} from './config-persistence.js';
-
-// Config Schemas
-export {
-  DEFAULT_CLAWDBOT_SETTINGS,
-  DEFAULT_GOOSE_CONFIG,
-  DEFAULT_CLINE_CONFIG,
-} from './config-schemas.js';
-
-// Summary - used by package command
-export {
-  getPackageSummary,
-  packageAgent,
-} from './packager.js';
-
-export type {
-  Memory,
-  Task,
-  AgentState,
-  SerializedAgentState,
-  SerializationOptions,
-} from './serializer.js';

package/src/packaging/packager.ts

@@ -1,118 +0,0 @@
-/**
- * Agent Packager
- *
- * Main orchestrator for the agent packaging pipeline.
- * Coordinates detection, validation, and compilation.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { PackageOptions, PackageResult, ValidationResult, ValidationError } from './types.js';
-import { detectAgent, validateSourcePath } from './detector.js';
-import { compileToWasm } from './compiler.js';
-
-/**
- * Default output directory name
- */
-const DEFAULT_OUTPUT_DIR = 'dist';
-
-/**
- * Validate agent before packaging
- */
-export function validateAgent(sourcePath: string): ValidationResult {
-  const errors: ValidationError[] = [];
-  const warnings: string[] = [];
-
-  // Validate source path exists
-  const pathValidation = validateSourcePath(sourcePath);
-  if (!pathValidation.valid) {
-    errors.push({
-      code: 'INVALID_SOURCE_PATH',
-      message: pathValidation.error!,
-      filePath: sourcePath,
-    });
-    return { valid: false, errors, warnings };
-  }
-
-  // Detect agent to check for basic configuration
-  const config = detectAgent(sourcePath);
-
-  // Warn if no entry point detected
-  if (!config.entryPoint) {
-    warnings.push(
-      `No entry point detected for agent '${config.name}'. Consider adding an index.ts or agent.ts file.`
-    );
-  }
-
-  if (config.type === 'goose' && !config.entryPoint) {
-    const pythonCandidates = ['goose.py', 'main.py'];
-    const hasPythonEntrypoint = pythonCandidates.some((candidate) =>
-      fs.existsSync(path.join(path.resolve(sourcePath), candidate))
-    );
-    if (hasPythonEntrypoint) {
-      warnings.push(
-        'Goose Python entrypoints are not supported by the bundler. Use a JS/TS entrypoint instead.'
-      );
-    }
-  }
-
-  // Warn if using generic type
-  if (config.type === 'generic') {
-    warnings.push(
-      `Agent type detected as 'generic'. For better support, add a config file for clawdbot, goose, or cline.`
-    );
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-  };
-}
-
-/**
- * Package an agent for deployment
- *
- * This is the main entry point for the packaging pipeline.
- *
- * @param options - Packaging options
- * @returns Package result with paths to generated files
- */
-export async function packageAgent(options: PackageOptions): Promise<PackageResult> {
-  const { sourcePath, outputPath, skipValidation = false } = options;
-
-  // Validate unless skipped
-  if (!skipValidation) {
-    const validation = validateAgent(sourcePath);
-    if (!validation.valid) {
-      const errorMessages = validation.errors.map((e) => e.message).join('; ');
-      throw new Error(`Validation failed: ${errorMessages}`);
-    }
-  }
-
-  // Detect agent configuration
-  const config = detectAgent(sourcePath);
-
-  // Determine output directory
-  const outputDir = outputPath ?? path.join(path.resolve(sourcePath), DEFAULT_OUTPUT_DIR);
-
-  // Compile to WASM (includes ic-wasm optimization pipeline)
-  const result = await compileToWasm(config, options, outputDir);
-
-  return result;
-}
-
-/**
- * Get a summary of what will be packaged
- *
- * Useful for preview/dry-run functionality
- */
-export function getPackageSummary(sourcePath: string): {
-  config: ReturnType<typeof detectAgent>;
-  validation: ValidationResult;
-} {
-  const config = detectAgent(sourcePath);
-  const validation = validateAgent(sourcePath);
-
-  return { config, validation };
-}