@ghl-ai/aw 0.1.37-beta.34 → 0.1.37-beta.36

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();
   }
 }
 
@@ -132,8 +139,8 @@ async function memoryPack(args) {
 
   const params = { query };
   if (args['--namespace']) params.namespace = args['--namespace'];
-  if (args['--budget'])    params.budget = parseInt(args['--budget'], 10);
-  else                     params.budget = 3500;
+  if (args['--budget'])    params.token_budget = parseInt(args['--budget'], 10);
+  else                     params.token_budget = 3500;
   if (args['--layer'])     params.layer = args['--layer'];
   if (args['--overlay'])   params.overlay = args['--overlay'];
   if (args['--angle'])     params.angle = args['--angle'];
@@ -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.2.9";
+const AW_ECC_TAG = "v1.4.0";
 
 const MARKETPLACE_NAME = "aw-marketplace";
 const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;

package/memory-bridge.mjs

@@ -1,9 +1,60 @@
 // memory-bridge.mjs — Bridge between CLI and MCP memory backend (JSON-RPC)
 
-import { MCP_BASE_URL } from './constants.mjs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { MCP_BASE_URL, AW_HOME, REGISTRY_DIR } from './constants.mjs';
+import * as config from './config.mjs';
 
 let _rpcId = 1;
 
+/** Cached headers — resolved once per process. */
+let _cachedHeaders = null;
+
+/**
+ * Resolve auth + namespace headers for MCP requests.
+ * - X-Namespace: from .sync-config.json namespace (team slug → server resolves to team_id)
+ * - Authorization: GitHub PAT from GITHUB_TOKEN env or `gh auth token`
+ */
+function resolveHeaders() {
+  if (_cachedHeaders) return _cachedHeaders;
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json, text/event-stream',
+  };
+
+  // Resolve namespace from .sync-config.json → X-Namespace header
+  const registryDir = join(AW_HOME, REGISTRY_DIR);
+  const cfg = config.load(registryDir);
+  if (cfg?.namespace) {
+    headers['X-Namespace'] = cfg.namespace;
+  }
+
+  // Resolve GitHub token for auth
+  const token = process.env.GITHUB_TOKEN || resolveGhToken();
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  _cachedHeaders = headers;
+  return headers;
+}
+
+/** Try `gh auth token` silently — returns null on failure. */
+function resolveGhToken() {
+  try {
+    const token = execSync('gh auth token', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000,
+    }).trim();
+    if (token && (token.startsWith('ghp_') || token.startsWith('gho_') || token.startsWith('github_pat_'))) {
+      return token;
+    }
+  } catch { /* gh not available or not authenticated */ }
+  return null;
+}
+
 /**
  * Call an MCP memory tool by name via JSON-RPC 2.0 (Streamable HTTP).
  * @param {string} toolName — MCP tool name (e.g. 'memory_curated_store', 'memory_search')
@@ -13,10 +64,7 @@ let _rpcId = 1;
 export async function callMemoryTool(toolName, params) {
   const response = await fetch(MCP_BASE_URL, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json, text/event-stream',
-    },
+    headers: resolveHeaders(),
     body: JSON.stringify({
       jsonrpc: '2.0',
       id: _rpcId++,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.34",
+  "version": "0.1.37-beta.36",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",