Evernote2md

https://github.com/wormi4ok/evernote2md
Admin
Evernote2md is a CLI tool that converts Evernote notes exported in .enex format to markdown files...
Tokens:6,377
Snippets:50
Trust Score:8.8
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install via Homebrew

Source: https://github.com/wormi4ok/evernote2md/blob/master/README.md

Use the Homebrew package manager to install the tool on macOS or Linux.

```bash
brew install evernote2md
```

--------------------------------

### Print Hello World in Go

Source: https://github.com/wormi4ok/evernote2md/blob/master/internal/testdata/evernote.html

A basic Go program to print 'hello world' to the console. This is a common starting point for Go development.

```go
fmt.Println("hello world")
```

--------------------------------

### Example Markdown Output with Custom Tags

Source: https://github.com/wormi4ok/evernote2md/wiki/Custom-tag-template

This shows the resulting markdown content when a custom tag template is applied. Multiple tags are space-separated.

```markdown
# My note

@Personal @top_secret

...
```

--------------------------------

### Custom Tag Template Example

Source: https://github.com/wormi4ok/evernote2md/wiki/Custom-tag-template

Use the --tagTemplate option to specify a custom format for tags. The template must include '{{tag}}', which will be replaced by the tag name. Spaces in tags are converted to underscores.

```bash
evernote2md --tagTemplate "@{{tag}}" note.enex ./notes
```

--------------------------------

### Run via Docker

Source: https://github.com/wormi4ok/evernote2md/blob/master/README.md

Execute the tool using a Docker container, mounting the current directory to access input files.

```bash
docker run -t --rm -v "$PWD":/tmp -w /tmp wormi4ok/evernote2md:latest (flags) [input] [outputDir]
```

--------------------------------

### Run via Docker

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Execute the tool in a containerized environment.

```bash
# Basic conversion with Docker
docker run -t --rm -v "$PWD":/tmp -w /tmp wormi4ok/evernote2md:latest export.enex ./notes

# With custom options
docker run -t --rm -v "$PWD":/tmp -w /tmp wormi4ok/evernote2md:latest \
  --folders --addFrontMatter -t "#{{tag}}" export.enex ./notes

# Convert all files in current directory
docker run -t --rm -v "$PWD":/tmp -w /tmp wormi4ok/evernote2md:latest \
  "*.enex" ./converted
```

--------------------------------

### Create Evernote to Markdown Converter

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Instantiate `internal.NewConverter` with options for tag templates, frontmatter, highlight preservation, and character escaping to customize markdown output. Handles conversion errors per note.

```go
package main

import (
    "fmt"
    "os"

    "github.com/wormi4ok/evernote2md/encoding/enex"
    "github.com/wormi4ok/evernote2md/internal"
)

func main() {
    // Create converter with options:
    // - tagTemplate: format string for tags (must contain {{tag}})
    // - enableFrontMatter: add YAML frontmatter
    // - enableHighlights: convert Evernote highlights to HTML spans
    // - escapeSpecialChars: escape markdown special characters
    converter, err := internal.NewConverter(
        "#{{tag}}",  // Custom tag template
        true,        // Enable frontmatter
        true,        // Enable highlights
        false,       // Don't escape special chars
    )
    if err != nil {
        panic(err)
    }

    file, _ := os.Open("export.enex")
    defer file.Close()
    export, _ := enex.Decode(file)

    for _, note := range export.Notes {
        md, err := converter.Convert(&note)
        if err != nil {
            fmt.Printf("Error converting %s: %v\n", note.Title, err)
            continue
        }

        fmt.Printf("Converted: %s\n", note.Title)
        fmt.Printf("  Content length: %d bytes\n", len(md.Content))
        fmt.Printf("  Media resources: %d\n", len(md.Media))
        fmt.Printf("  Created: %s\n", md.CTime)
        fmt.Printf("  Modified: %s\n", md.MTime)

        // Access converted content
        // md.Content contains the markdown bytes
        // md.Media contains extracted attachments
    }
}
```

--------------------------------

### Organize notes in folders

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Use the --folders flag to create a dedicated directory for each note, keeping attachments organized.

