bear-export 0.1.0__tar.gz

bear_export-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: bear-export
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: python-dateutil>=2.8.0
+
+# Bear Export CLI Tool
+
+A command-line tool to export Bear blog CSV data to organized markdown files.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```bash
+python main.py [OPTIONS]
+```
+
+### Options
+
+- `-c, --csv-file TEXT`: Path to Bear blog CSV export file (default: post_export.csv)
+- `-o, --output-dir TEXT`: Output directory name (default: Blog)
+- `--include-drafts`: Include unpublished draft posts
+- `--organize-by [date|tags|none]`: Organize files by date, tags, or no organization (default: none)
+- `--front-matter [yaml|toml|none]`: Front matter format for static site generators (default: yaml)
+
+### Examples
+
+Basic export (published posts only, flat structure):
+```bash
+python main.py
+```
+
+Include drafts and organize by date:
+```bash
+python main.py --include-drafts --organize-by date
+```
+
+Organize by tags with TOML front matter:
+```bash
+python main.py --organize-by tags --front-matter toml
+```
+
+Custom CSV file and output directory:
+```bash
+python main.py --csv-file my_export.csv --output-dir MyBlog
+```
+
+## Output Structure
+
+### Flat Organization (default)
+```
+Blog/
+├── post1.md
+├── post2.md
+├── post3.md
+└── README.md
+```
+
+### Date Organization
+```
+Blog/
+├── 2023/
+│   ├── 01/
+│   │   ├── january-post.md
+│   │   └── another-january-post.md
+│   └── 12/
+│       └── december-post.md
+├── 2024/
+│   └── 03/
+│       └── march-post.md
+└── README.md
+```
+
+### Tags Organization
+```
+Blog/
+├── personal/
+│   ├── my-life.md
+│   └── thoughts.md
+├── coding/
+│   ├── python-tips.md
+│   └── vim-guide.md
+├── uncategorized-post.md
+└── README.md
+```
+
+## Front Matter
+
+The tool generates front matter compatible with static site generators like Hugo, Jekyll, and others.
+
+### YAML Front Matter (default)
+```yaml
+---
+title: My Blog Post
+slug: my-blog-post
+date: 2024-03-15T10:30:00
+tags:
+  - personal
+  - coding
+lang: en
+published: true
+type: post
+uid: abc123
+---
+```
+
+### TOML Front Matter
+```toml
++++
+title = 'My Blog Post'
+slug = 'my-blog-post'
+date = '2024-03-15T10:30:00'
+tags = ['personal', 'coding']
+lang = 'en'
+published = true
+type = 'post'
+uid = 'abc123'
++++
+```
+
+## Features
+
+- ✅ Parse Bear blog CSV exports with proper encoding
+- ✅ Generate clean markdown files with front matter
+- ✅ Support for YAML and TOML front matter formats
+- ✅ Multiple organization strategies (flat, by date, by tags)
+- ✅ Filter published/draft posts
+- ✅ Generate index/README file with post listings
+- ✅ Handle special characters and filenames safely
+- ✅ Preserve post metadata (tags, dates, language, etc.)
+
+## Requirements
+
+- Python 3.7+
+- pandas
+- click
+- pyyaml
+- python-dateutil
+
+See `requirements.txt` for exact versions.

bear_export-0.1.0/README.md

