refactor: migrate memory service to controller registry pattern (tinyhumansai#138)

Move all 23 memory RPC methods from legacy dispatch (src/rpc/dispatch.rs)
to the controller registry pattern with typed schemas.

- Create src/openhuman/memory/schemas.rs with 23 ControllerSchema
  definitions, RegisteredController entries, and handler functions
- Wire memory controllers into src/core/all.rs registry builders
- Remove all memory.* and ai.* branches from dispatch.rs (only
  security_policy_info remains)
- Update frontend to use openhuman.memory_* method names directly
  in tauriCommands.ts (no legacy aliases needed)
- Move ai.list_memory_files/read/write into memory namespace as
  openhuman.memory_list_files/read_file/write_file
- Update jsonrpc.rs and tauriCommandsMemory test method strings

Methods are now accessible via both JSON-RPC (openhuman.memory_*)
and CLI (openhuman memory <function>).

Author: sanil-23

app/src/utils/__tests__/tauriCommandsMemory.test.ts

@@ -49,7 +49,7 @@ describe('memoryGraphQuery', () => {
     const result = await memoryGraphQuery('team', 'Alice', 'OWNS');
 
     expect(mockCallCoreRpc).toHaveBeenCalledWith({
-      method: 'memory.graph.query',
+      method: 'openhuman.memory_graph_query',
       params: { namespace: 'team', subject: 'Alice', predicate: 'OWNS' },
     });
     expect(result).toEqual(mockRelations);
@@ -62,7 +62,7 @@ describe('memoryGraphQuery', () => {
     await memoryGraphQuery();
 
     expect(mockCallCoreRpc).toHaveBeenCalledWith({
-      method: 'memory.graph.query',
+      method: 'openhuman.memory_graph_query',
       params: { namespace: undefined, subject: undefined, predicate: undefined },
     });
   });
@@ -100,7 +100,7 @@ describe('memoryDocIngest', () => {
 
     const result = await memoryDocIngest(params);
 
-    expect(mockCallCoreRpc).toHaveBeenCalledWith({ method: 'memory.doc.ingest', params });
+    expect(mockCallCoreRpc).toHaveBeenCalledWith({ method: 'openhuman.memory_doc_ingest', params });
     expect(result).toEqual(ingestResult);
   });
 
@@ -111,6 +111,6 @@ describe('memoryDocIngest', () => {
     const params = { namespace: 'ns', key: 'k', title: 't', content: 'c' };
     await memoryDocIngest(params);
 
-    expect(mockCallCoreRpc).toHaveBeenCalledWith({ method: 'memory.doc.ingest', params });
+    expect(mockCallCoreRpc).toHaveBeenCalledWith({ method: 'openhuman.memory_doc_ingest', params });
   });
 });

app/src/utils/tauriCommands.ts

@@ -199,7 +199,7 @@ export async function syncMemoryClientToken(token: string): Promise<void> {
   }
   try {
     console.debug('[memory] syncMemoryClientToken: payload → memory.init');
-    await callCoreRpc<boolean>({ method: 'memory.init', params: { jwt_token: token } });
+    await callCoreRpc<boolean>({ method: 'openhuman.memory_init', params: { jwt_token: token } });
     console.info('[memory] syncMemoryClientToken: exit — ok');
   } catch (err) {
     console.warn('[memory] syncMemoryClientToken: exit — error:', err);
@@ -217,14 +217,17 @@ export async function memoryListDocuments(namespace?: string): Promise<unknown>
   if (!isTauri()) {
     throw new Error('Not running in Tauri');
   }
-  return await callCoreRpc<unknown>({ method: 'memory.list_documents', params: { namespace } });
+  return await callCoreRpc<unknown>({
+    method: 'openhuman.memory_list_documents',
+    params: { namespace },
+  });
 }
 
 export async function memoryListNamespaces(): Promise<string[]> {
   if (!isTauri()) {
     throw new Error('Not running in Tauri');
   }
-  return await callCoreRpc<string[]>({ method: 'memory.list_namespaces' });
+  return await callCoreRpc<string[]>({ method: 'openhuman.memory_list_namespaces' });
 }
 
 export async function memoryDeleteDocument(
@@ -235,7 +238,7 @@ export async function memoryDeleteDocument(
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<unknown>({
-    method: 'memory.delete_document',
+    method: 'openhuman.memory_delete_document',
     params: { document_id: documentId, namespace },
   });
 }
@@ -249,7 +252,7 @@ export async function memoryQueryNamespace(
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<string>({
-    method: 'memory.query_namespace',
+    method: 'openhuman.memory_query_namespace',
     params: { namespace, query, max_chunks: maxChunks },
   });
 }
@@ -262,7 +265,7 @@ export async function memoryRecallNamespace(
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<string | null>({
-    method: 'memory.recall_namespace',
+    method: 'openhuman.memory_recall_context',
     params: { namespace, max_chunks: maxChunks },
   });
 }
@@ -289,7 +292,7 @@ export async function memoryGraphQuery(
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<GraphRelation[]>({
-    method: 'memory.graph.query',
+    method: 'openhuman.memory_graph_query',
     params: { namespace, subject, predicate },
   });
 }
@@ -310,15 +313,15 @@ export async function memoryDocIngest(params: {
   if (!isTauri()) {
     throw new Error('Not running in Tauri');
   }
-  return await callCoreRpc<unknown>({ method: 'memory.doc.ingest', params });
+  return await callCoreRpc<unknown>({ method: 'openhuman.memory_doc_ingest', params });
 }
 
 export async function aiListMemoryFiles(relativeDir = 'memory'): Promise<string[]> {
   if (!isTauri()) {
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<string[]>({
-    method: 'ai.list_memory_files',
+    method: 'openhuman.memory_list_files',
     params: { relative_dir: relativeDir },
   });
 }
@@ -328,7 +331,7 @@ export async function aiReadMemoryFile(relativePath: string): Promise<string> {
     throw new Error('Not running in Tauri');
   }
   return await callCoreRpc<string>({
-    method: 'ai.read_memory_file',
+    method: 'openhuman.memory_read_file',
     params: { relative_path: relativePath },
   });
 }
@@ -338,7 +341,7 @@ export async function aiWriteMemoryFile(relativePath: string, content: string):
     throw new Error('Not running in Tauri');
   }
   await callCoreRpc<boolean>({
-    method: 'ai.write_memory_file',
+    method: 'openhuman.memory_write_file',
     params: { relative_path: relativePath, content },
   });
 }

src/core/all.rs

@@ -62,6 +62,7 @@ fn build_registered_controllers() -> Vec<RegisteredController> {
     controllers.extend(crate::openhuman::skills::all_skills_registered_controllers());
     controllers.extend(crate::openhuman::workspace::all_workspace_registered_controllers());
     controllers.extend(crate::openhuman::tools::all_tools_registered_controllers());
+    controllers.extend(crate::openhuman::memory::all_memory_registered_controllers());
     controllers
 }
 
@@ -89,6 +90,7 @@ fn build_declared_controller_schemas() -> Vec<ControllerSchema> {
     schemas.extend(crate::openhuman::skills::all_skills_controller_schemas());
     schemas.extend(crate::openhuman::workspace::all_workspace_controller_schemas());
     schemas.extend(crate::openhuman::tools::all_tools_controller_schemas());
+    schemas.extend(crate::openhuman::memory::all_memory_controller_schemas());
     schemas
 }
 
@@ -122,6 +124,7 @@ pub fn namespace_description(namespace: &str) -> Option<&'static str> {
         "service" => Some("Desktop service lifecycle management."),
         "skills" => Some("Skill registry, runtime lifecycle, setup, tools, and sync."),
         "socket" => Some("Skills runtime socket bridge controls."),
+        "memory" => Some("Document storage, vector search, key-value store, and knowledge graph."),
         _ => None,
     }
 }

