Add command to extract build info from metadata

This will allow to recreate the metadata after patching the FS.

PUBLISHED_FROM=dae228bbf49d71f383e4dc52316cf98aba3914f5

docs/design-concept/events.md

+---
+title: Events
+---
+

docs/design-concept/intro.md

+---
+title: Design Concept
+---
+
+Mongoose is a multi-protocol networking library that implements non-blocking,
+asyncronous IO and provides event-based API. It has three basic data structures:
+
+- [`struct mg_mgr`](#TODO) is an event manager that holds all active
+  connections
+- [`struct mg_connection`](#TODO) describes a connection
+- [`struct mbuf`](#TODO) describes data buffer (received or sent data)
+
+Connections could be either *listening*, *outbound* or *inbound*.  Outbound
+connections are created by [`mg_connect()`](#TODO) call.  Listening connections
+are created by [`mg_bind()`](#TODO) call.  Inbound connections are those
+accepted by a listening connection.  Each connection is described by [`struct
+mg_connection`](#TODO) structure, which has a number of fields like socket,
+event handler function, send/receive buffer, flags, et cetera.
+
+Mongoose usage pattern is to declare and initialize event manager, create
+connections and create an event loop by calling [`mg_mgr_poll()`](#TODO) in a
+loop.  [`mg_mgr_poll()`](#TODO) iterates over all sockets, accepts new
+connections, sends and receives data, closes connections, and calls event
+handler functions for the respective events.

docs/design-concept/items.json

+{
+  "items": [
+    { "type": "markdown", "name": "intro.md" },
+    { "type": "markdown", "name": "memory-buffers.md" }
+  ]
+}

docs/design-concept/memory-buffers.md

+---
+title: Memory buffers
+---
+
+Each connection has send and receive buffer,
+[`struct mg_connection::send_mbuf`](#TODO)
+and
+[`struct mg_connection::recv_mbuf`](#ODO) respectively.
+When data arrives,
+Mongoose appends received data to the `recv_mbuf` and
+triggers `MG_EV_RECV` event. User may send data back by calling one of the
+output functions, like [`mg_send()`](#TODO) or
+[`mg_printf()`](#TODO). Output functions append data to the
+`send_mbuf`. When Mongoose
+successfully writes data to the socket, it discards data from
+[`mg_connection::send_mbuf`](#TODO) and
+sends `MG_EV_SEND` event. When connection is closed, `MG_EV_CLOSE` event is sent.
+
+![](../../static/img/mongoose/mbuf.png)
+

docs/items.json

+{
+  "items": [
+    { "type": "section", "name": "usage-example" },
+    { "type": "section", "name": "design-concept" }
+  ]
+}

docs/usage-example/intro.md

+---
+title: Usage Example
+---
+
+- Copy `mongoose.c` and `mongoose.h` to your build tree
+- Write code that uses Mongoose API, e.g. in `my_app.c`
+- Compile application: `$ cc my_app.c mongoose.c`
+
+```c
+#include "mongoose.h"  // Include Mongoose API definitions
+
+// Define an event handler function
+static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
+  struct mbuf *io = &nc->recv_mbuf;
+
+  switch (ev) {
+    case MG_EV_RECV:
+      // This event handler implements simple TCP echo server
+      mg_send(nc, io->buf, io->len);  // Echo received data back
+      mbuf_remove(io, io->len);      // Discard data from recv buffer
+      break;
+    default:
+      break;
+  }
+}
+
+int main(void) {
+  struct mg_mgr mgr;
+
+  mg_mgr_init(&mgr, NULL);  // Initialize event manager object
+
+  // Note that many connections can be added to a single event manager
+  // Connections can be created at any point, e.g. in event handler function
+  mg_bind(&mgr, "1234", ev_handler);  // Create listening connection and add it to the event manager
+
+  for (;;) {  // Start infinite event loop
+    mg_mgr_poll(&mgr, 1000);
+  }
+
+  mg_mgr_free(&mgr);
+  return 0;
+}
+```
+

docs/usage-example/items.json

+{
+  "items": [
+    { "type": "markdown", "name": "intro.md" }
+  ]
+}