5 Commits
Author SHA1 Message Date
olivier 543ce76207 feat: v0.2.0 — key-only frontmatter edits, link-complete move, --no-open/--print-path
- frontmatter --edit/--clear/--delete splice only the targeted keys; values written
  as Obsidian stores them (plain or double-quoted, no \xE9 escapes, no folding)
- move rewrites [[name|alias]], [[name#heading]], embeds, path and frontmatter links,
  escapes names, refuses to overwrite, leaves ambiguous bare links alone
- periodic commands: --no-open, --print-path
- stdout/stderr are UTF-8 with LF on every OS
2026-10-19 11:42:25 -04:00
olivier d77fac61c8 fix: write notes and config as LF without BOM on every OS 2026-10-19 11:21:03 -04:00
olivier 466fef3c23 docs: add RELEASING.md with the full release/update checklist 2026-09-24 20:10:12 -04:00
olivier 6eb27b7cd6 docs: document Linux build and prebuilt binary installation 2026-09-24 17:25:57 -04:00
olivier 43c50a889d build: use forward-slash path in onyx.spec for cross-platform PyInstaller builds
Backslash path only resolved on Windows; needed a working spec to build
the Linux binary (verified via PyInstaller in WSL Ubuntu 24.04).
2026-09-24 17:24:30 -04:00
5 changed files with 566 additions and 160 deletions

No files matched your search

+42 -4
View File
@@ -2,16 +2,30 @@
A Python-based command-line interface for interacting with Obsidian vaults. Manage notes directly from the terminal without opening Obsidian. A Python-based command-line interface for interacting with Obsidian vaults. Manage notes directly from the terminal without opening Obsidian.
## Building the Windows Executable (.exe) ## Building a Standalone Executable
You can build a standalone Windows executable using PyInstaller: The same `onyx.spec` builds on both Windows and Linux — PyInstaller doesn't
cross-compile, so build natively on each platform:
```bash ```bash
pip install pyinstaller pip install pyinstaller
python -m PyInstaller onyx.spec python -m PyInstaller onyx.spec
``` ```
The resulting `onyx.exe` will be found in the `dist` folder. - Windows produces `dist/onyx.exe`
- Linux produces `dist/onyx` (no extension)
Prebuilt binaries for both platforms are also attached to each release:
https://gitea.mithrilforge.dev/olivier/onyx-cli/releases
### Installing the Linux binary
Drop the binary (built or downloaded) anywhere on your `PATH`:
```bash
chmod +x onyx
mv onyx ~/.local/bin/onyx # or /usr/local/bin/onyx (needs sudo)
```
## Installation ## Installation
@@ -94,8 +108,16 @@ onyx weekly --previous # opens last week's note
onyx monthly --next # opens next month's note onyx monthly --next # opens next month's note
onyx quarterly --next # opens next quarter's note onyx quarterly --next # opens next quarter's note
onyx yearly --previous # opens last year's note onyx yearly --previous # opens last year's note
# Scripts and agents: create if missing without opening Obsidian, print only the path
onyx daily --date "2025-11-27" --no-open --print-path
``` ```
Output is UTF-8 with LF line endings on every OS, so `p=$(onyx daily --print-path)` works in
bash on Windows too. With `--no-open`, a newly created note keeps the template's raw Templater
syntax (`<% … %>`) until Obsidian processes it; when Obsidian is running, Templater's "trigger on
new file creation" renders it within seconds.
**Default filename formats** (used when nothing else is configured): **Default filename formats** (used when nothing else is configured):
- Daily: `YYYY-MM-DD.md` - Daily: `YYYY-MM-DD.md`
- Weekly: `YYYY-WWW.md` (ISO week, e.g. `2025-W48.md`) - Weekly: `YYYY-WWW.md` (ISO week, e.g. `2025-W48.md`)
@@ -169,7 +191,8 @@ onyx print-note "note-name" --vault "vault-name"
### Moving & Deleting Notes ### Moving & Deleting Notes
```bash ```bash
# Move or rename a note (auto-updates internal links) # Move or rename a note; rewrites every wikilink that resolves to it:
# [[name]], [[name|alias]], [[name#heading]], ![[embeds]], [[folder/name]], frontmatter links
onyx move "old-path" "new-path" onyx move "old-path" "new-path"
# Move in specific vault # Move in specific vault
@@ -180,7 +203,14 @@ onyx move "old-path" "new-path" --open
# Delete a note # Delete a note
onyx delete "note-path" onyx delete "note-path"
```
`move` refuses to overwrite an existing note. A bare `[[name]]` link is only rewritten when that
name was unique in the vault (otherwise it is reported and left alone); the new link stays bare
unless the new name is shared by another note, in which case it becomes a path link. Markdown
`[text](path.md)` links are not rewritten.
```bash
# Delete from specific vault # Delete from specific vault
onyx delete "note-path" --vault "vault-name" onyx delete "note-path" --vault "vault-name"
``` ```
@@ -210,6 +240,12 @@ onyx frontmatter "note-name" --delete --key "tags"
onyx frontmatter "note-name" --delete --key "date,status,tags" onyx frontmatter "note-name" --delete --key "date,status,tags"
``` ```
Edits only touch the targeted keys: key order, quoting, accents and long values elsewhere in the
frontmatter stay byte-for-byte identical. Values are written the way Obsidian stores them: plain
when YAML reads them back unchanged (`done`, `2026-10-19`, `3`), double-quoted otherwise
(`"[[Haro]]"`). `tags` takes a comma-separated list, written as a block list. Cleared keys become
empty (`status:`), cleared tags `tags: []`.
### Version ### Version
```bash ```bash
@@ -236,6 +272,8 @@ onyx --version
## Development ## Development
See [RELEASING.md](RELEASING.md) for the full version-bump/build/tag/release checklist.
### Running Tests ### Running Tests
```bash ```bash
+177
View File
@@ -0,0 +1,177 @@
# Release procedure
Onyx ships as two standalone binaries (Windows `.exe`, Linux ELF) attached to a
Gitea release — no PyPI package, no installer. This document is the checklist
for cutting a new version.
## 1. Land the change
Implement, then verify:
```bash
python -m pytest tests/ -q
```
All tests must pass (skips are fine) before bumping anything.
## 2. Bump the version
The version string lives in exactly one place: the `@click.version_option`
decorator on the `cli` group in `src/onyx.py`.
```python
@click.version_option(version='X.Y.Z', prog_name='onyx')
```
Use semver: patch for fixes only, minor for new commands/flags, major for
breaking changes (removed/renamed commands, changed config schema).
## 3. Build both platform binaries
PyInstaller does **not** cross-compile — each binary must be built natively
on its target platform.
**Windows** (run directly on this machine):
```bash
rm -rf build dist
python -m PyInstaller onyx.spec
# -> dist/onyx.exe
```
**Linux** (via WSL, since this machine is Windows): build on WSL's native
ext4 filesystem, not `/mnt/c/...` — PyInstaller/venvs are unreliable over
the drvfs 9p mount.
```bash
wsl -d Ubuntu-24.04 -- bash -lc '
set -e
rm -rf ~/onyx-build && mkdir -p ~/onyx-build
cp -r "/mnt/c/Users/oli/Documents/o/Resources/repos/Onyx - obsidian cli tool/src" ~/onyx-build/
cp "/mnt/c/Users/oli/Documents/o/Resources/repos/Onyx - obsidian cli tool/onyx.spec" ~/onyx-build/
cp "/mnt/c/Users/oli/Documents/o/Resources/repos/Onyx - obsidian cli tool/requirements.txt" ~/onyx-build/
cd ~/onyx-build
python3 -m venv .venv
.venv/bin/pip install -q --upgrade pip
.venv/bin/pip install -q -r requirements.txt pyinstaller
rm -rf build dist
.venv/bin/pyinstaller onyx.spec
'
```
Copy the result out and rename it (Windows already produced `dist/onyx.exe`
in the same folder, and Linux's output has no extension — rename to avoid
any ambiguity):
```bash
wsl -d Ubuntu-24.04 -- bash -lc "cp /home/oli/onyx-build/dist/onyx '/mnt/c/Users/oli/Documents/o/Resources/repos/Onyx - obsidian cli tool/dist/onyx-linux'"
```
> Passing multi-line scripts to `wsl.exe` through a shell tool can mangle
> line endings (CRLF) and silently break variable assignments. If a WSL
> command behaves inexplicably (e.g. `command not found` for something
> that should be a variable), write the script to a file and run that file
> instead of an inline heredoc.
## 4. Verify both binaries
```bash
dist/onyx.exe --version # Windows, via cmd.exe (see gotcha below)
wsl -d Ubuntu-24.04 -- ~/onyx-build/dist/onyx --version
```
Confirm the printed version matches step 2. Smoke-test at least one command
end to end (e.g. `periodic --view`, `weekly --date 2025-11-27`) against a
scratch vault/config — never against the real `~/.onyx-cli/config.yaml`.
> **Windows gotcha**: the plain bash tool can't execute a freshly built
> `.exe` directly (`command not found`) — always invoke it through
> `cmd.exe /c "onyx.exe ..."`.
## 5. Deploy locally (optional)
Copy the Windows build to the installed location so `onyx` on this machine
picks up the new version immediately:
```bash
cp dist/onyx.exe "/c/Users/oli/Documents/o/Resources/app back up/bin/onyx.exe"
```
## 6. Commit, tag, push
```bash
git add -A
git commit -m "chore: bump to vX.Y.Z"
git fetch origin # someone may have committed via the Gitea web UI
git log --oneline origin/main -3
```
If `origin/main` has commits you don't have locally, **rebase, don't
merge** (this repo's history is linear):
```bash
git rebase origin/main
```
Then tag (annotated, with a real changelog since the last tag) and push:
```bash
git tag -a vX.Y.Z -m "vX.Y.Z
- ..."
git push origin main
git push origin vX.Y.Z
```
> If you rebased *after* creating the tag, the tag still points at the
> pre-rebase (now orphaned) commit. Delete and recreate it:
> `git tag -d vX.Y.Z && git tag -a vX.Y.Z -m "..."` before pushing.
## 7. Create the Gitea release
`tea` hangs indefinitely under a plain non-interactive shell call, for
*any* subcommand, including fully local ones. Always launch it as a
supervised process (hub `start`/`wait`/`logs`), never via the bash tool
directly.
Write release notes to a scratch file, then create the release with both
assets in one call:
```
tea releases create --repo olivier/onyx-cli --tag vX.Y.Z --title vX.Y.Z \
--note-file release-notes-vX.Y.Z.md -a dist/onyx.exe -a dist/onyx-linux
```
If the release already exists and you're adding a platform binary later
(e.g. the Linux build wasn't ready yet), attach it separately instead:
```
tea releases assets create --repo olivier/onyx-cli vX.Y.Z dist/<file>
```
Delete the scratch release-notes file afterward — it's not a repo
convention file.
> `tea repos create --owner olivier` fails with `GetOrgByName` — `--owner`
> targets an organization, not your personal account. Omit it entirely
> when creating a repo under your own user.
## 8. Verify the release
```bash
curl -s https://gitea.mithrilforge.dev/api/v1/repos/olivier/onyx-cli/releases/tags/vX.Y.Z \
| python -c "import json,sys; d=json.load(sys.stdin); [print(a['name'], a['size']) for a in d['assets']]"
```
Confirm both `onyx.exe` and `onyx-linux` are listed with nonzero, distinct
sizes.
## 9. Clean up
```bash
wsl -d Ubuntu-24.04 -- bash -lc "rm -rf ~/onyx-build"
rm -f release-notes-vX.Y.Z.md
```
`dist/` and `build/` are gitignored — the binaries never get committed,
only attached to the release.
+1 -1
View File
@@ -2,7 +2,7 @@
a = Analysis( a = Analysis(
['src\\onyx.py'], ['src/onyx.py'],
pathex=[], pathex=[],
binaries=[], binaries=[],
datas=[], datas=[],
+240 -153
View File
@@ -9,9 +9,87 @@ import datetime
import builtins import builtins
from pathlib import Path from pathlib import Path
import re import re
from collections import Counter
from typing import List, Union, Optional, Dict, Any from typing import List, Union, Optional, Dict, Any
from urllib.parse import quote from urllib.parse import quote
def _write_text(path: Path, text: str, mode: str = 'w') -> None:
"""Write UTF-8 without BOM and with LF line endings on every OS.
Python's text mode would otherwise translate '\\n' to os.linesep (CRLF on
Windows), and 'utf-8-sig' would prepend a BOM before the frontmatter.
Reads keep 'utf-8-sig' so files that already carry a BOM still parse.
"""
with path.open(mode, encoding='utf-8', newline='\n') as f:
f.write(text)
_FRONTMATTER = re.compile(r'\A---\n(.*?)^---[ \t]*(?:\n|\Z)', re.S | re.M)
_FRONTMATTER_KEY = re.compile(r'^([^\s#\-][^:]*?):(?:[ \t]|$)')
_WIKILINK = re.compile(r'\[\[([^\[\]|#]+?)(#[^\[\]|]*)?(\|[^\[\]]*)?\]\]')
def _yaml_scalar(value: str) -> str:
"""Render a CLI string as Obsidian stores it: plain when YAML reads it back
as-is (text, numbers, dates, booleans), double-quoted otherwise ([[links]],
': ', '#', leading/trailing spaces)."""
try:
parsed = yaml.safe_load(value)
except yaml.YAMLError:
parsed = None
plain = parsed == value or isinstance(parsed, (bool, int, float, datetime.date))
return value if plain and value == value.strip() else json.dumps(value, ensure_ascii=False)
def _frontmatter_entry(key: str, value: Union[str, list]) -> str:
if isinstance(value, list):
if not value:
return f"{key}: []\n"
return f"{key}:\n" + ''.join(f" - {_yaml_scalar(v)}\n" for v in value)
return f"{key}: {_yaml_scalar(value)}\n" if value else f"{key}:\n"
def _splice_frontmatter(content: str, updates: Dict[str, Union[str, list]], deletions=()) -> str:
"""Replace, add or remove top-level frontmatter keys, leaving every other
line of the note byte-for-byte untouched. A key's block is its line plus the
following indented or '- ' lines. Removing the last key drops the frontmatter."""
match = _FRONTMATTER.match(content)
fm, body = (match.group(1), content[match.end():]) if match else ('', content)
blocks: List[list] = [] # [key or None, raw text]
for line in fm.splitlines(keepends=True):
key_match = _FRONTMATTER_KEY.match(line)
if key_match or not blocks:
blocks.append([key_match.group(1).strip() if key_match else None, line])
else:
blocks[-1][1] += line
if not updates and not any(key in deletions for key, _ in blocks):
return content
out, seen = [], set()
for key, text in blocks:
if key in deletions:
continue
if key in updates:
out.append(_frontmatter_entry(key, updates[key]))
seen.add(key)
else:
out.append(text if text.endswith('\n') else text + '\n')
out.extend(_frontmatter_entry(k, v) for k, v in updates.items() if k not in seen)
new_fm = ''.join(out)
return f"---\n{new_fm}---\n{body}" if new_fm.strip() else body
def _iter_notes(vault_path: Path):
"""Markdown files in the vault, skipping dot folders (.obsidian, .trash, .git)."""
for path in vault_path.rglob('*.md'):
if not any(part.startswith('.') for part in path.relative_to(vault_path).parts[:-1]):
yield path
class OnyxCLI: class OnyxCLI:
_PERIODIC_DEFAULTS: Dict[str, Dict[str, str]] = { _PERIODIC_DEFAULTS: Dict[str, Dict[str, str]] = {
'daily': {'format': 'YYYY-MM-DD', 'folder': '', 'template': ''}, 'daily': {'format': 'YYYY-MM-DD', 'folder': '', 'template': ''},
@@ -37,7 +115,7 @@ class OnyxCLI:
def _ensure_config_exists(self): def _ensure_config_exists(self):
self.config_file.parent.mkdir(parents=True, exist_ok=True) self.config_file.parent.mkdir(parents=True, exist_ok=True)
if not self.config_file.exists(): if not self.config_file.exists():
self.config_file.write_text(yaml.dump({'default_vault': None, 'vaults': {}}), encoding='utf-8-sig') _write_text(self.config_file, yaml.dump({'default_vault': None, 'vaults': {}}))
def _load_default_vault(self): def _load_default_vault(self):
if self.config_file.exists(): if self.config_file.exists():
@@ -117,7 +195,7 @@ class OnyxCLI:
config['vaults'][vault_name] = vault_config config['vaults'][vault_name] = vault_config
# Write updated config # Write updated config
self.config_file.write_text(yaml.dump(config, default_flow_style=False), encoding='utf-8-sig') _write_text(self.config_file, yaml.dump(config, default_flow_style=False))
# Update instance variables # Update instance variables
self.default_vault = vault_name self.default_vault = vault_name
@@ -169,8 +247,9 @@ class OnyxCLI:
return None return None
def create_note(self, note_name: str, content: str = "", vault: str = None, def create_note(self, note_name: str, content: str = "", vault: str = None,
overwrite: bool = False, append: bool = False, open_after: bool = False, template: str = None): overwrite: bool = False, append: bool = False, open_after: bool = False, template: str = None,
quiet: bool = False):
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
note_path = vault_path / note_name note_path = vault_path / note_name
if not str(note_path).endswith('.md'): if not str(note_path).endswith('.md'):
@@ -209,12 +288,12 @@ class OnyxCLI:
else: else:
mode = 'w' mode = 'w'
with note_path.open(mode, encoding='utf-8-sig') as f: if mode == 'a':
if append and note_path.exists(): content = '\n' + content
f.write('\n') _write_text(note_path, content, mode)
f.write(content)
click.echo(f"Note {'updated' if note_path.exists() else 'created'}: {note_path}") if not quiet:
click.echo(f"Note {'updated' if note_path.exists() else 'created'}: {note_path}")
if open_after: if open_after:
self.open_note(note_name, vault_name) self.open_note(note_name, vault_name)
@@ -325,8 +404,13 @@ class OnyxCLI:
return result return result
def _create_or_open_periodic_note(self, note_type: str, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def _create_or_open_periodic_note(self, note_type: str, vault: str = None, date: str = None, next_: bool = False,
"""Generic method to create or open periodic notes with date navigation.""" previous: bool = False, open_after: bool = True, print_path: bool = False):
"""Generic method to create or open periodic notes with date navigation.
open_after=False creates the note (if missing) without opening Obsidian; Templater
syntax in the template then stays raw until Obsidian processes the new file.
print_path=True prints only the note's absolute path."""
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
settings = self._resolve_periodic_settings(vault_name, vault_path, note_type) settings = self._resolve_periodic_settings(vault_name, vault_path, note_type)
@@ -424,29 +508,37 @@ class OnyxCLI:
full_note_path = full_note_path.with_suffix('.md') full_note_path = full_note_path.with_suffix('.md')
if full_note_path.exists(): if full_note_path.exists():
self.open_note(note_path, vault_name) if open_after:
self.open_note(note_path, vault_name)
else: else:
self.create_note(note_path, content=content, vault=vault_name, open_after=True) self.create_note(note_path, content=content, vault=vault_name, open_after=open_after, quiet=print_path)
if print_path:
click.echo(str(full_note_path))
def daily_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def daily_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False,
open_after: bool = True, print_path: bool = False):
"""Create or open a daily note for a specific date, next, or previous day.""" """Create or open a daily note for a specific date, next, or previous day."""
self._create_or_open_periodic_note('daily', vault, date=date, next_=next_, previous=previous) self._create_or_open_periodic_note('daily', vault, date, next_, previous, open_after, print_path)
def weekly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def weekly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False,
open_after: bool = True, print_path: bool = False):
"""Create or open a weekly note for a specific date, next, or previous week.""" """Create or open a weekly note for a specific date, next, or previous week."""
self._create_or_open_periodic_note('weekly', vault, date=date, next_=next_, previous=previous) self._create_or_open_periodic_note('weekly', vault, date, next_, previous, open_after, print_path)
def monthly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def monthly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False,
open_after: bool = True, print_path: bool = False):
"""Create or open a monthly note for a specific date, next, or previous month.""" """Create or open a monthly note for a specific date, next, or previous month."""
self._create_or_open_periodic_note('monthly', vault, date=date, next_=next_, previous=previous) self._create_or_open_periodic_note('monthly', vault, date, next_, previous, open_after, print_path)
def quarterly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def quarterly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False,
open_after: bool = True, print_path: bool = False):
"""Create or open a quarterly note for a specific date, next, or previous quarter.""" """Create or open a quarterly note for a specific date, next, or previous quarter."""
self._create_or_open_periodic_note('quarterly', vault, date=date, next_=next_, previous=previous) self._create_or_open_periodic_note('quarterly', vault, date, next_, previous, open_after, print_path)
def yearly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False): def yearly_note(self, vault: str = None, date: str = None, next_: bool = False, previous: bool = False,
open_after: bool = True, print_path: bool = False):
"""Create or open a yearly note for a specific date, next, or previous year.""" """Create or open a yearly note for a specific date, next, or previous year."""
self._create_or_open_periodic_note('yearly', vault, date=date, next_=next_, previous=previous) self._create_or_open_periodic_note('yearly', vault, date, next_, previous, open_after, print_path)
def print_note(self, note_name: str, vault: str = None): def print_note(self, note_name: str, vault: str = None):
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
@@ -460,35 +552,77 @@ class OnyxCLI:
click.echo(note_path.read_text(encoding='utf-8-sig')) click.echo(note_path.read_text(encoding='utf-8-sig'))
def move_note(self, current_path: str, new_path: str, vault: str = None, open_after: bool = False): def move_note(self, current_path: str, new_path: str, vault: str = None, open_after: bool = False):
"""Move/rename a note and rewrite wikilinks that resolve to it.
Handles [[name]], [[name|alias]], [[name#heading]], ![[embeds]], path links
([[folder/name]], partial paths, optional .md), frontmatter links, and links in
the moved note itself. A bare-name link is only rewritten when the old name was
unique in the vault; the new link is bare unless the new name is ambiguous.
Markdown-style [text](path.md) links are not rewritten."""
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
current = vault_path / current_path current = vault_path / current_path
if not current.suffix: if not current.suffix:
current = current.with_suffix('.md') current = current.with_suffix('.md')
new = vault_path / new_path new = vault_path / new_path
if not new.suffix: if not new.suffix:
new = new.with_suffix('.md') new = new.with_suffix('.md')
if not current.exists(): if not current.exists():
raise click.UsageError(f"Note {current_path} does not exist") raise click.UsageError(f"Note {current_path} does not exist")
if new.exists() and not new.samefile(current):
raise click.UsageError(f"Note {new_path} already exists")
old_rel = current.relative_to(vault_path).with_suffix('').as_posix()
new_rel = new.relative_to(vault_path).with_suffix('').as_posix()
new.parent.mkdir(parents=True, exist_ok=True) new.parent.mkdir(parents=True, exist_ok=True)
current.rename(new) 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(encoding='utf-8-sig')
updated_content = re.sub(old_link_pattern, new_link, content)
if updated_content != content:
md_file.write_text(updated_content, encoding='utf-8-sig')
click.echo(f"Moved {current_path} to {new_path}") notes = list(_iter_notes(vault_path))
stems = Counter(p.stem.casefold() for p in notes)
old_stem, new_stem = current.stem.casefold(), new.stem.casefold()
stem_changed = old_stem != new_stem
old_bare_unique = stems[old_stem] == (0 if stem_changed else 1)
new_target_bare = new.stem if stems[new_stem] == 1 else new_rel
old_rel_cf = old_rel.casefold()
links = ambiguous = 0
def rewrite(match: re.Match) -> str:
nonlocal links, ambiguous
target = match.group(1).strip().replace('\\', '/')
has_md = target.lower().endswith('.md')
key = (target[:-3] if has_md else target).casefold()
if '/' in key:
if key.lstrip('/') != old_rel_cf and not old_rel_cf.endswith('/' + key):
return match.group(0)
replacement = new_rel
else:
if key != old_stem:
return match.group(0)
if not old_bare_unique:
ambiguous += stem_changed
return match.group(0)
replacement = new_target_bare
replacement += '.md' if has_md else ''
if replacement == target:
return match.group(0)
links += 1
return f"[[{replacement}{match.group(2) or ''}{match.group(3) or ''}]]"
files = 0
for md_file in notes:
content = md_file.read_text(encoding='utf-8-sig')
updated = _WIKILINK.sub(rewrite, content)
if updated != content:
_write_text(md_file, updated)
files += 1
click.echo(f"Moved {current_path} to {new_path} ({links} link(s) updated in {files} note(s))")
if ambiguous:
click.echo(f"Warning: {ambiguous} [[{current.stem}]] link(s) left unchanged: "
f"several notes are named '{current.stem}'")
if open_after: if open_after:
self.open_note(new_path, vault_name) self.open_note(new_path, vault_name)
@@ -507,81 +641,67 @@ class OnyxCLI:
def _parse_frontmatter(self, content: str) -> tuple[dict, str, int]: def _parse_frontmatter(self, content: str) -> tuple[dict, str, int]:
if not content.startswith('---\n'): if not content.startswith('---\n'):
return {}, content, 0 return {}, content, 0
parts = content.split('---\n', 2) parts = content.split('---\n', 2)
if len(parts) < 3: if len(parts) < 3:
return {}, content, 0 return {}, content, 0
try: try:
frontmatter = yaml.safe_load(parts[1]) or {} frontmatter = yaml.safe_load(parts[1]) or {}
return frontmatter, parts[2], len(parts[0]) + len(parts[1]) + 6 return frontmatter, parts[2], len(parts[0]) + len(parts[1]) + 6
except yaml.YAMLError: except yaml.YAMLError:
return {}, content, 0 return {}, content, 0
def _update_frontmatter(self, note_path: Path, updates: dict): def _find_note(self, vault_path: Path, note_name: str) -> Path:
content = note_path.read_text(encoding='utf-8-sig') """Exact vault-relative path first, then the first note with that name anywhere."""
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, encoding='utf-8-sig')
def frontmatter_edit(self, note_name: str, keys: tuple, values: tuple = None, vault: str = None):
vault_name, vault_path = self._get_vault_and_path(vault)
note_path = vault_path / note_name note_path = vault_path / note_name
if not note_path.suffix: if not note_path.suffix:
note_path = note_path.with_suffix('.md') note_path = note_path.with_suffix('.md')
if not note_path.exists(): if not note_path.exists():
matches = list(vault_path.rglob(f"{note_name}.md")) matches = list(vault_path.rglob(f"{note_name}.md"))
if matches: if matches:
note_path = matches[0] note_path = matches[0]
if not note_path.exists(): if not note_path.exists():
raise click.UsageError(f"Note {note_name} does not exist") raise click.UsageError(f"Note {note_name} does not exist")
return note_path
@staticmethod
def _split_keys(keys: tuple) -> List[str]:
"""--key values, also accepting comma/bracket-separated keys (legacy)."""
return [k.strip() for key in keys for k in re.split(r',|\[|\]', key) if k.strip()]
def _rewrite_frontmatter(self, note_path: Path, updates: dict, deletions=()) -> bool:
content = note_path.read_text(encoding='utf-8-sig')
new_content = _splice_frontmatter(content, updates, deletions)
if new_content == content:
return False
_write_text(note_path, new_content)
return True
def frontmatter_edit(self, note_name: str, keys: tuple, values: tuple = None, vault: str = None):
vault_name, vault_path = self._get_vault_and_path(vault)
note_path = self._find_note(vault_path, note_name)
updates = {} updates = {}
# If we have one value and multiple keys, apply value to all keys # If we have one value and multiple keys, apply value to all keys
if values and len(values) == 1 and len(keys) > 1: if values and len(values) == 1 and len(keys) > 1:
values = values * len(keys) values = values * len(keys)
for i, key in enumerate(keys): for i, key in enumerate(keys):
# Handle comma-separated keys in a single string (legacy support)
sub_keys = [k.strip() for k in re.split(r',|\[|\]', key) if k.strip()]
value = values[i] if values and i < len(values) else None value = values[i] if values and i < len(values) else None
for k in self._split_keys((key,)):
for k in sub_keys:
if k == 'tags': if k == 'tags':
if value: updates[k] = [t.strip() for t in value.split(',') if t.strip()] if value else []
updates[k] = [t.strip() for t in value.split(',')] if ',' in value else [value.strip()]
else:
updates[k] = []
else: else:
updates[k] = value if value is not None else "" updates[k] = value if value is not None else ""
self._update_frontmatter(note_path, updates) self._rewrite_frontmatter(note_path, updates)
click.echo(f"Updated frontmatter for {note_name}") click.echo(f"Updated frontmatter for {note_name}")
def frontmatter_view(self, note_name: str, keys: tuple, value: str = None, vault: str = None, open_file: bool = False, output_path: Union[bool, str, None] = None): def frontmatter_view(self, note_name: str, keys: tuple, value: str = None, vault: str = None, open_file: bool = False, output_path: Union[bool, str, None] = None):
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
note_path = vault_path / note_name note_path = self._find_note(vault_path, note_name)
if not note_path.suffix:
note_path = note_path.with_suffix('.md')
if not note_path.exists():
matches = list(vault_path.rglob(f"{note_name}.md"))
if matches:
note_path = matches[0]
if not note_path.exists():
raise click.UsageError(f"Note {note_name} does not exist")
content = note_path.read_text(encoding='utf-8-sig') content = note_path.read_text(encoding='utf-8-sig')
frontmatter, _, _ = self._parse_frontmatter(content) frontmatter, _, _ = self._parse_frontmatter(content)
@@ -630,7 +750,7 @@ class OnyxCLI:
click.echo(val) click.echo(val)
else: else:
click.echo(yaml.dump({k: frontmatter[k]}, default_flow_style=False).strip()) click.echo(yaml.dump({k: frontmatter[k]}, default_flow_style=False, allow_unicode=True).strip())
def _handle_open_file(self, current_value, vault): def _handle_open_file(self, current_value, vault):
val_str = str(current_value) val_str = str(current_value)
@@ -650,68 +770,15 @@ class OnyxCLI:
def frontmatter_clear(self, note_name: str, keys: tuple, vault: str = None): def frontmatter_clear(self, note_name: str, keys: tuple, vault: str = None):
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
note_path = vault_path / note_name note_path = self._find_note(vault_path, note_name)
if not note_path.suffix: updates = {k: [] if k == 'tags' else "" for k in self._split_keys(keys)}
note_path = note_path.with_suffix('.md') self._rewrite_frontmatter(note_path, updates)
if not note_path.exists():
matches = list(vault_path.rglob(f"{note_name}.md"))
if matches:
note_path = matches[0]
if not note_path.exists():
raise click.UsageError(f"Note {note_name} does not exist")
all_keys = []
for key in keys:
all_keys.extend([k.strip() for k in re.split(r',|\[|\]', key) if k.strip()])
updates = {}
for k in all_keys:
updates[k] = [] if k == 'tags' else ""
self._update_frontmatter(note_path, updates)
click.echo(f"Cleared frontmatter values for {note_name}") click.echo(f"Cleared frontmatter values for {note_name}")
def frontmatter_delete(self, note_name: str, keys: tuple, vault: str = None): def frontmatter_delete(self, note_name: str, keys: tuple, vault: str = None):
vault_name, vault_path = self._get_vault_and_path(vault) vault_name, vault_path = self._get_vault_and_path(vault)
note_path = vault_path / note_name note_path = self._find_note(vault_path, note_name)
if not note_path.suffix: if self._rewrite_frontmatter(note_path, {}, set(self._split_keys(keys))):
note_path = note_path.with_suffix('.md')
if not note_path.exists():
matches = list(vault_path.rglob(f"{note_name}.md"))
if matches:
note_path = matches[0]
if not note_path.exists():
raise click.UsageError(f"Note {note_name} does not exist")
content = note_path.read_text(encoding='utf-8-sig')
frontmatter, rest_content, _ = self._parse_frontmatter(content)
all_keys = []
for key in keys:
all_keys.extend([k.strip() for k in re.split(r',|\[|\]', key) if k.strip()])
modified = False
for k in all_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, encoding='utf-8-sig')
click.echo(f"Deleted frontmatter keys from {note_name}") click.echo(f"Deleted frontmatter keys from {note_name}")
else: else:
click.echo("No matching keys found in frontmatter") click.echo("No matching keys found in frontmatter")
@@ -837,7 +904,7 @@ class OnyxCLI:
vaults[vault_name] = vault_entry vaults[vault_name] = vault_entry
config['vaults'] = vaults config['vaults'] = vaults
self.config_file.write_text(yaml.dump(config, default_flow_style=False), encoding='utf-8-sig') _write_text(self.config_file, yaml.dump(config, default_flow_style=False))
click.echo(f"Updated {note_type} note settings for vault '{vault_name}'") click.echo(f"Updated {note_type} note settings for vault '{vault_name}'")
def print_periodic_config(self, note_type: str, vault: str = None): def print_periodic_config(self, note_type: str, vault: str = None):
@@ -851,7 +918,15 @@ class OnyxCLI:
# CLI Commands # CLI Commands
@click.version_option(version='0.1.0', prog_name='onyx') def _periodic_output_options(command):
"""--no-open / --print-path, shared by the periodic note commands."""
command = click.option('--print-path', is_flag=True,
help="Print only the note's absolute path (for scripts)")(command)
return click.option('--no-open', is_flag=True,
help="Don't open Obsidian; a newly created note keeps raw Templater syntax "
"until Obsidian processes it")(command)
@click.version_option(version='0.2.0', prog_name='onyx')
@click.group(name='onyx') @click.group(name='onyx')
def cli(): def cli():
"""Onyx - Interact with Obsidian vaults from the command line """Onyx - Interact with Obsidian vaults from the command line
@@ -908,57 +983,62 @@ def open(note_name, vault):
@click.option('--date', help="Target date (YYYY-MM-DD) for the note") @click.option('--date', help="Target date (YYYY-MM-DD) for the note")
@click.option('--next', 'next_', is_flag=True, help="Open the next period's note") @click.option('--next', 'next_', is_flag=True, help="Open the next period's note")
@click.option('--previous', is_flag=True, help="Open the previous period's note") @click.option('--previous', is_flag=True, help="Open the previous period's note")
def daily(vault, date, next_, previous): @_periodic_output_options
def daily(vault, date, next_, previous, no_open, print_path):
"""Create or open a daily note for a specific date, next, or previous day """Create or open a daily note for a specific date, next, or previous day
Folder, filename format, and template are resolved from onyx's own config Folder, filename format, and template are resolved from onyx's own config
(see `onyx periodic --type daily`), falling back to Obsidian's Daily Notes (see `onyx periodic --type daily`), falling back to Obsidian's Daily Notes
or Periodic Notes plugin settings, then to built-in defaults.""" or Periodic Notes plugin settings, then to built-in defaults."""
OnyxCLI().daily_note(vault, date=date, next_=next_, previous=previous) OnyxCLI().daily_note(vault, date, next_, previous, not no_open, print_path)
@cli.command() @cli.command()
@click.option('--vault', help="Vault name (if not using default)") @click.option('--vault', help="Vault name (if not using default)")
@click.option('--date', help="Target date (YYYY-MM-DD) for the note") @click.option('--date', help="Target date (YYYY-MM-DD) for the note")
@click.option('--next', 'next_', is_flag=True, help="Open the next period's note") @click.option('--next', 'next_', is_flag=True, help="Open the next period's note")
@click.option('--previous', is_flag=True, help="Open the previous period's note") @click.option('--previous', is_flag=True, help="Open the previous period's note")
def weekly(vault, date, next_, previous): @_periodic_output_options
def weekly(vault, date, next_, previous, no_open, print_path):
"""Create or open a weekly note for a specific date, next, or previous week """Create or open a weekly note for a specific date, next, or previous week
Folder, filename format, and template are configurable via `onyx periodic --type weekly`.""" Folder, filename format, and template are configurable via `onyx periodic --type weekly`."""
OnyxCLI().weekly_note(vault, date=date, next_=next_, previous=previous) OnyxCLI().weekly_note(vault, date, next_, previous, not no_open, print_path)
@cli.command() @cli.command()
@click.option('--vault', help="Vault name (if not using default)") @click.option('--vault', help="Vault name (if not using default)")
@click.option('--date', help="Target date (YYYY-MM-DD) for the note") @click.option('--date', help="Target date (YYYY-MM-DD) for the note")
@click.option('--next', 'next_', is_flag=True, help="Open the next period's note") @click.option('--next', 'next_', is_flag=True, help="Open the next period's note")
@click.option('--previous', is_flag=True, help="Open the previous period's note") @click.option('--previous', is_flag=True, help="Open the previous period's note")
def monthly(vault, date, next_, previous): @_periodic_output_options
def monthly(vault, date, next_, previous, no_open, print_path):
"""Create or open a monthly note for a specific date, next, or previous month """Create or open a monthly note for a specific date, next, or previous month
Folder, filename format, and template are configurable via `onyx periodic --type monthly`.""" Folder, filename format, and template are configurable via `onyx periodic --type monthly`."""
OnyxCLI().monthly_note(vault, date=date, next_=next_, previous=previous) OnyxCLI().monthly_note(vault, date, next_, previous, not no_open, print_path)
@cli.command() @cli.command()
@click.option('--vault', help="Vault name (if not using default)") @click.option('--vault', help="Vault name (if not using default)")
@click.option('--date', help="Target date (YYYY-MM-DD) for the note") @click.option('--date', help="Target date (YYYY-MM-DD) for the note")
@click.option('--next', 'next_', is_flag=True, help="Open the next period's note") @click.option('--next', 'next_', is_flag=True, help="Open the next period's note")
@click.option('--previous', is_flag=True, help="Open the previous period's note") @click.option('--previous', is_flag=True, help="Open the previous period's note")
def quarterly(vault, date, next_, previous): @_periodic_output_options
def quarterly(vault, date, next_, previous, no_open, print_path):
"""Create or open a quarterly note for a specific date, next, or previous quarter """Create or open a quarterly note for a specific date, next, or previous quarter
Folder, filename format, and template are configurable via `onyx periodic --type quarterly`.""" Folder, filename format, and template are configurable via `onyx periodic --type quarterly`."""
OnyxCLI().quarterly_note(vault, date=date, next_=next_, previous=previous) OnyxCLI().quarterly_note(vault, date, next_, previous, not no_open, print_path)
@cli.command() @cli.command()
@click.option('--vault', help="Vault name (if not using default)") @click.option('--vault', help="Vault name (if not using default)")
@click.option('--date', help="Target date (YYYY-MM-DD) for the note") @click.option('--date', help="Target date (YYYY-MM-DD) for the note")
@click.option('--next', 'next_', is_flag=True, help="Open the next period's note") @click.option('--next', 'next_', is_flag=True, help="Open the next period's note")
@click.option('--previous', is_flag=True, help="Open the previous period's note") @click.option('--previous', is_flag=True, help="Open the previous period's note")
def yearly(vault, date, next_, previous): @_periodic_output_options
def yearly(vault, date, next_, previous, no_open, print_path):
"""Create or open a yearly note for a specific date, next, or previous year """Create or open a yearly note for a specific date, next, or previous year
Folder, filename format, and template are configurable via `onyx periodic --type yearly`.""" Folder, filename format, and template are configurable via `onyx periodic --type yearly`."""
OnyxCLI().yearly_note(vault, date=date, next_=next_, previous=previous) OnyxCLI().yearly_note(vault, date, next_, previous, not no_open, print_path)
@cli.command() @cli.command()
@click.option('--type', 'note_type', required=True, @click.option('--type', 'note_type', required=True,
@@ -1029,7 +1109,9 @@ def print_note(note_name, vault):
def move(current_path, new_path, vault, open_after): def move(current_path, new_path, vault, open_after):
"""Move or rename a note and auto-update internal links """Move or rename a note and auto-update internal links
Automatically updates all [[links]] pointing to this note in other vault files. Rewrites wikilinks that resolve to this note anywhere in the vault: [[name]],
[[name|alias]], [[name#heading]], embeds, path links and frontmatter links.
Refuses to overwrite an existing note.
USAGE: USAGE:
onyx move "old-name" "new-name" onyx move "old-name" "new-name"
@@ -1087,4 +1169,9 @@ def frontmatter_command(note_name, edit, view, clear, delete, key, value, open_f
cli.frontmatter_delete(note_name, key, vault) cli.frontmatter_delete(note_name, key, vault)
if __name__ == '__main__': if __name__ == '__main__':
# Scripts read onyx's output (e.g. `--print-path`): emit UTF-8 with LF on every OS.
# Without this, Windows pipes get the ANSI code page (é -> 0xE9; PyInstaller ignores
# PYTHONUTF8) and CRLF, whose trailing \r survives bash's $(...).
for stream in (sys.stdout, sys.stderr):
stream.reconfigure(encoding='utf-8', newline='\n')
cli() cli()
+106 -2
View File
@@ -51,6 +51,20 @@ class TestOnyxCLI(unittest.TestCase):
note_path = self.test_dir / 'test.md' note_path = self.test_dir / 'test.md'
self.assertTrue(note_path.exists()) self.assertTrue(note_path.exists())
def test_writes_keep_lf_without_bom(self):
"""Append and frontmatter edits write LF, no BOM, even on Windows"""
note_path = self.test_dir / 'lf.md'
note_path.write_bytes(b'---\nstatus: draft\n---\n# Journal\n')
self.cli.create_note('lf.md', '### 10:00 - Entry\nline', append=True)
self.cli.frontmatter_edit('lf', ('status',), ('done',))
data = note_path.read_bytes()
self.assertNotIn(b'\r', data)
self.assertFalse(data.startswith(b'\xef\xbb\xbf'))
self.assertIn(b'status: done', data)
self.assertTrue(data.endswith(b'# Journal\n\n### 10:00 - Entry\nline'))
@unittest.skip("Method export_to_csv not implemented") @unittest.skip("Method export_to_csv not implemented")
def test_export_to_csv(self): def test_export_to_csv(self):
"""Test exporting note frontmatter to CSV""" """Test exporting note frontmatter to CSV"""
@@ -172,8 +186,8 @@ Test content"""
self.cli.frontmatter_clear(test_note, ('status,title',)) self.cli.frontmatter_clear(test_note, ('status,title',))
content = (self.test_dir / test_note).read_text(encoding='utf-8-sig') content = (self.test_dir / test_note).read_text(encoding='utf-8-sig')
frontmatter = yaml.safe_load(content.split('---')[1]) frontmatter = yaml.safe_load(content.split('---')[1])
self.assertEqual(frontmatter['status'], '') self.assertIsNone(frontmatter['status'])
self.assertEqual(frontmatter['title'], '') self.assertIsNone(frontmatter['title'])
# Test frontmatter --delete # Test frontmatter --delete
self.cli.frontmatter_delete(test_note, ('tags',)) self.cli.frontmatter_delete(test_note, ('tags',))
@@ -204,6 +218,96 @@ Test content"""
link_content = (self.test_dir / 'link.md').read_text(encoding='utf-8-sig') link_content = (self.test_dir / 'link.md').read_text(encoding='utf-8-sig')
self.assertIn('[[dest]]', link_content) self.assertIn('[[dest]]', link_content)
def test_frontmatter_edit_only_touches_target_keys(self):
"""Editing keys keeps order, quoting, accents and long lines of the rest"""
note = self.test_dir / 'meeting.md'
note.write_text(
'---\n'
'client: "[[Symbolitech]]"\n'
'participants:\n'
' - "[[Stéphane Charbonneau|Stéphane]]"\n'
'type: meeting\n'
'summary: "Une longue phrase de résumé qui dépasse largement quatre-vingts caractères sans être repliée."\n'
'date: 2026-10-19\n'
'---\n'
'# Réunion\n', encoding='utf-8')
self.cli.frontmatter_edit('meeting', ('type', 'status', 'parent', 'reviewed'),
('réunion', 'done', '[[Haro]]', '2026-10-20'))
self.cli.frontmatter_delete('meeting', ('client',))
self.assertEqual(note.read_text(encoding='utf-8'),
'---\n'
'participants:\n'
' - "[[Stéphane Charbonneau|Stéphane]]"\n'
'type: réunion\n'
'summary: "Une longue phrase de résumé qui dépasse largement quatre-vingts caractères sans être repliée."\n'
'date: 2026-10-19\n'
'status: done\n'
'parent: "[[Haro]]"\n'
'reviewed: 2026-10-20\n'
'---\n'
'# Réunion\n')
def test_frontmatter_edit_adds_frontmatter_to_plain_note(self):
note = self.test_dir / 'plain.md'
note.write_text('Corps\n---\nPas un frontmatter\n', encoding='utf-8')
self.cli.frontmatter_edit('plain', ('tags',), ('a, b',))
self.assertEqual(note.read_text(encoding='utf-8'),
'---\ntags:\n - a\n - b\n---\nCorps\n---\nPas un frontmatter\n')
def test_move_rewrites_every_link_form(self):
"""Aliases, headings, embeds, path links, frontmatter links, regex characters"""
(self.test_dir / 'films').mkdir()
(self.test_dir / 'films' / 'Dune (film).md').write_text('Self: [[Dune (film)#Notes]]\n', encoding='utf-8')
linker = self.test_dir / 'index.md'
linker.write_text(
'---\nrelated: "[[Dune (film)|Dune]]"\n---\n'
'[[Dune (film)]] [[dune (film)#Cast|vu]] ![[Dune (film)#^b1]] '
'[[films/Dune (film).md]] [[Dune]] [[Other (film)]]\n', encoding='utf-8')
with patch('click.echo') as echo:
self.cli.move_note('films/Dune (film)', 'archives/Dune 2021')
echo.assert_any_call('Moved films/Dune (film) to archives/Dune 2021 (6 link(s) updated in 2 note(s))')
self.assertEqual(linker.read_text(encoding='utf-8'),
'---\nrelated: "[[Dune 2021|Dune]]"\n---\n'
'[[Dune 2021]] [[Dune 2021#Cast|vu]] ![[Dune 2021#^b1]] '
'[[archives/Dune 2021.md]] [[Dune]] [[Other (film)]]\n')
self.assertEqual((self.test_dir / 'archives' / 'Dune 2021.md').read_text(encoding='utf-8'),
'Self: [[Dune 2021#Notes]]\n')
def test_move_ambiguous_names(self):
"""Bare links to a non-unique old name stay; a non-unique new name gets a path link"""
for rel in ('a/Note.md', 'b/Note.md', 'c/Target.md', 'd/Old.md'):
(self.test_dir / rel).parent.mkdir(exist_ok=True)
(self.test_dir / rel).write_text('', encoding='utf-8')
linker = self.test_dir / 'links.md'
linker.write_text('[[Note]] [[a/Note]] [[Old]]\n', encoding='utf-8')
self.cli.move_note('a/Note', 'e/Renamed')
self.cli.move_note('d/Old', 'f/Target')
self.assertEqual(linker.read_text(encoding='utf-8'), '[[Note]] [[e/Renamed]] [[f/Target]]\n')
def test_move_refuses_to_overwrite(self):
self.cli.create_note('one.md', '1')
self.cli.create_note('two.md', '2')
with self.assertRaises(click.UsageError):
self.cli.move_note('one', 'two')
self.assertEqual((self.test_dir / 'two.md').read_text(encoding='utf-8'), '2')
self.assertTrue((self.test_dir / 'one.md').exists())
def test_periodic_no_open_print_path(self):
"""--no-open creates without opening Obsidian; --print-path prints only the path"""
expected = self.test_dir.resolve() / '2025-10-24.md'
with patch.object(OnyxCLI, 'open_note') as open_note, patch('click.echo') as echo:
self.cli.daily_note(date='2025-10-24', open_after=False, print_path=True)
self.cli.daily_note(date='2025-10-24', open_after=False, print_path=True)
open_note.assert_not_called()
self.assertEqual([c.args for c in echo.call_args_list], [(str(expected),), (str(expected),)])
self.assertTrue(expected.exists())
def test_daily_note(self): def test_daily_note(self):
"""Test daily note creation""" """Test daily note creation"""
# Mock datetime.now() to return a specific date # Mock datetime.now() to return a specific date