src/core/jsonrpc.rs

@@ -478,46 +478,46 @@ mod tests {
 
     #[tokio::test]
     async fn invoke_memory_init_missing_required_param_fails() {
-        let err = invoke_method(default_state(), "memory.init", json!({}))
+        let err = invoke_method(default_state(), "openhuman.memory_init", json!({}))
             .await
             .expect_err("missing jwt_token should fail");
-        assert!(err.contains("missing field `jwt_token`") || err.contains("jwt_token"));
+        assert!(err.contains("jwt_token"));
     }
 
     #[tokio::test]
     async fn invoke_memory_list_namespaces_rejects_unknown_param() {
         let err = invoke_method(
             default_state(),
-            "memory.list_namespaces",
+            "openhuman.memory_list_namespaces",
             json!({ "extra": true }),
         )
         .await
         .expect_err("unknown param should fail");
-        assert!(err.contains("unknown field `extra`") || err.contains("extra"));
+        assert!(err.contains("extra"));
     }
 
     #[tokio::test]
     async fn invoke_memory_query_namespace_missing_namespace_fails() {
         let err = invoke_method(
             default_state(),
-            "memory.query_namespace",
+            "openhuman.memory_query_namespace",
             json!({ "query": "who owns atlas" }),
         )
         .await
         .expect_err("missing namespace should fail");
-        assert!(err.contains("missing field `namespace`") || err.contains("namespace"));
+        assert!(err.contains("namespace"));
     }
 
     #[tokio::test]
     async fn invoke_memory_recall_memories_rejects_unknown_param() {
         let err = invoke_method(
             default_state(),
-            "memory.recall_memories",
+            "openhuman.memory_recall_memories",
             json!({ "namespace": "team", "extra": true }),
         )
         .await
         .expect_err("unknown param should fail");
-        assert!(err.contains("unknown field `extra`") || err.contains("extra"));
+        assert!(err.contains("extra"));
     }
 
     #[tokio::test]

src/openhuman/memory/mod.rs

@@ -4,6 +4,7 @@ pub mod ingestion;
 pub mod ops;
 pub(crate) mod relex;
 pub mod rpc_models;
+pub mod schemas;
 pub mod store;
 pub mod traits;
 
@@ -14,6 +15,10 @@ pub use ingestion::{
 pub use ops as rpc;
 pub use ops::*;
 pub use rpc_models::*;
+pub use schemas::{
+    all_controller_schemas as all_memory_controller_schemas,
+    all_registered_controllers as all_memory_registered_controllers,
+};
 pub use store::{
     create_memory, create_memory_for_migration, create_memory_with_storage,
     create_memory_with_storage_and_routes, effective_memory_backend_name, MemoryClient,