@ghl-ai/aw 0.1.37-beta.35 → 0.1.37-beta.37

package/commands/init.mjs

@@ -6,6 +6,7 @@
 
 import {
   existsSync,
+  mkdirSync,
   writeFileSync,
   symlinkSync,
   lstatSync,
@@ -246,6 +247,7 @@ export async function initCommand(args) {
     }
 
     ensureAwGitignore(AW_HOME);
+    mkdirSync(join(GLOBAL_AW_DIR, 'memory'), { recursive: true });
     const freshCfg = config.load(GLOBAL_AW_DIR);
     if (existsSync(GLOBAL_AW_DIR)) {
       syncFileTree(join(AW_HOME, RULES_SOURCE_DIR), join(GLOBAL_AW_DIR, RULES_SOURCE_DIR));
@@ -351,6 +353,7 @@ export async function initCommand(args) {
   try {
     await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
     ensureAwGitignore(AW_HOME);
+    mkdirSync(join(GLOBAL_AW_DIR, 'memory'), { recursive: true });
     s.stop('Registry cloned');
   } catch (e) {
     s.stop(chalk.red('Clone failed'));

package/commands/memory.mjs

@@ -1,17 +1,24 @@
-// commands/memory.mjs — `aw memory [store|search|pack|stats]`
+// commands/memory.mjs — `aw memory [store|search|pack|stats|validate|invalidate|sync]`
 
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { callMemoryTool } from '../memory-bridge.mjs';
+import { syncMemories } from '../memory-sync.mjs';
+import { REGISTRY_DIR } from '../constants.mjs';
 
 export async function memoryCommand(args) {
   const sub = args._positional?.[0];
   switch (sub) {
-    case 'store':  return memoryStore(args);
-    case 'search': return memorySearch(args);
-    case 'pack':   return memoryPack(args);
-    case 'stats':  return memoryStats(args);
-    default:       return memoryHelp();
+    case 'store':      return memoryStore(args);
+    case 'search':     return memorySearch(args);
+    case 'pack':       return memoryPack(args);
+    case 'stats':      return memoryStats(args);
+    case 'validate':   return memoryValidate(args);
+    case 'invalidate': return memoryInvalidate(args);
+    case 'sync':       return memorySync(args);
+    default:           return memoryHelp();
   }
 }
 
@@ -223,6 +230,121 @@ async function memoryStats(args) {
   }
 }
 
+// ── validate ──────────────────────────────────────────────────────────
+
+async function memoryValidate(args) {
+  const memoryId = args._positional?.[1];
+  if (!memoryId) {
+    fmt.cancel('Usage: aw memory validate <memory-id> [--reason "text"]');
+    return;
+  }
+
+  fmt.intro('aw memory validate');
+
+  const params = {
+    memory_id: memoryId,
+    feedback_type: 'validate',
+    actor_type: 'user',
+  };
+  if (args['--reason']) params.reason = args['--reason'];
+
+  const s = fmt.spinner();
+  s.start('Validating memory...');
+  try {
+    const result = await callMemoryTool('memory_feedback', params);
+    s.stop('Memory validated');
+
+    const data = result?.result ?? result;
+    const lines = [
+      `${chalk.dim('id:')}       ${memoryId}`,
+      `${chalk.dim('action:')}   ${chalk.green('validated')}`,
+      data.reason ? `${chalk.dim('reason:')}   ${data.reason}` : null,
+    ].filter(Boolean).join('\n');
+
+    fmt.note(lines, 'Result');
+    fmt.outro('Memory validated');
+  } catch (err) {
+    s.stop(chalk.red('Failed'));
+    fmt.cancel(`Validate failed: ${err.message}`);
+  }
+}
+
+// ── invalidate ────────────────────────────────────────────────────────
+
+async function memoryInvalidate(args) {
+  const memoryId = args._positional?.[1];
+  if (!memoryId) {
+    fmt.cancel('Usage: aw memory invalidate <memory-id> [--reason "text"]');
+    return;
+  }
+
+  fmt.intro('aw memory invalidate');
+
+  const params = {
+    memory_id: memoryId,
+    feedback_type: 'invalidate',
+    actor_type: 'user',
+  };
+  if (args['--reason']) params.reason = args['--reason'];
+
+  const s = fmt.spinner();
+  s.start('Invalidating memory...');
+  try {
+    const result = await callMemoryTool('memory_feedback', params);
+    s.stop('Memory invalidated');
+
+    const data = result?.result ?? result;
+    const lines = [
+      `${chalk.dim('id:')}       ${memoryId}`,
+      `${chalk.dim('action:')}   ${chalk.red('invalidated')}`,
+      data.reason ? `${chalk.dim('reason:')}   ${data.reason}` : null,
+    ].filter(Boolean).join('\n');
+
+    fmt.note(lines, 'Result');
+    fmt.outro('Memory invalidated');
+  } catch (err) {
+    s.stop(chalk.red('Failed'));
+    fmt.cancel(`Invalidate failed: ${err.message}`);
+  }
+}
+
+// ── sync ──────────────────────────────────────────────────────────────
+
+async function memorySync(args) {
+  fmt.intro('aw memory sync');
+
+  const registryDir = join(homedir(), REGISTRY_DIR, 'memory');
+  const force = args['--force'] === true;
+
+  const s = fmt.spinner();
+  s.start('Syncing memories...');
+  try {
+    const result = await syncMemories(registryDir, { force });
+    if (result.skipped) {
+      s.stop('Cache is fresh');
+      fmt.logInfo('Local memory cache is less than 24h old. Use --force to re-sync.');
+      fmt.outro('Sync skipped');
+      return;
+    }
+
+    s.stop('Memories synced');
+
+    const fileLines = Object.entries(result.files)
+      .map(([file, count]) => `  ${chalk.cyan(file.padEnd(20))} ${count} memories`)
+      .join('\n');
+
+    if (fileLines) {
+      fmt.note(fileLines, 'Files written');
+    }
+
+    fmt.logStep(`Total: ${chalk.bold(result.total)} memories synced to ${chalk.dim(registryDir)}`);
+    fmt.outro('Sync complete');
+  } catch (err) {
+    s.stop(chalk.red('Failed'));
+    fmt.cancel(`Sync failed: ${err.message}`);
+  }
+}
+
 // ── help ─────────────────────────────────────────────────────────────
 
 function memoryHelp() {
@@ -257,6 +379,15 @@ function memoryHelp() {
     cmd('aw memory stats', 'Show memory statistics'),
     cmd('  --namespace <ns>', 'Namespace scope'),
     '',
+    cmd('aw memory validate <memory-id>', 'Mark a memory as validated'),
+    cmd('  --reason "text"', 'Reason for validation'),
+    '',
+    cmd('aw memory invalidate <memory-id>', 'Mark a memory as invalidated'),
+    cmd('  --reason "text"', 'Reason for invalidation'),
+    '',
+    cmd('aw memory sync', 'Sync memories to local files'),
+    cmd('  --force', 'Force re-sync even if cache is fresh'),
+    '',
   ].join('\n');
 
   console.log(help);

package/ecc.mjs

@@ -9,7 +9,7 @@ import * as fmt from "./fmt.mjs";
 
 const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
 const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
-const AW_ECC_TAG = "v1.3.0";
+const AW_ECC_TAG = "v1.4.0";
 
 const MARKETPLACE_NAME = "aw-marketplace";
 const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;

package/memory-sync.mjs

@@ -0,0 +1,127 @@
+// memory-sync.mjs — Bidirectional memory sync: pull from MCP, write to local files.
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { callMemoryTool } from './memory-bridge.mjs';
+
+const MANIFEST_FILE = 'manifest.json';
+const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Check if local memory cache is stale (>24h since last sync).
+ * @param {string} registryDir — path to ~/.aw_registry/memory/
+ * @returns {boolean} true if stale or manifest missing
+ */
+export function checkStaleness(registryDir) {
+  const manifestPath = join(registryDir, MANIFEST_FILE);
+  if (!existsSync(manifestPath)) return true;
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    if (!manifest.lastSync) return true;
+    const lastSync = new Date(manifest.lastSync).getTime();
+    return Date.now() - lastSync > STALE_THRESHOLD_MS;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Group a memory into a target file based on overlay/angle.
+ * @param {object} mem — memory object with overlay, angle fields
+ * @returns {string} filename (e.g. 'incidents.md', 'patterns.md', 'product.md', 'core.md')
+ */
+function classifyMemory(mem) {
+  const overlays = Array.isArray(mem.overlay) ? mem.overlay : (Array.isArray(mem.overlays) ? mem.overlays : []);
+  const angles = Array.isArray(mem.angle) ? mem.angle : (Array.isArray(mem.angles) ? mem.angles : []);
+
+  const overlayStr = overlays.join(' ').toLowerCase();
+  const angleStr = angles.join(' ').toLowerCase();
+
+  if (overlayStr.includes('incident')) return 'incidents.md';
+  if (overlayStr.includes('service') || angleStr.includes('technical')) return 'patterns.md';
+  if (overlayStr.includes('product')) return 'product.md';
+  return 'core.md';
+}
+
+/**
+ * Pull top memories from MCP and write grouped files.
+ * @param {string} registryDir — path to ~/.aw_registry/memory/
+ * @returns {Promise<{ total: number, files: Record<string, number> }>}
+ */
+export async function pullAndWriteMemories(registryDir) {
+  const result = await callMemoryTool('memory_search', { query: '*', limit: 50 });
+  const memories = Array.isArray(result) ? result : (result?.memories ?? result?.results ?? []);
+
+  // Group by target file
+  const groups = {};
+  for (const mem of memories) {
+    const file = classifyMemory(mem);
+    if (!groups[file]) groups[file] = [];
+    groups[file].push(mem);
+  }
+
+  const now = new Date().toISOString();
+  const fileCounts = {};
+
+  for (const [filename, mems] of Object.entries(groups)) {
+    const sectionName = filename.replace('.md', '').replace(/^\w/, c => c.toUpperCase());
+    const lines = [
+      '<!-- aw:memory:auto-synced -->',
+      `<!-- last-sync: ${now} -->`,
+      '<!-- DO NOT EDIT — regenerated by `aw memory sync` -->',
+      '',
+      `## ${sectionName}`,
+    ];
+
+    for (const mem of mems) {
+      const content = mem.content ?? mem.text ?? JSON.stringify(mem);
+      const confidence = mem.confidence ?? mem.classification_confidence ?? '';
+      const id = mem.id ?? '';
+      const meta = [
+        confidence ? `confidence: ${confidence}` : null,
+        id ? `id: ${id}` : null,
+      ].filter(Boolean).join(' | ');
+
+      lines.push(`- ${content}${meta ? ` <!-- ${meta} -->` : ''}`);
+    }
+
+    lines.push('');
+    writeFileSync(join(registryDir, filename), lines.join('\n'));
+    fileCounts[filename] = mems.length;
+  }
+
+  return { total: memories.length, files: fileCounts };
+}
+
+/**
+ * Write manifest.json with sync metadata.
+ * @param {string} registryDir — path to ~/.aw_registry/memory/
+ * @param {number} count — number of memories synced
+ */
+export function writeManifest(registryDir, count) {
+  const manifest = {
+    lastSync: new Date().toISOString(),
+    memoriesSynced: count,
+    version: 1,
+  };
+  writeFileSync(join(registryDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2) + '\n');
+}
+
+/**
+ * Main sync function — check staleness, pull, write, update manifest.
+ * @param {string} registryDir — path to ~/.aw_registry/memory/
+ * @param {object} [opts]
+ * @param {boolean} [opts.force] — skip staleness check
+ * @returns {Promise<{ skipped: boolean, total?: number, files?: Record<string, number> }>}
+ */
+export async function syncMemories(registryDir, opts = {}) {
+  mkdirSync(registryDir, { recursive: true });
+
+  if (!opts.force && !checkStaleness(registryDir)) {
+    return { skipped: true };
+  }
+
+  const { total, files } = await pullAndWriteMemories(registryDir);
+  writeManifest(registryDir, total);
+  return { skipped: false, total, files };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.35",
+  "version": "0.1.37-beta.37",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -27,7 +27,8 @@
     "ecc.mjs",
     "render-rules.mjs",
     "telemetry.mjs",
-    "memory-bridge.mjs"
+    "memory-bridge.mjs",
+    "memory-sync.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"