agentmemory-cli 1.0.0

package/src/lib/sync.ts

@@ -0,0 +1,186 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getMemoryFilePath } from './config.js';
+import { getAllMemories, storeMemory } from './api.js';
+import type { Memory } from '../types.js';
+
+interface LocalMemory {
+  content: string;
+  metadata?: Record<string, unknown>;
+  id?: string;
+}
+
+/**
+ * Parse MEMORY.md file into memory entries
+ * Expected format:
+ * 
+ * ## Memory Title (optional)
+ * Content here...
+ * 
+ * ---
+ * 
+ * ## Another Memory
+ * More content...
+ */
+export function parseMemoryFile(filePath: string): LocalMemory[] {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const memories: LocalMemory[] = [];
+  
+  // Split by --- separator or ## headers
+  const sections = content.split(/\n---\n|\n(?=## )/);
+  
+  for (const section of sections) {
+    const trimmed = section.trim();
+    if (!trimmed || trimmed === '---') continue;
+    
+    // Check if it has an ID comment (for synced memories)
+    const idMatch = trimmed.match(/<!-- id: ([a-f0-9-]+) -->/);
+    const id = idMatch ? idMatch[1] : undefined;
+    
+    // Check for category in metadata comment
+    const metaMatch = trimmed.match(/<!-- metadata: ({.*?}) -->/);
+    let metadata: Record<string, unknown> | undefined;
+    if (metaMatch) {
+      try {
+        metadata = JSON.parse(metaMatch[1]);
+      } catch {
+        // Ignore invalid metadata
+      }
+    }
+    
+    // Remove the metadata comments from content
+    let cleanContent = trimmed
+      .replace(/<!-- id: [a-f0-9-]+ -->\n?/g, '')
+      .replace(/<!-- metadata: {.*?} -->\n?/g, '')
+      .replace(/^## .+\n?/, '') // Remove header if present
+      .trim();
+    
+    if (cleanContent) {
+      memories.push({ content: cleanContent, metadata, id });
+    }
+  }
+  
+  return memories;
+}
+
+/**
+ * Write memories to MEMORY.md file
+ */
+export function writeMemoryFile(filePath: string, memories: Memory[]): void {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  const lines: string[] = [
+    '# Agent Memory',
+    '',
+    `> Last synced: ${new Date().toISOString()}`,
+    `> Total memories: ${memories.length}`,
+    '',
+    '---',
+    '',
+  ];
+  
+  for (const memory of memories) {
+    lines.push(`<!-- id: ${memory.id} -->`);
+    if (memory.metadata && Object.keys(memory.metadata).length > 0) {
+      lines.push(`<!-- metadata: ${JSON.stringify(memory.metadata)} -->`);
+    }
+    lines.push(memory.content);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  }
+  
+  fs.writeFileSync(filePath, lines.join('\n'));
+}
+
+export interface SyncResult {
+  uploaded: number;
+  downloaded: number;
+  unchanged: number;
+  errors: string[];
+}
+
+/**
+ * Bidirectional sync between local MEMORY.md and cloud
+ */
+export async function syncMemories(direction: 'push' | 'pull' | 'both' = 'both'): Promise<SyncResult> {
+  const memoryFilePath = getMemoryFilePath();
+  const result: SyncResult = {
+    uploaded: 0,
+    downloaded: 0,
+    unchanged: 0,
+    errors: [],
+  };
+  
+  // Get cloud memories
+  const cloudMemories = await getAllMemories();
+  const cloudById = new Map(cloudMemories.map(m => [m.id, m]));
+  const cloudByContent = new Map(cloudMemories.map(m => [m.content.trim(), m]));
+  
+  // Get local memories
+  const localMemories = parseMemoryFile(memoryFilePath);
+  
+  if (direction === 'push' || direction === 'both') {
+    // Upload local memories that don't exist in cloud
+    for (const local of localMemories) {
+      // Skip if already synced (has ID) or content exists in cloud
+      if (local.id && cloudById.has(local.id)) {
+        result.unchanged++;
+        continue;
+      }
+      
+      if (cloudByContent.has(local.content.trim())) {
+        result.unchanged++;
+        continue;
+      }
+      
+      try {
+        await storeMemory(local.content, local.metadata);
+        result.uploaded++;
+      } catch (error) {
+        result.errors.push(`Failed to upload: ${local.content.substring(0, 50)}...`);
+      }
+    }
+  }
+  
+  if (direction === 'pull' || direction === 'both') {
+    // Refresh cloud memories after push
+    const updatedCloudMemories = await getAllMemories();
+    
+    // Write all cloud memories to local file
+    writeMemoryFile(memoryFilePath, updatedCloudMemories);
+    result.downloaded = updatedCloudMemories.length;
+  }
+  
+  return result;
+}
+
+/**
+ * Get sync status without making changes
+ */
+export async function getSyncStatus(): Promise<{
+  localOnly: LocalMemory[];
+  cloudOnly: Memory[];
+  synced: number;
+}> {
+  const memoryFilePath = getMemoryFilePath();
+  const cloudMemories = await getAllMemories();
+  const localMemories = parseMemoryFile(memoryFilePath);
+  
+  const cloudContents = new Set(cloudMemories.map(m => m.content.trim()));
+  const localContents = new Set(localMemories.map(m => m.content.trim()));
+  
+  const localOnly = localMemories.filter(m => !cloudContents.has(m.content.trim()));
+  const cloudOnly = cloudMemories.filter(m => !localContents.has(m.content.trim()));
+  
+  const synced = localMemories.length - localOnly.length;
+  
+  return { localOnly, cloudOnly, synced };
+}

package/src/types.ts

@@ -0,0 +1,47 @@
+export interface Config {
+  api_key: string;
+  api_url: string;
+  memory_file: string;
+}
+
+export interface Memory {
+  id: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+  created_at: string;
+  updated_at?: string;
+}
+
+export interface MemorySearchResult extends Memory {
+  similarity: number;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+export interface MemoriesListResponse {
+  memories: Memory[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+export interface MemoryCreateResponse {
+  memory: Memory;
+}
+
+export interface MemorySearchResponse {
+  memories: MemorySearchResult[];
+}
+
+export interface SyncStatus {
+  local_only: Memory[];
+  cloud_only: Memory[];
+  conflicts: Array<{
+    local: Memory;
+    cloud: Memory;
+  }>;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}