odcli 0.1.6__tar.gz → 0.1.7__tar.gz

{odcli-0.1.6 → odcli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odcli
-Version: 0.1.6
+Version: 0.1.7
 Summary: A small CLI for reading and writing notes in a local Obsidian vault.
 Author: odcli contributors
 Keywords: obsidian,cli,markdown,notes,vault
@@ -65,6 +65,47 @@ You can also override the vault per command:
 odcli --vault "/path/to/MyVault" list
 ```
 
+## Remote Vault over SSH
+
+You can operate on an Obsidian vault stored on another machine over SSH.
+
+Example:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  list
+```
+
+Read a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  read Inbox/today.md
+```
+
+Write a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  write Inbox/today.md --content "# Remote note"
+```
+
+Optional SSH flags:
+
+- `--ssh-port`
+- `--ssh-identity`
+
+In SSH mode, `--vault` or `OBSIDIAN_VAULT` should point to the remote vault path.
+
 ## Common Commands
 
 Read a note:
@@ -224,6 +265,14 @@ Arguments:
 - `query`
 - `--case-sensitive`
 
+## Global Options
+
+- `--vault`
+- `--ssh-host`
+- `--ssh-user`
+- `--ssh-port`
+- `--ssh-identity`
+
 ## For Developers
 
 Run from source:

{odcli-0.1.6 → odcli-0.1.7}/README.md

@@ -47,6 +47,47 @@ You can also override the vault per command:
 odcli --vault "/path/to/MyVault" list
 ```
 
+## Remote Vault over SSH
+
+You can operate on an Obsidian vault stored on another machine over SSH.
+
+Example:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  list
+```
+
+Read a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  read Inbox/today.md
+```
+
+Write a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  write Inbox/today.md --content "# Remote note"
+```
+
+Optional SSH flags:
+
+- `--ssh-port`
+- `--ssh-identity`
+
+In SSH mode, `--vault` or `OBSIDIAN_VAULT` should point to the remote vault path.
+
 ## Common Commands
 
 Read a note:
@@ -206,6 +247,14 @@ Arguments:
 - `query`
 - `--case-sensitive`
 
+## Global Options
+
+- `--vault`
+- `--ssh-host`
+- `--ssh-user`
+- `--ssh-port`
+- `--ssh-identity`
+
 ## For Developers
 
 Run from source:

{odcli-0.1.6 → odcli-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "odcli"
-version = "0.1.6"
+version = "0.1.7"
 description = "A small CLI for reading and writing notes in a local Obsidian vault."
 readme = "README.md"
 requires-python = ">=3.11"

{odcli-0.1.6 → odcli-0.1.7}/src/obsidian_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"

{odcli-0.1.6 → odcli-0.1.7}/src/obsidian_cli/cli.py

@@ -6,7 +6,13 @@ import sys
 from obsidian_cli.commands import CommandRunner
 from obsidian_cli.discovery import VaultLocator
 from obsidian_cli.plugins import SkillInstaller
-from obsidian_cli.vault import ObsidianVault, VaultError
+from obsidian_cli.vault import (
+    ObsidianVault,
+    SshConfig,
+    SshObsidianVault,
+    VaultBackend,
+    VaultError,
+)
 
 
 class ObsidianCLI:
@@ -22,9 +28,7 @@ class ObsidianCLI:
             if args.command == "plugin":
                 return self._run_plugin_command(args)
 
-            runner = CommandRunner(
-                ObsidianVault(self._vault_locator.resolve(args.vault))
-            )
+            runner = CommandRunner(self._build_vault(args))
 
             if args.command == "check":
                 return runner.check()
@@ -72,6 +76,13 @@ class ObsidianCLI:
             "--vault",
             help="Path to the Obsidian vault. Falls back to OBSIDIAN_VAULT.",
         )
+        parser.add_argument("--ssh-host", help="SSH host for a remote vault.")
+        parser.add_argument("--ssh-user", help="SSH username for a remote vault.")
+        parser.add_argument("--ssh-port", type=int, help="SSH port for a remote vault.")
+        parser.add_argument(
+            "--ssh-identity",
+            help="SSH identity file used when connecting to a remote vault.",
+        )
 
         subparsers = parser.add_subparsers(dest="command", required=True)
         subparsers.add_parser("check", help="Validate the vault path.")
@@ -175,6 +186,20 @@ class ObsidianCLI:
         self._parser.error(f"unsupported plugin command: {args.plugin_command}")
         return 2
 
+    def _build_vault(self, args: argparse.Namespace) -> VaultBackend:
+        if args.ssh_host:
+            ssh_root = self._vault_locator.resolve_configured(args.vault)
+            return SshObsidianVault(
+                str(ssh_root),
+                SshConfig(
+                    host=args.ssh_host,
+                    user=args.ssh_user,
+                    port=args.ssh_port,
+                    identity_file=args.ssh_identity,
+                ),
+            )
+        return ObsidianVault(self._vault_locator.resolve(args.vault))
+
     @staticmethod
     def _read_content_arg(content: str | None, use_stdin: bool) -> str:
         if content is not None and use_stdin:

{odcli-0.1.6 → odcli-0.1.7}/src/obsidian_cli/commands.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from obsidian_cli.vault import ObsidianVault, VaultError
+from obsidian_cli.vault import VaultBackend, VaultError
 
 
 class CommandRunner:
-    def __init__(self, vault: ObsidianVault) -> None:
+    def __init__(self, vault: VaultBackend) -> None:
         self._vault = vault
 
     def check(self) -> int:

{odcli-0.1.6 → odcli-0.1.7}/src/obsidian_cli/discovery.py

@@ -18,7 +18,7 @@ class VaultLocator:
     def __init__(
         self, env: dict[str, str] | None = None, home: Path | None = None
     ) -> None:
-        self._env = dict(env or os.environ)
+        self._env = dict(os.environ if env is None else env)
         self._home = (home or Path.home()).expanduser()
 
     def resolve(self, cli_value: str | None) -> Path:
@@ -38,6 +38,19 @@ class VaultLocator:
             "vault path is required; use --vault, OBSIDIAN_VAULT, or place your vault in a default Obsidian location"
         )
 
