diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..28a12f7
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "thirdparty/Jinja2Cpp"]
+	path = thirdparty/Jinja2Cpp
+	url = git@github.com:jinja2cpp/Jinja2Cpp.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..64453c0
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.1)
+project(jinja2cpp-cli CXX)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+
+set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+
+set (JINJA2CPP_DEPS_MODE conan-build CACHE STRING "" FORCE)
+add_subdirectory (thirdparty/Jinja2Cpp ${CMAKE_CURRENT_BINARY_DIR}/thirdparty/jinja2cpp)
+
+find_package(boost 1.71 COMPONENTS program_options filesystem REQUIRED)
+find_package(jsonformoderncpp 3.7.0 REQUIRED)
+find_package(yaml-cpp 0.6.0 REQUIRED)
+#find_package(jinja2cpp REQUIRED)
+
+# Generate Version file
+execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --always OUTPUT_VARIABLE GIT_REPO_VERSION
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/Jinja2Cpp)
+configure_file("version.h.in" "version.h")
+
+add_library(jinja2cpp-libcli
+        src/command_line.cpp
+        src/command_line_j2.cpp
+        src/command_line.h
+        src/param_resolver.cpp
+        src/param_resolver.h
+        src/yaml_reflector.h
+        )
+add_library(jinja2cpp::cli ALIAS jinja2cpp-libcli)
+target_include_directories(jinja2cpp-libcli PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(jinja2cpp-libcli PUBLIC jinja2cpp
+        jsonformoderncpp::jsonformoderncpp
+        yaml-cpp::yaml-cpp
+        boost::boost
+        )
+
+add_executable(${PROJECT_NAME} src/main.cpp)
+target_link_libraries(${PROJECT_NAME} jinja2cpp::cli)
+set_target_properties (${PROJECT_NAME} PROPERTIES
+        CXX_STANDARD 14
+        CXX_STANDARD_REQUIRED ON)
+
+add_executable(j2cpp-cli src/main_j2.cpp)
+target_link_libraries(j2cpp-cli jinja2cpp::cli)
+set_target_properties (j2cpp-cli PROPERTIES
+        CXX_STANDARD 14
+        CXX_STANDARD_REQUIRED ON)
+
+# Setup testing
+enable_testing()
+add_subdirectory(test)
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..99fa4ea
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,28 @@
+FROM ubuntu:disco as builder
+
+LABEL maintainer="Andrey Bronin <jonnib@yandex.ru>"
+
+RUN apt-get update && \
+    apt-get install -y nano git build-essential cmake python3-pip && \
+    pip3 install conan
+
+RUN conan user
+RUN conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
+RUN conan remote add flexferrum https://api.bintray.com/conan/flexferrum/conan-packages
+RUN conan remote add martin https://api.bintray.com/conan/martinmoene/nonstd-lite
+
+COPY . /project
+WORKDIR /project
+
+RUN conan install . --build=missing
+RUN cmake -DCMAKE_BUILD_TYPE=Release . && make
+
+FROM ubuntu:disco
+COPY --from=builder /project/bin/jinja2cpp-cli /jinja2cpp
+
+# RUN apk update && \
+#     apk upgrade && \
+#     apk --update add libstdc++ \
+#     rm -rf /var/cache/apk/*
+
+ENTRYPOINT [ "/jinja2cpp" ]
diff --git a/Dockerfile.alpine b/Dockerfile.alpine
new file mode 100644
index 0000000..c2e87cc
--- /dev/null
+++ b/Dockerfile.alpine
@@ -0,0 +1,37 @@
+FROM alpine:latest as builder
+
+LABEL maintainer="Andrey Bronin <jonnib@yandex.ru>"
+
+RUN apk update && \
+    apk upgrade && \
+    apk --update add \
+#        alpine-sdk \
+        g++ \
+        build-base \
+        cmake \
+        libstdc++ \
+        git \
+        linux-headers \
+        py-pip && \
+        pip install conan && \
+    rm -rf /var/cache/apk/*
+
+COPY . /project
+WORKDIR /project
+RUN conan user
+RUN conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
+RUN conan remote add andreybronin https://api.bintray.com/conan/andreybronin/conan
+RUN conan remote add martinmoene https://api.bintray.com/conan/martinmoene/nonstd-lite
+RUN conan remote add flexferrum https://api.bintray.com/conan/flexferrum/conan-packages
+RUN conan install . --build=missing
+RUN cmake -DCMAKE_BUILD_TYPE=Release . && make
+
+FROM alpine:latest
+COPY --from=builder /project/bin/jinja2cpp-cli /jinja2cpp
+
+RUN apk update && \
+    apk upgrade && \
+    apk --update add libstdc++ \
+    rm -rf /var/cache/apk/*
+
+ENTRYPOINT [ "/jinja2cpp" ]
diff --git a/README.md b/README.md
index f70d651..f61f825 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,17 @@
-# tools-cli
\ No newline at end of file
+# Jinja2cpp CLI tool
+
+```
+Usage: jinja2cpp [options] <input template> <input data>
+Options:
+  -h [ --help ]         Display this help message
+  -v [ --version ]      Display the version number
+  --format              Format of input variables: auto, ini, json, yaml, toml
+  --input-template arg  Input template file path
+  --input-data arg      Define template variable in the form of key=value
+```
+
+### Docker
+
+```
+docker run --rm bronin/jinja2cpp -h
+```
diff --git a/conanfile.txt b/conanfile.txt
new file mode 100644
index 0000000..00f825f
--- /dev/null
+++ b/conanfile.txt
@@ -0,0 +1,20 @@
+[requires]
+boost/1.71.0
+gtest/1.8.1
+variant-lite/1.2.2
+expected-lite/0.3.0
+optional-lite/3.2.0
+string-view-lite/1.3.0
+fmt/5.3.0
+
+yaml-cpp/0.6.3
+jsonformoderncpp/3.7.0@vthiery/stable
+tinytoml/0.4@bincrafters/stable
+
+[options]
+jinja2cpp:shared=False
+gtest:shared=False
+boost:shared=False
+
+[generators]
+cmake_find_package
diff --git a/src/command_line.cpp b/src/command_line.cpp
new file mode 100644
index 0000000..2fb6ec1
--- /dev/null
+++ b/src/command_line.cpp
@@ -0,0 +1,100 @@
+#include "command_line.h"
+#include "param_resolver.h"
+#include <version.h>
+
+#include <boost/program_options.hpp>
+
+#include <iostream>
+#include <memory>
+
+namespace jinja2
+{
+
+CommandLine::CommandLine(std::unique_ptr<Template> tpl) : m_tpl(std::move(tpl)) { }
+
+int CommandLine::Execute(int argc, char* argv[])
+{
+    namespace po = boost::program_options;
+    po::options_description desc("Options");
+
+    desc.add_options()
+            ("help,h", "Display this help message")
+            ("version,v", "Display the version number")
+            ("format", "Format of input variables: auto, ini, json, yaml, toml")
+            ("input-template", po::value<std::string>(), "Input template file path")
+            ("input-data", po::value<std::vector<std::string>>(),
+             "Define template variable in the form of key=value");
+
+    po::positional_options_description p;
+    p.add("input-template", 1);
+    p.add("input-data", -1);
+
+    try {
+        po::variables_map vm;
+        po::store(po::command_line_parser(argc, argv).options(desc).positional(p).allow_unregistered().run(), vm);
+        po::notify(vm);
+
+        if (vm.count("help")) {
+            std::cout << Help() << std::endl << desc << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        if (vm.count("version")) {
+            std::cout << Version() << std::endl;
+            return EXIT_SUCCESS;
+        }
+
+        for (auto &v : vm["input-data"].as<std::vector<std::string> >())
+        {
+            if (vm.count("input-data")) {
+                std::cout << "Input data are: ";
+                std::cout << v << std::endl;
+            }
+        }
+
+
+        if (vm.count("input-template"))
+        {
+            const auto &filename = vm["input-template"].as<std::string>();
+            RenderTemplate(filename);
+            return EXIT_SUCCESS;
+        }
+
+    }
+    catch (std::exception const& e)
+    {
+        std::cerr << e.what() << std::endl;
+    }
+    return EXIT_FAILURE;
+}
+
+std::string CommandLine::Help()
+{
+    return "Usage: jinja2cpp-cli [options] <input template> <input data>";
+}
+
+std::string CommandLine::Version()
+{
+    return jinja2cppVersion;
+}
+
+
+void CommandLine::RenderTemplate(const std::string& fileName)
+{
+    jinja2::Template tpl;
+    auto result = tpl.LoadFromFile(fileName);
+    if (!result.has_value()) {
+        std::cout << result.error() << std::endl;
+    }
+
+    std::cout << "Input template is: ";
+    std::cout << fileName << std::endl;
+
+
+    JsonParamResolver resolver;
+
+    ValuesMap vm = resolver.ParamsFromFile("sample.json");
+    tpl.Render(std::cout, vm);
+}
+
+} // namespace jinja2
diff --git a/src/command_line.h b/src/command_line.h
new file mode 100644
index 0000000..dd6409a
--- /dev/null
+++ b/src/command_line.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <jinja2cpp/template.h>
+
+#include <string>
+
+namespace jinja2 {
+
+struct ICommands {
+    virtual ~ICommands() = default;
+
+    virtual std::string Help() = 0;
+    virtual std::string Version() = 0;
+    virtual void RenderTemplate(const std::string& fileName) = 0;
+};
+
+/**
+ * CommandLine is analog CLI of python jinja2-cli
+ */
+class CommandLine : protected ICommands {
+public:
+    explicit CommandLine(std::unique_ptr<Template> tpl = std::make_unique<Template>());
+
+    int Execute(int argc, char **argv);
+
+protected:
+    std::string Help() override ;
+    std::string Version() override;
+    void RenderTemplate(const std::string& fileName) override;
+
+private:
+    std::unique_ptr<Template> m_tpl;
+};
+
+/**
+ * CommandLine is analog CLI of modern python j2cli (https://github.com/kolypto/j2cli)
+ */
+class CommandLineJ2 : protected ICommands {
+public:
+    explicit CommandLineJ2(std::unique_ptr<Template> tpl = std::make_unique<Template>());
+
+    int Execute(int argc, char **argv);
+
+protected:
+    std::string Help() override ;
+    std::string Version() override;
+    void RenderTemplate(const std::string& fileName) override;
+
+private:
+    std::unique_ptr<Template> m_tpl;
+};
+
+} // namespace jinja2
diff --git a/src/command_line_j2.cpp b/src/command_line_j2.cpp
new file mode 100644
index 0000000..ef5682b
--- /dev/null
+++ b/src/command_line_j2.cpp
@@ -0,0 +1,31 @@
+#include "command_line.h"
+#include <version.h>
+
+namespace jinja2
+{
+
+CommandLineJ2::CommandLineJ2(std::unique_ptr<Template> tpl) : m_tpl(std::move(tpl)) { }
+
+int CommandLineJ2::Execute(int argc, char* argv[])
+{
+    // todo: implement me
+    return 0;
+}
+
+std::string CommandLineJ2::Help()
+{
+    return "Usage: j2cpp-cli [options] <input template> <input data>";
+}
+
+std::string CommandLineJ2::Version()
+{
+    return jinja2cppVersion;
+}
+
+
+void CommandLineJ2::RenderTemplate(const std::string& fileName)
+{
+    // todo: implement me
+}
+
+} // namespace jinja2
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..6af666e
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,6 @@
+#include "command_line.h"
+
+int main(int argc, char* argv[]) {
+    jinja2::CommandLine cli;
+    return cli.Execute(argc, argv);
+}
diff --git a/src/main_j2.cpp b/src/main_j2.cpp
new file mode 100644
index 0000000..93e5065
--- /dev/null
+++ b/src/main_j2.cpp
@@ -0,0 +1,6 @@
+#include "command_line.h"
+
+int main(int argc, char* argv[]) {
+    jinja2::CommandLineJ2 cli;
+    return cli.Execute(argc, argv);
+}
diff --git a/src/param_resolver.cpp b/src/param_resolver.cpp
new file mode 100644
index 0000000..4ff1fc5
--- /dev/null
+++ b/src/param_resolver.cpp
@@ -0,0 +1,19 @@
+#include "param_resolver.h"
+
+// #include <jinja2cpp/template.h>
+#include <jinja2cpp/binding/nlohmann_json.h>
+
+using json = nlohmann::json;
+
+namespace jinja2 {
+
+const ValuesMap JsonParamResolver::ParamsFromFile(const std::string &filePath)
+{
+    nlohmann::json values = {
+            {"message", "Hello World from Parser!"}
+    };
+    auto x = Reflect(std::move(values));
+    return {{"params", x}};
+}
+
+} // namespace jinja2
diff --git a/src/param_resolver.h b/src/param_resolver.h
new file mode 100644
index 0000000..fe43afd
--- /dev/null
+++ b/src/param_resolver.h
@@ -0,0 +1,28 @@
+#pragma once
+
+//#include "yaml_reflector.h"
+#include <jinja2cpp/value.h>
+
+namespace jinja2 {
+
+struct IParamResolver
+{
+    virtual ~IParamResolver() = default;
+
+    virtual const ValuesMap ParamsFromFile(const std::string& filePath) = 0;
+
+};
+
+class JsonParamResolver : public IParamResolver
+{
+public:
+    // JsonParamResolver() = default;
+
+    const ValuesMap ParamsFromFile(const std::string& filePath) override;
+
+
+};
+
+
+
+} // namespace jinja2
diff --git a/src/yaml_reflector.h b/src/yaml_reflector.h
new file mode 100644
index 0000000..2b11f4f
--- /dev/null
+++ b/src/yaml_reflector.h
@@ -0,0 +1,143 @@
+#include <yaml-cpp/yaml.h>
+
+#include <jinja2cpp/reflected_value.h>
+
+namespace jinja2
+{
+namespace detail
+{
+
+class YamlCppObjectAccessor : public MapItemAccessor, public ReflectedDataHolder<YAML::Node>
+{
+public:
+    using ReflectedDataHolder<YAML::Node>::ReflectedDataHolder;
+    ~YamlCppObjectAccessor() override = default;
+
+    size_t GetSize() const override
+    {
+        auto j = this->GetValue();
+        return j ? j->size() : 0ULL;
+    }
+
+    bool HasValue(const std::string& name) const override
+    {
+        auto j = this->GetValue();
+
+        auto n = *j;
+        YAML::Node node = n[name];
+        return node.IsDefined() ? node : false;
+    }
+
+    Value GetValueByName(const std::string& name) const override
+    {
+        auto j = this->GetValue();
+        auto n = *j;
+        YAML::Node node = n[name];
+        if (node.IsDefined())
+            return Value();
+
+        return Reflect(&node);
+    }
+
+    std::vector<std::string> GetKeys() const override
+    {
+        auto j = this->GetValue();
+        if (!j)
+            return {};
+
+        std::vector<std::string> result;
+        // todo use iterator
+//        for (auto& item : j->items())
+//        {
+//            result.emplace_back(item.key());
+//        }
+        return result;
+    }
+};
+
+
+struct YamlCppArrayAccessor : ListItemAccessor, IndexBasedAccessor, ReflectedDataHolder<YAML::Node>
+{
+    using ReflectedDataHolder<YAML::Node>::ReflectedDataHolder;
+
+    nonstd::optional<size_t> GetSize() const override
+    {
+        auto j = this->GetValue();
+        return j ? j->size() : nonstd::optional<size_t>();
+    }
+    const IndexBasedAccessor* GetIndexer() const override
+    {
+        return this;
+    }
+
+    ListEnumeratorPtr CreateEnumerator() const override
+    {
+        using Enum = Enumerator<typename YAML::Node::const_iterator>;
+        auto j = this->GetValue();
+        if (!j)
+            jinja2::ListEnumeratorPtr(nullptr, Enum::Deleter);
+
+        return jinja2::ListEnumeratorPtr(new Enum(j->begin(), j->end()), Enum::Deleter);
+    }
+
+    Value GetItemByIndex(int64_t idx) const override
+    {
+        auto j = this->GetValue();
+        if (!j)
+            return Value();
+
+        return Reflect((*j)[idx]);
+    }
+};
+
+template<>
+struct Reflector<YAML::Node>
+{
+    static Value Create(YAML::Node val)
+    {
+        Value result;
+        switch (val.Type())
+        {
+            case YAML::NodeType::Map:
+                result = GenericMap([accessor = YamlCppObjectAccessor(std::move(val))]() { return &accessor; });
+                break;
+            case YAML::NodeType::Sequence:
+                result = GenericList([accessor = YamlCppArrayAccessor(std::move(val))]() { return &accessor; });
+                break;
+            case YAML::NodeType::Scalar:
+                result = val.as<std::string>();
+                break;
+            case YAML::NodeType::Undefined:
+            case YAML::NodeType::Null:
+            default:
+                break;
+        }
+        return result;
+    }
+
+    static Value CreateFromPtr(const YAML::Node *val)
+    {
+        Value result;
+        switch (val->Type())
+        {
+            case YAML::NodeType::Map:
+                result = GenericMap([accessor = YamlCppObjectAccessor(val)]() { return &accessor; });
+                break;
+            case YAML::NodeType::Sequence:
+                result = GenericList([accessor = YamlCppArrayAccessor(val)]() { return &accessor; });
+                break;
+            case YAML::NodeType::Scalar:
+                result = val->as<std::string>();
+                break;
+            case YAML::NodeType::Undefined:
+            case YAML::NodeType::Null:
+            default:
+                break;
+        }
+        return result;
+    }
+
+};
+
+} // namespace detail
+} // namespace jinja2
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..f7009ac
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.1)
+project(test_jinja2cpp-cli CXX)
+
+find_package(gtest REQUIRED)
+
+add_executable (${PROJECT_NAME}
+        command_line_test.cpp
+        param_resolver_test.cpp
+        )
+
+target_link_libraries(${PROJECT_NAME} gtest::gtest jinja2cpp::cli)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME} --gtest_output=xml)
diff --git a/test/command_line_test.cpp b/test/command_line_test.cpp
new file mode 100644
index 0000000..d0837a9
--- /dev/null
+++ b/test/command_line_test.cpp
@@ -0,0 +1,67 @@
+#include "../src/command_line.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using namespace testing;
+using namespace jinja2;
+
+class MockTemplate : public Template
+{
+public:
+    // Load();
+
+    MOCK_METHOD2(Load, Result<void> (const char* tpl, std::string tplName));
+
+//    MOCK_METHOD2(Load, ParseResult(const std::string& str, std::string tplName));
+//    MOCK_METHOD2(Load, ParseResult(std::istream& stream, std::string tplName));
+//
+//    MOCK_METHOD1(LoadFromFile, ParseResult (const std::string& fileName));
+    MOCK_METHOD2(Render, void (std::ostream& os, const ValuesMap& params));
+    MOCK_METHOD1(RenderAsString, std::string (const ValuesMap& params));
+};
+
+struct MockCommands : public ICommands
+{
+    MOCK_METHOD0(Help,std::string());
+    MOCK_METHOD0(Version,std::string());
+    MOCK_METHOD1(RenderTemplate, void(const std::string& fileName));
+};
+
+TEST(CommandLine, Execute_without_args_expect_show_help)
+{
+    MockTemplate tpl;
+    // EXPECT_CALL(tpl, Load(std::string("123"), std::string("321"))).WillOnce(Return(ParseResult{}));
+
+    //Template t = static_cast<Template>(tpl);
+    CommandLine cli(std::make_unique<Template>(tpl));
+    //auto argv =  *char[2]{"sf", "qeqwe"};
+
+    ASSERT_EQ(EXIT_FAILURE, cli.Execute(1, nullptr));
+
+}
+
+TEST(CommandLine, Execute_help)
+{
+    MockTemplate tpl;
+
+    CommandLine cli(std::make_unique<Template>(tpl));
+    const char* argv[] = {"jinja2cpp", "-v"};
+
+    //EXPECT_CALL(cli, Help())..WillOnce(Return());
+    // TODO: expect call Version()
+    ASSERT_EQ(EXIT_SUCCESS, cli.Execute(2, const_cast<char**>(argv)));
+}
+
+TEST(CommandLine, Execute_version)
+{
+    MockTemplate tpl;
+    // EXPECT_CALL(tpl, Load(std::string("123"), std::string("321"))).WillOnce(Return(ParseResult{}));
+
+    //Template t = static_cast<Template>(tpl);
+    CommandLine cli(std::make_unique<Template>(tpl));
+    //auto argv =  *char[2]{"sf", "version"};
+
+    // TODO: expect call Version()
+    ASSERT_EQ(EXIT_SUCCESS, cli.Execute(1, nullptr));
+}
diff --git a/test/param_resolver_test.cpp b/test/param_resolver_test.cpp
new file mode 100644
index 0000000..07a1c95
--- /dev/null
+++ b/test/param_resolver_test.cpp
@@ -0,0 +1,30 @@
+#include "../src/param_resolver.h"
+
+#include <gmock/gmock.h>
+
+using namespace testing;
+using namespace jinja2;
+
+TEST(ParamResolver, ResolveJson)
+{
+    JsonParamResolver resolver;
+    auto params = resolver.ParamsFromFile("");
+
+    try {
+        auto m = params["params"];
+
+        ASSERT_TRUE(m.isMap());
+
+        //auto genmap = nonstd::get_if<GenericMap>(&m)
+
+        for (auto el : params) {
+            std::cout << el.first << std::endl;
+            // ASSERT_EQ(std::string("j.at(name)"), el);
+        }
+    }
+    catch (std::exception &e)
+    {
+        std::cerr << e.what() << std::endl;
+    }
+
+}
\ No newline at end of file
diff --git a/thirdparty/Jinja2Cpp b/thirdparty/Jinja2Cpp
new file mode 160000
index 0000000..4870182
--- /dev/null
+++ b/thirdparty/Jinja2Cpp
@@ -0,0 +1 @@
+Subproject commit 4870182394feb41bb3afdb0c8e23ef3053972d8a
diff --git a/version.h.in b/version.h.in
new file mode 100644
index 0000000..966dc7e
--- /dev/null
+++ b/version.h.in
@@ -0,0 +1 @@
+constexpr char jinja2cppVersion[] = R"(Jinja2cpp version: ${GIT_REPO_VERSION})";
\ No newline at end of file