From 3d122b5022d2ac02713378f6a086ed9a7f1e12ac Mon Sep 17 00:00:00 2001 From: Olivier Date: Tue, 28 Oct 2025 11:14:35 -0400 Subject: [PATCH] initial --- README.md | 168 +++++ pyproject.toml | 20 + requirements.txt | 4 + src/__pycache__/obsidian_cli.cpython-312.pyc | Bin 0 -> 31830 bytes src/obsidian_cli.py | 675 ++++++++++++++++++ test_vault/2025-10-24.md | 0 ..._obsidian_cli.cpython-312-pytest-7.4.3.pyc | Bin 0 -> 11649 bytes tests/test_obsidian_cli.py | 198 +++++ 8 files changed, 1065 insertions(+) create mode 100644 README.md create mode 100644 pyproject.toml create mode 100644 requirements.txt create mode 100644 src/__pycache__/obsidian_cli.cpython-312.pyc create mode 100644 src/obsidian_cli.py create mode 100644 test_vault/2025-10-24.md create mode 100644 tests/__pycache__/test_obsidian_cli.cpython-312-pytest-7.4.3.pyc create mode 100644 tests/test_obsidian_cli.py diff --git a/README.md b/README.md new file mode 100644 index 0000000..5fc84f8 --- /dev/null +++ b/README.md @@ -0,0 +1,168 @@ +# Onyx Python Helper + +A Python-based command-line interface tool for interacting with Obsidian vaults. This tool allows you to manage your Obsidian notes directly from the terminal. + +## Installation + +1. Clone this repository +2. Install dependencies: +```bash +pip install -r requirements.txt +``` + +## Usage + +### Set Default Vault + +First, you need to set up your vault with both its name and path: + +```bash +# Set up a new vault with its path (required for first use) +ob-cli set-default "vault-name" --path "/path/to/vault" + +# Print current default vault and its path +ob-cli print-default + +# Switch to another existing vault (only works for already configured vaults) +ob-cli set-default "another-vault" +``` + +### Open Notes + +```bash +# Open a note in Obsidian +python src/obsidian_cli.py open "note-name" + +# Open a note in specific vault +python src/obsidian_cli.py open "note-name" --vault "vault-name" +``` + +### Daily Notes + +```bash +# Create and open today's daily note +python src/obsidian_cli.py daily + +# Create daily note in specific vault +python src/obsidian_cli.py daily --vault "vault-name" +``` + +### Create/Update Notes + +```bash +# Create a new note +python src/obsidian_cli.py create "note-name" + +# Create note with content +python src/obsidian_cli.py create "note-name" --content "Your content here" + +# Create note in specific vault +python src/obsidian_cli.py create "note-name" --vault "vault-name" + +# Overwrite existing note +python src/obsidian_cli.py create "note-name" --content "New content" --overwrite + +# Append to existing note +python src/obsidian_cli.py create "note-name" --content "Additional content" --append + +# Create and open note +python src/obsidian_cli.py create "note-name" --content "content" --open +``` + +### View Notes + +```bash +# Print note contents +python src/obsidian_cli.py print-note "note-name" + +# Print note from specific vault +python src/obsidian_cli.py print-note "note-name" --vault "vault-name" +``` + +### Move/Rename Notes + +```bash +# Move/rename a note +python src/obsidian_cli.py move "old-path" "new-path" + +# Move in specific vault +python src/obsidian_cli.py move "old-path" "new-path" --vault "vault-name" + +# Move and open note +python src/obsidian_cli.py move "old-path" "new-path" --open +``` + +### Delete Notes + +```bash +# Delete a note +python src/obsidian_cli.py delete "note-path" + +# Delete from specific vault +python src/obsidian_cli.py delete "note-path" --vault "vault-name" +``` + +### Frontmatter Management + +```bash +# Edit frontmatter +python src/obsidian_cli.py frontmatter "note-name" --edit --key "tags" --value "project" +python src/obsidian_cli.py frontmatter "note-name" --edit --key "tags" --value "project,urgent" +python src/obsidian_cli.py frontmatter "note-name" --edit --key "status" --value "in-progress" + +# View frontmatter +python src/obsidian_cli.py frontmatter "note-name" --view --key "tags" +python src/obsidian_cli.py frontmatter "note-name" --view --key "tags" --value "project" + +# Clear frontmatter values +python src/obsidian_cli.py frontmatter "note-name" --clear --key "tags" +python src/obsidian_cli.py frontmatter "note-name" --clear --key "date,status,tags" + +# Delete frontmatter keys +python src/obsidian_cli.py frontmatter "note-name" --delete --key "tags" +python src/obsidian_cli.py frontmatter "note-name" --delete --key "date,status,tags" +``` + +## Features + +The tool now includes all major features from the original Obsidian CLI tool: +- Set and manage default vault +- Open notes in Obsidian +- Create and manage daily notes +- Create/update notes with content +- Print note contents +- Move/rename notes (with automatic link updates) +- Delete notes +- Complete frontmatter management (edit, view, clear, delete) + +## Requirements + +- Python 3.7+ +- click +- pyyaml + +## Development + +### Running Tests + +To run the tests: + +```bash +# Install test dependencies +pip install -r requirements.txt + +# Run tests +python -m pytest + +# Run tests with coverage report +python -m pytest --cov=src tests/ +``` + +The test suite includes tests for: +- Vault management +- Note creation and modification +- Frontmatter operations +- Note movement and link updates +- Daily notes +- Platform-specific note opening +- Note deletion diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..2b83111 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,20 @@ +[tool.pytest] +testpaths = ["tests"] +python_files = ["test_*.py"] +python_classes = ["Test*"] +python_functions = ["test_*"] + +[tool.coverage.run] +source = ["src"] +omit = ["tests/*"] + +[tool.coverage.report] +exclude_lines = [ + "pragma: no cover", + "def __repr__", + "if self.debug:", + "raise NotImplementedError", + "if __name__ == .__main__.:", + "pass", + "raise ImportError", +] diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..9189146 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +click==8.1.7 +pyyaml==6.0.1 +pytest==7.4.3 +pytest-cov==4.1.0 diff --git a/src/__pycache__/obsidian_cli.cpython-312.pyc b/src/__pycache__/obsidian_cli.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f59befff91904c18c828af8012c3f959b58e497 GIT binary patch literal 31830 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 literal 0 HcmV?d00001 diff --git a/src/obsidian_cli.py b/src/obsidian_cli.py new file mode 100644 index 0000000..09c59ed --- /dev/null +++ b/src/obsidian_cli.py @@ -0,0 +1,675 @@ +#!/usr/bin/env python3 +import click +import os +import yaml +import json +import subprocess +import sys +from datetime import datetime +from pathlib import Path +import re +from typing import List, Union, Optional, Dict, Any +from urllib.parse import quote + +class OnyxCLI: + def __init__(self): + self.config_file = Path.home() / '.onyx-cli' / 'config.yaml' + self._ensure_config_exists() + self.default_vault = self._load_default_vault() + if self.default_vault: + try: + self.vault_path = self._get_vault_path(self.default_vault) + except click.UsageError: + # Vault is set but not configured - will be handled by commands + self.vault_path = None + else: + self.vault_path = None + + def _ensure_config_exists(self): + self.config_file.parent.mkdir(parents=True, exist_ok=True) + if not self.config_file.exists(): + self.config_file.write_text(yaml.dump({'default_vault': None, 'vaults': {}})) + + def _load_default_vault(self): + if self.config_file.exists(): + config = yaml.safe_load(self.config_file.read_text()) + return config.get('default_vault') + return None + + def _get_vault_path(self, vault_name: str) -> Path: + config = yaml.safe_load(self.config_file.read_text()) + vault_path = config.get('vaults', {}).get(vault_name) + if not vault_path: + raise click.UsageError(f"Vault '{vault_name}' not found in config") + return Path(vault_path) + + def _get_vault_and_path(self, vault: Optional[str] = None) -> tuple[str, Path]: + vault_name = vault or self.default_vault + if not vault_name: + raise click.UsageError("No vault specified. Either set a default vault or provide --vault option") + vault_path = self._get_vault_path(vault_name) + return vault_name, vault_path + + def _get_daily_note_settings(self, vault_path: Path) -> Dict[str, Any]: + """ + Get daily note settings from Periodic Notes plugin (if enabled), + falling back to core Daily Notes plugin if not available. + + Returns a dict with: format, folder, template + """ + # Try Periodic Notes plugin first + periodic_notes_config = vault_path / ".obsidian" / "plugins" / "periodic-notes" / "data.json" + if periodic_notes_config.exists(): + try: + config = json.loads(periodic_notes_config.read_text()) + daily_config = config.get('daily', {}) + + # Check if daily notes are enabled in Periodic Notes + if daily_config.get('enabled', False): + return { + 'format': daily_config.get('format', 'YYYY-MM-DD'), + 'folder': daily_config.get('folder', ''), + 'template': daily_config.get('template', '') + } + except (json.JSONDecodeError, KeyError): + pass # Fall through to core plugin + + # Fall back to core Daily Notes plugin + daily_notes_config = vault_path / ".obsidian" / "daily-notes.json" + if daily_notes_config.exists(): + try: + config = json.loads(daily_notes_config.read_text()) + return { + 'format': config.get('format', 'YYYY-MM-DD'), + 'folder': config.get('folder', ''), + 'template': config.get('template', '') + } + except (json.JSONDecodeError, KeyError): + pass + + # Default settings if neither plugin is configured + return { + 'format': 'YYYY-MM-DD', + 'folder': '', + 'template': '' + } + + def set_default_vault(self, vault_name: str, vault_path: str = None): + try: + config = yaml.safe_load(self.config_file.read_text()) if self.config_file.exists() else {} + except Exception: + config = {} + + config.setdefault('vaults', {}) + + if vault_path is not None: + # If path is provided, always update or create the vault entry + try: + resolved_path = Path(vault_path).resolve() + if not resolved_path.exists(): + click.echo(f"Creating vault directory: {resolved_path}") + resolved_path.mkdir(parents=True, exist_ok=True) + config['vaults'][vault_name] = str(resolved_path) + except Exception as e: + raise click.UsageError(f"Error setting vault path: {str(e)}") + elif vault_name not in config['vaults']: + # If no path and vault doesn't exist, show error + raise click.UsageError( + f"Vault '{vault_name}' not found. Please provide the path when setting a new vault:\n" + f"ob-cli set-default \"{vault_name}\" --path \"path/to/vault\"" + ) + + config['default_vault'] = vault_name + self.config_file.write_text(yaml.dump(config)) + self.default_vault = vault_name + + actual_path = config['vaults'][vault_name] + click.echo(f"Default vault set to: {vault_name}") + click.echo(f"Vault path: {actual_path}") + + def print_default(self): + if not self.default_vault: + click.echo("No default vault set") + return + + config = yaml.safe_load(self.config_file.read_text()) + vault_path = config.get('vaults', {}).get(self.default_vault) + + if not vault_path: + raise click.UsageError( + f"Vault '{self.default_vault}' not found in config. Please set it up with:\n" + f"ob-cli set-default \"{self.default_vault}\" --path \"path/to/vault\"" + ) + + click.echo(f"Default vault: {self.default_vault}") + click.echo(f"Path: {vault_path}") + + def create_note(self, note_name: str, content: str = "", vault: str = None, + overwrite: bool = False, append: bool = False, open_after: bool = False): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + note_path.parent.mkdir(parents=True, exist_ok=True) + + if note_path.exists(): + if overwrite: + mode = 'w' + elif append: + mode = 'a' + else: + raise click.UsageError(f"Note {note_name} already exists. Use --overwrite or --append to modify") + else: + mode = 'w' + + with note_path.open(mode) as f: + if append and note_path.exists(): + f.write('\n') + f.write(content) + + click.echo(f"Note {'updated' if note_path.exists() else 'created'}: {note_path}") + + if open_after: + self.open_note(note_name, vault_name) + + def open_note(self, note_name: str, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + + # Try exact path first + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + # If not found, try in daily notes folder if configured + # if not note_path.exists(): + # settings = self._get_daily_note_settings(vault_path) + # if settings['folder']: + # daily_note_path = vault_path / settings['folder'] / f"{note_name}.md" + # if daily_note_path.exists(): + # note_path = daily_note_path + + # If still not found, try searching the entire vault + if not note_path.exists(): + matches = list(vault_path.rglob(f"{note_name}.md")) + if matches: + note_path = matches[0] # Use first match + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + # Get the relative path from the vault root for the URI + relative_path = note_path.relative_to(vault_path) + # URL encode both the vault name and file path to handle special characters + encoded_vault = self._url_encode(vault_name) + encoded_file = self._url_encode(relative_path.as_posix()) + uri = f"obsidian://open?vault={encoded_vault}&file={encoded_file}" + self._open_uri(uri) + + def _convert_moment_format(self, moment_format: str) -> str: + """Convert moment.js date format to Python strftime format.""" + # Handle literal text in brackets first (e.g., [W] -> W) + result = re.sub(r'\[([^\]]+)\]', r'\1', moment_format) + + # Use non-printable placeholders to avoid conflicts + # Order matters: process longest patterns first + placeholders = [ + ('YYYY', '\x001'), + ('MMMM', '\x002'), + ('dddd', '\x003'), + ('MMM', '\x004'), + ('ddd', '\x005'), + ('Do', '\x006'), + ('YY', '\x007'), + ('MM', '\x008'), + ('DD', '\x009'), + ('HH', '\x00A'), + ('hh', '\x00B'), + ('mm', '\x00C'), + ('ss', '\x00D'), + ('M', '\x00E'), + ('D', '\x00F'), + ('H', '\x010'), + ('h', '\x011'), + ('A', '\x012'), + ('a', '\x013'), + ] + + strftime_codes = { + '\x001': '%Y', + '\x007': '%y', + '\x002': '%B', + '\x004': '%b', + '\x008': '%m', + '\x00E': '%m', + '\x009': '%d', + '\x00F': '%d', + '\x006': '%d', + '\x003': '%A', + '\x005': '%a', + '\x00A': '%H', + '\x010': '%H', + '\x00B': '%I', + '\x011': '%I', + '\x00C': '%M', + '\x00D': '%S', + '\x012': '%p', + '\x013': '%p', + } + + # First pass: replace moment patterns with placeholders + for moment_pattern, placeholder in placeholders: + result = result.replace(moment_pattern, placeholder) + + # Second pass: replace placeholders with strftime codes + for placeholder, strftime_code in strftime_codes.items(): + result = result.replace(placeholder, strftime_code) + + return result + + def _create_or_open_periodic_note(self, note_type: str, vault: str = None): + """Generic method to create or open periodic notes.""" + vault_name, vault_path = self._get_vault_and_path(vault) + + # Get settings from plugin + settings = self._get_daily_note_settings(vault_path) + + # Load periodic notes settings if available + periodic_notes_config = vault_path / ".obsidian" / "plugins" / "periodic-notes" / "data.json" + if periodic_notes_config.exists(): + try: + config = json.loads(periodic_notes_config.read_text()) + note_config = config.get(note_type, {}) + if note_config.get('enabled', False): + settings = { + 'format': note_config.get('format', 'YYYY-MM-DD'), + 'folder': note_config.get('folder', ''), + 'template': note_config.get('template', '') + } + except (json.JSONDecodeError, KeyError): + pass + + # Convert format and generate filename + date_format = self._convert_moment_format(settings['format']) + + # Handle week format specially for ISO weeks + if 'W' in settings['format'] and '[W]' in settings['format']: + # Handle formats like "yyyy-[W]WW" or "YYYY-[W]WW" or "yy-[W]WW" + # Use ISO week number + year_format = 'yyyy' if 'yyyy' in settings['format'] else ('YYYY' if 'YYYY' in settings['format'] else 'yy') + if year_format == 'yyyy' or year_format == 'YYYY': + year = datetime.now().strftime('%G') # ISO year (4 digits) + else: + year = datetime.now().strftime('%g') # ISO year (2 digits) + week = datetime.now().strftime('%V') # ISO week number + filename = f"{year}-W{week}" + else: + filename = datetime.now().strftime(date_format) + + # Get template content if specified + content = "" + if settings['template']: + template_path = vault_path / settings['template'] + if not template_path.suffix: + template_path = template_path.with_suffix('.md') + if template_path.exists(): + content = template_path.read_text() + + # Construct note path with folder + folder = settings['folder'] + if folder: + note_path = f"{folder}/{filename}.md" + else: + note_path = f"{filename}.md" + + # Check if note exists + full_note_path = vault_path / note_path + if not full_note_path.suffix: + full_note_path = full_note_path.with_suffix('.md') + + if full_note_path.exists(): + # Note exists, just open it + self.open_note(note_path, vault_name) + else: + # Note doesn't exist, create and open it + self.create_note(note_path, content=content, vault=vault_name, open_after=True) + + def daily_note(self, vault: str = None): + """Create or open today's daily note.""" + self._create_or_open_periodic_note('daily', vault) + + def weekly_note(self, vault: str = None): + """Create or open this week's note.""" + self._create_or_open_periodic_note('weekly', vault) + + def monthly_note(self, vault: str = None): + """Create or open this month's note.""" + self._create_or_open_periodic_note('monthly', vault) + + def quarterly_note(self, vault: str = None): + """Create or open this quarter's note.""" + self._create_or_open_periodic_note('quarterly', vault) + + def yearly_note(self, vault: str = None): + """Create or open this year's note.""" + self._create_or_open_periodic_note('yearly', vault) + + def print_note(self, note_name: str, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + click.echo(note_path.read_text()) + + def move_note(self, current_path: str, new_path: str, vault: str = None, open_after: bool = False): + vault_name, vault_path = self._get_vault_and_path(vault) + + current = vault_path / current_path + if not current.suffix: + current = current.with_suffix('.md') + + new = vault_path / new_path + if not new.suffix: + new = new.with_suffix('.md') + + if not current.exists(): + raise click.UsageError(f"Note {current_path} does not exist") + + new.parent.mkdir(parents=True, exist_ok=True) + current.rename(new) + + # Update internal links in all vault files + old_link_pattern = f"\\[\\[{current.stem}\\]\\]" + new_link = f"[[{new.stem}]]" + + for md_file in vault_path.rglob("*.md"): + if md_file != new: # Skip the moved file + content = md_file.read_text() + updated_content = re.sub(old_link_pattern, new_link, content) + if updated_content != content: + md_file.write_text(updated_content) + + click.echo(f"Moved {current_path} to {new_path}") + + if open_after: + self.open_note(new_path, vault_name) + + def delete_note(self, note_path: str, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note = vault_path / note_path + if not note.suffix: + note = note.with_suffix('.md') + + if not note.exists(): + raise click.UsageError(f"Note {note_path} does not exist") + + note.unlink() + click.echo(f"Deleted {note_path}") + + def _parse_frontmatter(self, content: str) -> tuple[dict, str, int]: + if not content.startswith('---\n'): + return {}, content, 0 + + parts = content.split('---\n', 2) + if len(parts) < 3: + return {}, content, 0 + + try: + frontmatter = yaml.safe_load(parts[1]) or {} + return frontmatter, parts[2], len(parts[0]) + len(parts[1]) + 6 + except yaml.YAMLError: + return {}, content, 0 + + def _update_frontmatter(self, note_path: Path, updates: dict): + content = note_path.read_text() + frontmatter, rest_content, fm_length = self._parse_frontmatter(content) + + frontmatter.update(updates) + + new_content = '---\n' + new_content += yaml.dump(frontmatter, default_flow_style=False) + new_content += '---\n' + new_content += rest_content if fm_length else content + + note_path.write_text(new_content) + + def frontmatter_edit(self, note_name: str, key: str, value: str = None, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + # Handle multiple keys + keys = [k.strip() for k in re.split(r',|\[|\]', key) if k.strip()] + updates = {} + + for k in keys: + if k == 'tags': + if value: + updates[k] = value.split(',') if ',' in value else [value] + else: + updates[k] = [] + else: + updates[k] = value if value is not None else "" + + self._update_frontmatter(note_path, updates) + click.echo(f"Updated frontmatter for {note_name}") + + def frontmatter_view(self, note_name: str, key: str, value: str = None, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + content = note_path.read_text() + frontmatter, _, _ = self._parse_frontmatter(content) + + if key not in frontmatter: + click.echo(f"Key '{key}' not found in frontmatter") + return + + if value is not None: + # Check if value exists + current_value = frontmatter[key] + if isinstance(current_value, list): + result = value in current_value + else: + result = str(current_value) == value + click.echo(str(result).lower()) + else: + click.echo(yaml.dump({key: frontmatter[key]}, default_flow_style=False).strip()) + + def frontmatter_clear(self, note_name: str, key: str, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + keys = [k.strip() for k in re.split(r',|\[|\]', key) if k.strip()] + updates = {} + + for k in keys: + updates[k] = [] if k == 'tags' else "" + + self._update_frontmatter(note_path, updates) + click.echo(f"Cleared frontmatter values for {note_name}") + + def frontmatter_delete(self, note_name: str, key: str, vault: str = None): + vault_name, vault_path = self._get_vault_and_path(vault) + note_path = vault_path / note_name + if not note_path.suffix: + note_path = note_path.with_suffix('.md') + + if not note_path.exists(): + raise click.UsageError(f"Note {note_name} does not exist") + + content = note_path.read_text() + frontmatter, rest_content, _ = self._parse_frontmatter(content) + + keys = [k.strip() for k in re.split(r',|\[|\]', key) if k.strip()] + modified = False + + for k in keys: + if k in frontmatter: + del frontmatter[k] + modified = True + + if modified: + if frontmatter: + new_content = '---\n' + new_content += yaml.dump(frontmatter, default_flow_style=False) + new_content += '---\n' + new_content += rest_content + else: + new_content = rest_content + + note_path.write_text(new_content) + click.echo(f"Deleted frontmatter keys from {note_name}") + else: + click.echo("No matching keys found in frontmatter") + + def _url_encode(self, text: str) -> str: + """URL encode a string, preserving forward slashes.""" + return quote(text, safe='/') + + def _open_uri(self, uri: str): + """Open URI using the appropriate command for the current platform.""" + if sys.platform == 'darwin': # macOS + subprocess.run(['open', uri]) + elif sys.platform == 'win32': # Windows + os.startfile(uri) + else: # Linux + subprocess.run(['xdg-open', uri]) + +# CLI Commands + +@click.group(name='ob-cli') +def cli(): + """Onyx CLI - Interact with Obsidian from the command line""" + pass + +@cli.command() +@click.argument('vault_name') +@click.option('--path', help="Path to the vault directory") +def set_default(vault_name, path): + """Set the default vault for future operations""" + # Convert Windows backslashes to forward slashes if needed + if path: + path = str(Path(path)) + OnyxCLI().set_default_vault(vault_name, path) + +@cli.command() +def print_default(): + """Print the current default vault and its path""" + OnyxCLI().print_default() + +@cli.command() +@click.argument('note_name') +@click.option('--vault', help="Vault name (if not using default)") +def open(note_name, vault): + """Open a note in Obsidian""" + OnyxCLI().open_note(note_name, vault) + +@cli.command() +@click.option('--vault', help="Vault name (if not using default)") +def daily(vault): + """Create or open today's daily note""" + OnyxCLI().daily_note(vault) + +@cli.command() +@click.option('--vault', help="Vault name (if not using default)") +def weekly(vault): + """Create or open this week's note""" + OnyxCLI().weekly_note(vault) + +@cli.command() +@click.option('--vault', help="Vault name (if not using default)") +def monthly(vault): + """Create or open this month's note""" + OnyxCLI().monthly_note(vault) + +@cli.command() +@click.option('--vault', help="Vault name (if not using default)") +def quarterly(vault): + """Create or open this quarter's note""" + OnyxCLI().quarterly_note(vault) + +@cli.command() +@click.option('--vault', help="Vault name (if not using default)") +def yearly(vault): + """Create or open this year's note""" + OnyxCLI().yearly_note(vault) + +@cli.command() +@click.argument('note_name') +@click.option('--content', default="", help="Content to write to the note") +@click.option('--vault', help="Vault name (if not using default)") +@click.option('--overwrite', is_flag=True, help="Overwrite existing note") +@click.option('--append', is_flag=True, help="Append to existing note") +@click.option('--open', 'open_after', is_flag=True, help="Open note after creation") +def create(note_name, content, vault, overwrite, append, open_after): + """Create a new note in the vault""" + OnyxCLI().create_note(note_name, content, vault, overwrite, append, open_after) + +@cli.command() +@click.argument('note_name') +@click.option('--vault', help="Vault name (if not using default)") +def print_note(note_name, vault): + """Print the contents of a note""" + OnyxCLI().print_note(note_name, vault) + +@cli.command() +@click.argument('current_path') +@click.argument('new_path') +@click.option('--vault', help="Vault name (if not using default)") +@click.option('--open', 'open_after', is_flag=True, help="Open note after moving") +def move(current_path, new_path, vault, open_after): + """Move/rename a note and update all internal links""" + OnyxCLI().move_note(current_path, new_path, vault, open_after) + +@cli.command() +@click.argument('note_path') +@click.option('--vault', help="Vault name (if not using default)") +def delete(note_path, vault): + """Delete a note""" + OnyxCLI().delete_note(note_path, vault) + +@cli.command(name='frontmatter') +@click.argument('note_name') +@click.option('--edit', is_flag=True, help="Edit frontmatter") +@click.option('--view', is_flag=True, help="View frontmatter") +@click.option('--clear', is_flag=True, help="Clear frontmatter values") +@click.option('--delete', is_flag=True, help="Delete frontmatter keys") +@click.option('--key', required=True, help="Frontmatter key to manage") +@click.option('--value', help="Value to set or check for") +@click.option('--vault', help="Vault name (if not using default)") +def frontmatter_command(note_name, edit, view, clear, delete, key, value, vault): + """Manage note frontmatter""" + cli = OnyxCLI() + if sum([edit, view, clear, delete]) != 1: + raise click.UsageError("Exactly one of --edit, --view, --clear, or --delete must be specified") + + if edit: + cli.frontmatter_edit(note_name, key, value, vault) + elif view: + cli.frontmatter_view(note_name, key, value, vault) + elif clear: + cli.frontmatter_clear(note_name, key, vault) + elif delete: + cli.frontmatter_delete(note_name, key, vault) + +if __name__ == '__main__': + cli() diff --git a/test_vault/2025-10-24.md b/test_vault/2025-10-24.md new file mode 100644 index 0000000..e69de29 diff --git a/tests/__pycache__/test_obsidian_cli.cpython-312-pytest-7.4.3.pyc b/tests/__pycache__/test_obsidian_cli.cpython-312-pytest-7.4.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..251a4140dee2e5eb36a04274b4497d34187dd50c GIT binary patch literal 11649 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