```bash
# Each note gets its own folder with README.md
evernote2md --folders export.enex ./notes

# Output structure:
# ./notes/
#   My-First-Note/
#     README.md
#     image/
#       photo.jpg
#     file/
#       document.pdf
#   My-Second-Note/
#     README.md
```

--------------------------------

### Run Evernote2MD from Custom Directory

Source: https://github.com/wormi4ok/evernote2md/wiki/macOS-FAQ

If you downloaded the application manually to a custom directory, prepend './' to the command to execute it from that location. Ensure you are in the correct directory before running.

```bash
cd ~/Downloads
./evernote2md my_export.enex notes
```

--------------------------------

### Convert Evernote exports via CLI

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Basic commands for converting .enex files to markdown using single files, directories, or glob patterns.

```bash
# Convert a single .enex file to markdown in ./notes directory
evernote2md export.enex

# Convert to a specific output directory
evernote2md export.enex ./my-notes

# Convert all .enex files in a directory
evernote2md ./exports/ ./converted-notes

# Use glob patterns to match specific files
evernote2md "exports/My*.enex" ./notes
evernote2md "exports/**/*.enex" ./notes

# Override output directory with -o flag
evernote2md export.enex -o ./markdown-output
```

--------------------------------

### Run evernote2md CLI

Source: https://github.com/wormi4ok/evernote2md/blob/master/README.md

Execute the tool by specifying flags, the input file or directory, and the optional output directory.

```bash
evernote2md (flags) [input] [outputDir]
```

--------------------------------

### Customize tag formatting

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Configure how tags appear in markdown using the --tagTemplate or -t flag.

```bash
# Default format: tags appear as inline code
# Output: `Personal` `Work`
evernote2md export.enex ./notes

# Twitter/social media style hashtags
# Output: #Personal #Work
evernote2md --tagTemplate "#{{tag}}" export.enex ./notes

# At-mention style
# Output: @Personal @Work
evernote2md -t "@{{tag}}" export.enex ./notes

# Wiki-style tags
# Output: [[Personal]] [[Work]]
evernote2md -t "[[{{tag}}]]" export.enex ./notes
```

--------------------------------

### internal.NewConverter

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Creates a converter instance with configurable options for transforming Evernote notes to markdown format.

```APIDOC
## internal.NewConverter

### Description
Creates a converter instance with configurable options for transforming Evernote notes to markdown format.

### Method
`internal.NewConverter`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
package main

import (
    "fmt"
    "os"

    "github.com/wormi4ok/evernote2md/encoding/enex"
    "github.com/wormi4ok/evernote2md/internal"
)

func main() {
    // Create converter with options:
    // - tagTemplate: format string for tags (must contain {{tag}})
    // - enableFrontMatter: add YAML frontmatter
    // - enableHighlights: convert Evernote highlights to HTML spans
    // - escapeSpecialChars: escape markdown special characters
    converter, err := internal.NewConverter(
        "#{{tag}}",  // Custom tag template
        true,        // Enable frontmatter
        true,        // Enable highlights
        false,       // Don't escape special chars
    )
    if err != nil {
        panic(err)
    }

    file, _ := os.Open("export.enex")
    defer file.Close()
    export, _ := enex.Decode(file)

    for _, note := range export.Notes {
        md, err := converter.Convert(&note)
        if err != nil {
            fmt.Printf("Error converting %s: %v\n", note.Title, err)
            continue
        }

        fmt.Printf("Converted: %s\n", note.Title)
        fmt.Printf("  Content length: %d bytes\n", len(md.Content))
        fmt.Printf("  Media resources: %d\n", len(md.Media))
        fmt.Printf("  Created: %s\n", md.CTime)
        fmt.Printf("  Modified: %s\n", md.MTime)

        // Access converted content
        // md.Content contains the markdown bytes
        // md.Media contains extracted attachments
    }
}
```

### Response
#### Success Response (200)
Returns a converter instance and potentially markdown conversion results.

#### Response Example
None
```

--------------------------------

### Create Streaming ENEX Decoder

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Use `enex.NewStreamDecoder` to process large .enex files note by note without loading the entire file into memory. Handles potential decoding errors for each note.

```go
package main

import (
    "fmt"
    "io"
    "os"

    "github.com/wormi4ok/evernote2md/encoding/enex"
)

