agentmemory-cli 1.0.0 → 1.3.0

package/src/commands/connect.ts

@@ -0,0 +1,216 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import { getApiKey, getMemoryFilePath } from '../lib/config.js';
+import { syncConnect, checkConnection } from '../lib/api.js';
+import { writeMemoryFile } from '../lib/sync.js';
+
+// Store sync cache locally
+interface SyncCache {
+  last_sync: string;
+  memory_count: number;
+  secret_count: number;
+}
+
+function getSyncCachePath(): string {
+  const configDir = require('path').join(require('os').homedir(), '.agentmemory');
+  return require('path').join(configDir, 'sync-cache.json');
+}
+
+function loadSyncCache(): SyncCache | null {
+  const cachePath = getSyncCachePath();
+  if (!fs.existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveSyncCache(cache: SyncCache): void {
+  const cachePath = getSyncCachePath();
+  fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+}
+
+// Connect and auto-sync command
+export async function connectCommand(options: {
+  offline?: boolean;
+  noMemories?: boolean;
+  noSecrets?: boolean;
+  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);
+  }
+  
+  if (options.offline) {
+    const cache = loadSyncCache();
+    if (cache) {
+      if (options.json) {
+        console.log(JSON.stringify({ status: 'offline', cached: cache }));
+      } else {
+        console.log(chalk.yellow('Offline mode - using cached data'));
+        console.log(chalk.gray(`  Last sync: ${cache.last_sync}`));
+        console.log(chalk.gray(`  Memories: ${cache.memory_count}`));
+        console.log(chalk.gray(`  Secrets: ${cache.secret_count}`));
+      }
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ status: 'offline', cached: null }));
+      } else {
+        console.log(chalk.yellow('Offline mode - no cached data available'));
+      }
+    }
+    return;
+  }
+  
+  try {
+    if (!options.json) {
+      console.log(chalk.cyan('🔗 Connecting to AgentMemory...'));
+    }
+    
+    // Call sync/connect endpoint
+    const response = await syncConnect({
+      include_files: true,
+      memories_limit: 1000,
+      secrets_limit: 100,
+    });
+    
+    if (options.json) {
+      console.log(JSON.stringify(response, null, 2));
+      return;
+    }
+    
+    // Display connection info
+    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();
+    
+    // Display sync summary
+    console.log(chalk.cyan('Synced data:'));
+    console.log(`  Memories: ${response.sync.memories.total}${response.sync.memories.has_more ? '+' : ''}`);
+    console.log(`  Secrets: ${response.sync.secrets.total}${response.sync.secrets.has_more ? '+' : ''}`);
+    console.log();
+    
+    // Save to local MEMORY.md if requested
+    if (!options.noMemories && 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(`✓ Saved ${response.sync.memories.items.length} memories to ${memoryFilePath}`));
+    }
+    
+    // Display secrets list (names only)
+    if (!options.noSecrets && response.sync.secrets.items.length > 0) {
+      console.log();
+      console.log(chalk.cyan('Available secrets:'));
+      for (const secret of response.sync.secrets.items) {
+        console.log(`  - ${secret.name} (${secret.type})`);
+      }
+    }
+    
+    // Save sync cache
+    saveSyncCache({
+      last_sync: response.sync.synced_at,
+      memory_count: response.sync.memories.total,
+      secret_count: response.sync.secrets.total,
+    });
+    
+    // Show plan limits
+    console.log();
+    console.log(chalk.gray(`Limits: ${response.sync.memories.total}/${response.plan.limits.memories === Infinity ? '∞' : response.plan.limits.memories} memories, ${response.sync.secrets.total}/${response.plan.limits.secrets === Infinity ? '∞' : response.plan.limits.secrets} secrets`));
+    
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Quick status check
+export async function statusCommand(options: {
+  json?: boolean;
+}): Promise<void> {
+  const apiKey = getApiKey();
+  
+  if (!apiKey) {
+    if (options.json) {
+      console.log(JSON.stringify({ configured: false }));
+    } else {
+      console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    }
+    process.exit(1);
+  }
+  
+  try {
+    const status = await checkConnection();
+    
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+    } else {
+      console.log(chalk.green('✓ Connected'));
+      console.log();
+      console.log(chalk.cyan('Agent:'), status.agent.name);
+      console.log(chalk.cyan('Memories:'), status.counts.memories);
+      console.log(chalk.cyan('Secrets:'), status.counts.secrets);
+      console.log();
+      console.log(chalk.gray(`Server time: ${status.server_time}`));
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ connected: false, error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Auto-sync helper (can be called from other commands)
+export async function autoSync(): Promise<boolean> {
+  const apiKey = getApiKey();
+  if (!apiKey) return false;
+  
+  try {
+    const response = await syncConnect({
+      include_files: false,
+      memories_limit: 1000,
+      secrets_limit: 100,
+    });
+    
+    // Save to local MEMORY.md
+    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,
+      })));
+    }
+    
+    // Save sync cache
+    saveSyncCache({
+      last_sync: response.sync.synced_at,
+      memory_count: response.sync.memories.total,
+      secret_count: response.sync.secrets.total,
+    });
+    
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/commands/delete.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { createInterface } from 'readline';
 import { deleteMemory, getMemory } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 interface DeleteOptions {
   force?: boolean;
@@ -31,6 +32,9 @@ export async function deleteCommand(
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   try {
     // First, get the memory to show what will be deleted
     if (!options.force) {

package/src/commands/download.ts

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { getApiKey, getApiUrl } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
+
+interface FileResponse {
+  file: {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url: string;
+    download_url: string;
+    description: string;
+    extracted_text: string;
+    metadata: Record<string, unknown>;
+    created_at: string;
+  };
+  error?: string;
+}
+
+export async function downloadCommand(
+  fileId: string,
+  options: { output?: string; info?: boolean }
+): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(chalk.red('Not configured. Run: agentmemory init'));
+    process.exit(1);
+  }
+
+  // Auto-sync in background (silent)
+  autoSync();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/files/${fileId}`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    const data = await response.json() as FileResponse;
+
+    if (!response.ok) {
+      console.error(chalk.red(`Error: ${data.error || 'File not found'}`));
+      process.exit(1);
+    }
+
+    const file = data.file;
+
+    // If --info flag, just show file information
+    if (options.info) {
+      console.log(chalk.bold(`\nFile Information:\n`));
+      console.log(`  ${chalk.cyan('Name:')} ${file.name}`);
+      console.log(`  ${chalk.cyan('Type:')} ${file.type}`);
+      console.log(`  ${chalk.cyan('Size:')} ${formatSize(file.size)}`);
+      console.log(`  ${chalk.cyan('Created:')} ${new Date(file.created_at).toLocaleString()}`);
+      console.log(`  ${chalk.cyan('ID:')} ${file.id}`);
+      if (file.description) {
+        console.log(`  ${chalk.cyan('Description:')} ${file.description}`);
+      }
+      if (file.extracted_text) {
+        console.log(`\n${chalk.cyan('Extracted Content:')}`);
+        console.log(chalk.gray(file.extracted_text.slice(0, 500)));
+        if (file.extracted_text.length > 500) {
+          console.log(chalk.gray('... (truncated)'));
+        }
+      }
+      return;
+    }
+
+    // Download the file
+    if (!file.download_url) {
+      console.error(chalk.red('No download URL available'));
+      process.exit(1);
+    }
+
+    console.log(chalk.blue(`Downloading ${file.name}...`));
+
+    const downloadResponse = await fetch(file.download_url);
+    if (!downloadResponse.ok) {
+      console.error(chalk.red('Failed to download file'));
+      process.exit(1);
+    }
+
+    const buffer = Buffer.from(await downloadResponse.arrayBuffer());
+    const outputPath = options.output || path.join(process.cwd(), file.name);
+
+    fs.writeFileSync(outputPath, buffer);
+
+    console.log(chalk.green(`✓ Downloaded to: ${outputPath}`));
+    console.log(chalk.gray(`  Size: ${formatSize(buffer.length)}`));
+  } catch (error) {
+    console.error(chalk.red(`Download failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    process.exit(1);
+  }
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/src/commands/export.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import { getAllMemories } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 interface ExportOptions {
   output?: string;
@@ -14,6 +15,9 @@ export async function exportCommand(options: ExportOptions): Promise<void> {
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   try {
     console.log(chalk.dim('Fetching all memories...'));
     const memories = await getAllMemories();

package/src/commands/files.ts

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import { getApiKey, getApiUrl } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
+
+interface FileMemory {
+  id: string;
+  content: string;
+  file_url: string;
+  file_name: string;
+  file_type: string;
+  file_size: number;
+  created_at: string;
+  metadata: Record<string, unknown>;
+}
+
+interface FilesResponse {
+  files: FileMemory[];
+  total: number;
+  limit: number;
+  offset: number;
+  error?: string;
+}
+
+export async function filesCommand(options: {
+  limit?: string;
+  type?: string;
+  json?: boolean;
+}): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(chalk.red('Not configured. Run: agentmemory init'));
+    process.exit(1);
+  }
+
+  // Auto-sync in background (silent)
+  autoSync();
+
+  try {
+    const apiUrl = getApiUrl();
+    const params = new URLSearchParams();
+    if (options.limit) params.set('limit', options.limit);
+    if (options.type) params.set('type', options.type);
+
+    const response = await fetch(`${apiUrl}/files?${params}`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    const data = await response.json() as FilesResponse;
+
+    if (!response.ok) {
+      console.error(chalk.red(`Error: ${data.error || 'Failed to list files'}`));
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    if (!data.files || data.files.length === 0) {
+      console.log(chalk.yellow('No files found.'));
+      console.log(chalk.gray('Upload a file with: agentmemory upload <file>'));
+      return;
+    }
+
+    console.log(chalk.bold(`\nFiles (${data.total} total):\n`));
+
+    for (const file of data.files) {
+      const category = getFileCategory(file.file_type);
+      const icon = getCategoryIcon(category);
+      const size = formatSize(file.file_size);
+      const date = new Date(file.created_at).toLocaleDateString();
+
+      console.log(`${icon} ${chalk.cyan(file.file_name)}`);
+      console.log(chalk.gray(`   ID: ${file.id}`));
+      console.log(chalk.gray(`   Type: ${file.file_type} | Size: ${size} | Date: ${date}`));
+      if (file.content && file.content !== `File: ${file.file_name}`) {
+        console.log(chalk.gray(`   Description: ${file.content.slice(0, 60)}...`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to list files: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    process.exit(1);
+  }
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function getFileCategory(mimeType: string): string {
+  if (mimeType.startsWith('image/')) return 'image';
+  if (mimeType.startsWith('audio/')) return 'audio';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType === 'application/pdf') return 'pdf';
+  if (mimeType.includes('word') || mimeType.includes('document')) return 'document';
+  if (mimeType.includes('excel') || mimeType.includes('spreadsheet')) return 'spreadsheet';
+  if (mimeType.startsWith('text/')) return 'text';
+  return 'other';
+}
+
+function getCategoryIcon(category: string): string {
+  const icons: Record<string, string> = {
+    image: '🖼️',
+    audio: '🎵',
+    video: '🎬',
+    pdf: '📄',
+    document: '📝',
+    spreadsheet: '📊',
+    text: '📃',
+    other: '📁',
+  };
+  return icons[category] || '📁';
+}