@@ -0,0 +1,139 @@
+# Bear Export CLI Tool
+
+A command-line tool to export Bear blog CSV data to organized markdown files.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```bash
+python main.py [OPTIONS]
+```
+
+### Options
+
+- `-c, --csv-file TEXT`: Path to Bear blog CSV export file (default: post_export.csv)
+- `-o, --output-dir TEXT`: Output directory name (default: Blog)
+- `--include-drafts`: Include unpublished draft posts
+- `--organize-by [date|tags|none]`: Organize files by date, tags, or no organization (default: none)
+- `--front-matter [yaml|toml|none]`: Front matter format for static site generators (default: yaml)
+
+### Examples
+
+Basic export (published posts only, flat structure):
+```bash
+python main.py
+```
+
+Include drafts and organize by date:
+```bash
+python main.py --include-drafts --organize-by date
+```
+
+Organize by tags with TOML front matter:
+```bash
+python main.py --organize-by tags --front-matter toml
+```
+
+Custom CSV file and output directory:
+```bash
+python main.py --csv-file my_export.csv --output-dir MyBlog
+```
+
+## Output Structure
+
+### Flat Organization (default)
+```
+Blog/
+├── post1.md
+├── post2.md
+├── post3.md
+└── README.md
+```
+
+### Date Organization
+```
+Blog/
+├── 2023/
+│   ├── 01/
+│   │   ├── january-post.md
+│   │   └── another-january-post.md
+│   └── 12/
+│       └── december-post.md
+├── 2024/
+│   └── 03/
+│       └── march-post.md
+└── README.md
+```
+
+### Tags Organization
+```
+Blog/
+├── personal/
+│   ├── my-life.md
+│   └── thoughts.md
+├── coding/
+│   ├── python-tips.md
+│   └── vim-guide.md
+├── uncategorized-post.md
+└── README.md
+```
+
+## Front Matter
+
+The tool generates front matter compatible with static site generators like Hugo, Jekyll, and others.
+
+### YAML Front Matter (default)
+```yaml
+---
+title: My Blog Post
+slug: my-blog-post
+date: 2024-03-15T10:30:00
+tags:
+  - personal
+  - coding
+lang: en
+published: true
+type: post
+uid: abc123
+---
+```
+
+### TOML Front Matter
+```toml
++++
+title = 'My Blog Post'
+slug = 'my-blog-post'
+date = '2024-03-15T10:30:00'
+tags = ['personal', 'coding']
+lang = 'en'
+published = true
+type = 'post'
+uid = 'abc123'
++++
+```
+
+## Features
+
+- ✅ Parse Bear blog CSV exports with proper encoding
+- ✅ Generate clean markdown files with front matter
+- ✅ Support for YAML and TOML front matter formats
+- ✅ Multiple organization strategies (flat, by date, by tags)
+- ✅ Filter published/draft posts
+- ✅ Generate index/README file with post listings
+- ✅ Handle special characters and filenames safely
+- ✅ Preserve post metadata (tags, dates, language, etc.)
+
+## Requirements
+
+- Python 3.7+
+- pandas
+- click
+- pyyaml
+- python-dateutil
+
+See `requirements.txt` for exact versions.

bear_export-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "bear-export"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "pandas>=2.0.0",
+    "click>=8.0.0",
+    "pyyaml>=6.0",
+    "python-dateutil>=2.8.0",
+]

bear_export-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bear_export-0.1.0/src/__init__.py

@@ -0,0 +1 @@
+# Bear Export Package

