odcli 0.1.0__tar.gz

odcli-0.1.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: odcli
+Version: 0.1.0
+Summary: A small CLI for reading and writing notes in a local Obsidian vault.
+Author: Chang LeHung
+Project-URL: Homepage, https://github.com/Chang-LeHung/obsidian-cli
+Project-URL: Repository, https://github.com/Chang-LeHung/obsidian-cli
+Project-URL: Issues, https://github.com/Chang-LeHung/obsidian-cli/issues
+Keywords: obsidian,cli,markdown,notes,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# odcli
+
+一个基于 Python 的本地 CLI，用来对 Obsidian vault 做读写操作。它直接操作 vault 里的 Markdown 文件，不依赖 Obsidian 的私有接口，因此稳定、可移植，也方便后续扩展。
+
+## 功能
+
+- 校验 vault 路径是否有效
+- 列出 vault 中的 Markdown 笔记
+- 读取指定笔记
+- 按指定行区间读取笔记
+- 覆盖写入或自动创建笔记
+- 按指定行区间覆盖写入
+- 追加内容到笔记末尾
+- 在 vault 中全文搜索
+
+## 使用 uv
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+uv run obsidian-cli --help
+```
+
+运行测试：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```
+
+构建分发包：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv build
+```
+
+发布到 PyPI 后，安装包名会是 `odcli`。
+
+## 直接运行
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+./obsidian-cli --help
+```
+
+如果你更喜欢显式调用 Python：
+
+```bash
+PYTHONPATH=src python3 -m obsidian_cli --help
+```
+
+## 可选安装
+
+如果你想安装到虚拟环境中：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+```
+
+## 指定 vault
+
+优先级如下：
+
+1. `--vault /path/to/vault`
+2. 环境变量 `OBSIDIAN_VAULT`
+
+示例：
+
+```bash
+export OBSIDIAN_VAULT="/Users/your-name/Documents/MyVault"
+./obsidian-cli check
+./obsidian-cli list
+./obsidian-cli read Inbox/today.md
+./obsidian-cli read-lines Inbox/today.md 3 8
+./obsidian-cli write Inbox/today.md --content "# Today"
+./obsidian-cli write-lines Inbox/today.md 3 4 --content "- replaced\n- lines\n"
+./obsidian-cli append Inbox/today.md --content "\n- new item"
+./obsidian-cli search "project alpha"
+```
+
+## 命令
+
+### `check`
+
+检查 vault 是否存在，以及是否包含 `.obsidian` 目录。
+
+### `list`
+
+列出 vault 中的 Markdown 文件。
+
+可选参数：
+
+- `--limit N`
+
+### `read`
+
+读取笔记内容。
+
+参数：
+
+- `note_path`：相对于 vault 根目录的路径
+
+### `write`
+
+覆盖写入笔记；若父目录不存在会自动创建。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`：从标准输入读取内容
+
+可选参数：
+
+- `--create-only`：若文件已存在则报错
+
+### `read-lines`
+
+读取指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+
+### `write-lines`
+
+用新内容替换指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+- `--content TEXT`
+- `--stdin`
+
+### `append`
+
+追加内容到笔记末尾。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`
+
+### `search`
+
+在所有 Markdown 笔记中搜索文本。
+
+参数：
+
+- `query`
+- `--case-sensitive`
+
+## 测试
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```

odcli-0.1.0/README.md

