agentmemory-cli 1.0.0 → 1.3.0

package/src/commands/heartbeat.ts

@@ -0,0 +1,241 @@
+import chalk from 'chalk';
+import { getApiKey, getApiUrl, getMemoryFilePath } from '../lib/config.js';
+import { writeMemoryFile } from '../lib/sync.js';
+
+interface HeartbeatResponse {
+  status: string;
+  agent: {
+    id: string;
+    name: string;
+    memory_count: number;
+    is_online: boolean;
+    last_active: string;
+  };
+  plan: {
+    name: string;
+    activated: boolean;
+  };
+  heartbeat: {
+    received_at: string;
+    next_heartbeat: string;
+    interval_seconds: number;
+  };
+  sync?: {
+    memories: {
+      items: Array<{
+        id: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+        created_at: string;
+        updated_at?: string;
+      }>;
+      count: number;
+      has_more: boolean;
+    };
+    secrets: {
+      items: Array<{
+        id: string;
+        name: string;
+        type: string;
+        description?: string;
+      }>;
+      count: number;
+      has_more: boolean;
+    };
+    synced_at: string;
+  };
+  error?: string;
+}
+
+// Send a single heartbeat
+export async function sendHeartbeat(options: {
+  sync?: boolean;
+  memoriesLimit?: number;
+  secretsLimit?: number;
+} = {}): Promise<HeartbeatResponse | null> {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  
+  if (!apiKey) {
+    return null;
+  }
+  
+  try {
+    const body: Record<string, unknown> = {};
+    if (options.sync !== undefined) body.sync = options.sync;
+    if (options.memoriesLimit) body.memories_limit = options.memoriesLimit;
+    if (options.secretsLimit) body.secrets_limit = options.secretsLimit;
+    
+    const response = await fetch(`${apiUrl}/heartbeat`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+    
+    return await response.json() as HeartbeatResponse;
+  } catch (error) {
+    console.error('Heartbeat error:', error);
+    return null;
+  }
+}
+
+// Send disconnect signal
+export async function sendDisconnect(): Promise<boolean> {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  
+  if (!apiKey) {
+    return false;
+  }
+  
+  try {
+    const response = await fetch(`${apiUrl}/heartbeat`, {
+      method: 'DELETE',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+    
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// Heartbeat command - single heartbeat with optional sync
+export async function heartbeatCommand(options: {
+  sync?: boolean;
+  continuous?: boolean;
+  interval?: string;
+  json?: boolean;
+}): Promise<void> {
+  const apiKey = getApiKey();
+  
+  if (!apiKey) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'Not configured' }));
+    } else {
+      console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    }
+    process.exit(1);
+  }
+  
+  // Continuous heartbeat mode
+  if (options.continuous) {
+    const interval = parseInt(options.interval || '60') * 1000;
+    
+    if (!options.json) {
+      console.log(chalk.cyan('Starting continuous heartbeat...'));
+      console.log(chalk.gray(`Interval: ${interval / 1000}s | Press Ctrl+C to stop`));
+      console.log();
+    }
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      if (!options.json) {
+        console.log(chalk.yellow('\nDisconnecting...'));
+      }
+      await sendDisconnect();
+      if (!options.json) {
+        console.log(chalk.green('Disconnected.'));
+      }
+      process.exit(0);
+    });
+    
+    // Initial heartbeat
+    await doHeartbeat(options);
+    
+    // Continuous heartbeats
+    setInterval(async () => {
+      await doHeartbeat(options);
+    }, interval);
+    
+    return;
+  }
+  
+  // Single heartbeat
+  await doHeartbeat(options);
+}
+
+async function doHeartbeat(options: { sync?: boolean; json?: boolean }): Promise<void> {
+  const syncEnabled = options.sync !== false;
+  
+  const response = await sendHeartbeat({ sync: syncEnabled });
+  
+  if (!response || response.error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: response?.error || 'Heartbeat failed' }));
+    } else {
+      console.error(chalk.red(`Heartbeat failed: ${response?.error || 'Unknown error'}`));
+    }
+    return;
+  }
+  
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  
+  // Display heartbeat info
+  const time = new Date().toLocaleTimeString();
+  console.log(chalk.green(`💓 [${time}] Heartbeat sent`));
+  console.log(chalk.gray(`   Agent: ${response.agent.name} | Online: ${response.agent.is_online}`));
+  
+  // Sync data if available
+  if (response.sync) {
+    const { memories, secrets } = response.sync;
+    console.log(chalk.gray(`   Synced: ${memories.count} memories, ${secrets.count} secrets`));
+    
+    // Save memories to local file
+    if (memories.items.length > 0) {
+      try {
+        const memoryFilePath = getMemoryFilePath();
+        writeMemoryFile(memoryFilePath, memories.items.map(m => ({
+          ...m,
+          updated_at: m.updated_at || m.created_at,
+        })));
+      } catch {
+        // Silently ignore file write errors in heartbeat
+      }
+    }
+  }
+}
+
+// Watch command - continuous heartbeat with auto-sync
+export async function watchCommand(options: {
+  interval?: string;
+  json?: boolean;
+}): Promise<void> {
+  return heartbeatCommand({
+    ...options,
+    continuous: true,
+    sync: true,
+  });
+}
+
+// Disconnect command
+export async function disconnectCommand(options: { json?: boolean }): Promise<void> {
+  const apiKey = getApiKey();
+  
+  if (!apiKey) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'Not configured' }));
+    } else {
+      console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    }
+    process.exit(1);
+  }
+  
+  const success = await sendDisconnect();
+  
+  if (options.json) {
+    console.log(JSON.stringify({ success, disconnected: success }));
+  } else if (success) {
+    console.log(chalk.green('✓ Disconnected from AgentMemory'));
+  } else {
+    console.error(chalk.red('Failed to disconnect'));
+  }
+}

