agentvault 1.0.1 → 1.0.2

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

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

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

@@ -0,0 +1,175 @@
+/**
+ * Goose Configuration Parser
+ *
+ * Parses Goose agent configuration from YAML files.
+ * Reads goose.yaml, goose.yml, or .gooserc files and constructs configuration object.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+import { DEFAULT_GOOSE_CONFIG, } from '../config-schemas.js';
+/**
+ * Find Goose configuration file
+ */
+function findGooseConfig(sourcePath) {
+    const absolutePath = path.resolve(sourcePath);
+    const configFiles = ['goose.yaml', 'goose.yml', '.gooserc'];
+    for (const file of configFiles) {
+        const filePath = path.join(absolutePath, file);
+        if (fs.existsSync(filePath)) {
+            return {
+                path: filePath,
+                type: 'yaml',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Validate Goose configuration
+ */
+function validateGooseConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate name
+    if (!config.name || config.name.trim() === '') {
+        errors.push('Agent name is required');
+    }
+    // Validate model (required for Goose)
+    if (!config.model || config.model.trim() === '') {
+        errors.push('Model is required for Goose agent');
+    }
+    // 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 temperature (must be between 0 and 2)
+    if (config.temperature !== undefined) {
+        if (config.temperature < 0 || config.temperature > 2) {
+            errors.push(`Temperature must be between 0 and 2, got: ${config.temperature}`);
+        }
+    }
+    // Validate maxTokens (must be positive)
+    if (config.maxTokens !== undefined) {
+        if (config.maxTokens <= 0) {
+            errors.push(`maxTokens must be positive, got: ${config.maxTokens}`);
+        }
+    }
+    // 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}`);
+        }
+    }
+    // Warn if no tools defined
+    if (!config.tools || config.tools.length === 0) {
+        warnings.push('No tools defined in configuration');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Parse Goose agent configuration
+ *
+ * This function reads goose.yaml, goose.yml, or .gooserc file
+ * and returns a fully validated configuration object.
+ *
+ * @param sourcePath - Path to agent source directory
+ * @param verbose - Enable verbose logging
+ * @returns Parsed and validated Goose configuration
+ */
+export async function parseGooseConfig(sourcePath, verbose = false) {
+    if (verbose) {
+        console.log(`[Goose] Parsing configuration from: ${sourcePath}`);
+    }
+    const configLocation = findGooseConfig(sourcePath);
+    if (configLocation === null) {
+        throw new Error('No Goose configuration found. ' +
+            'Expected goose.yaml, goose.yml, or .gooserc file in the agent source path.');
+    }
+    if (verbose) {
+        console.log(`[Goose] Found YAML config: ${configLocation.path}`);
+    }
+    let config;
+    try {
+        const content = fs.readFileSync(configLocation.path, 'utf-8');
+        const parsed = yaml.parse(content);
+        // Merge with defaults
+        config = {
+            type: 'goose',
+            name: parsed.name || DEFAULT_GOOSE_CONFIG.name,
+            version: parsed.version || DEFAULT_GOOSE_CONFIG.version,
+            description: parsed.description || DEFAULT_GOOSE_CONFIG.description,
+            model: parsed.model || DEFAULT_GOOSE_CONFIG.model,
+            temperature: parsed.temperature !== undefined ? parsed.temperature : DEFAULT_GOOSE_CONFIG.temperature,
+            maxTokens: parsed.maxTokens !== undefined ? parsed.maxTokens : DEFAULT_GOOSE_CONFIG.maxTokens,
+            systemPrompt: parsed.systemPrompt || DEFAULT_GOOSE_CONFIG.systemPrompt,
+            tools: parsed.tools || DEFAULT_GOOSE_CONFIG.tools,
+            workingDirectory: parsed.workingDirectory || DEFAULT_GOOSE_CONFIG.workingDirectory,
+        };
+        if (verbose) {
+            console.log(`[Goose] Parsed name: ${config.name}`);
+            console.log(`[Goose] Parsed version: ${config.version}`);
+            console.log(`[Goose] Parsed model: ${config.model}`);
+            console.log(`[Goose] Parsed temperature: ${config.temperature}`);
+            console.log(`[Goose] Parsed maxTokens: ${config.maxTokens}`);
+            console.log(`[Goose] Parsed tools: ${config.tools?.length || 0}`);
+            console.log(`[Goose] Parsed workingDirectory: ${config.workingDirectory}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse Goose config: ${message}`);
+    }
+    // Validate configuration
+    const validation = validateGooseConfig(config);
+    if (!validation.valid) {
+        const errorMessage = `Goose 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(`[Goose] Warnings:`);
+        for (const warning of validation.warnings) {
+            console.log(`[Goose]   - ${warning}`);
+        }
+    }
+    return config;
+}
+/**
+ * Find all Goose configurations in a directory tree
+ *
+ * @param rootPath - Root directory to search
+ * @returns Array of paths to Goose configuration files
+ */
+export function findGooseConfigs(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 Goose config files
+                if (entry.name === 'goose.yaml' || entry.name === 'goose.yml' || entry.name === '.gooserc') {
+                    configs.push(fullPath);
+                }
+            }
+        }
+    }
+    searchDirectory(rootPath);
+    return configs;
+}
+//# sourceMappingURL=goose.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Agent Parser Registry
+ *
+ * Central exports for all agent configuration parsers.
+ * Provides convenient imports for Clawdbot, Goose, Cline, and Generic agents.
+ */
+export { parseClawdbotConfig, findClawdbotConfigs } from './clawdbot.js';
+export { parseGooseConfig, findGooseConfigs } from './goose.js';
+export { parseClineConfig, findClineConfigs } from './cline.js';
+export { parseGenericConfig, findGenericConfigs } from './generic.js';
+//# sourceMappingURL=index.d.ts.map

package/{src/packaging/parsers/index.ts → dist/src/packaging/parsers/index.js}

@@ -4,8 +4,8 @@
  * Central exports for all agent configuration parsers.
  * Provides convenient imports for Clawdbot, Goose, Cline, and Generic agents.
  */
-
 export { parseClawdbotConfig, findClawdbotConfigs } from './clawdbot.js';
 export { parseGooseConfig, findGooseConfigs } from './goose.js';
 export { parseClineConfig, findClineConfigs } from './cline.js';
 export { parseGenericConfig, findGenericConfigs } from './generic.js';
+//# sourceMappingURL=index.js.map

package/dist/src/packaging/serializer.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Agent State Serializer
+ *
+ * This module handles serialization and deserialization of agent state
+ * for storage in canisters and local files.
+ */
+import type { AgentConfig } from './types.js';
+/**
+ * Agent state schema version
+ */
+export declare const SCHEMA_VERSION = "1.0.0";
+/**
+ * Memory item in agent state
+ */
+export interface Memory {
+    id: string;
+    type: 'fact' | 'user_preference' | 'task_result';
+    content: unknown;
+    timestamp: number;
+    importance: number;
+}
+/**
+ * Task in agent queue
+ */
+export interface Task {
+    id: string;
+    description: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: unknown;
+    timestamp: number;
+}
+/**
+ * Agent state stored in canister
+ */
+export interface AgentState {
+    config: AgentConfig;
+    memories: Memory[];
+    tasks: Task[];
+    context: Map<string, unknown>;
+    version: string;
+    lastUpdated: number;
+}
+/**
+ * Serialized agent state (for storage/transmission)
+ */
+export interface SerializedAgentState {
+    $schema: string;
+    version: string;
+    agent: {
+        name: string;
+        type: string;
+        version?: string;
+    };
+    metadata: {
+        createdAt: string;
+        sourcePath: string;
+        entryPoint?: string;
+    };
+    state: {
+        initialized: boolean;
+        data: {
+            memories?: Memory[];
+            tasks?: Task[];
+            context?: Record<string, unknown>;
+        };
+    };
+}
+/**
+ * Serialization options
+ */
+export interface SerializationOptions {
+    pretty?: boolean;
+    includeMemories?: boolean;
+    includeTasks?: boolean;
+    includeContext?: boolean;
+}
+/**
+ * Serialize agent state to JSON
+ */
+export declare function serializeState(state: AgentState, options?: SerializationOptions): string;
+/**
+ * Deserialize agent state from JSON
+ */
+export declare function deserializeState(json: string): AgentState;
+/**
+ * Write serialized state to file
+ */
+export declare function writeStateFile(state: AgentState, filePath: string, options?: SerializationOptions): Promise<void>;
+/**
+ * Read state from file
+ */
+export declare function readStateFile(filePath: string): Promise<AgentState>;
+/**
+ * Create empty agent state
+ */
+export declare function createEmptyState(config: AgentConfig): AgentState;
+/**
+ * Merge two agent states
+ */
+export declare function mergeStates(base: AgentState, updates: Partial<AgentState>): AgentState;
+/**
+ * Validate serialized state
+ */
+export declare function validateState(serialized: SerializedAgentState): {
+    valid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=serializer.d.ts.map

package/dist/src/packaging/serializer.js

@@ -0,0 +1,153 @@
+/**
+ * Agent State Serializer
+ *
+ * This module handles serialization and deserialization of agent state
+ * for storage in canisters and local files.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Agent state schema version
+ */
+export const SCHEMA_VERSION = '1.0.0';
+/**
+ * Default serialization options
+ */
+const DEFAULT_OPTIONS = {
+    pretty: true,
+    includeMemories: true,
+    includeTasks: true,
+    includeContext: true,
+};
+/**
+ * Serialize agent state to JSON
+ */
+export function serializeState(state, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const serialized = {
+        $schema: `https://agentvault.dev/schemas/agent-state-v${SCHEMA_VERSION}.json`,
+        version: SCHEMA_VERSION,
+        agent: {
+            name: state.config.name,
+            type: state.config.type,
+            version: state.config.version,
+        },
+        metadata: {
+            createdAt: new Date().toISOString(),
+            sourcePath: state.config.sourcePath,
+            entryPoint: state.config.entryPoint,
+        },
+        state: {
+            initialized: state.memories.length > 0 || state.tasks.length > 0,
+            data: {},
+        },
+    };
+    if (opts.includeMemories) {
+        serialized.state.data.memories = state.memories;
+    }
+    if (opts.includeTasks) {
+        serialized.state.data.tasks = state.tasks;
+    }
+    if (opts.includeContext) {
+        serialized.state.data.context = mapToObject(state.context);
+    }
+    return JSON.stringify(serialized, null, opts.pretty ? 2 : 0);
+}
+/**
+ * Deserialize agent state from JSON
+ */
+export function deserializeState(json) {
+    const serialized = JSON.parse(json);
+    return {
+        config: {
+            name: serialized.agent.name,
+            type: serialized.agent.type,
+            sourcePath: serialized.metadata.sourcePath,
+            entryPoint: serialized.metadata.entryPoint,
+            version: serialized.agent.version,
+        },
+        memories: serialized.state.data.memories ?? [],
+        tasks: serialized.state.data.tasks ?? [],
+        context: new Map(Object.entries(serialized.state.data.context ?? {})),
+        version: serialized.version,
+        lastUpdated: Date.now(),
+    };
+}
+/**
+ * Write serialized state to file
+ */
+export async function writeStateFile(state, filePath, options = {}) {
+    const serialized = serializeState(state, options);
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Write file
+    fs.writeFileSync(filePath, serialized, 'utf-8');
+}
+/**
+ * Read state from file
+ */
+export async function readStateFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return deserializeState(content);
+}
+/**
+ * Convert Map to plain object
+ */
+function mapToObject(map) {
+    const obj = {};
+    for (const [key, value] of map.entries()) {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Create empty agent state
+ */
+export function createEmptyState(config) {
+    return {
+        config,
+        memories: [],
+        tasks: [],
+        context: new Map(),
+        version: SCHEMA_VERSION,
+        lastUpdated: Date.now(),
+    };
+}
+/**
+ * Merge two agent states
+ */
+export function mergeStates(base, updates) {
+    const merged = {
+        ...base,
+        config: updates.config ?? base.config,
+        memories: updates.memories ?? base.memories,
+        tasks: updates.tasks ?? base.tasks,
+        context: updates.context ?? base.context,
+        version: updates.version ?? base.version,
+        lastUpdated: updates.lastUpdated ?? Date.now(),
+    };
+    return merged;
+}
+/**
+ * Validate serialized state
+ */
+export function validateState(serialized) {
+    const errors = [];
+    if (!serialized.agent?.name) {
+        errors.push('Missing agent name');
+    }
+    if (!serialized.agent?.type) {
+        errors.push('Missing agent type');
+    }
+    if (!serialized.version) {
+        errors.push('Missing version');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+//# sourceMappingURL=serializer.js.map

package/dist/src/packaging/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Types for agent packaging
+ */
+/**
+ * Supported agent types that can be packaged
+ */
+export type AgentType = 'clawdbot' | 'goose' | 'cline' | 'generic';
+/**
+ * Agent configuration as detected from the source directory
+ */
+export interface AgentConfig {
+    /** Name of the agent */
+    name: string;
+    /** Detected agent type */
+    type: AgentType;
+    /** Source directory path */
+    sourcePath: string;
+    /** Entry point file (if detected) */
+    entryPoint?: string;
+    /** Agent version (if detected) */
+    version?: string;
+}
+/**
+ * Options for the packaging process
+ */
+export interface PackageOptions {
+    /** Source directory containing the agent */
+    sourcePath: string;
+    /** Output directory for compiled artifacts */
+    outputPath?: string;
+    /** Force overwrite of existing output files */
+    force?: boolean;
+    /** Skip validation steps */
+    skipValidation?: boolean;
+    /** Compilation target (wasmedge for local, motoko for ICP) */
+    target?: 'wasmedge' | 'motoko' | 'pure-wasm';
+    /** Enable debugging features (source maps, verbose output) */
+    debug?: boolean;
+    /** Optimization level (0-3) */
+    optimize?: number;
+    /** Run ic-wasm optimize after WASM generation (requires ic-wasm) */
+    icWasmOptimize?: boolean;
+    /** Run ic-wasm shrink to remove unused functions (requires ic-wasm) */
+    icWasmShrink?: boolean;
+    /** Validate WASM against Candid .did interface (requires ic-wasm) */
+    candidInterface?: string;
+    /** Memory limit to set via ic-wasm resource (e.g. '4GiB') */
+    memoryLimit?: string;
+    /** Compute quota to set via ic-wasm resource */
+    computeQuota?: string;
+}
+/**
+ * Result of a successful packaging operation
+ */
+export interface PackageResult {
+    /** Detected agent configuration */
+    config: AgentConfig;
+    /** Path to the generated WASM file */
+    wasmPath: string;
+    /** Path to the generated WAT file (WebAssembly Text format) */
+    watPath: string;
+    /** Path to the serialized state JSON */
+    statePath: string;
+    /** Path to the generated JavaScript bundle */
+    jsBundlePath?: string;
+    /** Path to the generated source map (if enabled) */
+    sourceMapPath?: string;
+    /** Path to the generated manifest file */
+    manifestPath?: string;
+    /** Path to the generated Candid interface (if motoko target) */
+    didPath?: string;
+    /** Size of the WASM file in bytes */
+    wasmSize: number;
+    /** Compilation target used */
+    target: 'wasmedge' | 'motoko' | 'pure-wasm';
+    /** Timestamp of the packaging operation */
+    timestamp: Date;
+    /** Compilation duration in milliseconds */
+    duration?: number;
+    /** Number of functions exported */
+    functionCount?: number;
+    /** Original WASM size before ic-wasm optimization (bytes) */
+    originalWasmSize?: number;
+    /** Size reduction percentage from optimization (0-100) */
+    optimizationReductionPercent?: number;
+    /** Whether Candid validation passed */
+    candidValidationPassed?: boolean;
+    /** Optimization warnings */
+    optimizationWarnings?: string[];
+}
+/**
+ * Validation error that occurred during packaging
+ */
+export interface ValidationError {
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** File path related to the error (if applicable) */
+    filePath?: string;
+}
+/**
+ * Result of agent validation
+ */
+export interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** List of validation errors (if any) */
+    errors: ValidationError[];
+    /** List of validation warnings */
+    warnings: string[];
+}
+/**
+ * Parsed agent configuration with agent-specific settings
+ */
+export interface ParsedAgentConfig {
+    base: {
+        name: string;
+        version?: string;
+        description?: string;
+    };
+    type: 'clawdbot' | 'goose' | 'cline' | 'generic';
+}
+/**
+ * Config file location
+ */
+export interface ConfigFilePath {
+    path: string;
+    type: 'json' | 'yaml' | 'directory';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/packaging/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for agent packaging
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/packaging/wasmedge-compiler.d.ts

@@ -0,0 +1,76 @@
+/**
+ * WasmEdge Compiler
+ *
+ * Integrates WasmEdge SDK for compiling JavaScript to WebAssembly.
+ * Provides WASI-compliant module generation for agent execution.
+ */
+import type { AgentConfig } from '../packaging/types.js';
+/**
+ * Compilation target types
+ */
+export type CompilationTarget = 'wasmedge' | 'motoko' | 'pure-wasm';
+/**
+ * WasmEdge compilation options
+ */
+export interface WasmEdgeOptions {
+    /** Enable debugging support */
+    debug?: boolean;
+    /** Generate source maps */
+    sourcemap?: boolean;
+    /** Optimization level (0-3) */
+    optimize?: number;
+    /** Enable WASI support */
+    wasi?: boolean;
+}
+/**
+ * Default WasmEdge options
+ */
+export declare const DEFAULT_WASMEDGE_OPTIONS: WasmEdgeOptions;
+/**
+ * Generate WasmEdge-compatible JavaScript wrapper
+ *
+ * Creates a JavaScript module that implements the standard agent interface
+ * and can be compiled with WasmEdge.
+ */
+export declare function generateWasmEdgeWrapper(agentCode: string, config: AgentConfig): string;
+/**
+ * Generate WasmEdge build configuration
+ *
+ * Creates configuration for WasmEdge compiler.
+ */
+export declare function generateWasmEdgeConfig(config: AgentConfig, options?: WasmEdgeOptions): string;
+/**
+ * Validate WasmEdge module
+ *
+ * Checks that a compiled module is valid WasmEdge WASM.
+ */
+export declare function validateWasmEdgeModule(wasmBuffer: Buffer): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate WasmEdge build command
+ *
+ * Returns the command line to compile JavaScript to WasmEdge WASM.
+ * This is a placeholder - actual WasmEdge SDK usage would be integrated.
+ */
+export declare function getWasmEdgeBuildCommand(sourcePath: string, outputPath: string, options?: WasmEdgeOptions): string;
+/**
+ * Extract compilation errors from WasmEdge output
+ *
+ * Parses error messages from WasmEdge compiler output.
+ */
+export declare function parseWasmEdgeErrors(output: string): string[];
+/**
+ * Get source map path for compiled WASM
+ *
+ * Returns the expected source map file path.
+ */
+export declare function getSourceMapPath(wasmPath: string): string;
+/**
+ * Generate module manifest for WasmEdge
+ *
+ * Creates a manifest file with module metadata.
+ */
+export declare function generateWasmEdgeManifest(config: AgentConfig, wasmPath: string, _outputPath: string): string;
+//# sourceMappingURL=wasmedge-compiler.d.ts.map