func main() {
    file, err := os.Open("large-export.enex")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    decoder, err := enex.NewStreamDecoder(file)
    if err != nil {
        panic(err)
    }

    count := 0
    for {
        var note enex.Note
        err := decoder.Next(&note)
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("Error decoding note: %v\n", err)
            continue
        }

        count++
        fmt.Printf("Processing note %d: %s\n", count, note.Title)
        // Process each note as needed
    }
    fmt.Printf("Total notes processed: %d\n", count)
}
```

--------------------------------

### Convert HTML to Markdown

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Use `markdown.Convert` for low-level HTML to markdown conversion. Supports optional highlight preservation and character escaping. Input is read from an `io.Reader` and output is written to an `io.Writer`.

```go
package main

import (
    "bytes"
    "fmt"
    "strings"

    "github.com/wormi4ok/evernote2md/encoding/markdown"
)

func main() {
    html := `
        <h1>My Note</h1>
        <p>This is <strong>important</strong> text.</p>
        <span style="-evernote-highlight:true">Highlighted text</span>
        <ul>
            <li><en-todo checked="true"/>Completed task</li>
            <li><en-todo checked="false"/>Pending task</li>
        </ul>
    `

    var output bytes.Buffer

    // Convert with highlights enabled, special char escaping disabled
    err := markdown.Convert(&output, strings.NewReader(html), true, false)
    if err != nil {
        panic(err)
    }

    fmt.Println(output.String())
    // Output:
    // # My Note
    //
    // This is **important** text.
    // <span style="background-color: #ffaaaa">Highlighted text</span>
    // - [x] Completed task
    // - [ ] Pending task
}
```

--------------------------------

### Configure highlight and special character handling

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Adjust processing of highlights, special characters, and timestamps.

```bash
# Disable highlight conversion (removes HTML span tags)
evernote2md --noHighlights export.enex ./notes

# Escape special characters for strict markdown rendering
evernote2md --escape-special-chars export.enex ./notes

# Ignore file timestamps (use current time instead)
evernote2md --resetTimestamps export.enex ./notes

# Enable debug output for troubleshooting
evernote2md -v export.enex ./notes
```

--------------------------------

### Define Evernote and Markdown Data Structures

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

These structures represent the schema for Evernote exports (enex) and the resulting converted Markdown notes.

```go
package main

import (
    "fmt"

    "github.com/wormi4ok/evernote2md/encoding/enex"
    "github.com/wormi4ok/evernote2md/encoding/markdown"
)

// enex.Export - Root structure of an Evernote export
type Export struct {
    Date  string // Export date
    Notes []Note // All notes in the export
}

// enex.Note - Single Evernote note
type Note struct {
    Title      string         // Note title
    Content    []byte         // HTML content
    Updated    string         // Last update timestamp (20060102T150405Z format)
    Created    string         // Creation timestamp
    Tags       []string       // Associated tags
    Attributes NoteAttributes // Metadata
    Resources  []Resource     // Attached files/images
}

// enex.NoteAttributes - Note metadata
type NoteAttributes struct {
    Source            string // Source application
    SourceApplication string // Application name
    Latitude          string // GPS latitude
    Longitude         string // GPS longitude
    Altitude          string // GPS altitude
    Author            string // Note author
    SourceUrl         string // Original URL if clipped
}

// enex.Resource - Embedded attachment
type Resource struct {
    ID          string     // Unique hash identifier
    Type        string     // Resource type
    Data        Data       // Base64-encoded content
    Mime        string     // MIME type (image/png, application/pdf, etc.)
    Width       int        // Image width
    Height      int        // Image height
    Attributes  Attributes // File attributes
}

// markdown.Note - Converted markdown output
type MarkdownNote struct {
    Content []byte                      // Markdown content
    Media   map[string]markdown.Resource // Extracted resources by ID
    CTime   time.Time                   // Creation time
    MTime   time.Time                   // Modification time
}

// markdown.Resource - Extracted media file
type MarkdownResource struct {
    Name    string               // Filename
    Type    markdown.ResourceType // "image" or "file"
    Content []byte               // Binary content
}