package/src/commands/import.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import { storeMemory } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 import type { Memory } from '../types.js';
 
 interface ImportOptions {
@@ -24,6 +25,9 @@ export async function importCommand(
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   // Check if file exists
   if (!fs.existsSync(file)) {
     console.log(chalk.red(`❌ File not found: ${file}`));

package/src/commands/init.ts

@@ -1,6 +1,9 @@
 import chalk from 'chalk';
 import { createInterface } from 'readline';
 import { saveConfig, loadConfig, getConfigPath, isConfigured } from '../lib/config.js';
+import { syncConnect } from '../lib/api.js';
+import { writeMemoryFile } from '../lib/sync.js';
+import { getMemoryFilePath } from '../lib/config.js';
 
 async function prompt(question: string): Promise<string> {
   const rl = createInterface({
@@ -63,9 +66,49 @@ export async function initCommand(): Promise<void> {
   console.log(chalk.green('\n✅ Configuration saved!'));
   console.log(chalk.dim(`   Config file: ${getConfigPath()}\n`));
   
+  // Auto-sync on first setup
+  console.log(chalk.cyan('Connecting and syncing data...'));
+  
+  try {
+    const response = await syncConnect({
+      include_files: true,
+      memories_limit: 1000,
+      secrets_limit: 100,
+    });
+    
+    console.log(chalk.green('✓ Connected successfully!'));
+    console.log();
+    console.log(chalk.cyan('Agent:'), response.agent.name);
+    console.log(chalk.cyan('Plan:'), response.plan.name);
+    console.log();
+    
+    // Save memories to local file
+    if (response.sync.memories.items.length > 0) {
+      const memoryFilePath = getMemoryFilePath();
+      writeMemoryFile(memoryFilePath, response.sync.memories.items.map(m => ({
+        ...m,
+        updated_at: m.updated_at || m.created_at,
+      })));
+      console.log(chalk.green(`✓ Synced ${response.sync.memories.items.length} memories to ${memoryFilePath}`));
+    }
+    
+    // Show secrets count
+    if (response.sync.secrets.items.length > 0) {
+      console.log(chalk.green(`✓ Found ${response.sync.secrets.items.length} secrets in vault`));
+    }
+    
+    console.log();
+  } catch (error) {
+    console.log(chalk.yellow(`⚠ Could not sync: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    console.log(chalk.dim('  You can try again later with: agentmemory connect'));
+    console.log();
+  }
+  
   console.log(chalk.cyan('You can now use AgentMemory CLI:'));
   console.log(chalk.dim('  agentmemory store "Your memory content"'));
   console.log(chalk.dim('  agentmemory search "query"'));
   console.log(chalk.dim('  agentmemory list'));
-  console.log(chalk.dim('  agentmemory sync\n'));
+  console.log(chalk.dim('  agentmemory sync'));
+  console.log(chalk.dim('  agentmemory connect              # Sync all data'));
+  console.log(chalk.dim('  agentmemory secret set KEY val   # Store secrets\n'));
 }

package/src/commands/list.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { listMemories } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 interface ListOptions {
   limit?: string;
@@ -14,6 +15,9 @@ export async function listCommand(options: ListOptions): Promise<void> {
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   try {
     const limit = options.limit ? parseInt(options.limit, 10) : 50;
     const offset = options.offset ? parseInt(options.offset, 10) : 0;

package/src/commands/search.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { searchMemories } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 interface SearchOptions {
   limit?: string;
@@ -16,6 +17,9 @@ export async function searchCommand(
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   try {
     const limit = options.limit ? parseInt(options.limit, 10) : 10;
     const memories = await searchMemories(query, limit);