bear_export-0.1.0/src/bear_export.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: bear-export
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: python-dateutil>=2.8.0
+
+# Bear Export CLI Tool
+
+A command-line tool to export Bear blog CSV data to organized markdown files.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```bash
+python main.py [OPTIONS]
+```
+
+### Options
+
+- `-c, --csv-file TEXT`: Path to Bear blog CSV export file (default: post_export.csv)
+- `-o, --output-dir TEXT`: Output directory name (default: Blog)
+- `--include-drafts`: Include unpublished draft posts
+- `--organize-by [date|tags|none]`: Organize files by date, tags, or no organization (default: none)
+- `--front-matter [yaml|toml|none]`: Front matter format for static site generators (default: yaml)
+
+### Examples
+
+Basic export (published posts only, flat structure):
+```bash
+python main.py
+```
+
+Include drafts and organize by date:
+```bash
+python main.py --include-drafts --organize-by date
+```
+
+Organize by tags with TOML front matter:
+```bash
+python main.py --organize-by tags --front-matter toml
+```
+
+Custom CSV file and output directory:
+```bash
+python main.py --csv-file my_export.csv --output-dir MyBlog
+```
+
+## Output Structure
+
+### Flat Organization (default)
+```
+Blog/
+├── post1.md
+├── post2.md
+├── post3.md
+└── README.md
+```
+
+### Date Organization
+```
+Blog/
+├── 2023/
+│   ├── 01/
+│   │   ├── january-post.md
+│   │   └── another-january-post.md
+│   └── 12/
+│       └── december-post.md
+├── 2024/
+│   └── 03/
+│       └── march-post.md
+└── README.md
+```
+
+### Tags Organization
+```
+Blog/
+├── personal/
+│   ├── my-life.md
+│   └── thoughts.md
+├── coding/
+│   ├── python-tips.md
+│   └── vim-guide.md
+├── uncategorized-post.md
+└── README.md
+```
+
+## Front Matter
+
+The tool generates front matter compatible with static site generators like Hugo, Jekyll, and others.
+
+### YAML Front Matter (default)
+```yaml
+---
+title: My Blog Post
+slug: my-blog-post
+date: 2024-03-15T10:30:00
+tags:
+  - personal
+  - coding
+lang: en
+published: true
+type: post
+uid: abc123
+---
+```
+
+### TOML Front Matter
+```toml
++++
+title = 'My Blog Post'
+slug = 'my-blog-post'
+date = '2024-03-15T10:30:00'
+tags = ['personal', 'coding']
+lang = 'en'
+published = true
+type = 'post'
+uid = 'abc123'
++++
+```
+
+## Features
+
+- ✅ Parse Bear blog CSV exports with proper encoding
+- ✅ Generate clean markdown files with front matter
+- ✅ Support for YAML and TOML front matter formats
+- ✅ Multiple organization strategies (flat, by date, by tags)
+- ✅ Filter published/draft posts
+- ✅ Generate index/README file with post listings
+- ✅ Handle special characters and filenames safely
+- ✅ Preserve post metadata (tags, dates, language, etc.)
+
+## Requirements
+
+- Python 3.7+
+- pandas
+- click
+- pyyaml
+- python-dateutil
+
+See `requirements.txt` for exact versions.

bear_export-0.1.0/src/bear_export.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/__init__.py
+src/converter.py
+src/organizer.py
+src/parser.py
+src/bear_export.egg-info/PKG-INFO
+src/bear_export.egg-info/SOURCES.txt
+src/bear_export.egg-info/dependency_links.txt
+src/bear_export.egg-info/requires.txt
+src/bear_export.egg-info/top_level.txt

bear_export-0.1.0/src/bear_export.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bear_export-0.1.0/src/bear_export.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pandas>=2.0.0
+click>=8.0.0
+pyyaml>=6.0
+python-dateutil>=2.8.0

bear_export-0.1.0/src/bear_export.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+__init__
+converter
+organizer
+parser

bear_export-0.1.0/src/converter.py