@@ -0,0 +1,165 @@
+# odcli
+
+一个基于 Python 的本地 CLI，用来对 Obsidian vault 做读写操作。它直接操作 vault 里的 Markdown 文件，不依赖 Obsidian 的私有接口，因此稳定、可移植，也方便后续扩展。
+
+## 功能
+
+- 校验 vault 路径是否有效
+- 列出 vault 中的 Markdown 笔记
+- 读取指定笔记
+- 按指定行区间读取笔记
+- 覆盖写入或自动创建笔记
+- 按指定行区间覆盖写入
+- 追加内容到笔记末尾
+- 在 vault 中全文搜索
+
+## 使用 uv
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+uv run obsidian-cli --help
+```
+
+运行测试：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```
+
+构建分发包：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv build
+```
+
+发布到 PyPI 后，安装包名会是 `odcli`。
+
+## 直接运行
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+./obsidian-cli --help
+```
+
+如果你更喜欢显式调用 Python：
+
+```bash
+PYTHONPATH=src python3 -m obsidian_cli --help
+```
+
+## 可选安装
+
+如果你想安装到虚拟环境中：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+```
+
+## 指定 vault
+
+优先级如下：
+
+1. `--vault /path/to/vault`
+2. 环境变量 `OBSIDIAN_VAULT`
+
+示例：
+
+```bash
+export OBSIDIAN_VAULT="/Users/your-name/Documents/MyVault"
+./obsidian-cli check
+./obsidian-cli list
+./obsidian-cli read Inbox/today.md
+./obsidian-cli read-lines Inbox/today.md 3 8
+./obsidian-cli write Inbox/today.md --content "# Today"
+./obsidian-cli write-lines Inbox/today.md 3 4 --content "- replaced\n- lines\n"
+./obsidian-cli append Inbox/today.md --content "\n- new item"
+./obsidian-cli search "project alpha"
+```
+
+## 命令
+
+### `check`
+
+检查 vault 是否存在，以及是否包含 `.obsidian` 目录。
+
+### `list`
+
+列出 vault 中的 Markdown 文件。
+
+可选参数：
+
+- `--limit N`
+
+### `read`
+
+读取笔记内容。
+
+参数：
+
+- `note_path`：相对于 vault 根目录的路径
+
+### `write`
+
+覆盖写入笔记；若父目录不存在会自动创建。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`：从标准输入读取内容
+
+可选参数：
+
+- `--create-only`：若文件已存在则报错
+
+### `read-lines`
+
+读取指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+
+### `write-lines`
+
+用新内容替换指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+- `--content TEXT`
+- `--stdin`
+
+### `append`
+
+追加内容到笔记末尾。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`
+
+### `search`
+
+在所有 Markdown 笔记中搜索文本。
+
+参数：
+
+- `query`
+- `--case-sensitive`
+
+## 测试
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```

