agentmemory-cli 1.0.0

package/src/commands/search.ts

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import { searchMemories } from '../lib/api.js';
+import { isConfigured } from '../lib/config.js';
+
+interface SearchOptions {
+  limit?: string;
+  json?: boolean;
+}
+
+export async function searchCommand(
+  query: string, 
+  options: SearchOptions
+): Promise<void> {
+  if (!isConfigured()) {
+    console.log(chalk.red('❌ Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  try {
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    const memories = await searchMemories(query, limit);
+    
+    if (options.json) {
+      console.log(JSON.stringify(memories, null, 2));
+      return;
+    }
+    
+    if (memories.length === 0) {
+      console.log(chalk.yellow('No memories found matching your query.'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`\n🔍 Found ${memories.length} memories:\n`));
+    
+    for (const memory of memories) {
+      const similarity = (memory.similarity * 100).toFixed(1);
+      console.log(chalk.green(`[${similarity}%] `) + chalk.white(memory.content));
+      console.log(chalk.dim(`   ID: ${memory.id}`));
+      if (memory.metadata && Object.keys(memory.metadata).length > 0) {
+        console.log(chalk.dim(`   Metadata: ${JSON.stringify(memory.metadata)}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.log(chalk.red(`❌ Error: ${error.message}`));
+    } else {
+      console.log(chalk.red('❌ Unknown error occurred'));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/store.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { storeMemory } from '../lib/api.js';
+import { isConfigured } from '../lib/config.js';
+
+interface StoreOptions {
+  category?: string;
+  metadata?: string;
+  json?: boolean;
+}
+
+export async function storeCommand(
+  content: string, 
+  options: StoreOptions
+): Promise<void> {
+  if (!isConfigured()) {
+    console.log(chalk.red('❌ Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  try {
+    // Build metadata
+    let metadata: Record<string, unknown> = {};
+    
+    if (options.category) {
+      metadata.category = options.category;
+    }
+    
+    if (options.metadata) {
+      try {
+        const parsed = JSON.parse(options.metadata);
+        metadata = { ...metadata, ...parsed };
+      } catch {
+        console.log(chalk.red('❌ Invalid metadata JSON format'));
+        process.exit(1);
+      }
+    }
+    
+    const memory = await storeMemory(
+      content, 
+      Object.keys(metadata).length > 0 ? metadata : undefined
+    );
+    
+    if (options.json) {
+      console.log(JSON.stringify(memory, null, 2));
+    } else {
+      console.log(chalk.green('✅ Memory stored successfully!'));
+      console.log(chalk.dim(`   ID: ${memory.id}`));
+      console.log(chalk.dim(`   Created: ${memory.created_at}`));
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.log(chalk.red(`❌ Error: ${error.message}`));
+    } else {
+      console.log(chalk.red('❌ Unknown error occurred'));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import { isConfigured, getMemoryFilePath } from '../lib/config.js';
+import { syncMemories, getSyncStatus } from '../lib/sync.js';
+
+interface SyncOptions {
+  push?: boolean;
+  pull?: boolean;
+  status?: boolean;
+  json?: boolean;
+}
+
+export async function syncCommand(options: SyncOptions): Promise<void> {
+  if (!isConfigured()) {
+    console.log(chalk.red('❌ Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  const memoryFile = getMemoryFilePath();
+  
+  try {
+    // Status only mode
+    if (options.status) {
+      console.log(chalk.dim('Checking sync status...'));
+      const status = await getSyncStatus();
+      
+      if (options.json) {
+        console.log(JSON.stringify(status, null, 2));
+        return;
+      }
+      
+      console.log(chalk.cyan('\n📊 Sync Status:\n'));
+      console.log(`  Memory file: ${memoryFile}`);
+      console.log(`  Synced: ${chalk.green(status.synced)}`);
+      console.log(`  Local only: ${chalk.yellow(status.localOnly.length)}`);
+      console.log(`  Cloud only: ${chalk.blue(status.cloudOnly.length)}`);
+      
+      if (status.localOnly.length > 0) {
+        console.log(chalk.yellow('\n  Local memories not in cloud:'));
+        for (const m of status.localOnly.slice(0, 5)) {
+          const preview = m.content.substring(0, 50);
+          console.log(chalk.dim(`    • ${preview}...`));
+        }
+        if (status.localOnly.length > 5) {
+          console.log(chalk.dim(`    ... and ${status.localOnly.length - 5} more`));
+        }
+      }
+      
+      if (status.cloudOnly.length > 0) {
+        console.log(chalk.blue('\n  Cloud memories not in local file:'));
+        for (const m of status.cloudOnly.slice(0, 5)) {
+          const preview = m.content.substring(0, 50);
+          console.log(chalk.dim(`    • ${preview}...`));
+        }
+        if (status.cloudOnly.length > 5) {
+          console.log(chalk.dim(`    ... and ${status.cloudOnly.length - 5} more`));
+        }
+      }
+      
+      console.log();
+      return;
+    }
+    
+    // Determine sync direction
+    let direction: 'push' | 'pull' | 'both' = 'both';
+    if (options.push && !options.pull) {
+      direction = 'push';
+    } else if (options.pull && !options.push) {
+      direction = 'pull';
+    }
+    
+    console.log(chalk.dim(`Syncing memories (${direction})...`));
+    console.log(chalk.dim(`Memory file: ${memoryFile}\n`));
+    
+    const result = await syncMemories(direction);
+    
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    
+    console.log(chalk.green('✅ Sync complete!\n'));
+    console.log(`  📤 Uploaded: ${chalk.green(result.uploaded)}`);
+    console.log(`  📥 Downloaded: ${chalk.blue(result.downloaded)}`);
+    console.log(`  ⏭️  Unchanged: ${chalk.dim(result.unchanged)}`);
+    
+    if (result.errors.length > 0) {
+      console.log(chalk.red(`\n  ❌ Errors: ${result.errors.length}`));
+      for (const error of result.errors) {
+        console.log(chalk.red(`     • ${error}`));
+      }
+    }
+    
+    console.log();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.log(chalk.red(`❌ Error: ${error.message}`));
+    } else {
+      console.log(chalk.red('❌ Unknown error occurred'));
+    }
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { initCommand } from './commands/init.js';
+import { storeCommand } from './commands/store.js';
+import { searchCommand } from './commands/search.js';
+import { listCommand } from './commands/list.js';
+import { deleteCommand } from './commands/delete.js';
+import { syncCommand } from './commands/sync.js';
+import { exportCommand } from './commands/export.js';
+import { importCommand } from './commands/import.js';
+
+const program = new Command();
+
+program
+  .name('agentmemory')
+  .description('CLI tool for AgentMemory - persistent cloud memory for AI agents')
+  .version('1.0.0');
+
+// Init command
+program
+  .command('init')
+  .description('Initialize AgentMemory CLI with your API key')
+  .action(initCommand);
+
+// Store command
+program
+  .command('store <content>')
+  .description('Store a new memory')
+  .option('-c, --category <category>', 'Category for the memory')
+  .option('-m, --metadata <json>', 'Additional metadata as JSON')
+  .option('--json', 'Output as JSON')
+  .action(storeCommand);
+
+// Search command
+program
+  .command('search <query>')
+  .description('Search memories semantically')
+  .option('-l, --limit <number>', 'Maximum number of results', '10')
+  .option('--json', 'Output as JSON')
+  .action(searchCommand);
+
+// List command
+program
+  .command('list')
+  .description('List all memories')
+  .option('-l, --limit <number>', 'Maximum number of results', '50')
+  .option('-o, --offset <number>', 'Offset for pagination', '0')
+  .option('--json', 'Output as JSON')
+  .action(listCommand);
+
+// Delete command
+program
+  .command('delete <id>')
+  .description('Delete a memory by ID')
+  .option('-f, --force', 'Skip confirmation')
+  .option('--json', 'Output as JSON')
+  .action(deleteCommand);
+
+// Sync command
+program
+  .command('sync')
+  .description('Sync memories with local MEMORY.md file')
+  .option('--push', 'Only push local to cloud')
+  .option('--pull', 'Only pull cloud to local')
+  .option('--status', 'Show sync status without making changes')
+  .option('--json', 'Output as JSON')
+  .action(syncCommand);
+
+// Export command
+program
+  .command('export')
+  .description('Export all memories as JSON')
+  .option('-o, --output <file>', 'Output file path')
+  .option('-p, --pretty', 'Pretty print JSON')
+  .action(exportCommand);
+
+// Import command
+program
+  .command('import <file>')
+  .description('Import memories from JSON file')
+  .option('--json', 'Output as JSON')
+  .action(importCommand);
+
+// Custom help
+program.addHelpText('after', `
+${chalk.cyan('Examples:')}
+  $ agentmemory init                          # Setup with your API key
+  $ agentmemory store "User prefers dark mode"
+  $ agentmemory search "user preferences"
+  $ agentmemory list --limit 10
+  $ agentmemory sync                          # Sync with MEMORY.md
+  $ agentmemory export > backup.json
+
+${chalk.cyan('Documentation:')}
+  https://agentmemory.cloud/docs
+
+${chalk.cyan('Get your API key:')}
+  https://agentmemory.cloud/dashboard
+`);
+
+// Parse arguments
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  console.log(chalk.cyan(`
+  🧠 AgentMemory CLI v1.0.0
+  
+  Persistent cloud memory for AI agents.
+  `));
+  program.outputHelp();
+}

package/src/lib/api.ts

@@ -0,0 +1,139 @@
+import { getApiKey, getApiUrl } from './config.js';
+import type { 
+  Memory, 
+  MemoriesListResponse, 
+  MemoryCreateResponse, 
+  MemorySearchResponse,
+  MemorySearchResult 
+} from '../types.js';
+
+class ApiError extends Error {
+  constructor(public statusCode: number, message: string) {
+    super(message);
+    this.name = 'ApiError';
+  }
+}
+
+async function request<T>(
+  endpoint: string, 
+  options: RequestInit = {}
+): Promise<T> {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  
+  if (!apiKey) {
+    throw new Error('API key not configured. Run "agentmemory init" first.');
+  }
+  
+  const url = `${apiUrl}${endpoint}`;
+  
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+  });
+  
+  const data = await response.json() as { error?: string } & T;
+  
+  if (!response.ok) {
+    throw new ApiError(
+      response.status, 
+      data.error || `Request failed with status ${response.status}`
+    );
+  }
+  
+  return data;
+}
+
+export async function storeMemory(
+  content: string, 
+  metadata?: Record<string, unknown>
+): Promise<Memory> {
+  const body: { content: string; metadata?: Record<string, unknown> } = { content };
+  if (metadata) {
+    body.metadata = metadata;
+  }
+  
+  const response = await request<MemoryCreateResponse>('/memories', {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+  
+  return response.memory;
+}
+
+export async function searchMemories(
+  query: string, 
+  limit: number = 10
+): Promise<MemorySearchResult[]> {
+  const response = await request<MemorySearchResponse>('/memories/search', {
+    method: 'POST',
+    body: JSON.stringify({ query, limit }),
+  });
+  
+  return response.memories;
+}
+
+export async function listMemories(
+  limit: number = 50, 
+  offset: number = 0
+): Promise<MemoriesListResponse> {
+  const response = await request<MemoriesListResponse>(
+    `/memories?limit=${limit}&offset=${offset}`
+  );
+  
+  return response;
+}
+
+export async function getMemory(id: string): Promise<Memory> {
+  const response = await request<{ memory: Memory }>(`/memories/${id}`);
+  return response.memory;
+}
+
+export async function updateMemory(
+  id: string, 
+  content: string, 
+  metadata?: Record<string, unknown>
+): Promise<Memory> {
+  const body: { content: string; metadata?: Record<string, unknown> } = { content };
+  if (metadata) {
+    body.metadata = metadata;
+  }
+  
+  const response = await request<{ memory: Memory }>(`/memories/${id}`, {
+    method: 'PUT',
+    body: JSON.stringify(body),
+  });
+  
+  return response.memory;
+}
+
+export async function deleteMemory(id: string): Promise<void> {
+  await request<{ success: boolean }>(`/memories/${id}`, {
+    method: 'DELETE',
+  });
+}
+
+export async function getAllMemories(): Promise<Memory[]> {
+  const allMemories: Memory[] = [];
+  let offset = 0;
+  const limit = 100;
+  
+  while (true) {
+    const response = await listMemories(limit, offset);
+    allMemories.push(...response.memories);
+    
+    if (response.memories.length < limit) {
+      break;
+    }
+    
+    offset += limit;
+  }
+  
+  return allMemories;
+}
+
+export { ApiError };

package/src/lib/config.ts

@@ -0,0 +1,95 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import type { Config } from '../types.js';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agentmemory');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG: Config = {
+  api_key: '',
+  api_url: 'https://agentmemory.cloud/api',
+  memory_file: './MEMORY.md'
+};
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+export function ensureConfigDir(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function configExists(): boolean {
+  return fs.existsSync(CONFIG_FILE);
+}
+
+export function loadConfig(): Config {
+  ensureConfigDir();
+  
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(content) as Partial<Config>;
+    return { ...DEFAULT_CONFIG, ...config };
+  } catch (error) {
+    console.error('Error reading config file:', error);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config: Partial<Config>): void {
+  ensureConfigDir();
+  
+  const existingConfig = loadConfig();
+  const newConfig = { ...existingConfig, ...config };
+  
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+}
+
+export function getApiKey(): string {
+  // Check environment variable first
+  const envKey = process.env.AGENTMEMORY_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+  
+  // Fall back to config file
+  const config = loadConfig();
+  return config.api_key;
+}
+
+export function getApiUrl(): string {
+  const envUrl = process.env.AGENTMEMORY_API_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  
+  const config = loadConfig();
+  return config.api_url;
+}
+
+export function getMemoryFilePath(): string {
+  const config = loadConfig();
+  return config.memory_file;
+}
+
+export function isConfigured(): boolean {
+  const apiKey = getApiKey();
+  return apiKey.length > 0 && apiKey.startsWith('am_');
+}
+
+export function clearConfig(): void {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}