@@ -0,0 +1,300 @@
+"""
+Markdown Converter Module
+
+Converts Bear blog posts to markdown format with front matter.
+"""
+
+import re
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+from urllib.parse import urlparse
+
+
+class MarkdownConverter:
+    """Converts Bear blog posts to markdown format."""
+
+    def __init__(self, front_matter_format: str = "yaml"):
+        """
+        Initialize converter with front matter format.
+
+        Args:
+            front_matter_format: 'yaml', 'toml', or 'none'
+        """
+        self.front_matter_format = front_matter_format.lower()
+
+    def convert_posts(self, posts: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Convert a list of posts to markdown format.
+
+        Args:
+            posts: List of post dictionaries
+
+        Returns:
+            List of posts with added 'markdown_content' field
+        """
+        converted_posts = []
+
+        for post in posts:
+            markdown_post = post.copy()
+            markdown_post["markdown_content"] = self.convert_post(post)
+            markdown_post["filename"] = self.generate_filename(post)
+            converted_posts.append(markdown_post)
+
+        return converted_posts
+
+    def convert_post(self, post: Dict[str, Any]) -> str:
+        """
+        Convert a single post to markdown format.
+
+        Args:
+            post: Post dictionary
+
+        Returns:
+            Complete markdown content with front matter
+        """
+        # Generate front matter
+        front_matter = self.generate_front_matter(post)
+
+        # Clean and process content
+        content = self.clean_content(post.get("content", ""))
+
+        # Combine front matter and content
+        if self.front_matter_format == "none":
+            return content
+        else:
+            delimiter = "---" if self.front_matter_format == "yaml" else "+++"
+            return f"{delimiter}\n{front_matter}\n{delimiter}\n\n{content}"
+
+    def generate_front_matter(self, post: Dict[str, Any]) -> str:
+        """
+        Generate front matter in the specified format.
+
+        Args:
+            post: Post dictionary
+
+        Returns:
+            Front matter string
+        """
+        if self.front_matter_format == "yaml":
+            return self._generate_yaml_front_matter(post)
+        elif self.front_matter_format == "toml":
+            return self._generate_toml_front_matter(post)
+        else:
+            return ""
+
+    def _generate_yaml_front_matter(self, post: Dict[str, Any]) -> str:
+        """Generate YAML front matter."""
+        lines = []
+
+        # Title
+        if post.get("title"):
+            lines.append(f"title: {self._escape_yaml(post['title'])}")
+
+        # Slug
+        if post.get("slug"):
+            lines.append(f"slug: {self._escape_yaml(post['slug'])}")
+
+        # Date (use published date, fallback to first published at)
+        date = post.get("published date") or post.get("first published at")
+        if date:
+            lines.append(f"date: {date}")
+
+        # Tags
+        tags = post.get("all tags", [])
+        if tags:
+            tags_yaml = "\n  ".join([f"- {self._escape_yaml(tag)}" for tag in tags])
+            lines.append(f"tags:\n  {tags_yaml}")
+
+        # Language
+        if post.get("lang"):
+            lines.append(f"lang: {post['lang']}")
+
+        # Meta description
+        if post.get("meta description"):
+            lines.append(f"description: {self._escape_yaml(post['meta description'])}")
+
+        # Meta image
+        if post.get("meta image"):
+            lines.append(f"image: {self._escape_yaml(post['meta image'])}")
+
+        # Post type
+        if post.get("is page"):
+            lines.append("type: page")
+        else:
+            lines.append("type: post")
+
+        # Published status
+        lines.append(f"published: {str(post.get('publish', False)).lower()}")
+
+        # UID (for reference)
+        if post.get("uid"):
+            lines.append(f"uid: {post['uid']}")
+
+        # Custom CSS class
+        if post.get("class name"):
+            lines.append(f"className: {self._escape_yaml(post['class name'])}")
+
+        return "\n".join(lines)
+
+    def _generate_toml_front_matter(self, post: Dict[str, Any]) -> str:
+        """Generate TOML front matter."""
+        lines = []
+
+        # Title
+        if post.get("title"):
+            lines.append(f"title = '{self._escape_toml(post['title'])}'")
+
+        # Slug
+        if post.get("slug"):
+            lines.append(f"slug = '{self._escape_toml(post['slug'])}'")
+
+        # Date
+        date = post.get("published date") or post.get("first published at")
+        if date:
+            lines.append(f"date = '{date}'")
+
+        # Tags
+        tags = post.get("all tags", [])
+        if tags:
+            tags_toml = ", ".join([f"'{self._escape_toml(tag)}'" for tag in tags])
+            lines.append(f"tags = [{tags_toml}]")
+
+        # Language
+        if post.get("lang"):
+            lines.append(f"lang = '{post['lang']}'")
+
+        # Meta description
+        if post.get("meta description"):
+            lines.append(
+                f"description = '{self._escape_toml(post['meta description'])}'"
+            )
+
+        # Meta image
+        if post.get("meta image"):
+            lines.append(f"image = '{self._escape_toml(post['meta image'])}'")
+
+        # Post type
+        post_type = "page" if post.get("is page") else "post"
+        lines.append(f"type = '{post_type}'")
+
+        # Published status
+        lines.append(f"published = {str(post.get('publish', False)).lower()}")
+
+        # UID
+        if post.get("uid"):
+            lines.append(f"uid = '{post['uid']}'")
+
+        # Custom CSS class
+        if post.get("class name"):
+            lines.append(f"className = '{self._escape_toml(post['class name'])}'")
+
+        return "\n".join(lines)
+
+    def generate_filename(self, post: Dict[str, Any]) -> str:
+        """
+        Generate a safe filename for the post.
+
+        Args:
+            post: Post dictionary
+
+        Returns:
+            Filename with .md extension
+        """
+        # Try to use slug first, then title, then UID
+        name = post.get("slug") or post.get("title") or post.get("uid", "untitled")
+
+        # Clean the name
+        name = self._clean_filename(name)
+
+        # Ensure it's not empty
+        if not name:
+            name = f"post-{post.get('uid', 'unknown')}"
+
+        return f"{name}.md"
+
+    def clean_content(self, content: str) -> str:
+        """
+        Clean and process post content.
+
+        Args:
+            content: Raw post content
+
+        Returns:
+            Cleaned markdown content
+        """
+        if not content:
+            return ""
+
+        # Normalize line endings
+        content = content.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Clean up excessive whitespace
+        content = re.sub(r"\n{3,}", "\n\n", content)
+
+        # Fix common Bear-specific markdown issues
+        content = self._fix_bear_markdown(content)
+
+        # Strip leading/trailing whitespace
+        content = content.strip()
+
+        return content
+
+    def _fix_bear_markdown(self, content: str) -> str:
+        """Fix Bear-specific markdown issues."""
+        # Fix Bear's image syntax: ![image](/path/to/image) -> ![alt text](/path/to/image)
+        content = re.sub(r"!\[image\]", "![image]", content)
+
+        # Fix Bear's link syntax issues
+        content = re.sub(r"\[([^\]]+)\]\(\s*([^\)]+)\s*\)", r"[\1](\2)", content)
+
+        # Clean up HTML that Bear might have added
+        content = re.sub(r"<br\s*/?>", "\n", content)
+
+        return content
+
+    def _clean_filename(self, name: str) -> str:
+        """Clean string to be safe for filename."""
+        # Remove or replace unsafe characters
+        name = re.sub(r'[<>:"/\\|?*]', "", name)
+
+        # Replace spaces and other separators with hyphens
+        name = re.sub(r"[\s_]+", "-", name)
+
+        # Remove consecutive hyphens
+        name = re.sub(r"-+", "-", name)
+
+        # Remove leading/trailing hyphens and dots
+        name = name.strip("-.")
+
+        # Convert to lowercase
+        name = name.lower()
+
+        # Limit length
+        if len(name) > 50:
+            name = name[:50].rstrip("-")
+
+        return name
+
+    def _escape_yaml(self, text: str) -> str:
+        """Escape text for YAML."""
+        if not text:
+            return ""
+
+        # Basic YAML escaping
+        text = str(text).replace("'", "''")
+
+        # If it contains special characters, quote it
+        if any(char in text for char in ":{}[],&*#?|-<>" + " \n\t"):
+            return f"'{text}'"
+
+        return text
+
+    def _escape_toml(self, text: str) -> str:
+        """Escape text for TOML."""
+        if not text:
+            return ""
+
+        # Basic TOML escaping
+        text = str(text).replace("\\", "\\\\").replace("'", "\\'")
+
+        return text

bear_export-0.1.0/src/organizer.py

@@ -0,0 +1,225 @@
+"""
+File Organizer Module
+
+Organizes markdown files into directory structures.
+"""
+
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+class FileOrganizer:
+    """Organizes markdown files into directory structures."""
+
+    def __init__(self, output_dir: str = "Blog", organization: str = "none"):
+        """
+        Initialize file organizer.
+
+        Args:
+            output_dir: Base output directory name
+            organization: How to organize files ('date', 'tags', 'none')
+        """
+        self.output_dir = Path(output_dir)
+        self.organization = organization.lower()
+
+        # Create output directory if it doesn't exist
+        self.output_dir.mkdir(exist_ok=True)
+
+    def organize_posts(self, posts: List[Dict[str, Any]]) -> None:
+        """
+        Organize posts into directory structure and write files.
+
+        Args:
+            posts: List of posts with markdown_content and filename
+        """
+        # Clean existing directory if it exists (except for hidden files)
+        if self.output_dir.exists():
+            self._clean_output_directory()
+
+        # Organize based on selected method
+        if self.organization == "date":
+            self._organize_by_date(posts)
+        elif self.organization == "tags":
+            self._organize_by_tags(posts)
+        else:
+            self._organize_flat(posts)
+
+        # Create index file
+        self._create_index(posts)
+
+    def _clean_output_directory(self) -> None:
+        """Clean output directory of non-hidden files."""
+        for item in self.output_dir.iterdir():
+            if not item.name.startswith("."):
+                if item.is_file():
+                    item.unlink()
+                elif item.is_dir():
+                    shutil.rmtree(item)
+
+    def _organize_flat(self, posts: List[Dict[str, Any]]) -> None:
+        """Organize posts in a flat structure."""
+        for post in posts:
+            filename = post.get("filename", "untitled.md")
+            content = post.get("markdown_content", "")
+
+            filepath = self.output_dir / filename
+            self._write_file(filepath, content)
+
+    def _organize_by_date(self, posts: List[Dict[str, Any]]) -> None:
+        """Organize posts by year/month."""
+        for post in posts:
+            filename = post.get("filename", "untitled.md")
+            content = post.get("markdown_content", "")
+
+            # Get date from post
+            date_str = post.get("published date") or post.get("first published at")
+            if date_str:
+                try:
+                    # Parse date and create year/month directory
+                    date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+                    year_dir = self.output_dir / str(date.year)
+                    month_dir = year_dir / f"{date.month:02d}"
+
+                    year_dir.mkdir(exist_ok=True)
+                    month_dir.mkdir(exist_ok=True)
+
+                    filepath = month_dir / filename
+                except (ValueError, TypeError):
+                    # Fallback to root if date parsing fails
+                    filepath = self.output_dir / filename
+            else:
+                # No date, put in root
+                filepath = self.output_dir / filename
+
+            self._write_file(filepath, content)
+
+    def _organize_by_tags(self, posts: List[Dict[str, Any]]) -> None:
+        """Organize posts by tags (posts can be in multiple tag directories)."""
+        # Create a mapping of tag to posts
+        tag_posts = {}
+        uncategorized_posts = []
+
+        for post in posts:
+            tags = post.get("all tags", [])
+            if tags:
+                for tag in tags:
+                    if tag not in tag_posts:
+                        tag_posts[tag] = []
+                    tag_posts[tag].append(post)
+            else:
+                uncategorized_posts.append(post)
+
+        # Write posts to tag directories
+        for tag, tagged_posts in tag_posts.items():
+            # Create tag directory
+            tag_dir = self.output_dir / self._clean_tag_name(tag)
+            tag_dir.mkdir(exist_ok=True)
+
+            # Write posts to this tag directory
+            for post in tagged_posts:
+                filename = post.get("filename", "untitled.md")
+                content = post.get("markdown_content", "")
+
+                filepath = tag_dir / filename
+                self._write_file(filepath, content)
+
+        # Write uncategorized posts to root
+        for post in uncategorized_posts:
+            filename = post.get("filename", "untitled.md")
+            content = post.get("markdown_content", "")
+
+            filepath = self.output_dir / filename
+            self._write_file(filepath, content)
+
+    def _create_index(self, posts: List[Dict[str, Any]]) -> None:
+        """Create an index file listing all posts."""
+        index_content = self._generate_index_content(posts)
+        index_path = self.output_dir / "README.md"
+        self._write_file(index_path, index_content)
+
+    def _generate_index_content(self, posts: List[Dict[str, Any]]) -> str:
+        """Generate content for index file."""
+        lines = ["# Blog Posts\n"]
+
+        # Sort posts by date (newest first)
+        sorted_posts = sorted(posts, key=self._get_post_date, reverse=True)
+
+        for post in sorted_posts:
+            title = post.get("title", "Untitled")
+            filename = post.get("filename", "untitled.md")
+            date_str = post.get("published date") or post.get("first published at")
+            tags = post.get("all tags", [])
+
+            # Format date
+            date_display = ""
+            if date_str:
+                try:
+                    date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+                    date_display = date.strftime("%Y-%m-%d")
+                except (ValueError, TypeError):
+                    date_display = date_str
+
+            # Format tags
+            tags_display = ""
+            if tags:
+                tags_display = f" - `{'`, `'.join(tags)}`"
+
+            # Add to index
+            line = f"- [{title}]({filename})"
+            if date_display:
+                line += f" ({date_display})"
+            if tags_display:
+                line += f" {tags_display}"
+
+            lines.append(line)
+
+        # Add summary
+        lines.append(f"\n---")
+        lines.append(f"**Total posts:** {len(posts)}")
+
+        published_count = sum(1 for p in posts if p.get("publish", False))
+        draft_count = len(posts) - published_count
+
+        lines.append(f"**Published:** {published_count}")
+        lines.append(f"**Drafts:** {draft_count}")
+
+        return "\n".join(lines)
+
+    def _write_file(self, filepath: Path, content: str) -> None:
+        """Write content to file, creating directories as needed."""
+        # Create parent directories if they don't exist
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write file
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def _clean_tag_name(self, tag: str) -> str:
+        """Clean tag name for directory use."""
+        # Remove special characters and replace spaces with hyphens
+        import re
+
+        tag = re.sub(r'[<>:"/\\|?*]', "", tag)
+        tag = re.sub(r"[\s_]+", "-", tag)
+        tag = re.sub(r"-+", "-", tag)
+        tag = tag.strip("-.")
+
+        # Convert to lowercase
+        tag = tag.lower()
+
+        return tag or "untagged"
+
+    def _get_post_date(self, post: Dict[str, Any]) -> datetime:
+        """Get datetime for sorting posts."""
+        date_str = post.get("published date") or post.get("first published at")
+        if date_str:
+            try:
+                return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+            except (ValueError, TypeError):
+                pass
+
+        # Fallback to very old date for posts without dates
+        return datetime(1970, 1, 1)

bear_export-0.1.0/src/parser.py

@@ -0,0 +1,191 @@
+"""
+Bear CSV Parser Module
+
+Handles parsing of Bear blog export CSV files with proper encoding and data cleaning.
+"""
+
+import pandas as pd
+import json
+from datetime import datetime
+from typing import List, Dict, Any
+
+
+class BearCSVParser:
+    """Parser for Bear blog CSV export files."""
+
+    def __init__(self):
+        self.expected_columns = [
+            "uid",
+            "title",
+            "slug",
+            "alias",
+            "published date",
+            "all tags",
+            "publish",
+            "make discoverable",
+            "is page",
+            "content",
+            "canonical url",
+            "meta description",
+            "meta image",
+            "lang",
+            "class name",
+            "first published at",
+        ]
+
+    def parse(self, csv_file: str) -> List[Dict[str, Any]]:
+        """
+        Parse Bear blog CSV file and return list of post dictionaries.
+
+        Args:
+            csv_file: Path to the CSV file
+
+        Returns:
+            List of post dictionaries with cleaned data
+        """
+        try:
+            # Read CSV with UTF-8 BOM encoding (common in Bear exports)
+            df = pd.read_csv(csv_file, encoding="utf-8-sig")
+
+            # Validate columns
+            self._validate_columns(df)
+
+            # Convert to list of dictionaries and clean data
+            posts = []
+            for _, row in df.iterrows():
+                post = self._clean_post_data(row.to_dict())
+                posts.append(post)
+
+            return posts
+
+        except UnicodeDecodeError:
+            # Fallback to other encodings
+            try:
+                df = pd.read_csv(csv_file, encoding="utf-8")
+                posts = [
+                    self._clean_post_data(row.to_dict()) for _, row in df.iterrows()
+                ]
+                return posts
+            except Exception as e:
+                raise ValueError(f"Could not read CSV file with any encoding: {str(e)}")
+        except Exception as e:
+            raise ValueError(f"Error parsing CSV file: {str(e)}")
+
+    def _validate_columns(self, df: pd.DataFrame) -> None:
+        """Validate that expected columns exist in the DataFrame."""
+        missing_columns = set(self.expected_columns) - set(df.columns)
+        if missing_columns:
+            raise ValueError(f"Missing expected columns in CSV: {missing_columns}")
+
+    def _clean_post_data(self, post_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Clean and normalize post data.
+
+        Args:
+            post_data: Raw post data from CSV
+
+        Returns:
+            Cleaned post data dictionary
+        """
+        cleaned = {}
+
+        # Basic string fields
+        string_fields = [
+            "uid",
+            "title",
+            "slug",
+            "alias",
+            "canonical url",
+            "meta description",
+            "meta image",
+            "lang",
+            "class name",
+        ]
+
+        for field in string_fields:
+            cleaned[field] = self._clean_string(post_data.get(field, ""))
+
+        # Date fields
+        date_fields = ["published date", "first published at"]
+        for field in date_fields:
+            cleaned[field] = self._clean_date(post_data.get(field, ""))
+
+        # Boolean fields
+        bool_fields = ["publish", "make discoverable", "is page"]
+        for field in bool_fields:
+            cleaned[field] = self._clean_boolean(post_data.get(field, False))
+
+        # Tags field (JSON array)
+        cleaned["all tags"] = self._clean_tags(post_data.get("all tags", "[]"))
+
+        # Content field
+        cleaned["content"] = self._clean_content(post_data.get("content", ""))
+
+        return cleaned
+
+    def _clean_string(self, value: Any) -> str:
+        """Clean string values."""
+        if pd.isna(value) or value is None:
+            return ""
+        return str(value).strip()
+
+    def _clean_date(self, value: Any) -> str:
+        """Clean date values."""
+        if pd.isna(value) or value is None or value == "":
+            return ""
+
+        try:
+            # Try to parse as datetime and format as ISO
+            if isinstance(value, str):
+                # Handle various date formats
+                for fmt in ["%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"]:
+                    try:
+                        dt = datetime.strptime(value, fmt)
+                        return dt.isoformat()
+                    except ValueError:
+                        continue
+            return str(value)
+        except:
+            return str(value)
+
+    def _clean_boolean(self, value: Any) -> bool:
+        """Clean boolean values."""
+        if pd.isna(value) or value is None:
+            return False
+
+        if isinstance(value, bool):
+            return value
+
+        if isinstance(value, str):
+            return value.lower() in ["true", "yes", "1", "on"]
+
+        return bool(value)
+
+    def _clean_tags(self, value: Any) -> List[str]:
+        """Clean tags field (JSON array)."""
+        if pd.isna(value) or value is None or value == "":
+            return []
+
+        try:
+            if isinstance(value, str):
+                tags = json.loads(value)
+                if isinstance(tags, list):
+                    return [
+                        tag.strip()
+                        for tag in tags
+                        if isinstance(tag, str) and tag.strip()
+                    ]
+            elif isinstance(value, list):
+                return [
+                    tag.strip() for tag in value if isinstance(tag, str) and tag.strip()
+                ]
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+        return []
+
+    def _clean_content(self, value: Any) -> str:
+        """Clean content field."""
+        if pd.isna(value) or value is None:
+            return ""
+        return str(value)