docs+skills: add main UI/UX visual-truth PRD and skill links

.agents/skills/rlm-mem/brain/scripts/memory_cli.py

@@ -0,0 +1,161 @@
+"""
+CLI helpers for layered memory operations.
+
+Usage:
+  python -m brain.scripts.memory_cli put --content "..." --scope project_agent
+  python -m brain.scripts.memory_cli get --id chunk-123
+  python -m brain.scripts.memory_cli search --query "..."
+  python -m brain.scripts.memory_cli prune --days 90
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+
+from .layered_memory_store import LayeredMemoryStore
+from .memory_policy import load_memory_policy, MemoryPolicy
+from .layered_adapter import LayeredChunkStoreAdapter
+from .memory_layers import resolve_all_layer_paths
+from .recall_operation import RecallOperation
+
+def setup_store(project_root: Path = None) -> LayeredMemoryStore:
+    if project_root is None:
+        project_root = Path.cwd()
+    policy = load_memory_policy(project_root=project_root)
+    # Default to a generic agent ID for CLI operations if not specified env var
+    # Ideally this should be configurable
+    agent_id = "cli-operator"
+    return LayeredMemoryStore(policy=policy, agent_id=agent_id)
+
+def cmd_put(args):
+    store = setup_store()
+    
+    if args.scope not in store.policy.write_layers:
+        print(f"Error: Write to layer '{args.scope}' not allowed by policy.")
+        print(f"Allowed write layers: {store.policy.write_layers}")
+        sys.exit(1)
+
+    record = {
+        "id": f"cli-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}",
+        "created_at": datetime.utcnow().isoformat() + "Z",
+        "scope": args.scope,
+        "entry_type": args.type,
+        "content": args.content,
+        "project_id": "rlm-mem",
+        "tags": args.tags or []
+    }
+    
+    try:
+        chunk_id = store.append_entry(args.scope, record)
+        print(f"Success: Wrote chunk {chunk_id} to {args.scope}")
+    except Exception as e:
+        print(f"Error writing to memory: {e}")
+        sys.exit(1)
+
+def cmd_get(args):
+    store = setup_store()
+    adapter = LayeredChunkStoreAdapter(store)
+    
+    chunk = adapter.get_chunk(args.id)
+    if chunk:
+        print(json.dumps(chunk.to_dict(), indent=2))
+    else:
+        print(f"Error: Chunk {args.id} not found.")
+        sys.exit(1)
+
+def cmd_search(args):
+    store = setup_store()
+    adapter = LayeredChunkStoreAdapter(store)
+    recall = RecallOperation(adapter) # Uses basic search if no LLM
+    
+    # Basic search for now
+    result = recall.recall(args.query, max_results=args.limit)
+    
+    print(f"Found {len(result.source_chunks)} matches:")
+    for chunk_id in result.source_chunks:
+        chunk = adapter.get_chunk(chunk_id)
+        if chunk:
+            preview = chunk.content[:100] + "..." if len(chunk.content) > 100 else chunk.content
+            print(f"- {chunk_id} ({chunk.metadata.confidence:.2f}): {preview}")
+
+def cmd_prune(args):
+    store = setup_store()
+    cutoff = datetime.utcnow() - timedelta(days=args.days)
+    paths = resolve_all_layer_paths(policy=store.policy, agent_id=store.agent_id)
+    pruned = 0
+    layers = 0
+
+    for layer in store.policy.write_layers:
+        target = paths.get(layer)
+        if target is None or not target.exists():
+            continue
+        layers += 1
+        with target.open("r", encoding="utf-8") as handle:
+            lines = handle.readlines()
+        retained = []
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                retained.append(line)
+                continue
+            try:
+                record = json.loads(stripped)
+            except json.JSONDecodeError:
+                retained.append(line)
+                continue
+            created_raw = record.get("created_at")
+            if not created_raw:
+                retained.append(line)
+                continue
+            try:
+                created_at = datetime.fromisoformat(created_raw.replace("Z", "+00:00"))
+            except ValueError:
+                retained.append(line)
+                continue
+            if created_at.tzinfo is not None:
+                created_at = created_at.replace(tzinfo=None)
+            if created_at < cutoff:
+                pruned += 1
+                continue
+            retained.append(line)
+        if retained != lines:
+            with store._file_lock(target):
+                target.write_text("".join(retained), encoding="utf-8", newline="\n")
+
+    print(f"Pruned {pruned} record(s) across {layers} layer(s).")
+
+def main():
+    parser = argparse.ArgumentParser(description="RLM-MEM Memory CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # PUT
+    put_parser = subparsers.add_parser("put", help="Write a memory record")
+    put_parser.add_argument("--content", required=True, help="Content to store")
+    put_parser.add_argument("--scope", default="project_agent", help="Target layer scope")
+    put_parser.add_argument("--type", default="note", help="Entry type (fact, note, etc)")
+    put_parser.add_argument("--tags", nargs="*", help="Tags")
+    put_parser.set_defaults(func=cmd_put)
+
+    # GET
+    get_parser = subparsers.add_parser("get", help="Retrieve a memory record")
+    get_parser.add_argument("--id", required=True, help="Chunk ID")
+    get_parser.set_defaults(func=cmd_get)
+
+    # SEARCH
+    search_parser = subparsers.add_parser("search", help="Search memory records")
+    search_parser.add_argument("--query", required=True, help="Search query")
+    search_parser.add_argument("--limit", type=int, default=10, help="Max results")
+    search_parser.set_defaults(func=cmd_search)
+
+    # PRUNE
+    prune_parser = subparsers.add_parser("prune", help="Prune old records")
+    prune_parser.add_argument("--days", type=int, default=90, help="Retention days")
+    prune_parser.set_defaults(func=cmd_prune)
+
+    args = parser.parse_args()
+    args.func(args)
+
+if __name__ == "__main__":
+    main()