diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..cf4c669
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Launch Package",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/glee.go",
+      "args": ["sample_post.md"]
+    }
+  ]
+}
diff --git a/ghost_upload_image.py b/ghost_upload_image.py
index 64b4a94..54849d8 100644
--- a/ghost_upload_image.py
+++ b/ghost_upload_image.py
@@ -28,14 +28,17 @@ def upload_to_ghost(token, image, hash_name, blog_image_list, logging):
             if hash_value in image_name:
                 logging.debug(f"The image {name} already exists and is being reused.")
                 return name
-
+        print("image",image)
+        print("hash_name",hash_name)    
         mulit_encoder = MultipartEncoder(
             fields={
                 "file": (hash_name, open(image, "rb"), "image/png"),
                 "ref": hash_name,
             }
         )
+        # print(mulit_encoder, "mulit_encoder")
         boundary_value = mulit_encoder.boundary_value
+        # print(boundary_value, "boundary_value")
         response = {}
         response = requests.post(
             POSTS_API_BASE,
diff --git a/glee.go b/glee.go
index de089f5..0fa431f 100644
--- a/glee.go
+++ b/glee.go
@@ -6,12 +6,14 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"errors"
-	"flag"
+
 	"fmt"
 	"io"
 	"io/ioutil"
 	"mime"
+	"mime/multipart"
 	"net/http"
+	"net/textproto"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -26,6 +28,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"
 	"github.com/ghodss/yaml"
+	"github.com/jessevdk/go-flags"
 	"github.com/pelletier/go-toml"
 
 	// "github.com/russross/blackfriday/v2"
@@ -54,6 +57,13 @@ type ResponseData struct {
 	Posts []Post `json:"posts"`
 }
 
+var opts struct {
+	ShowConfig bool `short:"c" long:"config" description:"Show glee configuration global file"`
+	Debug      bool   `short:"d" long:"debug" description:"debug mode"`
+	File       string `description:"Markdown file to process"`
+	Help 	  	bool 	`short:"h" long:"help" description:"Show this help message"`
+}
+
 var postsApiBase string
 
 var buf bytes.Buffer
@@ -110,7 +120,7 @@ func getPostId(slug string, headers http.Header) (*Post, error) {
 		if resp.StatusCode == http.StatusNotFound {
 			return nil, nil
 		}
-		return nil, fmt.Errorf("Unable to communicate with the Ghost Admin API: %s", body)
+		return nil, fmt.Errorf("unable to communicate with the Ghost Admin API: %s", body)
 	}
 
 	var data ResponseData
@@ -123,7 +133,7 @@ func getPostId(slug string, headers http.Header) (*Post, error) {
 		return &data.Posts[0], nil
 	}
 
-	return nil, errors.New("No posts found for the given slug")
+	return nil, errors.New("no posts found for the given slug")
 }
 
 func toHTML(markdown string) string {
@@ -154,14 +164,13 @@ func initLogging(debug bool) {
 }
 
 func addBlogConfigurations(meta map[string]interface{}) map[string]interface{} {
-	// Check if config is nil
 	if config == nil {
-		log.Fatal("Configuration is not initialized. Call viewTOMLFile to initialize it.")
+		log.Fatal("Configuration is not initialized. Call loadGlobalConfig to initialize it.")
 	}
 
 	globalSidebarTOC := config.GetDefault("blog-configuration.SIDEBAR_TOC", "").(bool)
-	globalFeatured := config.GetDefault("blog-configuration.FEATURED", "").(bool)
-	globalStatus := config.GetDefault("blog-configuration.STATUS", "").(string)
+	// globalFeatured := config.GetDefault("blog-configuration.FEATURED", "").(bool)
+	// globalStatus := config.GetDefault("blog-configuration.STATUS", "").(string)
 
 	defaultStyle := `pre { line-height: 125%; }
    td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
@@ -259,33 +268,26 @@ func addBlogConfigurations(meta map[string]interface{}) map[string]interface{} {
    }
 </script>`
 
-	// Append the default styles to the head
-	// Ensure meta["codeinjection_head"] is a string before appending
 	if existingHead, ok := meta["codeinjection_head"].(string); ok {
 		meta["codeinjection_head"] = existingHead + "<style>" + defaultStyle + "</style>"
 	} else {
 		meta["codeinjection_head"] = "<style> " + defaultStyle + "</style>"
 	}
-
-	// Conditionally append sidebar TOC head and footer
+	
 	if globalSidebarTOC {
 		if existingHead, ok := meta["codeinjection_head"].(string); ok {
 			meta["codeinjection_head"] = existingHead + sidebarTocHead
+			log.Debug("Done Sidebar TOC Code injection")
 		} else {
 			meta["codeinjection_head"] = sidebarTocHead
 		}
 		meta["codeinjection_foot"] = sidebarTocFooter
 	}
 
-	// Assuming meta is a map[string]interface{}, add or update relevant fields
-	fmt.Printf("SIDEBAR_TOC: %v\n", globalSidebarTOC)
-	fmt.Printf("FEATURED: %v\n", globalFeatured)
-	fmt.Printf("STATUS: %v\n", globalStatus)
-
 	return meta
 }
 
-func viewTOMLFile() {
+func loadGlobalConfig() {
 	configPath := filepath.Join(os.Getenv("HOME"), ".glee.toml")
 	var err error
 	config, err = toml.LoadFile(configPath)
@@ -296,10 +298,10 @@ func viewTOMLFile() {
 }
 
 func getTOMLFile(configPath string) {
-	fmt.Printf("The configuration file at %s was not found.\n", configPath)
+	log.Error("The configuration file at %s was not found.\n", configPath)
 
 	var configResponse string
-	fmt.Print("Would you like me to create the configuration file? (yes/no): ")
+	log.Info("Would you like me to create the configuration file? (yes/no): ")
 	fmt.Scanln(&configResponse)
 
 	if configResponse == "yes" || configResponse == "y" {
@@ -322,7 +324,6 @@ func makeRequest(headers http.Header, body map[string]interface{}, pid string, u
 		postsApiBase = ghostUrl + "/api/" + ghostVersion + "/admin/posts/"
 	}
 	if pid == "" {
-		// fmt.Printf("%#v\n", body)
 		method = http.MethodPost
 		apiEndpoint = postsApiBase + "?source=html"
 	} else {
@@ -334,13 +335,13 @@ func makeRequest(headers http.Header, body map[string]interface{}, pid string, u
 	client := &http.Client{}
 	bodyJson, err := json.Marshal(body)
 	if err != nil {
-		fmt.Println("Error marshaling body to JSON:", err)
+		log.Error("Error marshaling body to JSON:", err)
 		return
 	}
 
 	req, err := http.NewRequest(method, apiEndpoint, bytes.NewBuffer(bodyJson))
 	if err != nil {
-		fmt.Println("Error creating request:", err)
+		log.Error("Error creating request:", err)
 		return
 	}
 	req.Header = headers
@@ -348,19 +349,18 @@ func makeRequest(headers http.Header, body map[string]interface{}, pid string, u
 
 	resp, err := client.Do(req)
 	if err != nil {
-		fmt.Println("Error executing request:", err)
+		log.Error("Error executing request:", err)
 		return
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
 		var errorMessage string
-		errorBytes, _ := ioutil.ReadAll(resp.Body) // Read the response body
-		if err := json.Unmarshal(errorBytes, &errorMessage); err != nil {
-			// If the error message is not JSON, just use the raw response body
+		errorBytes, _ := ioutil.ReadAll(resp.Body) 
+		if err := json.Unmarshal(errorBytes, &errorMessage); err != nil {	
 			errorMessage = string(errorBytes)
 		}
-		fmt.Printf("Request failed with status: %s. Error message: %s\n", resp.Status, errorMessage)
+		log.Error("Request failed with status: %s. Error message: %s\n", resp.Status, errorMessage)
 		return
 	}
 
@@ -368,21 +368,19 @@ func makeRequest(headers http.Header, body map[string]interface{}, pid string, u
 	var responseData map[string]interface{}
 	err = json.NewDecoder(resp.Body).Decode(&responseData)
 	if err != nil {
-		fmt.Println("Error unmarshaling response:", err)
+		log.Error("Error unmarshaling response:", err)
 		return
 	}
 
 	// Log the result
 	if pid == "" {
-		fmt.Println("Created new post")
+		log.Info("Created new post")
 	} else {
-		fmt.Println("Updated existing post based on slug")
+		log.Info("Updated existing post based on slug")
 	}
 	fmt.Printf("Blog preview link: %s\n", responseData["posts"].([]interface{})[0].(map[string]interface{})["url"])
 }
 
-
-
 func injectMultiTitles(meta map[string]interface{}) error {
 	meta["codeinjection_head"] = ""
 
@@ -390,23 +388,26 @@ func injectMultiTitles(meta map[string]interface{}) error {
 	if !ok {
 		titleDataMap, ok := meta["title"].(map[string]interface{})
 		if !ok {
-			return fmt.Errorf("missing default title")
+			log.Error("missing default title")
+			return nil
 		}
 
 		defaultTitle, ok := titleDataMap["default"].(string)
 		if !ok {
-			return fmt.Errorf("missing 'default' key in title_data")
+			log.Error("missing default title in multi-title")
+			return nil
 		}
 
 		meta["title"] = defaultTitle
 
 		titleDataBytes, err := json.Marshal(titleDataMap)
 		if err != nil {
-			log.Printf("error marshaling title data: %v", err)
+			log.Error("error marshaling title data: %v", err)
 			return err
 		}
 
 		titleDataStr := string(titleDataBytes)
+		log.Debug("multi title: ", titleDataStr)
 
 		meta["codeinjection_head"] = fmt.Sprintf(`<script>
 			changetitle(%s);
@@ -416,13 +417,11 @@ func injectMultiTitles(meta map[string]interface{}) error {
 	return nil
 }
 
-
-
 func postToGhost(metadata map[string]interface{}, content string) {
-	// Add configurations to metadata
 	injectMultiTitles(metadata)
 	if val, ok := metadata["code_hilite_theme"]; ok {
 		theme = val.(string)
+		log.Debug("Theme from markdown:", theme)
 	} else {
 		codeTheme := config.GetDefault("blog-configuration.CODE_HILITE_THEME", "").(string)
 		if codeTheme != "" {
@@ -430,6 +429,7 @@ func postToGhost(metadata map[string]interface{}, content string) {
 		} else {
 			theme = "monokai" // Default theme if none is specified
 		}
+		log.Debug("Default/Global Configured theme:", theme)
 	}
 	md = goldmark.New(
 		goldmark.WithExtensions(
@@ -448,42 +448,47 @@ func postToGhost(metadata map[string]interface{}, content string) {
 			goldmarkHTML.WithUnsafe(),
 		),
 	)
-	
-	
 
 	metadata = addBlogConfigurations(metadata)
 	metadata["html"] = toHTML(content)
 	token, err := getJWToken()
-	
 	if err != nil {
-		log.Fatalf("Failed generate jwt token: %v", err)
+		log.Error("Failed generate jwt token: %v", err)
+	} else{
+		log.Debug("Generated jwt token")
 	}
 	headers := http.Header{}
 	headers.Set("Authorization", "Ghost "+token)
 	post, err := getPostId(metadata["slug"].(string), headers)
 	if err != nil {
-		fmt.Printf("Error: Unable to communicate with the Ghost Admin API. Please verify your Ghost configurations: %v\n", err)
+		log.Error("Error: Unable to communicate with the Ghost Admin API. Please verify your Ghost configurations: %v\n", err)
 		return
 	}
-
-	// fmt.Printf("Post ID: %s\nUpdated At: %s\nHTML Data: %s\nFeature Image: %s\n",pid, updated_at, html_data, feature_image)
 	var pid, updated_at, htmlData, featureImage string
 	if post == nil {
-		fmt.Println("No post found for the given slug.")
+		log.Info("No post found for the given slug.")
 	} else {
 		pid, updated_at, htmlData, featureImage = post.ID, post.UpdatedAt, post.Mobiledoc, post.FeatureImage
 	}
 	if _, ok := metadata["feature_image"]; ok {
 		uploadFeatureImage(metadata, token, featureImage)
 	} else {
+		log.Fatal("Feature image not provided")
 		metadata["feature_image"] = ""
 	}
 
 	uploadedImages, err := uploadImages(token, htmlData)
+	if err != nil{
+		log.Error("Error uploading images:", err)
+	} else{
+		log.Info("Uploaded Blog Images")
+	}
 	result, err := replaceImageLinks(metadata, uploadedImages)
+	if err != nil {
+		log.Error("Error replacing image links:", err)
+	}
 	metadata["html"] = result
 
-	// fmt.Println("Uploaded images:", uploadedImages)
 	postObj := metadata
 	body := map[string]interface{}{
 		"posts": []map[string]interface{}{postObj},
@@ -493,19 +498,18 @@ func postToGhost(metadata map[string]interface{}, content string) {
 }
 
 func replaceImageLinks(metadata map[string]interface{}, imgMap map[string]string) (string, error) {
-	// Extract the HTML string from the metadata map
+	
 	htmlStr, ok := metadata["html"].(string)
 	if !ok {
 		return "", errors.New("metadata does not contain a string under the 'html' key")
 	}
 
-	// Parse the HTML string into a DOM tree
+	
 	doc, err := html.Parse(strings.NewReader(htmlStr))
 	if err != nil {
 		return "", err
 	}
 
-	// Traverse the DOM tree to replace img src attributes and a href attributes
 	var f func(*html.Node)
 	f = func(n *html.Node) {
 		if n.Type == html.ElementNode {
@@ -515,7 +519,6 @@ func replaceImageLinks(metadata map[string]interface{}, imgMap map[string]string
 					fallthrough
 				case n.Data == "a" && attr.Key == "href":
 					if newSrc, ok := imgMap[attr.Val]; ok {
-						// Replace the old src or href with the new one
 						n.Attr[i].Val = newSrc
 					}
 				}
@@ -527,7 +530,6 @@ func replaceImageLinks(metadata map[string]interface{}, imgMap map[string]string
 	}
 	f(doc)
 
-	// Render the modified DOM tree back into an HTML string
 	var buf bytes.Buffer
 	err = html.Render(&buf, doc)
 	if err != nil {
@@ -542,43 +544,48 @@ func uploadImages(token, htmlData string) (map[string]string, error) {
 	imageBackend := config.GetDefault("image-configuration.IMAGE_BACKEND", "").(string)
 	blogImageList := []string{}
 
-	// Regular expression to find img tags and extract src attributes
 	pattern := `<img[^>]+src="([^"]+)"[^>]*>`
-	// htmlData = `<html><body><img src="http://example.com/image1.jpg"></body></html>`
 	re := regexp.MustCompile(pattern)
 
-	// Use the regex to find all matches in the htmlData
 	matches := re.FindAllStringSubmatch(buf.String(), -1)
-	// fmt.Println("Matches:", matches)
 
-	// Extract the src attribute from each match
+	if imageBackend == "ghost" {
+		var err error
+		blogImageList, err = getImageFromPost(htmlData)
+		if err != nil {
+			log.Error("Error getting images from post:", err)
+			
+		}
+	}
 	var mdlibImages []string
 	for _, m := range matches {
 		if len(m) > 1 {
 			mdlibImages = append(mdlibImages, m[1])
 		}
 	}
-	// fmt.Println("mdlibImages:", mdlibImages)
+
 
 	for _, image := range mdlibImages {
 		hashValue, imageData, err := imageToHash(image) // Implement imageToHash function
 		if err != nil {
-			fmt.Println("Error calculating hash:", err)
+			log.Error("Error calculating hash:", err)
 			return nil, err
 		}
-		// fmt.Println("image", image)
+		
 		var imageLink string
 		if strings.HasPrefix(image, "http://") || strings.HasPrefix(image, "https://") {
 			if imageBackend == "s3" {
-				imageLink, err = uploadToS3(imageData, hashValue, log.StandardLogger())
+				imageLink, err = uploadToS3(imageData, hashValue)
 			} else if imageBackend == "ghost" {
 				imageLink, err = uploadToGhost(token, imageData, hashValue, blogImageList)
 			}
 		} else {
 			if imageBackend == "s3" {
-				imageLink, err = uploadToS3(image, hashValue, log.StandardLogger())
+				log.Debug("Uploading image to AWS S3")
+				imageLink, err = uploadToS3(image, hashValue)
 			} else if imageBackend == "ghost" {
 				imageLink, err = uploadToGhost(token, image, hashValue, blogImageList)
+				log.Debug("Uploading image to Ghost Database")
 			}
 		}
 
@@ -587,20 +594,109 @@ func uploadImages(token, htmlData string) (map[string]string, error) {
 		}
 
 		uploadedImages[image] = imageLink
-	}
 
+	}
 	return uploadedImages, nil
 }
 
-func uploadToGhost(token, imageData, hashValue string, blogImageList []string) (string, error) {
-	// Implementation goes here
-	return "", nil
+func uploadToGhost(token, imageData, hashName string, blogImageList []string) (string, error) {
+	ghostVersion := config.GetDefault("ghost-configuration.GHOST_VERSION", "").(string)
+	ghostUrl := config.GetDefault("ghost-configuration.GHOST_URL", "").(string)
+	var postsApiBase string
+	if ghostVersion == "v5" {
+		postsApiBase = ghostUrl + "/api/admin/images/upload/"
+	} else {
+		postsApiBase = ghostUrl + "/api/" + ghostVersion + "/admin/images/upload/"
+	}
+
+	
+
+	for _, name := range blogImageList {
+		hashValue := strings.Split(hashName, ".")[0]
+		filename := filepath.Base(name)
+		filenameWithoutExt := strings.TrimSuffix(filename, filepath.Ext(filename))
+		if hashValue == filenameWithoutExt {
+			log.Debug("The image already exists and is being reused: ", name)
+			return name, nil
+		}
+	}
+
+	// Open the file for reading
+	file, err := os.Open(imageData)
+	
+	if err != nil {
+		return "", errors.New("Failed to open image file: " + err.Error())
+	}
+	defer file.Close()
+	// Create a buffer to hold the multipart encoded form
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	contentType := mime.TypeByExtension(filepath.Ext(imageData))
+	
+	if contentType == "" {
+		contentType = "application/octet-stream" 
+	}
+
+	part, err := writer.CreatePart(textproto.MIMEHeader{
+		"Content-Disposition": []string{`form-data; name="file"; filename="` + hashName + `"`},
+		"Content-Type":        []string{contentType},
+	})
+
+	
+	if err != nil {
+		return "", errors.New("Failed to create form file part: " + err.Error())
+	}
+	_, err = io.Copy(part, file)
+	
+	if err != nil {
+		return "", errors.New("Failed to copy image data to form part: " + err.Error())
+	}
+
+	err = writer.WriteField("ref", hashName)
+	if err != nil {
+		return "", errors.New("Failed to write ref field: " + err.Error())
+	}
+
+	
+	err = writer.Close()
+
+	if err != nil {
+		return "", errors.New("Failed to close multipart writer: " + err.Error())
+	}
+
+	req, err := http.NewRequest("POST", postsApiBase, body)
+
+	if err != nil {
+		return "", errors.New("Failed to create HTTP request: " + err.Error())
+	}
+	req.Header.Set("Authorization", "Ghost "+token)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", errors.New("Failed to send HTTP request: " + err.Error())
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusCreated {
+		return "", errors.New("Failed to upload image: HTTP status " + resp.Status)
+	}
+
+	var result map[string]interface{}
+	err = json.NewDecoder(resp.Body).Decode(&result)
+	if err != nil {
+		return "", errors.New("Failed to decode JSON response: " + err.Error())
+	}
+
+	imageLink := result["images"].([]interface{})[0].(map[string]interface{})["url"].(string)
+
+	return imageLink, nil
 }
 
 func getImageFromPost(postJSON string) ([]string, error) {
 	var post map[string]interface{}
 	if err := json.Unmarshal([]byte(postJSON), &post); err != nil {
-		return nil, err
+		log.Error("Error during JSON unmarshaling:", err)
 	}
 	htmlContent := ""
 	if cards, ok := post["cards"].([]interface{}); ok {
@@ -615,7 +711,6 @@ func getImageFromPost(postJSON string) ([]string, error) {
 		}
 	}
 
-	// Parse the HTML and find all image tags
 	imageList := []string{}
 	z := html.NewTokenizer(strings.NewReader(htmlContent))
 	for {
@@ -643,19 +738,16 @@ func getImageFromPost(postJSON string) ([]string, error) {
 func sha256Sum(filename string) (string, error) {
 	h := sha256.New()
 
-	// Open the file
 	file, err := os.Open(filename)
 	if err != nil {
 		return "", err
 	}
 	defer file.Close()
 
-	// Copy the file's content to the hash
 	if _, err := io.Copy(h, file); err != nil {
 		return "", err
 	}
 
-	// Calculate the hash
 	hashInBytes := h.Sum(nil)
 	hash := hex.EncodeToString(hashInBytes)
 
@@ -717,7 +809,7 @@ func uploadFeatureImage(meta map[string]interface{}, token string, featureImage
 	if featureImagePath, ok := meta["feature_image"].(string); ok {
 		hashValue, err := sha256Sum(featureImagePath)
 		if err != nil {
-			fmt.Println("Error calculating SHA-256 sum:", err)
+			log.Error("Error calculating SHA-256 sum:", err)
 			return
 		}
 
@@ -726,29 +818,31 @@ func uploadFeatureImage(meta map[string]interface{}, token string, featureImage
 		imageBackend := config.GetDefault("image-configuration.IMAGE_BACKEND", "").(string)
 
 		if imageBackend == "s3" {
-			// Upload to S3
-			// You would need to implement the s3Upload function
-			// s3Upload(S3BucketName, featureImagePath, imageName)
-			// fmt.Println("Image uploaded to S3:", imageName)
-
-			meta["feature_image"], err = uploadToS3(featureImagePath, imageName, log.StandardLogger())
-			// fmt.Println("Feature image uploaded to S3", meta["feature_image"])
+			log.Debug("Uploading feature image to AWS S3")
+			meta["feature_image"], err = uploadToS3(featureImagePath, imageName)
 			if err != nil {
-				fmt.Println("Error uploading file to S3:", err)
+				log.Error("Error uploading file to S3:", err)
 			} else {
-				fmt.Println("File uploaded to S3 successfully.")
+				log.Info("File uploaded to S3 successfully.")
 			}
 		} else {
-			meta["feature_image"] = imageName
-			// Upload to Ghost's admin API
-			// uploadToGhost(GhostAdminAPI, token, featureImagePath, imageName)
-		}
+			log.Debug("Uploading feature image to Ghost Database")
+			var featureImgList []string
+			if featureImage != "" {
+				featureImgList = []string{featureImage}
+			} else {
+				featureImgList = []string{}
+			}
+			meta["feature_image"], err = uploadToGhost(token, featureImagePath, imageName, featureImgList)
+			if err != nil {
+				log.Error("Error uploading feature image to Ghost:", err)
+			}
 
-		// Update the feature_image in the metadata
+		}
 
-		fmt.Println("Uploaded feature image")
+		log.Info("Uploaded feature image")
 	} else {
-		fmt.Println("Feature image not provided")
+		log.Info("Feature image not provided")
 	}
 }
 
@@ -757,53 +851,50 @@ func getMimeType(filePath string) (string, error) {
 	return mime.TypeByExtension(ext), nil
 }
 
-func uploadToS3(localFilePath, s3FilePath string, logger *log.Logger) (string, error) {
+func uploadToS3(localFilePath, s3FilePath string) (string, error) {
 	accessKeyID := config.GetDefault("aws-s3-configuration.ACCESS_KEY_ID", "").(string)
 	secretAccessKey := config.GetDefault("aws-s3-configuration.SECRET_ACCESS_KEY", "").(string)
 	bucketName := config.GetDefault("aws-s3-configuration.BUCKET_NAME", "").(string)
 	s3BaseUrl := config.GetDefault("aws-s3-configuration.S3_BASE_URL", "").(string)
 	region := config.GetDefault("aws-s3-configuration.REGION", "").(string)
 
-	// Create a custom credentials provider
 	creds := credentials.NewStaticCredentials(accessKeyID, secretAccessKey, "")
 	sess, err := session.NewSession(&aws.Config{
 		Region: aws.String(region), Credentials: creds},
 	)
 	if err != nil {
-		logger.Println("Error creating session:", err)
+		log.Error("Error creating session:", err)
 		return "", err
 	}
 
-	// Get the S3 service client
+	
 	svc := s3.New(sess)
 
-	// Determine the MIME type of the file
+	
 	mimeType, err := getMimeType(localFilePath)
 	if err != nil {
-		logger.Println("Error determining MIME type:", err)
+		log.Error("Error determining MIME type:", err)
 		return "", err
 	}
 
-	// Read the local file
+	
 	file, err := os.Open(localFilePath)
 	if err != nil {
-		logger.Println("Error opening file:", err)
+		log.Error("Error opening file:", err)
 		return "", err
 	}
 	defer file.Close()
 
-	// Get the file size and read the file into a buffer
+	
 	stat, err := file.Stat()
 	if err != nil {
-		logger.Println("Error getting file stats:", err)
+		log.Error("Error getting file stats:", err)
 		return "", err
 	}
 	size := stat.Size()
 	buffer := make([]byte, size)
 	file.Read(buffer)
 
-	// Upload the file to S3
-
 	input := &s3.PutObjectInput{
 		Bucket:      aws.String(bucketName),
 		Key:         aws.String(s3FilePath),
@@ -818,17 +909,16 @@ func uploadToS3(localFilePath, s3FilePath string, logger *log.Logger) (string, e
 			case s3.ErrCodeNoSuchBucket:
 				fallthrough
 			default:
-				logger.Println(aerr.Error())
+				log.Error(aerr.Error())
 			}
 		} else {
-			logger.Println(err.Error())
+			log.Error(err.Error())
 		}
 		return "", err
 	}
 
-	// Construct the full URL of the uploaded file
-	// fmt.Println("s3FilePath", s3FilePath)
 	s3URL := s3BaseUrl + s3FilePath
+	log.Debug("Image s3 url", s3URL)
 	return s3URL, nil
 }
 
@@ -875,52 +965,66 @@ func getJWToken() (string, error) {
 }
 
 func main() {
-	// newMarkdown()
-	initLogging(true)
-	showConfig := flag.Bool("config", false, "Show glee configuration file")
-	flag.Parse()
-
-	// Check if the --config flag was set
-	if *showConfig {
-		printConfiguration()
+	loadGlobalConfig()
+
+	parser := flags.NewParser(&opts, flags.Default)
+	parser.Usage = "Usage: glee <markdown_file_path>"
+	args, err := parser.Parse()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if opts.ShowConfig {
+			printConfiguration()
+			return
+		}
+
+	if opts.Help {
+		parser.WriteHelp(os.Stdout)
 		return
+	
 	}
-	viewTOMLFile()
-	if len(os.Args) != 2 {
-		fmt.Println("Usage: go run glee.go <markdown_file>")
-		os.Exit(1)
+
+	if opts.Debug {
+		log.SetLevel(log.DebugLevel)
+	} else {
+		log.SetLevel(log.InfoLevel)
 	}
 
-	// Read the markdown file from the command line argument
-	filePath := os.Args[1]
-	content, err := ioutil.ReadFile(filePath)
+	log.SetFormatter(&log.TextFormatter{
+		DisableColors: false,
+		FullTimestamp: true,
+	})
+		
+	
+
+	if len(args) == 1 {
+		filePath := args[0]
+		content, err := ioutil.ReadFile(filePath)
 
-	if err != nil {
-		log.Fatalf("Failed to read file %s: %v", filePath, err)
-	}
+		if err != nil {
+			log.Fatalf("Failed to read file %s: %v", filePath, err)
+		}
 
-	// Convert to string
-	contentStr := string(content)
+		contentStr := string(content)
 
-	// Find the index of the second delimiter to isolate the YAML front matter
 	index := strings.Index(contentStr, "\n---\n")
 	if index == -1 {
-		log.Fatal("Could not find YAML front matter delimiter")
+		log.Fatal("Could not find YAML delimiter")
 	}
 
-	// Extract the YAML front matter and the rest of the content
 	yamlFrontMatter := contentStr[:index]
 	markdownContent := contentStr[index+len("\n---\n"):]
-
-	// Parse the YAML front matter into a Go struct or map
+	
 	var metadata map[string]interface{}
 	err = yaml.Unmarshal([]byte(yamlFrontMatter), &metadata)
 	if err != nil {
 		log.Fatalf("Failed to parse YAML: %v", err)
 	}
 
-	// Call the postToGhost function with metadata and content
 	postToGhost(metadata, markdownContent)
+	} else {
+		log.Fatal("Please provide a markdown file.")
+	}
 }
 
 func printConfiguration() {
@@ -938,4 +1042,4 @@ func printConfiguration() {
 	fmt.Printf("Configuration path: %s\n", configPath)
 	fmt.Println("-------------------")
 	fmt.Println(string(content))
-}
\ No newline at end of file
+}
diff --git a/glee.py b/glee.py
index e4ff277..00374cb 100644
--- a/glee.py
+++ b/glee.py
@@ -233,6 +233,7 @@ def replace_image_links(post, img_map):
 
 
 def upload_feature_image(meta, token, feature_image):
+    print(feature_image, "feature_image")
     try:
         i = meta["feature_image"]
         if i:
@@ -250,6 +251,7 @@ def upload_feature_image(meta, token, feature_image):
                 image_link = upload_to_ghost(
                     token, i, image_name, feature_img_list, logging
                 )
+                print("image_link", image_link)
                 meta["feature_image"] = image_link
 
             logging.info("Uploaded feature image")
@@ -279,7 +281,7 @@ def post_to_ghost(meta, md):
     else:
         meta["feature_image"] = ""
     uploaded_images = upload_images(token, html_data, IMAGE_BACKEND)
-    replace_image_links(meta, uploaded_images)
+    # replace_image_links(meta, uploaded_images)
     post_obj = meta
 
     body = {"posts": [post_obj]}
@@ -350,7 +352,7 @@ def inject_multi_titles(meta):
 
 if __name__ == "__main__":
     post = frontmatter.load(args.markdown_file)
-    print(post.metadata)
+    # print(post.metadata)
     print('-----')
-    print(post.content)
+    # print(post.content)
     post_to_ghost(post.metadata, post.content)
diff --git a/go.mod b/go.mod
index 88d0ec1..d44d833 100644
--- a/go.mod
+++ b/go.mod
@@ -12,8 +12,10 @@ require (
 	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
 	github.com/gomarkdown/markdown v0.0.0-20231222211730-1d6d20845b47 // indirect
 	github.com/gorilla/css v1.0.0 // indirect
+	github.com/jessevdk/go-flags v1.5.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/microcosm-cc/bluemonday v1.0.26 // indirect
+	github.com/mkmueller/option v0.0.0-20180706023220-9210a226e4aa // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
diff --git a/go.sum b/go.sum
index ed81299..7318ea8 100644
--- a/go.sum
+++ b/go.sum
@@ -20,11 +20,15 @@ github.com/gomarkdown/markdown v0.0.0-20231222211730-1d6d20845b47 h1:k4Tw0nt6lwr
 github.com/gomarkdown/markdown v0.0.0-20231222211730-1d6d20845b47/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
 github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
 github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
+github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc=
+github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
 github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
+github.com/mkmueller/option v0.0.0-20180706023220-9210a226e4aa h1:OPsvCzDQ2hgOeVCF7oZoY40gQ5tZSl5VQmQ0sP2k//I=
+github.com/mkmueller/option v0.0.0-20180706023220-9210a226e4aa/go.mod h1:5UoxHYGFrbZiKM0D6lwGneCP7TmUioOLosunIujXqis=
 github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
 github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -42,6 +46,7 @@ github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc h1:+
 github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc/go.mod h1:ovIvrum6DQJA4QsJSovrkC4saKHQVs7TvcaeO8AIl5I=
 golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
 golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
diff --git a/rough.txt b/rough.txt
new file mode 100644
index 0000000..87e2974
--- /dev/null
+++ b/rough.txt
@@ -0,0 +1,77 @@
+// func uploadToGhost(token, imageData, hashName string, blogImageList []string) (string, error)   {
+// 	GHOST_VERSION := config.Get("ghost-configuration.GHOST_VERSION").(string)
+// 	GHOST_URL := config.Get("ghost-configuration.GHOST_URL").(string)
+
+// 	var POSTS_API_BASE string
+// 	if GHOST_VERSION == "v5" {
+// 		POSTS_API_BASE = GHOST_URL + "/api/admin/images/upload/"
+// 	} else {
+// 		POSTS_API_BASE = GHOST_URL + "/api/" + GHOST_VERSION + "/admin/images/upload/"
+// 	}
+
+// 	headers := map[string]string{"Authorization": "Ghost " + token}
+
+// 	for _, name := range blogImageList {
+// 		imageName := strings.Split(name, "/")[len(strings.Split(name, "/"))-1]
+// 		hashValue := strings.Split(hashName, ".")[0]
+// 		if strings.Contains(imageName, hashValue) {
+			
+// 			return name, nil
+// 		}
+// 	}
+
+// 	file, err := os.Open(imageData)
+// if err != nil {
+//     return "", errors.New("Failed to open image file: " + err.Error())
+// }
+// defer file.Close()
+
+// body := &bytes.Buffer{}
+// writer := multipart.NewWriter(body)
+
+// part, err := writer.CreateFormFile("file", hashName)
+// if err != nil {
+//     return "", errors.New("Failed to create form file part: " + err.Error())
+// }
+// _, err = io.Copy(part, file)
+// if err != nil {
+//     return "", errors.New("Failed to copy image data to form part: " + err.Error())
+// }
+
+// err = writer.WriteField("ref", hashName)
+// if err != nil {
+//     return "", errors.New("Failed to write ref field: " + err.Error())
+// }
+
+// err = writer.Close()
+// if err != nil {
+//     return "", errors.New("Failed to close multipart writer: " + err.Error())
+// }
+
+// req, err := http.NewRequest("POST", POSTS_API_BASE, body)
+// if err != nil {
+//     return "", errors.New("Failed to create HTTP request: " + err.Error())
+// }
+// req.Header.Set("Authorization", headers["Authorization"])
+// req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
+
+// resp, err := http.DefaultClient.Do(req)
+// if err != nil {
+//     return "", errors.New("Failed to send HTTP request: " + err.Error())
+// }
+// defer resp.Body.Close()
+
+// fmt.Println("Response:", resp.StatusCode)
+// if resp.StatusCode != http.StatusOK {
+//     return "", errors.New("Failed to upload image: HTTP status " + resp.Status)
+// }
+
+// var result map[string]interface{}
+// err = json.NewDecoder(resp.Body).Decode(&result)
+// if err != nil {
+//     return "", errors.New("Failed to decode JSON response: " + err.Error())
+// }
+
+// imageLink := result["images"].([]interface{})[0].(map[string]interface{})["url"].(string)
+// return imageLink, nil
+// }
diff --git a/sample_post.md b/sample_post.md
index 3e18875..31e90c6 100644
--- a/sample_post.md
+++ b/sample_post.md
@@ -12,7 +12,7 @@ featured: false
 status: draft
 
 custom_excerpt: This is a custom excerpt
-feature_image: ./test_images/Animhorse.gif
+feature_image: ./test_images/smiley.png
 # sidebar_toc: false
 # code_hilite_theme: solarized-dark
 slug: testing-glee-1
@@ -24,7 +24,7 @@ slug: testing-glee-1
 
  
 
-This is  basic Markdown file with some common formatting elements.
+This is basic Markdown file with some common formatting elements.
 
 ## Headers
 
@@ -88,7 +88,7 @@ You can embed images like this:
 ![ico](./test_images/icon.ico)
 
 ### heic
-![heic](./test_images/apple.heic)
+<!-- ![heic](./test_images/apple.heic) -->
 ## Code
 
 You can include inline code using backticks (`) like `code`.