agentvault 1.0.0 → 1.0.2

package/dist/src/packaging/config-persistence.js

@@ -0,0 +1,108 @@
+/**
+ * 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';
+/**
+ * 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, fileName = 'agent.json') {
+    const agentDir = path.join(AGENTS_DIR, agentId);
+    return path.join(agentDir, fileName);
+}
+/**
+ * Ensure agent vault directories exist
+ */
+export function ensureVaultStructure() {
+    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, config, fileName = 'agent.json') {
+    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(agentId, fileName = 'agent.json') {
+    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);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List all agents in vault
+ *
+ * @returns Array of agent IDs
+ */
+export function listAgents() {
+    ensureVaultStructure();
+    if (!fs.existsSync(AGENTS_DIR)) {
+        return [];
+    }
+    const entries = fs.readdirSync(AGENTS_DIR, { withFileTypes: true });
+    const agentIds = [];
+    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) {
+    const agentDir = path.join(AGENTS_DIR, agentId);
+    if (fs.existsSync(agentDir)) {
+        fs.rmSync(agentDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=config-persistence.js.map

package/dist/src/packaging/config-schemas.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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 declare const DEFAULT_CLAWDBOT_SETTINGS: ClawdbotSettings;
+/**
+ * Default values for Goose configuration
+ */
+export declare const DEFAULT_GOOSE_CONFIG: Omit<GooseConfig, 'type'>;
+/**
+ * Default values for Cline configuration
+ */
+export declare const DEFAULT_CLINE_CONFIG: Omit<ClineConfig, 'type'>;
+//# sourceMappingURL=config-schemas.d.ts.map

package/dist/src/packaging/config-schemas.js

@@ -0,0 +1,43 @@
+/**
+ * Agent Configuration Schemas
+ *
+ * Defines types and schemas for different agent configurations.
+ * Supports Clawdbot, Goose, Cline, and Generic agents.
+ */
+/**
+ * Default values for Clawdbot settings
+ */
+export const DEFAULT_CLAWDBOT_SETTINGS = {
+    model: 'claude-3-5-sonnet-20240229',
+    temperature: 0.7,
+    maxTokens: 4096,
+    systemPrompt: '',
+    tools: [],
+};
+/**
+ * Default values for Goose configuration
+ */
+export const DEFAULT_GOOSE_CONFIG = {
+    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 = {
+    mode: 'auto',
+    autoConfirm: false,
+    useReadline: true,
+    workingDirectory: '.',
+    name: 'Agent',
+    version: '1.0.0',
+    description: '',
+};
+//# sourceMappingURL=config-schemas.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Agent type detection logic
+ *
+ * Detects what type of agent is in a given directory based on
+ * configuration files and directory structure.
+ */
+import type { AgentType, AgentConfig } from './types.js';
+/**
+ * Detect agent type from a source directory
+ */
+export declare function detectAgentType(sourcePath: string): AgentType;
+/**
+ * Detect agent configuration from a source directory
+ *
+ * @param sourcePath - Path to agent directory
+ * @returns Agent configuration with basic detection
+ */
+export declare function detectAgent(sourcePath: string): AgentConfig;
+/**
+ * Validate that the source path exists and is a directory
+ */
+export declare function validateSourcePath(sourcePath: string): {
+    valid: boolean;
+    error?: string;
+};
+//# sourceMappingURL=detector.d.ts.map

package/dist/src/packaging/detector.js

@@ -0,0 +1,193 @@
+/**
+ * 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';
+/**
+ * Configuration file patterns for each agent type
+ */
+const AGENT_PATTERNS = {
+    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) {
+    try {
+        return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a directory exists at the given path
+ */
+function directoryExists(dirPath) {
+    try {
+        return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect agent type from a source directory
+ */
+export function detectAgentType(sourcePath) {
+    const absolutePath = path.resolve(sourcePath);
+    for (const agentType of ['clawdbot', 'goose', 'cline']) {
+        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, config) {
+    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, agentType) {
+    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, agentType) {
+    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) {
+    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,
+    };
+}
+/**
+ * Validate that the source path exists and is a directory
+ */
+export function validateSourcePath(sourcePath) {
+    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) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // Check file extension to determine format
+        if (filePath.endsWith('.json')) {
+            return JSON.parse(content);
+        }
+        else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml') || filePath.endsWith('.gooserc')) {
+            return yaml.parse(content);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=detector.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Agent Packaging Module
+ *
+ * Exports all packaging-related functionality.
+ */
+export type { AgentType, AgentConfig, PackageOptions, PackageResult, ValidationError, ValidationResult, } from './types.js';
+export { detectAgent, detectAgentType, validateSourcePath } from './detector.js';
+export { compileToWasm, generateWasm, generateWat, generateStateJson, validateWasmFile, } from './compiler.js';
+export { generateWasmEdgeWrapper, validateWasmEdgeModule, generateWasmEdgeConfig, generateWasmEdgeManifest, type WasmEdgeOptions, DEFAULT_WASMEDGE_OPTIONS, } from './wasmedge-compiler.js';
+export { serializeState, deserializeState, writeStateFile, readStateFile, createEmptyState, mergeStates, validateState, } from './serializer.js';
+export { parseClawdbotConfig, findClawdbotConfigs, parseGooseConfig, findGooseConfigs, parseClineConfig, findClineConfigs, parseGenericConfig, findGenericConfigs, } from './parsers/index.js';
+export { getConfigPath, writeAgentConfig, readAgentConfig, listAgents, deleteAgentConfig, } from './config-persistence.js';
+export { DEFAULT_CLAWDBOT_SETTINGS, DEFAULT_GOOSE_CONFIG, DEFAULT_CLINE_CONFIG, } from './config-schemas.js';
+export { getPackageSummary, packageAgent, } from './packager.js';
+export type { Memory, Task, AgentState, SerializedAgentState, SerializationOptions, } from './serializer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/packaging/index.js

@@ -0,0 +1,22 @@
+/**
+ * Agent Packaging Module
+ *
+ * Exports all packaging-related functionality.
+ */
+// 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, 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';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Agent Packager
+ *
+ * Main orchestrator for the agent packaging pipeline.
+ * Coordinates detection, validation, and compilation.
+ */
+import type { PackageOptions, PackageResult, ValidationResult } from './types.js';
+import { detectAgent } from './detector.js';
+/**
+ * Validate agent before packaging
+ */
+export declare function validateAgent(sourcePath: string): ValidationResult;
+/**
+ * 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 declare function packageAgent(options: PackageOptions): Promise<PackageResult>;
+/**
+ * Get a summary of what will be packaged
+ *
+ * Useful for preview/dry-run functionality
+ */
+export declare function getPackageSummary(sourcePath: string): {
+    config: ReturnType<typeof detectAgent>;
+    validation: ValidationResult;
+};
+//# sourceMappingURL=packager.d.ts.map

package/dist/src/packaging/packager.js

@@ -0,0 +1,90 @@
+/**
+ * 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 { 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) {
+    const errors = [];
+    const warnings = [];
+    // 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) {
+    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) {
+    const config = detectAgent(sourcePath);
+    const validation = validateAgent(sourcePath);
+    return { config, validation };
+}
+//# sourceMappingURL=packager.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * Clawdbot Configuration Parser
+ *
+ * Parses Clawdbot agent configuration from .clawdbot directory.
+ * Reads JSON files and constructs full configuration object.
+ */
+import type { ClawdbotConfig } from '../config-schemas.js';
+/**
+ * Parse Clawdbot agent configuration
+ *
+ * This function reads .clawdbot directory or clawdbot.json file
+ * and returns a fully validated configuration object.
+ */
+export declare function parseClawdbotConfig(sourcePath: string, verbose?: boolean): Promise<ClawdbotConfig>;
+/**
+ * Find all Clawdbot configurations in a directory
+ */
+export declare function findClawdbotConfigs(dir: string): Promise<string[]>;
+//# sourceMappingURL=clawdbot.d.ts.map