func main() {
    fmt.Println("Data structures for Evernote to Markdown conversion")
}
```

--------------------------------

### Generate YAML frontmatter

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Enable frontmatter generation for compatibility with static site generators.

```bash
# Enable frontmatter generation
evernote2md --addFrontMatter export.enex ./notes

# Generated markdown output:
# ---
# date: '2024-01-15 10:30:00 -0500'
# updated_at: '2024-01-20 14:22:00 -0500'
# title: "My Note Title"
# tags: [ 'Personal', 'Work' ]
# url: https://source.url.com
# latitude: 40.7128
# longitude: -74.0060
# ---
#
# # My Note Title
# ...
```

--------------------------------

### Parse .enex files with Go API

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Use the enex.Decode function to programmatically access note content and metadata.

```go
package main

import (
    "fmt"
    "os"

    "github.com/wormi4ok/evernote2md/encoding/enex"
)

func main() {
    file, err := os.Open("export.enex")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    export, err := enex.Decode(file)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Export date: %s\n", export.Date)
    fmt.Printf("Total notes: %d\n", len(export.Notes))

    for _, note := range export.Notes {
        fmt.Printf("Note: %s\n", note.Title)
        fmt.Printf("  Created: %s\n", note.Created)
        fmt.Printf("  Updated: %s\n", note.Updated)
        fmt.Printf("  Tags: %v\n", note.Tags)
        fmt.Printf("  Resources: %d\n", len(note.Resources))
        fmt.Printf("  Author: %s\n", note.Attributes.Author)
        fmt.Printf("  Source URL: %s\n", note.Attributes.SourceUrl)
    }
}
```

--------------------------------

### Save Content to File

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Utilize `file.Save` to write content to a specified file path within a directory. The function automatically creates necessary directories. It can save both markdown content and binary resources like images.

```go
package main

import (
    "bytes"
    "fmt"

    "github.com/wormi4ok/evernote2md/file"
)

func main() {
    content := []byte("# My Note\n\nThis is my converted note content.")

    // Save markdown file
    err := file.Save("./output/notes", "my-note.md", bytes.NewReader(content))
    if err != nil {
        panic(err)
    }
    fmt.Println("Saved: ./output/notes/my-note.md")

    // Save an image resource
    imageData := []byte{/* image bytes */}
    err = file.Save("./output/notes/image", "photo.jpg", bytes.NewReader(imageData))
    if err != nil {
        panic(err)
    }
    fmt.Println("Saved: ./output/notes/image/photo.jpg")
}
```

--------------------------------

### file.Save

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Saves content to a file in the specified directory, creating the directory structure if it doesn't exist.

```APIDOC
## file.Save

### Description
Saves content to a file in the specified directory, creating the directory structure if it doesn't exist.

### Method
`file.Save`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
package main

import (
    "bytes"
    "fmt"

    "github.com/wormi4ok/evernote2md/file"
)

func main() {
    content := []byte("# My Note\n\nThis is my converted note content.")

    // Save markdown file
    err := file.Save("./output/notes", "my-note.md", bytes.NewReader(content))
    if err != nil {
        panic(err)
    }
    fmt.Println("Saved: ./output/notes/my-note.md")

    // Save an image resource
    imageData := []byte{/* image bytes */}
    err = file.Save("./output/notes/image", "photo.jpg", bytes.NewReader(imageData))
    if err != nil {
        panic(err)
    }
    fmt.Println("Saved: ./output/notes/image/photo.jpg")
}
```

### Response
#### Success Response (200)
None explicitly defined, but saves the content to the specified file path.

#### Response Example
None
```

--------------------------------

### Normalize Filenames with file.BaseName

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Use this function to sanitize strings for use as filenames by removing illegal characters and enforcing length constraints.

```go
package main

import (
    "fmt"

    "github.com/wormi4ok/evernote2md/file"
)

func main() {
    // Normalize note titles for safe filenames
    titles := []string{
        "My Note: Important!",
        "Notes/Ideas/2024",
        "Recipe  with   spaces",
        "File<with>illegal*chars?",
    }

    for _, title := range titles {
        safe := file.BaseName(title)
        fmt.Printf("Original: %q -> Safe: %q\n", title, safe)
    }
    // Output:
    // Original: "My Note: Important!" -> Safe: "My Note_ Important_"
    // Original: "Notes/Ideas/2024" -> Safe: "Notes-Ideas-2024"
    // Original: "Recipe  with   spaces" -> Safe: "Recipe  with   spaces"
    // Original: "File<with>illegal*chars?" -> Safe: "File_with_illegal_chars_"
}
```