odcli-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "odcli"
+version = "0.1.0"
+description = "A small CLI for reading and writing notes in a local Obsidian vault."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+  { name = "Chang LeHung" }
+]
+dependencies = []
+keywords = ["obsidian", "cli", "markdown", "notes", "vault"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: MacOS",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Utilities",
+  "Environment :: Console",
+]
+
+[project.urls]
+Homepage = "https://github.com/Chang-LeHung/obsidian-cli"
+Repository = "https://github.com/Chang-LeHung/obsidian-cli"
+Issues = "https://github.com/Chang-LeHung/obsidian-cli/issues"
+
+[project.scripts]
+obsidian-cli = "obsidian_cli.cli:main"
+
+[dependency-groups]
+dev = [
+  "build>=1.2.2",
+  "twine>=6.1.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.uv]
+package = true

odcli-0.1.0/setup.cfg

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

odcli-0.1.0/src/obsidian_cli/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+

odcli-0.1.0/src/obsidian_cli/__main__.py

@@ -0,0 +1,6 @@
+from obsidian_cli.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

odcli-0.1.0/src/obsidian_cli/cli.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from obsidian_cli.vault import ObsidianVault, VaultError
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="obsidian-cli",
+        description="Read and write notes inside a local Obsidian vault.",
+    )
+    parser.add_argument(
+        "--vault",
+        help="Path to the Obsidian vault. Falls back to OBSIDIAN_VAULT.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("check", help="Validate the vault path.")
+
+    list_parser = subparsers.add_parser("list", help="List markdown notes.")
+    list_parser.add_argument("--limit", type=int, default=0, help="Maximum number of notes to show.")
+
+    read_parser = subparsers.add_parser("read", help="Read a note.")
+    read_parser.add_argument("note_path", help="Path to the note relative to the vault root.")
+
+    read_lines_parser = subparsers.add_parser("read-lines", help="Read a line range from a note.")
+    read_lines_parser.add_argument("note_path", help="Path to the note relative to the vault root.")
+    read_lines_parser.add_argument("start_line", type=int, help="1-based start line, inclusive.")
+    read_lines_parser.add_argument("end_line", type=int, help="1-based end line, inclusive.")
+
+    write_parser = subparsers.add_parser("write", help="Write a note.")
+    write_parser.add_argument("note_path", help="Path to the note relative to the vault root.")
+    write_parser.add_argument("--content", help="Text content to write.")
+    write_parser.add_argument("--stdin", action="store_true", help="Read note content from stdin.")
+    write_parser.add_argument(
+        "--create-only",
+        action="store_true",
+        help="Fail if the note already exists.",
+    )
+
+    append_parser = subparsers.add_parser("append", help="Append to a note.")
+    append_parser.add_argument("note_path", help="Path to the note relative to the vault root.")
+    append_parser.add_argument("--content", help="Text content to append.")
+    append_parser.add_argument("--stdin", action="store_true", help="Read appended content from stdin.")
+
+    write_lines_parser = subparsers.add_parser(
+        "write-lines",
+        help="Replace a line range inside a note.",
+    )
+    write_lines_parser.add_argument("note_path", help="Path to the note relative to the vault root.")
+    write_lines_parser.add_argument("start_line", type=int, help="1-based start line, inclusive.")
+    write_lines_parser.add_argument("end_line", type=int, help="1-based end line, inclusive.")
+    write_lines_parser.add_argument("--content", help="Replacement text for the selected lines.")
+    write_lines_parser.add_argument("--stdin", action="store_true", help="Read replacement text from stdin.")
+
+    search_parser = subparsers.add_parser("search", help="Search text in notes.")
+    search_parser.add_argument("query", help="Text to search for.")
+    search_parser.add_argument(
+        "--case-sensitive",
+        action="store_true",
+        help="Use case-sensitive matching.",
+    )
+
+    return parser
+
+
+def resolve_vault_path(cli_value: str | None) -> Path:
+    raw_value = cli_value or os.environ.get("OBSIDIAN_VAULT")
+    if not raw_value:
+        raise VaultError("vault path is required; use --vault or OBSIDIAN_VAULT")
+    return Path(raw_value)
+
+
+def read_content_arg(content: str | None, use_stdin: bool) -> str:
+    if content is not None and use_stdin:
+        raise VaultError("use either --content or --stdin, not both")
+    if content is not None:
+        return content
+    if use_stdin:
+        return sys.stdin.read()
+    raise VaultError("content is required; provide --content or --stdin")
+
+
+def cmd_check(vault: ObsidianVault) -> int:
+    if not vault.exists():
+        raise VaultError(f"vault does not exist: {vault.root}")
+    print(f"vault: {vault.root}")
+    if vault.is_obsidian_vault():
+        print("status: ok (.obsidian found)")
+    else:
+        print("status: warning (.obsidian not found)")
+    return 0
+
+
+def cmd_list(vault: ObsidianVault, limit: int) -> int:
+    notes = vault.list_notes()
+    if limit > 0:
+        notes = notes[:limit]
+    for note in notes:
+        print(note)
+    return 0
+
+
+def cmd_read(vault: ObsidianVault, note_path: str) -> int:
+    print(vault.read_note(note_path), end="")
+    return 0
+
+
+def cmd_read_lines(vault: ObsidianVault, note_path: str, start_line: int, end_line: int) -> int:
+    print(vault.read_note_lines(note_path, start_line, end_line), end="")
+    return 0
+
+
+def cmd_write(vault: ObsidianVault, note_path: str, content: str, create_only: bool) -> int:
+    path = vault.write_note(note_path, content, create_only=create_only)
+    print(path)
+    return 0
+
+
+def cmd_append(vault: ObsidianVault, note_path: str, content: str) -> int:
+    path = vault.append_note(note_path, content)
+    print(path)
+    return 0
+
+
+def cmd_write_lines(
+    vault: ObsidianVault,
+    note_path: str,
+    start_line: int,
+    end_line: int,
+    content: str,
+) -> int:
+    path = vault.write_note_lines(note_path, start_line, end_line, content)
+    print(path)
+    return 0
+
+
+def cmd_search(vault: ObsidianVault, query: str, case_sensitive: bool) -> int:
+    matches = vault.search(query, case_sensitive=case_sensitive)
+    for match in matches:
+        print(f"{match.note_path}:{match.line_number}: {match.line_text}")
+    return 0 if matches else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        vault = ObsidianVault(resolve_vault_path(args.vault))
+
+        if args.command == "check":
+            return cmd_check(vault)
+        if args.command == "list":
+            return cmd_list(vault, args.limit)
+        if args.command == "read":
+            return cmd_read(vault, args.note_path)
+        if args.command == "read-lines":
+            return cmd_read_lines(vault, args.note_path, args.start_line, args.end_line)
+        if args.command == "write":
+            content = read_content_arg(args.content, args.stdin)
+            return cmd_write(vault, args.note_path, content, args.create_only)
+        if args.command == "append":
+            content = read_content_arg(args.content, args.stdin)
+            return cmd_append(vault, args.note_path, content)
+        if args.command == "write-lines":
+            content = read_content_arg(args.content, args.stdin)
+            return cmd_write_lines(
+                vault,
+                args.note_path,
+                args.start_line,
+                args.end_line,
+                content,
+            )
+        if args.command == "search":
+            return cmd_search(vault, args.query, args.case_sensitive)
+    except VaultError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    parser.error(f"unsupported command: {args.command}")
+    return 2

odcli-0.1.0/src/obsidian_cli/vault.py

@@ -0,0 +1,127 @@
+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

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

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: odcli
+Version: 0.1.0
+Summary: A small CLI for reading and writing notes in a local Obsidian vault.
+Author: Chang LeHung
+Project-URL: Homepage, https://github.com/Chang-LeHung/obsidian-cli
+Project-URL: Repository, https://github.com/Chang-LeHung/obsidian-cli
+Project-URL: Issues, https://github.com/Chang-LeHung/obsidian-cli/issues
+Keywords: obsidian,cli,markdown,notes,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# odcli
+
+一个基于 Python 的本地 CLI，用来对 Obsidian vault 做读写操作。它直接操作 vault 里的 Markdown 文件，不依赖 Obsidian 的私有接口，因此稳定、可移植，也方便后续扩展。
+
+## 功能
+
+- 校验 vault 路径是否有效
+- 列出 vault 中的 Markdown 笔记
+- 读取指定笔记
+- 按指定行区间读取笔记
+- 覆盖写入或自动创建笔记
+- 按指定行区间覆盖写入
+- 追加内容到笔记末尾
+- 在 vault 中全文搜索
+
+## 使用 uv
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+uv run obsidian-cli --help
+```
+
+运行测试：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```
+
+构建分发包：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv build
+```
+
+发布到 PyPI 后，安装包名会是 `odcli`。
+
+## 直接运行
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+./obsidian-cli --help
+```
+
+如果你更喜欢显式调用 Python：
+
+```bash
+PYTHONPATH=src python3 -m obsidian_cli --help
+```
+
+## 可选安装
+
+如果你想安装到虚拟环境中：
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv sync
+```
+
+## 指定 vault
+
+优先级如下：
+
+1. `--vault /path/to/vault`
+2. 环境变量 `OBSIDIAN_VAULT`
+
+示例：
+
+```bash
+export OBSIDIAN_VAULT="/Users/your-name/Documents/MyVault"
+./obsidian-cli check
+./obsidian-cli list
+./obsidian-cli read Inbox/today.md
+./obsidian-cli read-lines Inbox/today.md 3 8
+./obsidian-cli write Inbox/today.md --content "# Today"
+./obsidian-cli write-lines Inbox/today.md 3 4 --content "- replaced\n- lines\n"
+./obsidian-cli append Inbox/today.md --content "\n- new item"
+./obsidian-cli search "project alpha"
+```
+
+## 命令
+
+### `check`
+
+检查 vault 是否存在，以及是否包含 `.obsidian` 目录。
+
+### `list`
+
+列出 vault 中的 Markdown 文件。
+
+可选参数：
+
+- `--limit N`
+
+### `read`
+
+读取笔记内容。
+
+参数：
+
+- `note_path`：相对于 vault 根目录的路径
+
+### `write`
+
+覆盖写入笔记；若父目录不存在会自动创建。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`：从标准输入读取内容
+
+可选参数：
+
+- `--create-only`：若文件已存在则报错
+
+### `read-lines`
+
+读取指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+
+### `write-lines`
+
+用新内容替换指定行区间，行号从 `1` 开始，区间是闭区间。
+
+参数：
+
+- `note_path`
+- `start_line`
+- `end_line`
+- `--content TEXT`
+- `--stdin`
+
+### `append`
+
+追加内容到笔记末尾。
+
+参数：
+
+- `note_path`
+- `--content TEXT`
+- `--stdin`
+
+### `search`
+
+在所有 Markdown 笔记中搜索文本。
+
+参数：
+
+- `query`
+- `--case-sensitive`
+
+## 测试
+
+```bash
+cd /Users/huchang/agents/obsidian_cli
+uv run python -m unittest discover -s tests
+```

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/obsidian_cli/__init__.py
+src/obsidian_cli/__main__.py
+src/obsidian_cli/cli.py
+src/obsidian_cli/vault.py
+src/odcli.egg-info/PKG-INFO
+src/odcli.egg-info/SOURCES.txt
+src/odcli.egg-info/dependency_links.txt
+src/odcli.egg-info/entry_points.txt
+src/odcli.egg-info/top_level.txt
+tests/test_cli.py

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

@@ -0,0 +1 @@
+

odcli-0.1.0/src/odcli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+obsidian-cli = obsidian_cli.cli:main

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

@@ -0,0 +1 @@
+obsidian_cli

odcli-0.1.0/tests/test_cli.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+from io import StringIO
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from obsidian_cli.cli import main
+from obsidian_cli.vault import ObsidianVault, VaultError
+
+
+class VaultTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.vault_root = Path(self.temp_dir.name) / "vault"
+        self.vault_root.mkdir()
+        (self.vault_root / ".obsidian").mkdir()
+        self.vault = ObsidianVault(self.vault_root)
+
+    def tearDown(self) -> None:
+        self.temp_dir.cleanup()
+
+    def test_write_and_read_note(self) -> None:
+        self.vault.write_note("Inbox/test.md", "# Hello")
+        self.assertEqual(self.vault.read_note("Inbox/test.md"), "# Hello")
+
+    def test_list_notes_excludes_obsidian_config(self) -> None:
+        self.vault.write_note("Note.md", "body")
+        (self.vault_root / ".obsidian" / "workspace.md").write_text(
+            "ignored", encoding="utf-8"
+        )
+        self.assertEqual(self.vault.list_notes(), ["Note.md"])
+
+    def test_search_matches_line(self) -> None:
+        self.vault.write_note("Note.md", "alpha\nbeta project\nomega")
+        matches = self.vault.search("project")
+        self.assertEqual(len(matches), 1)
+        self.assertEqual(matches[0].line_number, 2)
+
+    def test_read_note_lines(self) -> None:
+        self.vault.write_note("Note.md", "a\nb\nc\nd\n")
+        self.assertEqual(self.vault.read_note_lines("Note.md", 2, 3), "b\nc\n")
+
+    def test_write_note_lines_replaces_only_selected_range(self) -> None:
+        self.vault.write_note("Note.md", "a\nb\nc\nd\n")
+        self.vault.write_note_lines("Note.md", 2, 3, "x\ny\n")
+        self.assertEqual(self.vault.read_note("Note.md"), "a\nx\ny\nd\n")
+
+    def test_write_note_lines_rejects_invalid_range(self) -> None:
+        self.vault.write_note("Note.md", "a\nb\n")
+        with self.assertRaises(VaultError):
+            self.vault.write_note_lines("Note.md", 2, 4, "x\n")
+
+    def test_cli_check(self) -> None:
+        with redirect_stdout(StringIO()), redirect_stderr(StringIO()):
+            exit_code = main(["--vault", str(self.vault_root), "check"])
+        self.assertEqual(exit_code, 0)
+
+    def test_cli_write_requires_content(self) -> None:
+        with redirect_stdout(StringIO()), redirect_stderr(StringIO()):
+            exit_code = main(["--vault", str(self.vault_root), "write", "x.md"])
+        self.assertEqual(exit_code, 2)
+
+    def test_cli_read_lines(self) -> None:
+        self.vault.write_note("Note.md", "a\nb\nc\n")
+        stdout = StringIO()
+        with redirect_stdout(stdout), redirect_stderr(StringIO()):
+            exit_code = main(
+                ["--vault", str(self.vault_root), "read-lines", "Note.md", "2", "3"]
+            )
+        self.assertEqual(exit_code, 0)
+        self.assertEqual(stdout.getvalue(), "b\nc\n")
+
+    def test_cli_write_lines(self) -> None:
+        self.vault.write_note("Note.md", "a\nb\nc\n")
+        with redirect_stdout(StringIO()), redirect_stderr(StringIO()):
+            exit_code = main(
+                [
+                    "--vault",
+                    str(self.vault_root),
+                    "write-lines",
+                    "Note.md",
+                    "2",
+                    "2",
+                    "--content",
+                    "beta\n",
+                ]
+            )
+        self.assertEqual(exit_code, 0)
+        self.assertEqual(self.vault.read_note("Note.md"), "a\nbeta\nc\n")
+
+
+if __name__ == "__main__":
+    unittest.main()