+    def resolve_configured(self, cli_value: str | None) -> Path:
+        cli_path = self._path_from_string(cli_value)
+        if cli_path is not None:
+            return cli_path
+
+        env_path = self._path_from_string(self._env.get("OBSIDIAN_VAULT"))
+        if env_path is not None:
+            return env_path
+
+        raise VaultError(
+            "vault path is required for SSH mode; use --vault or OBSIDIAN_VAULT"
+        )
+
     def discover_default_vault(self) -> VaultCandidate | None:
         config_candidate = self._discover_from_obsidian_config()
         if config_candidate is not None:

odcli-0.1.7/src/obsidian_cli/vault.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import shlex
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Callable
+
+
+class VaultError(Exception):
+    """Raised when the vault cannot fulfill a requested operation."""
+
+
+@dataclass(slots=True)
+class SearchMatch:
+    note_path: str
+    line_number: int
+    line_text: str
+
+
+@dataclass(frozen=True, slots=True)
+class SshConfig:
+    host: str
+    user: str | None = None
+    port: int | None = None
+    identity_file: str | None = None
+
+    @property
+    def destination(self) -> str:
+        return f"{self.user}@{self.host}" if self.user else self.host
+
+
+class VaultBackend:
+    root: Path | str
+
+    def exists(self) -> bool:
+        raise NotImplementedError
+
+    def is_obsidian_vault(self) -> bool:
+        raise NotImplementedError
+
+    def list_notes(self) -> list[str]:
+        raise NotImplementedError
+
+    def read_note(self, note_path: str) -> str:
+        raise NotImplementedError
+
+    def write_note(
+        self, note_path: str, content: str, create_only: bool = False
+    ) -> Path | str:
+        raise NotImplementedError
+
+    def append_note(self, note_path: str, content: str) -> Path | str:
+        raise NotImplementedError
+
+    def read_note_lines(self, note_path: str, start_line: int, end_line: int) -> str:
+        raise NotImplementedError
+
+    def write_note_lines(
+        self, note_path: str, start_line: int, end_line: int, content: str
+    ) -> Path | str:
+        raise NotImplementedError
+
+    def search(self, query: str, case_sensitive: bool = False) -> list[SearchMatch]:
+        raise NotImplementedError
+
+
+class ObsidianVault(VaultBackend):
+    def __init__(self, root: Path) -> None:
+        self.root = root.expanduser().resolve()
+
+    def exists(self) -> bool:
+        return self.root.exists() and self.root.is_dir()
+
+    def is_obsidian_vault(self) -> bool:
+        return (self.root / ".obsidian").exists()
+
+    def resolve_note(self, note_path: str) -> Path:
+        candidate = (self.root / note_path).resolve()
+        if candidate != self.root and self.root not in candidate.parents:
+            raise VaultError(f"path escapes vault root: {note_path}")
+        return candidate
+
+    def list_notes(self) -> list[str]:
+        if not self.exists():
+            raise VaultError(f"vault does not exist: {self.root}")
+        return sorted(
+            str(path.relative_to(self.root))
+            for path in self.root.rglob("*.md")
+            if ".obsidian" not in path.parts
+        )
+
+    def read_note(self, note_path: str) -> str:
+        path = self.resolve_note(note_path)
+        if not path.exists():
+            raise VaultError(f"note not found: {note_path}")
+        if not path.is_file():
+            raise VaultError(f"not a file: {note_path}")
+        return path.read_text(encoding="utf-8")
+
+    def _read_existing_markdown_path(self, note_path: str) -> Path:
+        path = self.resolve_note(note_path)
+        self._validate_markdown_extension(path, note_path)
+        if not path.exists():
+            raise VaultError(f"note not found: {note_path}")
+        if not path.is_file():
+            raise VaultError(f"not a file: {note_path}")
+        return path
+
+    @staticmethod
+    def _validate_markdown_extension(path: Path, note_path: str) -> None:
+        if path.suffix.lower() != ".md":
+            raise VaultError(f"only markdown files are supported (.md): {note_path}")
+
+    @staticmethod
+    def _validate_line_range(start_line: int, end_line: int, line_count: int) -> None:
+        if start_line < 1 or end_line < 1:
+            raise VaultError("line numbers must be >= 1")
+        if start_line > end_line:
+            raise VaultError("start line must be <= end line")
+        if end_line > line_count:
+            raise VaultError(
+                f"line range {start_line}-{end_line} exceeds file length {line_count}"
+            )
+
+    def write_note(
+        self, note_path: str, content: str, create_only: bool = False
+    ) -> Path:
+        path = self.resolve_note(note_path)
+        self._validate_markdown_extension(path, note_path)
+        if create_only and path.exists():
+            raise VaultError(f"note already exists: {note_path}")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        return path
+
+    def append_note(self, note_path: str, content: str) -> Path:
+        path = self.resolve_note(note_path)
+        self._validate_markdown_extension(path, note_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(content)
+        return path
+
+    def read_note_lines(self, note_path: str, start_line: int, end_line: int) -> str:
+        path = self._read_existing_markdown_path(note_path)
+        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+        self._validate_line_range(start_line, end_line, len(lines))
+        return "".join(lines[start_line - 1 : end_line])
+
+    def write_note_lines(
+        self, note_path: str, start_line: int, end_line: int, content: str
+    ) -> Path:
+        path = self._read_existing_markdown_path(note_path)
+        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+        self._validate_line_range(start_line, end_line, len(lines))
+
+        replacement_lines = content.splitlines(keepends=True)
+        lines[start_line - 1 : end_line] = replacement_lines
+        path.write_text("".join(lines), encoding="utf-8")
+        return path
+
+    def search(self, query: str, case_sensitive: bool = False) -> list[SearchMatch]:
+        if not query:
+            raise VaultError("query must not be empty")
+
+        needle = query if case_sensitive else query.lower()
+        matches: list[SearchMatch] = []
+
+        for note_path in self.list_notes():
+            content = self.read_note(note_path)
+            for idx, line in enumerate(content.splitlines(), start=1):
+                haystack = line if case_sensitive else line.lower()
+                if needle in haystack:
+                    matches.append(
+                        SearchMatch(
+                            note_path=note_path,
+                            line_number=idx,
+                            line_text=line,
+                        )
+                    )
+        return matches
+
+
+class SshObsidianVault(VaultBackend):
+    def __init__(
+        self,
+        root: str,
+        ssh_config: SshConfig,
+        runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+    ) -> None:
+        self._root = PurePosixPath(root)
+        self.root = f"{ssh_config.destination}:{self._root}"
+        self._ssh_config = ssh_config
+        self._runner = runner
+
+    def exists(self) -> bool:
+        return self._remote_test(f"test -d {self._quote(self._root)}")
+
+    def is_obsidian_vault(self) -> bool:
+        return self._remote_test(f"test -d {self._quote(self._root / '.obsidian')}")
+
+    def list_notes(self) -> list[str]:
+        if not self.exists():
+            raise VaultError(f"vault does not exist: {self.root}")
+        command = (
+            f"cd {self._quote(self._root)} && "
+            "find . -path './.obsidian' -prune -o -type f -name '*.md' -print | "
+            "sed 's#^\\./##' | sort"
+        )
+        output = self._run_ssh(command)
+        return [line for line in output.splitlines() if line]
+
+    def read_note(self, note_path: str) -> str:
+        path = self._resolve_note(note_path)
+        self._ensure_remote_markdown(path, note_path)
+        self._ensure_remote_exists(path, note_path)
+        return self._run_ssh(f"cat {self._quote(path)}", strip_output=False)
+
+    def write_note(
+        self, note_path: str, content: str, create_only: bool = False
+    ) -> str:
+        path = self._resolve_note(note_path)
+        self._ensure_remote_markdown(path, note_path)
+        if create_only and self._remote_test(f"test -e {self._quote(path)}"):
+            raise VaultError(f"note already exists: {note_path}")
+        self._run_ssh(
+            f"mkdir -p {self._quote(path.parent)} && cat > {self._quote(path)}",
+            input_text=content,
+            strip_output=False,
+        )
+        return str(path)
+
+    def append_note(self, note_path: str, content: str) -> str:
+        path = self._resolve_note(note_path)
+        self._ensure_remote_markdown(path, note_path)
+        self._run_ssh(
+            f"mkdir -p {self._quote(path.parent)} && cat >> {self._quote(path)}",
+            input_text=content,
+            strip_output=False,
+        )
+        return str(path)
+
+    def read_note_lines(self, note_path: str, start_line: int, end_line: int) -> str:
+        content = self.read_note(note_path)
+        lines = content.splitlines(keepends=True)
+        ObsidianVault._validate_line_range(start_line, end_line, len(lines))
+        return "".join(lines[start_line - 1 : end_line])
+
+    def write_note_lines(
+        self, note_path: str, start_line: int, end_line: int, content: str
+    ) -> str:
+        existing = self.read_note(note_path)
+        lines = existing.splitlines(keepends=True)
+        ObsidianVault._validate_line_range(start_line, end_line, len(lines))
+        lines[start_line - 1 : end_line] = content.splitlines(keepends=True)
+        return self.write_note(note_path, "".join(lines))
+
+    def search(self, query: str, case_sensitive: bool = False) -> list[SearchMatch]:
+        if not query:
+            raise VaultError("query must not be empty")
+
+        needle = query if case_sensitive else query.lower()
+        matches: list[SearchMatch] = []
+        for note_path in self.list_notes():
+            content = self.read_note(note_path)
+            for idx, line in enumerate(content.splitlines(), start=1):
+                haystack = line if case_sensitive else line.lower()
+                if needle in haystack:
+                    matches.append(
+                        SearchMatch(
+                            note_path=note_path,
+                            line_number=idx,
+                            line_text=line,
+                        )
+                    )
+        return matches
+
+    def _ensure_remote_exists(self, path: PurePosixPath, note_path: str) -> None:
+        if not self._remote_test(f"test -f {self._quote(path)}"):
+            raise VaultError(f"note not found: {note_path}")
+
+    @staticmethod
+    def _ensure_remote_markdown(path: PurePosixPath, note_path: str) -> None:
+        if path.suffix.lower() != ".md":
+            raise VaultError(f"only markdown files are supported (.md): {note_path}")
+
+    def _resolve_note(self, note_path: str) -> PurePosixPath:
+        relative = PurePosixPath(note_path)
+        if relative.is_absolute() or ".." in relative.parts:
+            raise VaultError(f"path escapes vault root: {note_path}")
+        return self._root / relative
+
+    def _remote_test(self, command: str) -> bool:
+        ssh_command = self._build_ssh_command(command)
+        result = self._runner(ssh_command, text=True, capture_output=True)
+        return result.returncode == 0
+
+    def _run_ssh(
+        self, command: str, input_text: str | None = None, strip_output: bool = True
+    ) -> str:
+        ssh_command = self._build_ssh_command(command)
+        result = self._runner(
+            ssh_command,
+            text=True,
+            capture_output=True,
+            input=input_text,
+        )
+        if result.returncode != 0:
+            message = (
+                result.stderr.strip() or result.stdout.strip() or "ssh command failed"
+            )
+            raise VaultError(message)
+        return result.stdout.strip() if strip_output else result.stdout
+
+    def _build_ssh_command(self, remote_command: str) -> list[str]:
+        command = ["ssh"]
+        if self._ssh_config.port is not None:
+            command.extend(["-p", str(self._ssh_config.port)])
+        if self._ssh_config.identity_file:
+            command.extend(["-i", self._ssh_config.identity_file])
+        command.append(self._ssh_config.destination)
+        command.append(remote_command)
+        return command
+
+    @staticmethod
+    def _quote(path: PurePosixPath) -> str:
+        return shlex.quote(str(path))

{odcli-0.1.6 → odcli-0.1.7}/src/odcli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odcli
-Version: 0.1.6
+Version: 0.1.7
 Summary: A small CLI for reading and writing notes in a local Obsidian vault.
 Author: odcli contributors
 Keywords: obsidian,cli,markdown,notes,vault
@@ -65,6 +65,47 @@ You can also override the vault per command:
 odcli --vault "/path/to/MyVault" list
 ```
 
+## Remote Vault over SSH
+
+You can operate on an Obsidian vault stored on another machine over SSH.
+
+Example:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  list
+```
+
+Read a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  read Inbox/today.md
+```
+
+Write a remote note:
+
+```bash
+odcli \
+  --ssh-host your-server \
+  --ssh-user your-user \
+  --vault /path/to/ObsidianVault \
+  write Inbox/today.md --content "# Remote note"
+```
+
+Optional SSH flags:
+
+- `--ssh-port`
+- `--ssh-identity`
+
+In SSH mode, `--vault` or `OBSIDIAN_VAULT` should point to the remote vault path.
+
 ## Common Commands
 
 Read a note:
@@ -224,6 +265,14 @@ Arguments:
 - `query`
 - `--case-sensitive`
 
+## Global Options
+
+- `--vault`
+- `--ssh-host`
+- `--ssh-user`
+- `--ssh-port`
+- `--ssh-identity`
+
 ## For Developers
 
 Run from source:

{odcli-0.1.6 → odcli-0.1.7}/tests/test_cli.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import sys
+import subprocess
 import tempfile
 import unittest
 from contextlib import redirect_stderr, redirect_stdout
@@ -13,7 +14,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 from obsidian_cli.cli import ObsidianCLI, main
 from obsidian_cli.discovery import VaultCandidate, VaultLocator
 from obsidian_cli.plugins import SkillInstaller
-from obsidian_cli.vault import ObsidianVault, VaultError
+from obsidian_cli.vault import ObsidianVault, SshConfig, SshObsidianVault, VaultError
 
 
 class VaultTests(unittest.TestCase):
@@ -102,6 +103,11 @@ class VaultTests(unittest.TestCase):
         )
         self.assertEqual(locator.resolve(None), self.vault_root)
 
+    def test_vault_locator_resolve_configured_requires_explicit_or_env(self) -> None:
+        locator = VaultLocator(env={}, home=self.vault_root)
+        with self.assertRaises(VaultError):
+            locator.resolve_configured(None)
+
     def test_vault_locator_discovers_default_vault(self) -> None:
         locator = VaultLocator(env={}, home=self.vault_root.parent)
         with patch.object(locator, "_discover_from_obsidian_config", return_value=None):
@@ -160,6 +166,75 @@ class VaultTests(unittest.TestCase):
         self.assertIn("codex-skill:", output)
         self.assertIn("claude-skill:", output)
 
+    def test_ssh_vault_list_notes(self) -> None:
+        def fake_runner(
+            command: list[str], **_: object
+        ) -> subprocess.CompletedProcess[str]:
+            if "test -d" in command[-1]:
+                return subprocess.CompletedProcess(command, 0, "", "")
+            if "find ." in command[-1]:
+                return subprocess.CompletedProcess(
+                    command,
+                    0,
+                    "Inbox/today.md\nProjects/alpha.md\n",
+                    "",
+                )
+            return subprocess.CompletedProcess(command, 1, "", "unexpected command")
+
+        vault = SshObsidianVault(
+            "/vault", SshConfig(host="example.com"), runner=fake_runner
+        )
+        self.assertEqual(vault.list_notes(), ["Inbox/today.md", "Projects/alpha.md"])
+
+    def test_ssh_vault_write_and_read_note(self) -> None:
+        written: dict[str, str] = {}
+
+        def fake_runner(
+            command: list[str], **kwargs: object
+        ) -> subprocess.CompletedProcess[str]:
+            remote_command = command[-1]
+            if "test -f" in remote_command:
+                exists = "/vault/Inbox/test.md" in written
+                return subprocess.CompletedProcess(command, 0 if exists else 1, "", "")
+            if "mkdir -p" in remote_command and "cat >" in remote_command:
+                written["/vault/Inbox/test.md"] = str(kwargs.get("input", ""))
+                return subprocess.CompletedProcess(command, 0, "", "")
+            if remote_command == "cat /vault/Inbox/test.md":
+                return subprocess.CompletedProcess(
+                    command,
+                    0,
+                    written["/vault/Inbox/test.md"],
+                    "",
+                )
+            return subprocess.CompletedProcess(command, 1, "", "unexpected command")
+
+        vault = SshObsidianVault(
+            "/vault", SshConfig(host="example.com"), runner=fake_runner
+        )
+        vault.write_note("Inbox/test.md", "# Hello\n")
+        self.assertEqual(vault.read_note("Inbox/test.md"), "# Hello\n")
+
+    def test_cli_builds_ssh_vault_when_requested(self) -> None:
+        cli = ObsidianCLI(
+            vault_locator=VaultLocator(
+                env={"OBSIDIAN_VAULT": "/remote/vault"}, home=self.vault_root
+            )
+        )
+        vault = cli._build_vault(
+            type(
+                "Args",
+                (),
+                {
+                    "vault": None,
+                    "ssh_host": "example.com",
+                    "ssh_user": "alice",
+                    "ssh_port": 2222,
+                    "ssh_identity": "~/.ssh/id_ed25519",
+                },
+            )()
+        )
+        self.assertIsInstance(vault, SshObsidianVault)
+
 
 if __name__ == "__main__":
     unittest.main()

odcli-0.1.6/src/obsidian_cli/vault.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-
-
-class VaultError(Exception):
-    """Raised when the vault cannot fulfill a requested operation."""
-
-
-@dataclass(slots=True)
-class SearchMatch:
-    note_path: str
-    line_number: int
-    line_text: str
-
-
-class ObsidianVault:
-    def __init__(self, root: Path) -> None:
-        self.root = root.expanduser().resolve()
-
-    def exists(self) -> bool:
-        return self.root.exists() and self.root.is_dir()
-
-    def is_obsidian_vault(self) -> bool:
-        return (self.root / ".obsidian").exists()
-
-    def resolve_note(self, note_path: str) -> Path:
-        candidate = (self.root / note_path).resolve()
-        if candidate != self.root and self.root not in candidate.parents:
-            raise VaultError(f"path escapes vault root: {note_path}")
-        return candidate
-
-    def list_notes(self) -> list[str]:
-        if not self.exists():
-            raise VaultError(f"vault does not exist: {self.root}")
-        return sorted(
-            str(path.relative_to(self.root))
-            for path in self.root.rglob("*.md")
-            if ".obsidian" not in path.parts
-        )
-
-    def read_note(self, note_path: str) -> str:
-        path = self.resolve_note(note_path)
-        if not path.exists():
-            raise VaultError(f"note not found: {note_path}")
-        if not path.is_file():
-            raise VaultError(f"not a file: {note_path}")
-        return path.read_text(encoding="utf-8")
-
-    def _read_existing_markdown_path(self, note_path: str) -> Path:
-        path = self.resolve_note(note_path)
-        if path.suffix.lower() != ".md":
-            raise VaultError("only markdown files are supported (.md)")
-        if not path.exists():
-            raise VaultError(f"note not found: {note_path}")
-        if not path.is_file():
-            raise VaultError(f"not a file: {note_path}")
-        return path
-
-    def _validate_line_range(
-        self, start_line: int, end_line: int, line_count: int
-    ) -> None:
-        if start_line < 1 or end_line < 1:
-            raise VaultError("line numbers must be >= 1")
-        if start_line > end_line:
-            raise VaultError("start line must be <= end line")
-        if end_line > line_count:
-            raise VaultError(
-                f"line range {start_line}-{end_line} exceeds file length {line_count}"
-            )
-
-    def write_note(
-        self, note_path: str, content: str, create_only: bool = False
-    ) -> Path:
-        path = self.resolve_note(note_path)
-        if path.suffix.lower() != ".md":
-            raise VaultError("only markdown files are supported (.md)")
-        if create_only and path.exists():
-            raise VaultError(f"note already exists: {note_path}")
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(content, encoding="utf-8")
-        return path
-
-    def append_note(self, note_path: str, content: str) -> Path:
-        path = self.resolve_note(note_path)
-        if path.suffix.lower() != ".md":
-            raise VaultError("only markdown files are supported (.md)")
-        path.parent.mkdir(parents=True, exist_ok=True)
-        with path.open("a", encoding="utf-8") as handle:
-            handle.write(content)
-        return path
-
-    def read_note_lines(self, note_path: str, start_line: int, end_line: int) -> str:
-        path = self._read_existing_markdown_path(note_path)
-        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
-        self._validate_line_range(start_line, end_line, len(lines))
-        return "".join(lines[start_line - 1 : end_line])
-
-    def write_note_lines(
-        self, note_path: str, start_line: int, end_line: int, content: str
-    ) -> Path:
-        path = self._read_existing_markdown_path(note_path)
-        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
-        self._validate_line_range(start_line, end_line, len(lines))
-
-        replacement_lines = content.splitlines(keepends=True)
-        lines[start_line - 1 : end_line] = replacement_lines
-        path.write_text("".join(lines), encoding="utf-8")
-        return path
-
-    def search(self, query: str, case_sensitive: bool = False) -> list[SearchMatch]:
-        if not query:
-            raise VaultError("query must not be empty")
-
-        needle = query if case_sensitive else query.lower()
-        matches: list[SearchMatch] = []
-
-        for note_path in self.list_notes():
-            content = self.read_note(note_path)
-            for idx, line in enumerate(content.splitlines(), start=1):
-                haystack = line if case_sensitive else line.lower()
-                if needle in haystack:
-                    matches.append(
-                        SearchMatch(
-                            note_path=note_path,
-                            line_number=idx,
-                            line_text=line,
-                        )
-                    )
-        return matches