agentvault 1.0.0

package/dist/cli/commands/inference.js

@@ -0,0 +1,225 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BittensorClient, getCachedInference, setCachedInference, clearCache, getCacheStats, formatInferenceTime, } from '../../src/inference/index.js';
+const inferenceCmd = new Command('inference');
+inferenceCmd
+    .description('[Experimental] Query AI inference services (Bittensor network)')
+    .action(async () => {
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.'));
+    console.log(chalk.yellow('Please specify a subcommand: query, subnets, modules, cache, or stats'));
+    console.log(chalk.gray(`\nExamples:
+  ${chalk.cyan('soulrecall inference query <netuid> <inputs>')}${chalk.gray('    Query inference')}
+  ${chalk.cyan('soulrecall inference subnets')}${chalk.gray('               List Bittensor subnets')}
+  ${chalk.cyan('soulrecall inference modules <netuid>')}${chalk.gray('         List subnet modules')}
+  ${chalk.cyan('soulrecall inference cache clear')}${chalk.gray('           Clear inference cache')}
+  ${chalk.cyan('soulrecall inference cache stats')}${chalk.gray('           Show cache statistics')}`));
+});
+inferenceCmd
+    .command('query')
+    .description('Query AI inference from Bittensor network')
+    .argument('<netuid>', 'Subnet UID')
+    .argument('<inputs>', 'Inference inputs (JSON string)')
+    .option('--uid <number>', 'Module UID (defaults to best module)')
+    .option('--batch <number>', 'Query multiple modules (default: 1)', '1')
+    .option('--timeout <ms>', 'Request timeout', '30000')
+    .option('--no-cache', 'Disable caching', false)
+    .action(async (netuidArg, inputsArg, options) => {
+    const spinner = ora(`Querying subnet ${netuidArg}...`).start();
+    try {
+        const netuid = parseInt(netuidArg, 10);
+        if (isNaN(netuid)) {
+            spinner.fail(chalk.red('Invalid netuid'));
+            process.exit(1);
+        }
+        const inputs = JSON.parse(inputsArg);
+        const config = {
+            netuid,
+            uid: options.uid ? parseInt(options.uid, 10) : undefined,
+            batchSize: parseInt(options.batch, 10),
+            timeout: parseInt(options.timeout, 10),
+            enableCache: !options.noCache,
+        };
+        const client = new BittensorClient();
+        if (!options.noCache) {
+            const cached = getCachedInference(netuid, inputs);
+            if (cached) {
+                spinner.succeed(chalk.green('Using cached result'));
+                console.log(chalk.gray(`Cached at: ${cached.timestamp.toLocaleString()}`));
+                console.log(chalk.gray(`Expires: ${cached.expiresAt.toLocaleString()}`));
+                console.log(JSON.stringify(cached.result, null, 2));
+                return;
+            }
+        }
+        const batchSize = config.batchSize || 1;
+        const startTime = Date.now();
+        const inference = async () => {
+            if (config.uid) {
+                return client.infer({ netuid, uid: config.uid, inputs });
+            }
+            else if (batchSize > 1) {
+                const results = await client.batchInfer({ netuid, inputs }, batchSize);
+                return {
+                    success: results.length > 0,
+                    data: results[0]?.data,
+                    metadata: results[0]?.metadata,
+                };
+            }
+            else {
+                const bestModule = await client.findBestModule(netuid);
+                if (!bestModule) {
+                    return { success: false, error: 'No modules found' };
+                }
+                return client.infer({ netuid, uid: bestModule.uid, inputs });
+            }
+        };
+        const response = await inference();
+        const responseTime = Date.now() - startTime;
+        if (response.success) {
+            spinner.succeed(chalk.green(`Inference complete (${formatInferenceTime(responseTime)})`));
+            console.log(JSON.stringify(response.data, null, 2));
+            if (response.metadata) {
+                console.log(chalk.gray(`\nModule: ${response.metadata.name} (${response.metadata.uid})`));
+                console.log(chalk.gray(`Response time: ${formatInferenceTime(response.metadata.responseTime)}`));
+            }
+            if (!options.noCache && response.data) {
+                setCachedInference(netuid, inputs, response.data, 3600000);
+            }
+        }
+        else {
+            spinner.fail(chalk.red('Inference failed'));
+            if (response.error) {
+                console.error(chalk.red(response.error));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Inference query failed'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+inferenceCmd
+    .command('subnets')
+    .description('List Bittensor subnets')
+    .action(async () => {
+    const spinner = ora('Loading subnets...').start();
+    try {
+        const client = new BittensorClient();
+        const subnets = await client.getSubnets();
+        spinner.succeed(chalk.green(`Found ${subnets.length} subnet(s)`));
+        if (subnets.length === 0) {
+            console.log(chalk.gray('No subnets found'));
+            return;
+        }
+        for (const subnet of subnets) {
+            console.log(`\n${chalk.bold(`NetUID: ${subnet.netuid}`)}`);
+            console.log(`  Name: ${subnet.name}`);
+            console.log(`  Modality: ${subnet.modality}`);
+            console.log(`  Registered: ${subnet.registered} modules`);
+            console.log(`  Tempo: ${subnet.tempo}`);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list subnets'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+inferenceCmd
+    .command('modules')
+    .description('List modules for a subnet')
+    .argument('<netuid>', 'Subnet UID')
+    .action(async (netuidArg) => {
+    const spinner = ora(`Loading modules for subnet ${netuidArg}...`).start();
+    try {
+        const client = new BittensorClient();
+        const netuid = parseInt(netuidArg, 10);
+        const modules = await client.getModules(netuid);
+        spinner.succeed(chalk.green(`Found ${modules.length} module(s)`));
+        if (modules.length === 0) {
+            console.log(chalk.gray('No modules found'));
+            return;
+        }
+        const sorted = modules.sort((a, b) => b.rank - a.rank);
+        for (const module of sorted.slice(0, 20)) {
+            const status = module.validator_permit ? chalk.green('✓') : chalk.gray('○');
+            console.log(`${status} ${chalk.bold(`UID ${module.uid}`)}: ${module.name || 'Unnamed'} (Rank: ${module.rank})`);
+        }
+        if (modules.length > 20) {
+            console.log(chalk.gray(`\n... and ${modules.length - 20} more`));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list modules'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+inferenceCmd
+    .command('cache')
+    .description('Manage inference cache')
+    .argument('<action>', 'Action: clear or stats')
+    .action(async (action) => {
+    switch (action) {
+        case 'clear': {
+            const spinner = ora('Clearing cache...').start();
+            clearCache();
+            spinner.succeed(chalk.green('Cache cleared'));
+            break;
+        }
+        case 'stats':
+            try {
+                const stats = getCacheStats();
+                console.log(chalk.bold('\nCache Statistics:'));
+                console.log(`  Total entries: ${stats.total}`);
+                console.log(`  Expired: ${stats.expired}`);
+                console.log(`  Size: ${(stats.sizeBytes / 1024 / 1024).toFixed(2)} MB`);
+            }
+            catch (error) {
+                console.error(chalk.red('Failed to get cache stats'));
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                console.error(chalk.red(message));
+                process.exit(1);
+            }
+            break;
+        default:
+            console.log(chalk.red('Invalid action. Use "clear" or "stats"'));
+            process.exit(1);
+    }
+});
+inferenceCmd
+    .command('health')
+    .description('Check Bittensor API health')
+    .action(async () => {
+    const spinner = ora('Checking API health...').start();
+    try {
+        const client = new BittensorClient();
+        const status = await client.getApiStatus();
+        if (status.online) {
+            spinner.succeed(chalk.green('Bittensor API is online'));
+            if (status.version) {
+                console.log(chalk.gray(`API version: ${status.version}`));
+            }
+        }
+        else {
+            spinner.fail(chalk.red('Bittensor API is offline'));
+            if (status.error) {
+                console.error(chalk.red(status.error));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to check API health'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+export { inferenceCmd };
+//# sourceMappingURL=inference.js.map

package/dist/cli/commands/info.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Info Command
+ *
+ * Displays detailed canister information.
+ */
+import { Command } from 'commander';
+export declare function infoCommand(): Command;
+//# sourceMappingURL=info.d.ts.map

package/dist/cli/commands/info.js

@@ -0,0 +1,59 @@
+/**
+ * Info Command
+ *
+ * Displays detailed canister information.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getCanisterInfo } from '../../src/monitoring/info.js';
+export function infoCommand() {
+    const command = new Command('info');
+    command
+        .description('Display canister information and status')
+        .argument('<canister-id>', 'Canister ID to query')
+        .option('-t, --thresholds <json>', 'Health check thresholds as JSON')
+        .option('-i, --interval <ms>', 'Polling interval in milliseconds')
+        .option('--max-alerts <n>', 'Maximum number of alerts to display');
+    command
+        .action(async (canisterId, options) => {
+        const thresholds = options.thresholds ? JSON.parse(options.thresholds) : undefined;
+        const monitoringOpts = {
+            canister: canisterId,
+            thresholds,
+            pollInterval: options.interval ? parseInt(options.interval) : undefined,
+            maxSnapshots: options.maxAlerts ? parseInt(options.maxAlerts) : undefined,
+        };
+        const spinner = ora('Fetching canister info...').start();
+        try {
+            const statusInfo = await getCanisterInfo(canisterId, monitoringOpts);
+            spinner.succeed('Canister info retrieved successfully');
+            displayInfo(statusInfo);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            spinner.fail(`Failed to fetch info: ${message}`);
+            throw error;
+        }
+    });
+    return command;
+}
+function displayInfo(statusInfo) {
+    console.log();
+    console.log(chalk.cyan('Canister ID:'), chalk.bold(statusInfo.canisterId));
+    console.log();
+    console.log(chalk.cyan('Status:'), chalk.bold(statusInfo.status));
+    if (statusInfo.memorySize !== undefined) {
+        const memoryMB = Number(statusInfo.memorySize) / (1024 * 1024);
+        console.log(chalk.cyan('Memory:'), chalk.bold(`${memoryMB.toFixed(2)} MB`));
+    }
+    if (statusInfo.cycles !== undefined) {
+        console.log(chalk.cyan('Cycles:'), chalk.bold(statusInfo.cycles.toString()));
+    }
+    if (statusInfo.moduleHash !== undefined) {
+        console.log(chalk.cyan('WASM Hash:'), chalk.bold(statusInfo.moduleHash.substring(0, 16)));
+    }
+    console.log();
+    console.log(chalk.cyan('Timestamp:'), statusInfo.timestamp?.toISOString() || 'N/A');
+}
+//# sourceMappingURL=info.js.map

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Init command - Initialize a new SoulRecall project
+ */
+import { Command } from 'commander';
+export interface InitOptions {
+    name?: string;
+    yes?: boolean;
+    verbose?: boolean;
+    v?: boolean;
+}
+export interface InitAnswers {
+    name: string;
+    description: string;
+    confirm: boolean;
+}
+export declare function promptForInitOptions(options: InitOptions): Promise<InitAnswers | null>;
+export declare function executeInit(answers: InitAnswers, _options: InitOptions, sourcePath: string): Promise<void>;
+export declare function initCommand(): Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.js

@@ -0,0 +1,135 @@
+/**
+ * Init command - Initialize a new SoulRecall project
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+export async function promptForInitOptions(options) {
+    // If --yes flag is provided, use defaults
+    if (options.yes) {
+        return {
+            name: options.name ?? 'my-agent',
+            description: 'An SoulRecall agent',
+            confirm: true,
+        };
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'What is the name of your agent?',
+            default: options.name ?? 'my-agent',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Agent name is required';
+                }
+                if (!/^[a-z0-9-]+$/.test(input)) {
+                    return 'Agent name must be lowercase alphanumeric with hyphens only';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Provide a description for your agent:',
+            default: 'An SoulRecall agent',
+        },
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Create agent with these settings?',
+            default: true,
+        },
+    ]);
+    return answers;
+}
+export async function executeInit(answers, _options, sourcePath) {
+    const spinner = ora('Initializing SoulRecall project...').start();
+    const projectDir = path.resolve(sourcePath, '.soulrecall');
+    const agentDir = path.join(projectDir, 'agent');
+    const canisterDir = path.join(projectDir, 'canister');
+    const configDir = path.join(projectDir, 'config');
+    const srcDir = path.join(projectDir, 'src');
+    const canisterWasmDir = path.join(canisterDir, 'wasm');
+    const directories = [agentDir, canisterDir, configDir, srcDir, canisterWasmDir];
+    for (const dir of directories) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    const configPath = path.join(configDir, 'agent.config.json');
+    const configContent = {
+        name: answers.name,
+        type: 'generic',
+        version: '1.0.0',
+        createdAt: Date.now(),
+        description: answers.description || 'An SoulRecall agent',
+    };
+    fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2), 'utf-8');
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const gitignoreContent = `# SoulRecall dependencies
+node_modules/
+dist/
+*.log
+.env
+*.local
+.DS_Store
+
+# SoulRecall generated files
+*.wasm
+*.backup
+*.state.json
+
+# SoulRecall project structure
+.soulrecall/
+src/
+canister/
+config/
+`;
+    fs.writeFileSync(gitignorePath, gitignoreContent, 'utf-8');
+    spinner.succeed('SoulRecall project initialized successfully!');
+    console.log();
+    console.log(chalk.green('✓'), 'Project initialized at:', chalk.bold(projectDir));
+    console.log(chalk.cyan('Directory structure:'));
+    console.log('  ├── src/', chalk.yellow('(agent source code)'));
+    console.log('  ├── canister/', chalk.yellow('(WASM files)'));
+    console.log('  ├── config/', chalk.yellow('(agent config)'));
+    console.log('  └── .gitignore', chalk.yellow('(git ignore file)'));
+    console.log();
+    console.log(chalk.cyan('Configuration:'));
+    console.log('  ├── Name:', chalk.bold(configContent.name));
+    console.log('  ├── Type:', chalk.bold(configContent.type));
+    console.log('  ├── Version:', chalk.bold(configContent.version));
+    console.log('  ├── Description:', chalk.bold(configContent.description));
+    console.log();
+    console.log(chalk.cyan('Next steps:'));
+    console.log('  1. Run', chalk.bold('soulrecall status'), 'to check your project');
+    console.log('  2. Configure your agent in', chalk.bold('agent.config.json'), '(add agent type, description, etc.)');
+    console.log('  3. Compile agent with', chalk.bold('soulrecall package'), 'to prepare for deployment');
+    console.log('  4. Deploy with', chalk.bold('soulrecall deploy'), 'to upload to ICP');
+}
+export function initCommand() {
+    const command = new Command('init');
+    command
+        .description('Initialize a new SoulRecall project')
+        .argument('[source]', 'path to agent source directory', '.')
+        .option('-n, --name <name>', 'name of the agent')
+        .option('-y, --yes', 'skip prompts and use defaults')
+        .option('-v, --verbose', 'display detailed configuration information')
+        .option('--vv', 'extra verbose mode for debugging')
+        .action(async (source, options) => {
+        console.log(chalk.bold('\n🔐 SoulRecall Project Initialization\n'));
+        const answers = await promptForInitOptions(options);
+        if (!answers || !answers.confirm) {
+            console.log(chalk.yellow('Initialization cancelled.'));
+            return;
+        }
+        await executeInit(answers, options, source);
+    });
+    return command;
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/instrument.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Instrument CLI command
+ *
+ * Provides command for instrumenting WASM files for debugging
+ */
+import { Command } from 'commander';
+export declare const instrumentCmd: Command;
+//# sourceMappingURL=instrument.d.ts.map

package/dist/cli/commands/instrument.js

@@ -0,0 +1,35 @@
+/**
+ * Instrument CLI command
+ *
+ * Provides command for instrumenting WASM files for debugging
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { instrument } from '../../src/icp/icwasm.js';
+export const instrumentCmd = new Command('instrument');
+instrumentCmd
+    .description('Instrument WASM file for debugging')
+    .argument('<input-wasm>', 'Input WASM file path')
+    .option('-o, --output <path>', 'Output WASM file path')
+    .action(async (inputWasm, options) => {
+    const outputPath = options.output || inputWasm.replace(/\.wasm$/, '.instrumented.wasm');
+    const spinner = ora(`Instrumenting ${inputWasm}...`).start();
+    try {
+        const result = await instrument({ input: inputWasm, output: outputPath });
+        if (!result.success) {
+            spinner.fail(chalk.red('Instrumentation failed'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green(`Instrumented WASM saved to ${outputPath}`));
+        console.log(chalk.gray(result.stdout));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to instrument WASM'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=instrument.js.map

package/dist/cli/commands/list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * List command - List all agents
+ */
+import { Command } from 'commander';
+export interface ListCommandOptions {
+    all?: boolean;
+    deployed?: boolean;
+    local?: boolean;
+    json?: boolean;
+}
+export interface AgentInfo {
+    name: string;
+    type: string;
+    sourcePath: string;
+    deployed?: boolean;
+    canisterId?: string;
+    network?: string;
+    lastUpdated?: string;
+}
+/**
+ * Get list of all agents
+ */
+export declare function getAgents(options: ListCommandOptions): Promise<AgentInfo[]>;
+/**
+ * Display list of agents
+ */
+export declare function displayAgents(agents: AgentInfo[], options: ListCommandOptions): void;
+/**
+ * Execute list command
+ */
+export declare function executeList(options: ListCommandOptions): Promise<void>;
+/**
+ * Create list command
+ */
+export declare function listCommand(): Command;
+//# sourceMappingURL=list.d.ts.map