agentvault 1.0.0

package/src/packaging/config-persistence.ts

@@ -0,0 +1,135 @@
+/**
+ * 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

@@ -0,0 +1,156 @@
+/**
+ * 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

@@ -0,0 +1,220 @@
+/**
+ * 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

@@ -0,0 +1,90 @@
+/**
+ * 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

@@ -0,0 +1,118 @@
+/**
+ * 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 };
+}