--------------------------------

### markdown.Convert

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Low-level function to convert HTML content to markdown with optional highlight preservation and character escaping.

```APIDOC
## markdown.Convert

### Description
Low-level function to convert HTML content to markdown with optional highlight preservation and character escaping.

### Method
`markdown.Convert`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
package main

import (
    "bytes"
    "fmt"
    "strings"

    "github.com/wormi4ok/evernote2md/encoding/markdown"
)

func main() {
    html := `
        <h1>My Note</h1>
        <p>This is <strong>important</strong> text.</p>
        <span style="-evernote-highlight:true">Highlighted text</span>
        <ul>
            <li><en-todo checked="true"/>Completed task</li>
            <li><en-todo checked="false"/>Pending task</li>
        </ul>
    `

    var output bytes.Buffer

    // Convert with highlights enabled, special char escaping disabled
    err := markdown.Convert(&output, strings.NewReader(html), true, false)
    if err != nil {
        panic(err)
    }

    fmt.Println(output.String())
    // Output:
    // # My Note
    //
    // This is **important** text.
    // <span style="background-color: #ffaaaa">Highlighted text</span>
    // - [x] Completed task
    // - [ ] Pending task
}
```

### Response
#### Success Response (200)
None explicitly defined, but writes converted markdown to the provided `io.Writer`.

#### Response Example
```
# My Note

This is **important** text.
<span style="background-color: #ffaaaa">Highlighted text</span>
- [x] Completed task
- [ ] Pending task
```
```

--------------------------------

### enex.NewStreamDecoder

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Creates a streaming decoder for processing large .enex files note-by-note without loading the entire file into memory.

```APIDOC
## enex.NewStreamDecoder

### Description
Creates a streaming decoder for processing large .enex files note-by-note without loading the entire file into memory.

### Method
`enex.NewStreamDecoder`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
package main

import (
    "fmt"
    "io"
    "os"

    "github.com/wormi4ok/evernote2md/encoding/enex"
)

func main() {
    file, err := os.Open("large-export.enex")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    decoder, err := enex.NewStreamDecoder(file)
    if err != nil {
        panic(err)
    }

    count := 0
    for {
        var note enex.Note
        err := decoder.Next(&note)
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("Error decoding note: %v\n", err)
            continue
        }

        count++
        fmt.Printf("Processing note %d: %s\n", count, note.Title)
        // Process each note as needed
    }
    fmt.Printf("Total notes processed: %d\n", count)
}
```

### Response
#### Success Response (200)
None explicitly defined, but returns a decoder instance.

#### Response Example
None
```

--------------------------------

### enex.Decode

Source: https://context7.com/wormi4ok/evernote2md/llms.txt

Parses an Evernote .enex export file and returns the complete Export structure containing all notes with their content, resources, and metadata.

```APIDOC
## enex.Decode

### Description
Parses an Evernote .enex export file and returns the complete Export structure containing all notes with their content, resources, and metadata.

### Parameters
#### Request Body
- **file** (io.Reader) - Required - The .enex file stream to be decoded.

### Response
#### Success Response (200)
- **export** (struct) - The parsed Export structure containing notes, metadata, and resources.

### Request Example
```go
file, err := os.Open("export.enex")
export, err := enex.Decode(file)
```
```

--------------------------------

### Empty Code Block

Source: https://github.com/wormi4ok/evernote2md/blob/master/internal/testdata/golden-frontmatter.md

An empty code block is present in the content.

```plaintext

```

--------------------------------

### Clear Extended Attributes on macOS

Source: https://github.com/wormi4ok/evernote2md/wiki/macOS-FAQ

On macOS Catalina or later, use this command to remove extended attributes from the downloaded file, which resolves the 'developer cannot be verified' warning. This is safe for open-source applications.

```bash
xattr -c evernote2md
```
Tokens:
Raw