"CLI-Anything: Making ALL Software Agent-Native" -- CLI-Hub: https://clianything.cc/
Python
feat: add Obsidian CLI harness
Doruk Özgen25149e66b29a
diff --git a/.gitignore b/.gitignoreindex fbba89872..0cd81b6a2 100644--- a/.gitignore+++ b/.gitignore@@ -92,6 +92,7 @@!/cloudcompare/!/openscreen/!/n8n/+!/obsidian/# Step 5: Inside each software dir, ignore everything (including dotfiles)/gimp/*@@ -168,6 +169,8 @@/exa/.*/n8n/*/n8n/.*+/obsidian/*+/obsidian/.*# Step 6: ...except agent-harness/!/gimp/agent-harness/@@ -211,6 +214,7 @@!/wiremock/agent-harness/!/exa/agent-harness/!/n8n/agent-harness/+!/obsidian/agent-harness/# Step 7: Ignore build artifacts within allowed dirs**/__pycache__/diff --git a/obsidian/agent-harness/OBSIDIAN.md b/obsidian/agent-harness/OBSIDIAN.mdnew file mode 100644index 000000000..48f10cf49--- /dev/null+++ b/obsidian/agent-harness/OBSIDIAN.md@@ -0,0 +1,78 @@+# Obsidian: Project-Specific Analysis & SOP++## Architecture Summary++Obsidian is a knowledge management and note-taking app that stores notes as local Markdown files.+The Local REST API plugin exposes vault operations via an HTTPS server on `localhost:27124`.++```+┌───────────────────────────────────────────────────┐+│ Obsidian Desktop App │+│ ┌───────────┐ ┌──────────┐ ┌──────────────────┐ │+│ │ Vault │ │ Search │ │ Commands │ │+│ │ Manager │ │ Engine │ │ Registry │ │+│ └─────┬──────┘ └────┬─────┘ └───────┬──────────┘ │+│ │ │ │ │+│ ┌─────┴─────────────┴───────────────┴───────────┐ │+│ │ Local REST API Plugin (port 27124) │ │+│ │ /vault/ /search/ /commands/ │ │+│ │ /active/ /periodic-notes/ │ │+│ └───────────────────┬───────────────────────────┘ │+└──────────────────────┼─────────────────────────────┘+ │ HTTPS + Bearer Token+ ┌─────────────┴──────────────┐+ │ cli-anything-obsidian │+ │ Click CLI + REPL │+ └────────────────────────────┘+```++## CLI Strategy: REST API Wrapper++Our CLI wraps the Obsidian Local REST API plugin with:++1. **requests** — HTTP client for all API calls (HTTPS, self-signed cert)+2. **Bearer token** — Authentication via API key+3. **Click CLI** — Structured command groups matching the API surface+4. **REPL** — Interactive mode for exploratory use++### API Endpoints++| Endpoint | Method | Purpose |+|----------|--------|---------|+| `/` | GET | Server status/auth check |+| `/vault/` | GET | List vault files |+| `/vault/{path}` | GET | Read note content |+| `/vault/{path}` | PUT | Create/update note |+| `/vault/{path}` | DELETE | Delete note |+| `/vault/{path}` | PATCH | Append/prepend to note |+| `/search/` | POST | Search with Obsidian syntax |+| `/search/simple/` | POST | Plain text search |+| `/active/` | GET | Get active note |+| `/active/` | PUT | Open a note |+| `/commands/` | GET | List commands |+| `/commands/{id}/` | POST | Execute command |++### Authentication++The Local REST API plugin generates an API key in its settings.+Pass via `--api-key` flag or `OBSIDIAN_API_KEY` environment variable.+All requests use HTTPS with a self-signed certificate (`verify=False`).++## CLI → API Mapping++| CLI Command | API Call |+|-------------|----------|+| `vault list [path]` | `GET /vault/[path]/` |+| `vault read <path>` | `GET /vault/{path}` |+| `vault create <path>` | `PUT /vault/{path}` |+| `vault update <path>` | `PUT /vault/{path}` |+| `vault delete <path>` | `DELETE /vault/{path}` |+| `vault append <path>` | `PATCH /vault/{path}` |+| `search query <q>` | `POST /search/` |+| `search simple <q>` | `POST /search/simple/` |+| `note active` | `GET /active/` |+| `note open <path>` | `PUT /active/` |+| `command list` | `GET /commands/` |+| `command execute <id>` | `POST /commands/{id}/` |+| `server status` | `GET /` |+| `session status` | (local state) |diff --git a/obsidian/agent-harness/cli_anything/__init__.py b/obsidian/agent-harness/cli_anything/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/obsidian/agent-harness/cli_anything/obsidian/README.md b/obsidian/agent-harness/cli_anything/obsidian/README.mdnew file mode 100644index 000000000..7f445d784--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/README.md@@ -0,0 +1,190 @@+# Obsidian CLI++A command-line interface for knowledge management and note-taking via the Obsidian Local REST API.+Designed for AI agents and power users who need to manage notes, search the vault, and execute commands without a GUI.++## Prerequisites++- Python 3.10++- [Obsidian](https://obsidian.md) installed and running with the [Local REST API plugin](https://github.com/coddingtonbear/obsidian-local-rest-api) enabled+- `click` (CLI framework)+- `requests` (HTTP client)++Optional (for interactive REPL):+- `prompt_toolkit`++## Install Dependencies++```bash+pip install click requests prompt_toolkit+```++## How to Run++All commands are run from the `agent-harness/` directory, or via the installed entry point.++### One-shot commands++```bash+# Show help+cli-anything-obsidian --help++# List vault files+cli-anything-obsidian vault list++# Read a note+cli-anything-obsidian vault read "Notes/my-note.md"++# Search the vault+cli-anything-obsidian search simple "meeting notes"++# JSON output (for agent consumption)+cli-anything-obsidian --json server status+```++### Interactive REPL++```bash+cli-anything-obsidian+# Enter commands interactively with tab-completion and history+```++Inside the REPL, type `help` for all available commands.++## Command Reference++### Vault++```bash+vault list [path] # List files in the vault (or subdirectory)+vault read <path> # Read note content+vault create <path> --content "..." # Create a new note+vault update <path> --content "..." # Overwrite a note+vault delete <path> # Delete a note+vault append <path> --content "..." # Append content to a note+```++### Search++```bash+search query <query> # Search using Obsidian query syntax+search simple <query> # Plain text search across the vault+```++### Note++```bash+note active # Get the currently active note+note open <path> # Open a note in Obsidian+```++### Command++```bash+command list # List all available Obsidian commands+command execute <id> # Execute a command by ID+```++### Server++```bash+server status # Check if Obsidian Local REST API is running+```++### Session++```bash+session status # Show session state+```++## JSON Mode++Add `--json` before the subcommand for machine-readable output:++```bash+cli-anything-obsidian --json vault list+cli-anything-obsidian --json search simple "project ideas"+```++## API Key++Provide your Obsidian Local REST API key via flag or environment variable:++```bash+# Via flag+cli-anything-obsidian --api-key YOUR_KEY vault list++# Via environment variable+export OBSIDIAN_API_KEY=YOUR_KEY+cli-anything-obsidian vault list+```++## Example Workflow++```bash+# Check server+cli-anything-obsidian server status++# List all notes+cli-anything-obsidian vault list++# Read a specific note+cli-anything-obsidian vault read "Daily Notes/2024-01-15.md"++# Create a new note+cli-anything-obsidian vault create "Projects/new-project.md" --content "# New Project\n\nProject notes here."++# Search for notes+cli-anything-obsidian search simple "quarterly review"++# Append to a note+cli-anything-obsidian vault append "Projects/new-project.md" --content "\n## Update\nProgress notes."++# Open a note in Obsidian+cli-anything-obsidian note open "Projects/new-project.md"++# Execute a command+cli-anything-obsidian command list+cli-anything-obsidian command execute "editor:toggle-bold"++# Clean up+cli-anything-obsidian vault delete "Projects/new-project.md"+```++## Output Formats++All commands support dual output modes:++- **Human-readable** (default): Tables, colors, formatted text+- **Machine-readable** (`--json` flag): Structured JSON for agent consumption++```bash+# Human output+cli-anything-obsidian vault list++# JSON output for agents+cli-anything-obsidian --json vault list+```++## For AI Agents++When using this CLI programmatically:++1. **Always use `--json` flag** for parseable output+2. **Check return codes** - 0 for success, non-zero for errors+3. **Parse stderr** for error messages on failure+4. **Set `OBSIDIAN_API_KEY`** environment variable to avoid passing `--api-key` on every call+5. **Verify Obsidian is running** with `server status` before other commands++## Running Tests++```bash+cd agent-harness+python -m pytest cli_anything/obsidian/tests/test_core.py -v # Unit tests (no Obsidian needed)+python -m pytest cli_anything/obsidian/tests/test_full_e2e.py -v # E2E tests (requires Obsidian)+python -m pytest cli_anything/obsidian/tests/ -v # All tests+```++## Version++1.0.0diff --git a/obsidian/agent-harness/cli_anything/obsidian/__init__.py b/obsidian/agent-harness/cli_anything/obsidian/__init__.pynew file mode 100644index 000000000..1ba925328--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/__init__.py@@ -0,0 +1 @@+"""Obsidian CLI - Knowledge management and note-taking."""diff --git a/obsidian/agent-harness/cli_anything/obsidian/__main__.py b/obsidian/agent-harness/cli_anything/obsidian/__main__.pynew file mode 100644index 000000000..0b46208fa--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/__main__.py@@ -0,0 +1,3 @@+"""Allow running as python -m cli_anything.obsidian"""+from cli_anything.obsidian.obsidian_cli import main+main()diff --git a/obsidian/agent-harness/cli_anything/obsidian/core/__init__.py b/obsidian/agent-harness/cli_anything/obsidian/core/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/obsidian/agent-harness/cli_anything/obsidian/core/command.py b/obsidian/agent-harness/cli_anything/obsidian/core/command.pynew file mode 100644index 000000000..59468e8a4--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/core/command.py@@ -0,0 +1,14 @@+"""Obsidian command operations — list and execute."""++from cli_anything.obsidian.utils.obsidian_backend import api_get, api_post+++def list_commands(base_url: str, api_key: str) -> dict:+ """List available Obsidian commands."""+ return api_get(base_url, "/commands/", api_key)+++def execute_command(base_url: str, api_key: str, command_id: str) -> dict:+ """Execute an Obsidian command by ID."""+ endpoint = f"/commands/{command_id}/"+ return api_post(base_url, endpoint, api_key)diff --git a/obsidian/agent-harness/cli_anything/obsidian/core/note.py b/obsidian/agent-harness/cli_anything/obsidian/core/note.pynew file mode 100644index 000000000..7fc97ea0f--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/core/note.py@@ -0,0 +1,14 @@+"""Obsidian active note operations — get and open."""++from cli_anything.obsidian.utils.obsidian_backend import api_get, api_put+++def get_active(base_url: str, api_key: str) -> dict:+ """Get the currently active (open) note in Obsidian."""+ return api_get(base_url, "/active/", api_key)+++def open_note(base_url: str, api_key: str, path: str) -> dict:+ """Open a note in Obsidian."""+ return api_put(base_url, "/active/", api_key, content=path,+ content_type="text/plain")diff --git a/obsidian/agent-harness/cli_anything/obsidian/core/search.py b/obsidian/agent-harness/cli_anything/obsidian/core/search.pynew file mode 100644index 000000000..9b6ad9723--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/core/search.py@@ -0,0 +1,35 @@+"""Obsidian search operations — query and simple text search."""++from cli_anything.obsidian.utils.obsidian_backend import api_post+++def search_query(base_url: str, api_key: str, query: str) -> dict:+ """Search vault using Obsidian's simple text search.++ Args:+ base_url: API base URL.+ api_key: Bearer token.+ query: Search query string.++ Returns:+ List of search results with filename, score, and matches.+ """+ return api_post(base_url, "/search/simple/", api_key,+ params={"query": query, "contextLength": 100})+++def search_simple(base_url: str, api_key: str, query: str,+ context_length: int = 100) -> dict:+ """Simple text search across the vault.++ Args:+ base_url: API base URL.+ api_key: Bearer token.+ query: Plain text to search for.+ context_length: Number of context characters around matches.++ Returns:+ List of search results with filename and matches.+ """+ return api_post(base_url, "/search/simple/", api_key,+ params={"query": query, "contextLength": context_length})diff --git a/obsidian/agent-harness/cli_anything/obsidian/core/server.py b/obsidian/agent-harness/cli_anything/obsidian/core/server.pynew file mode 100644index 000000000..7a0ace8fc--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/core/server.py@@ -0,0 +1,12 @@+"""Obsidian server info — status check."""++from cli_anything.obsidian.utils.obsidian_backend import api_get+++def server_status(base_url: str, api_key: str) -> dict:+ """Check if Obsidian REST API is running and authenticated.++ Returns:+ Dict with server status info.+ """+ return api_get(base_url, "/", api_key)diff --git a/obsidian/agent-harness/cli_anything/obsidian/core/vault.py b/obsidian/agent-harness/cli_anything/obsidian/core/vault.pynew file mode 100644index 000000000..3ecd65681--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/core/vault.py@@ -0,0 +1,62 @@+"""Obsidian vault operations — list, read, create, update, delete, append."""++from cli_anything.obsidian.utils.obsidian_backend import (+ api_get, api_put, api_delete,+)+++def list_files(base_url: str, api_key: str, path: str = "/") -> dict:+ """List files and folders in the vault."""+ endpoint = f"/vault/{path.strip('/')}/" if path != "/" else "/vault/"+ return api_get(base_url, endpoint, api_key)+++def read_note(base_url: str, api_key: str, path: str) -> dict:+ """Read a note's content."""+ endpoint = f"/vault/{path.lstrip('/')}"+ return api_get(base_url, endpoint, api_key)+++def create_note(base_url: str, api_key: str, path: str, content: str) -> dict:+ """Create a new note in the vault."""+ endpoint = f"/vault/{path.lstrip('/')}"+ return api_put(base_url, endpoint, api_key, content=content)+++def update_note(base_url: str, api_key: str, path: str, content: str) -> dict:+ """Update an existing note's content (overwrites)."""+ endpoint = f"/vault/{path.lstrip('/')}"+ return api_put(base_url, endpoint, api_key, content=content)+++def delete_note(base_url: str, api_key: str, path: str) -> dict:+ """Delete a note from the vault."""+ endpoint = f"/vault/{path.lstrip('/')}"+ return api_delete(base_url, endpoint, api_key)+++def append_note(base_url: str, api_key: str, path: str, content: str,+ position: str = "end") -> dict:+ """Append or prepend content to an existing note.++ Reads the current content, inserts new content at the specified position,+ and writes back. This approach works with Obsidian REST API v3.x which+ changed PATCH to target-based operations.++ Args:+ base_url: API base URL.+ api_key: Bearer token.+ path: Path to the note.+ content: Content to insert.+ position: 'end' to append, 'beginning' to prepend.++ Returns:+ Status dict.+ """+ existing = read_note(base_url, api_key, path)+ current = existing.get("content", "")+ if position == "beginning":+ new_content = content + current+ else:+ new_content = current + content+ return update_note(base_url, api_key, path, new_content)diff --git a/obsidian/agent-harness/cli_anything/obsidian/obsidian_cli.py b/obsidian/agent-harness/cli_anything/obsidian/obsidian_cli.pynew file mode 100644index 000000000..91f7d4877--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/obsidian_cli.py@@ -0,0 +1,452 @@+#!/usr/bin/env python3+"""Obsidian CLI — Knowledge management and note-taking via Obsidian Local REST API.++This CLI provides full access to the Obsidian REST API for managing notes,+searching the vault, and executing Obsidian commands.++Usage:+ # One-shot commands+ cli-anything-obsidian --api-key YOUR_KEY vault list+ cli-anything-obsidian --api-key YOUR_KEY vault read "My Note.md"+ cli-anything-obsidian --api-key YOUR_KEY --json search query "tag:#project"++ # Interactive REPL+ cli-anything-obsidian --api-key YOUR_KEY+"""++import sys+import os+import json+import shlex+import click+from cli_anything.obsidian.utils.obsidian_backend import DEFAULT_BASE_URL+from cli_anything.obsidian.core import vault as vault_mod+from cli_anything.obsidian.core import search as search_mod+from cli_anything.obsidian.core import note as note_mod+from cli_anything.obsidian.core import command as cmd_mod+from cli_anything.obsidian.core import server as server_mod++# Global state+_json_output = False+_repl_mode = False+_host = DEFAULT_BASE_URL+_api_key = ""+_last_path: str = ""+++def output(data, message: str = ""):+ if _json_output:+ click.echo(json.dumps(data, indent=2, default=str))+ else:+ if message:+ click.echo(message)+ if isinstance(data, dict):+ _print_dict(data)+ elif isinstance(data, list):+ _print_list(data)+ else:+ click.echo(str(data))+++def _print_dict(d: dict, indent: int = 0):+ prefix = " " * indent+ for k, v in d.items():+ if isinstance(v, dict):+ click.echo(f"{prefix}{k}:")+ _print_dict(v, indent + 1)+ elif isinstance(v, list):+ click.echo(f"{prefix}{k}:")+ _print_list(v, indent + 1)+ else:+ click.echo(f"{prefix}{k}: {v}")+++def _print_list(items: list, indent: int = 0):+ prefix = " " * indent+ for i, item in enumerate(items):+ if isinstance(item, dict):+ click.echo(f"{prefix}[{i}]")+ _print_dict(item, indent + 1)+ else:+ click.echo(f"{prefix}- {item}")+++def handle_error(func):+ def wrapper(*args, **kwargs):+ try:+ return func(*args, **kwargs)+ except RuntimeError as e:+ if _json_output:+ click.echo(json.dumps({"error": str(e), "type": "runtime_error"}))+ else:+ click.echo(f"Error: {e}", err=True)+ if not _repl_mode:+ sys.exit(1)+ except (ValueError, IndexError) as e:+ if _json_output:+ click.echo(json.dumps({"error": str(e), "type": type(e).__name__}))+ else:+ click.echo(f"Error: {e}", err=True)+ if not _repl_mode:+ sys.exit(1)+ wrapper.__name__ = func.__name__+ wrapper.__doc__ = func.__doc__+ return wrapper+++def _require_api_key():+ """Check that API key is set, raise error if not."""+ if not _api_key:+ raise RuntimeError("API key required. Use --api-key or set OBSIDIAN_API_KEY env var.")+++# ── Main CLI Group ──────────────────────────────────────────────[email protected](invoke_without_command=True)[email protected]("--json", "use_json", is_flag=True, help="Output as JSON")[email protected]("--host", type=str, default=None,+ help=f"Obsidian REST API URL (default: {DEFAULT_BASE_URL})")[email protected]("--api-key", type=str, default=None,+ help="API key for authentication (or set OBSIDIAN_API_KEY env var)")[email protected]_context+def cli(ctx, use_json, host, api_key):+ """Obsidian CLI — Knowledge management and note-taking.++ Run without a subcommand to enter interactive REPL mode.+ """+ global _json_output, _host, _api_key+ _json_output = use_json+ if host:+ _host = host+ _api_key = api_key or os.environ.get("OBSIDIAN_API_KEY", "")++ if ctx.invoked_subcommand is None:+ _require_api_key()+ ctx.invoke(repl)+++# ── Vault Commands ──────────────────────────────────────────────+def vault():+ """Vault file operations."""+ pass++[email protected]("list")[email protected]("path", default="/")+@handle_error+def vault_list(path):+ """List files and folders in the vault."""+ _require_api_key()+ result = vault_mod.list_files(_host, _api_key, path)+ files = result.get("files", [])+ if _json_output:+ output(result)+ else:+ if not files:+ click.echo("No files found.")+ return+ click.echo(f"{'FILE':<60}")+ click.echo("─" * 60)+ for f in files:+ click.echo(f"{f}")++[email protected]("read")[email protected]("path")+@handle_error+def vault_read(path):+ """Read a note's content."""+ _require_api_key()+ global _last_path+ _last_path = path+ result = vault_mod.read_note(_host, _api_key, path)+ if _json_output:+ output(result)+ else:+ click.echo(result.get("content", ""))++[email protected]("create")[email protected]("path")[email protected]("--content", "-c", default="", help="Note content (markdown)")[email protected]("--file", "-f", "input_file", type=click.Path(exists=True),+ help="Read content from file")+@handle_error+def vault_create(path, content, input_file):+ """Create a new note in the vault."""+ _require_api_key()+ if input_file:+ with open(input_file, "r", encoding="utf-8") as fh:+ content = fh.read()+ result = vault_mod.create_note(_host, _api_key, path, content)+ output(result, f"Created: {path}")++[email protected]("update")[email protected]("path")[email protected]("--content", "-c", default="", help="New note content (markdown)")[email protected]("--file", "-f", "input_file", type=click.Path(exists=True),+ help="Read content from file")+@handle_error+def vault_update(path, content, input_file):+ """Update an existing note (overwrites content)."""+ _require_api_key()+ if input_file:+ with open(input_file, "r", encoding="utf-8") as fh:+ content = fh.read()+ result = vault_mod.update_note(_host, _api_key, path, content)+ output(result, f"Updated: {path}")++[email protected]("delete")[email protected]("path")+@handle_error+def vault_delete(path):+ """Delete a note from the vault."""+ _require_api_key()+ result = vault_mod.delete_note(_host, _api_key, path)+ output(result, f"Deleted: {path}")++[email protected]("append")[email protected]("path")[email protected]("--content", "-c", required=True, help="Content to append")[email protected]("--position", "-p", type=click.Choice(["end", "beginning"]),+ default="end", help="Insert position (default: end)")+@handle_error+def vault_append(path, content, position):+ """Append or prepend content to a note."""+ _require_api_key()+ result = vault_mod.append_note(_host, _api_key, path, content, position=position)+ output(result, f"{'Appended to' if position == 'end' else 'Prepended to'}: {path}")+++# ── Search Commands ─────────────────────────────────────────────+def search():+ """Search operations."""+ pass++[email protected]("query")[email protected]("query")+@handle_error+def search_query(query):+ """Search vault using Obsidian's search engine."""+ _require_api_key()+ result = search_mod.search_query(_host, _api_key, query)+ if _json_output:+ output(result)+ else:+ if isinstance(result, list):+ if not result:+ click.echo("No results found.")+ return+ for item in result:+ filename = item.get("filename", "unknown")+ score = item.get("score", "")+ click.echo(f" {filename}" + (f" (score: {score})" if score else ""))+ else:+ output(result)++[email protected]("simple")[email protected]("query")[email protected]("--context-length", "-l", type=int, default=100,+ help="Context characters around matches (default: 100)")+@handle_error+def search_simple(query, context_length):+ """Simple text search across the vault."""+ _require_api_key()+ result = search_mod.search_simple(_host, _api_key, query, context_length=context_length)+ if _json_output:+ output(result)+ else:+ if isinstance(result, list):+ if not result:+ click.echo("No results found.")+ return+ for item in result:+ filename = item.get("filename", "unknown")+ matches = item.get("matches", [])+ click.echo(f" {filename} ({len(matches)} matches)")+ for match in matches[:3]:+ context = match.get("context", match.get("match", ""))+ if len(context) > 120:+ context = context[:120] + "..."+ click.echo(f" ...{context}...")+ else:+ output(result)+++# ── Note Commands ───────────────────────────────────────────────+def note():+ """Active note operations."""+ pass++[email protected]("active")+@handle_error+def note_active():+ """Get the currently active note in Obsidian."""+ _require_api_key()+ result = note_mod.get_active(_host, _api_key)+ if _json_output:+ output(result)+ else:+ click.echo(result.get("content", "(no active note)"))++[email protected]("open")[email protected]("path")+@handle_error+def note_open(path):+ """Open a note in Obsidian."""+ _require_api_key()+ global _last_path+ _last_path = path+ result = note_mod.open_note(_host, _api_key, path)+ output(result, f"Opened: {path}")+++# ── Command Commands ────────────────────────────────────────────[email protected]("command")+def command_group():+ """Obsidian command operations."""+ pass+++@command_group.command("list")+@handle_error+def command_list():+ """List available Obsidian commands."""+ _require_api_key()+ result = cmd_mod.list_commands(_host, _api_key)+ if _json_output:+ output(result)+ else:+ commands = result.get("commands", result if isinstance(result, list) else [])+ if not commands:+ click.echo("No commands available.")+ return+ click.echo(f"{'ID':<40} {'NAME'}")+ click.echo("─" * 70)+ for cmd in commands:+ cmd_id = cmd.get("id", "")+ cmd_name = cmd.get("name", "")+ click.echo(f"{cmd_id:<40} {cmd_name}")+++@command_group.command("execute")[email protected]("command_id")+@handle_error+def command_execute(command_id):+ """Execute an Obsidian command by ID."""+ _require_api_key()+ result = cmd_mod.execute_command(_host, _api_key, command_id)+ output(result, f"Executed: {command_id}")+++# ── Server Commands ─────────────────────────────────────────────+def server():+ """Server status commands."""+ pass++[email protected]("status")+@handle_error+def server_status():+ """Check if Obsidian REST API is running."""+ _require_api_key()+ result = server_mod.server_status(_host, _api_key)+ output(result, f"Obsidian REST API at {_host}: running")+++# ── Session Commands ────────────────────────────────────────────+def session():+ """Session state commands."""+ pass++[email protected]("status")+@handle_error+def session_status():+ """Show current session state."""+ data = {+ "host": _host,+ "api_key_set": bool(_api_key),+ "last_path": _last_path or "(none)",+ "json_output": _json_output,+ }+ output(data, "Session Status")+++# ── REPL ────────────────────────────────────────────────────────+@handle_error+def repl():+ """Start interactive REPL session."""+ from cli_anything.obsidian.utils.repl_skin import ReplSkin++ global _repl_mode+ _repl_mode = True++ skin = ReplSkin("obsidian", version="1.0.0")+ skin.print_banner()++ pt_session = skin.create_prompt_session()++ _repl_commands = {+ "vault": "list|read|create|update|delete|append",+ "search": "query|simple",+ "note": "active|open",+ "command": "list|execute",+ "server": "status",+ "session": "status",+ "help": "Show this help",+ "quit": "Exit REPL",+ }++ while True:+ try:+ context = _last_path if _last_path else ""+ line = skin.get_input(pt_session, project_name=context, modified=False)+ if not line:+ continue+ if line.lower() in ("quit", "exit", "q"):+ skin.print_goodbye()+ break+ if line.lower() == "help":+ skin.help(_repl_commands)+ continue++ try:+ args = shlex.split(line)+ except ValueError:+ args = line.split()+ try:+ cli.main(args, standalone_mode=False)+ except SystemExit:+ pass+ except click.exceptions.UsageError as e:+ skin.warning(f"Usage error: {e}")+ except Exception as e:+ skin.error(f"{e}")++ except (EOFError, KeyboardInterrupt):+ skin.print_goodbye()+ break++ _repl_mode = False+++# ── Entry Point ─────────────────────────────────────────────────+def main():+ cli()+++if __name__ == "__main__":+ main()diff --git a/obsidian/agent-harness/cli_anything/obsidian/skills/SKILL.md b/obsidian/agent-harness/cli_anything/obsidian/skills/SKILL.mdnew file mode 100644index 000000000..d7e1fd9f1--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/skills/SKILL.md@@ -0,0 +1,235 @@+---+name: >-+ cli-anything-obsidian+description: >-+ Command-line interface for Obsidian — Knowledge management and note-taking via Obsidian Local REST API. Designed for AI agents and power users who need to manage notes, search the vault, and execute commands without the GUI.+---++# cli-anything-obsidian++Knowledge management and note-taking via the Obsidian Local REST API. Designed for AI agents and power users who need to manage notes, search the vault, and execute commands without the GUI.++## Installation++This CLI is installed as part of the cli-anything-obsidian package:++```bash+pip install cli-anything-obsidian+```++**Prerequisites:**+- Python 3.10++- Obsidian must be installed and running with the [Local REST API plugin](https://github.com/coddingtonbear/obsidian-local-rest-api) enabled+++## Usage++### Basic Commands++```bash+# Show help+cli-anything-obsidian --help++# Start interactive REPL mode+cli-anything-obsidian++# List vault files+cli-anything-obsidian vault list++# Run with JSON output (for agent consumption)+cli-anything-obsidian --json vault list+```++### REPL Mode++When invoked without a subcommand, the CLI enters an interactive REPL session:++```bash+cli-anything-obsidian+# Enter commands interactively with tab-completion and history+```+++## Command Groups+++### Vault++Vault file management commands.++| Command | Description |+|---------|-------------|+| `list` | List files in the vault or a subdirectory |+| `read` | Read the content of a note |+| `create` | Create a new note |+| `update` | Overwrite an existing note |+| `delete` | Delete a note from the vault |+| `append` | Append content to an existing note |+++### Search++Vault search commands.++| Command | Description |+|---------|-------------|+| `query` | Search using Obsidian query syntax |+| `simple` | Plain text search across the vault |+++### Note++Active note commands.++| Command | Description |+|---------|-------------|+| `active` | Get the currently active note in Obsidian |+| `open` | Open a note in the Obsidian editor |+++### Command++Obsidian command palette commands.++| Command | Description |+|---------|-------------|+| `list` | List all available Obsidian commands |+| `execute` | Execute a command by its ID |+++### Server++Server status and info commands.++| Command | Description |+|---------|-------------|+| `status` | Check if the Obsidian Local REST API is running |+++### Session++Session state commands.++| Command | Description |+|---------|-------------|+| `status` | Show current session state |++++## Examples+++### List and Read Notes++```bash+# List all vault files+cli-anything-obsidian vault list++# List files in a subdirectory+cli-anything-obsidian vault list "Daily Notes"++# Read a note+cli-anything-obsidian vault read "Projects/my-project.md"+```+++### Create and Update Notes++```bash+# Create a new note+cli-anything-obsidian vault create "Projects/new-project.md" --content "# New Project"++# Update (overwrite) a note+cli-anything-obsidian vault update "Projects/new-project.md" --content "# Updated Content"++# Append to a note+cli-anything-obsidian vault append "Projects/new-project.md" --content "\n## New Section"+```+++### Search++```bash+# Plain text search+cli-anything-obsidian search simple "meeting notes"++# Obsidian query syntax search (tags, links, etc.)+cli-anything-obsidian search query "tag:#project"+```+++### Commands++```bash+# List available commands+cli-anything-obsidian command list++# Execute a command by ID+cli-anything-obsidian command execute "editor:toggle-bold"+```+++### Interactive REPL Session++Start an interactive session for exploratory use.++```bash+cli-anything-obsidian+# Enter commands interactively+# Use 'help' to see available commands+```+++### API Key Configuration++```bash+# Via flag+cli-anything-obsidian --api-key YOUR_KEY vault list++# Via environment variable (recommended for agents)+export OBSIDIAN_API_KEY=YOUR_KEY+cli-anything-obsidian vault list+```+++## State Management++The CLI maintains lightweight session state:++- **API key**: Configurable via `--api-key` or `OBSIDIAN_API_KEY` environment variable+- **Host URL**: Defaults to `https://localhost:27124`; configurable via `--host`++## Output Formats++All commands support dual output modes:++- **Human-readable** (default): Tables, colors, formatted text+- **Machine-readable** (`--json` flag): Structured JSON for agent consumption++```bash+# Human output+cli-anything-obsidian vault list++# JSON output for agents+cli-anything-obsidian --json vault list+```++## For AI Agents++When using this CLI programmatically:++1. **Always use `--json` flag** for parseable output+2. **Check return codes** - 0 for success, non-zero for errors+3. **Parse stderr** for error messages on failure+4. **Set `OBSIDIAN_API_KEY`** environment variable to avoid passing `--api-key` on every call+5. **Verify Obsidian is running** with `server status` before other commands++## More Information++- Full documentation: See README.md in the package+- Test coverage: See TEST.md in the package+- Methodology: See HARNESS.md in the cli-anything-plugin++## Version++1.0.0diff --git a/obsidian/agent-harness/cli_anything/obsidian/tests/TEST.md b/obsidian/agent-harness/cli_anything/obsidian/tests/TEST.mdnew file mode 100644index 000000000..2079a5464--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/tests/TEST.md@@ -0,0 +1,36 @@+# Test Plan — cli-anything-obsidian++## Unit Tests (`test_core.py`)++Run without any backend:++```bash+python -m pytest cli_anything/obsidian/tests/test_core.py -v+```++Covers:+- Backend URL construction and auth headers+- API client error handling (connection, timeout, HTTP errors)+- JSON and text response parsing+- CLI argument parsing (--help for all groups)+- --json flag output+- --api-key and --host flags+- Session state management+- Vault commands with mocked API+- Search commands with mocked API+- Error handling (missing API key, connection errors)+- Core module function calls with mocked backend++## E2E Tests (`test_full_e2e.py`)++Requires Obsidian running with Local REST API plugin:++```bash+OBSIDIAN_API_KEY=your-key python -m pytest cli_anything/obsidian/tests/test_full_e2e.py -v+```++Covers:+- Server status check+- Vault list, create, read, append, delete lifecycle+- Simple search+- Automatic cleanup of test notesdiff --git a/obsidian/agent-harness/cli_anything/obsidian/tests/__init__.py b/obsidian/agent-harness/cli_anything/obsidian/tests/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/obsidian/agent-harness/cli_anything/obsidian/tests/test_core.py b/obsidian/agent-harness/cli_anything/obsidian/tests/test_core.pynew file mode 100644index 000000000..a404e7aa7--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/tests/test_core.py@@ -0,0 +1,434 @@+"""Unit tests for cli-anything-obsidian — no Obsidian server required."""++import json+import pytest+from unittest.mock import patch, MagicMock+from click.testing import CliRunner+++# ── Backend URL construction & API calls ─────────────────────────++class TestBackend:+ def test_default_base_url(self):+ from cli_anything.obsidian.utils.obsidian_backend import DEFAULT_BASE_URL+ assert DEFAULT_BASE_URL == "https://localhost:27124"++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_is_available_true(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import is_available+ mock_resp = MagicMock()+ mock_resp.status_code = 200+ mock_get.return_value = mock_resp+ assert is_available("test-key") is True+ mock_get.assert_called_once_with(+ "https://localhost:27124/",+ headers={"Authorization": "Bearer test-key"},+ timeout=5,+ verify=False,+ )++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_is_available_false(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import is_available+ import requests+ mock_get.side_effect = requests.exceptions.ConnectionError()+ assert is_available("test-key") is False++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_api_get_connection_error(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import api_get+ import requests+ mock_get.side_effect = requests.exceptions.ConnectionError()+ with pytest.raises(RuntimeError, match="Cannot connect to Obsidian"):+ api_get("https://localhost:27124", "/", "test-key")++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.post")+ def test_api_post_connection_error(self, mock_post):+ from cli_anything.obsidian.utils.obsidian_backend import api_post+ import requests+ mock_post.side_effect = requests.exceptions.ConnectionError()+ with pytest.raises(RuntimeError, match="Cannot connect to Obsidian"):+ api_post("https://localhost:27124", "/search/", "test-key", data={"query": "test"})++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.delete")+ def test_api_delete_connection_error(self, mock_delete):+ from cli_anything.obsidian.utils.obsidian_backend import api_delete+ import requests+ mock_delete.side_effect = requests.exceptions.ConnectionError()+ with pytest.raises(RuntimeError, match="Cannot connect to Obsidian"):+ api_delete("https://localhost:27124", "/vault/test.md", "test-key")++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_api_get_json_response(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import api_get+ mock_resp = MagicMock()+ mock_resp.status_code = 200+ mock_resp.content = b'{"files": []}'+ mock_resp.headers = {"content-type": "application/json"}+ mock_resp.json.return_value = {"files": []}+ mock_resp.raise_for_status.return_value = None+ mock_get.return_value = mock_resp+ result = api_get("https://localhost:27124", "/vault/", "test-key")+ assert result == {"files": []}++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_api_get_text_response(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import api_get+ mock_resp = MagicMock()+ mock_resp.status_code = 200+ mock_resp.content = b"# My Note\nHello world"+ mock_resp.headers = {"content-type": "text/markdown"}+ mock_resp.text = "# My Note\nHello world"+ mock_resp.raise_for_status.return_value = None+ mock_get.return_value = mock_resp+ result = api_get("https://localhost:27124", "/vault/test.md", "test-key")+ assert result == {"content": "# My Note\nHello world"}++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_api_get_trailing_slash_stripped(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import api_get+ mock_resp = MagicMock()+ mock_resp.status_code = 200+ mock_resp.content = b'{"status": "ok"}'+ mock_resp.headers = {"content-type": "application/json"}+ mock_resp.json.return_value = {"status": "ok"}+ mock_resp.raise_for_status.return_value = None+ mock_get.return_value = mock_resp+ api_get("https://localhost:27124/", "/", "test-key")+ mock_get.assert_called_once_with(+ "https://localhost:27124/",+ headers={"Authorization": "Bearer test-key", "Accept": "application/json"},+ params=None,+ timeout=30,+ verify=False,+ )++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.get")+ def test_api_get_timeout(self, mock_get):+ from cli_anything.obsidian.utils.obsidian_backend import api_get+ import requests+ mock_get.side_effect = requests.exceptions.Timeout()+ with pytest.raises(RuntimeError, match="timed out"):+ api_get("https://localhost:27124", "/", "test-key")++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.put")+ def test_api_put_text(self, mock_put):+ from cli_anything.obsidian.utils.obsidian_backend import api_put+ mock_resp = MagicMock()+ mock_resp.status_code = 204+ mock_resp.content = b""+ mock_resp.raise_for_status.return_value = None+ mock_put.return_value = mock_resp+ result = api_put("https://localhost:27124", "/vault/test.md", "test-key", content="# Hello")+ assert result == {"status": "ok"}++ @patch("cli_anything.obsidian.utils.obsidian_backend.requests.patch")+ def test_api_patch(self, mock_patch):+ from cli_anything.obsidian.utils.obsidian_backend import api_patch+ mock_resp = MagicMock()+ mock_resp.status_code = 200+ mock_resp.content = b'{"status": "ok"}'+ mock_resp.headers = {"content-type": "application/json"}+ mock_resp.json.return_value = {"status": "ok"}+ mock_resp.raise_for_status.return_value = None+ mock_patch.return_value = mock_resp+ result = api_patch("https://localhost:27124", "/vault/test.md", "test-key",+ content="appended text", position="end")+ assert result == {"status": "ok"}+++# ── Core module tests ────────────────────────────────────────────++class TestServerModule:+ @patch("cli_anything.obsidian.core.server.api_get")+ def test_server_status(self, mock_api):+ from cli_anything.obsidian.core.server import server_status+ mock_api.return_value = {"status": "OK", "authenticated": True}+ result = server_status("https://localhost:27124", "test-key")+ assert result["status"] == "OK"+ mock_api.assert_called_once_with("https://localhost:27124", "/", "test-key")+++class TestVaultModule:+ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_list_files_root(self, mock_api):+ from cli_anything.obsidian.core.vault import list_files+ mock_api.return_value = {"files": ["note1.md", "folder/note2.md"]}+ result = list_files("https://localhost:27124", "test-key")+ assert len(result["files"]) == 2+ mock_api.assert_called_once_with("https://localhost:27124", "/vault/", "test-key")++ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_list_files_subfolder(self, mock_api):+ from cli_anything.obsidian.core.vault import list_files+ mock_api.return_value = {"files": ["note2.md"]}+ result = list_files("https://localhost:27124", "test-key", path="folder")+ mock_api.assert_called_once_with("https://localhost:27124", "/vault/folder/", "test-key")++ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_read_note(self, mock_api):+ from cli_anything.obsidian.core.vault import read_note+ mock_api.return_value = {"content": "# Hello\nWorld"}+ result = read_note("https://localhost:27124", "test-key", "note.md")+ assert result["content"] == "# Hello\nWorld"++ @patch("cli_anything.obsidian.core.vault.api_put")+ def test_create_note(self, mock_api):+ from cli_anything.obsidian.core.vault import create_note+ mock_api.return_value = {"status": "ok"}+ result = create_note("https://localhost:27124", "test-key", "new.md", "# New")+ assert result["status"] == "ok"+ mock_api.assert_called_once_with(+ "https://localhost:27124", "/vault/new.md", "test-key", content="# New"+ )++ @patch("cli_anything.obsidian.core.vault.api_put")+ def test_update_note(self, mock_api):+ from cli_anything.obsidian.core.vault import update_note+ mock_api.return_value = {"status": "ok"}+ result = update_note("https://localhost:27124", "test-key", "note.md", "# Updated")+ assert result["status"] == "ok"++ @patch("cli_anything.obsidian.core.vault.api_delete")+ def test_delete_note(self, mock_api):+ from cli_anything.obsidian.core.vault import delete_note+ mock_api.return_value = {"status": "ok"}+ result = delete_note("https://localhost:27124", "test-key", "note.md")+ assert result["status"] == "ok"++ @patch("cli_anything.obsidian.core.vault.api_put")+ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_append_note(self, mock_get, mock_put):+ from cli_anything.obsidian.core.vault import append_note+ mock_get.return_value = {"content": "# Existing"}+ mock_put.return_value = {"status": "ok"}+ result = append_note("https://localhost:27124", "test-key", "note.md",+ "\nnew content", position="end")+ assert result["status"] == "ok"+ mock_put.assert_called_once_with(+ "https://localhost:27124", "/vault/note.md", "test-key",+ content="# Existing\nnew content"+ )+++class TestSearchModule:+ @patch("cli_anything.obsidian.core.search.api_post")+ def test_search_query(self, mock_api):+ from cli_anything.obsidian.core.search import search_query+ mock_api.return_value = [{"filename": "note.md", "score": 0.9}]+ result = search_query("https://localhost:27124", "test-key", "test query")+ mock_api.assert_called_once_with(+ "https://localhost:27124", "/search/simple/", "test-key",+ params={"query": "test query", "contextLength": 100}+ )++ @patch("cli_anything.obsidian.core.search.api_post")+ def test_search_simple(self, mock_api):+ from cli_anything.obsidian.core.search import search_simple+ mock_api.return_value = [{"filename": "note.md", "matches": []}]+ result = search_simple("https://localhost:27124", "test-key", "hello", context_length=50)+ mock_api.assert_called_once_with(+ "https://localhost:27124", "/search/simple/", "test-key",+ params={"query": "hello", "contextLength": 50}+ )+++class TestNoteModule:+ @patch("cli_anything.obsidian.core.note.api_get")+ def test_get_active(self, mock_api):+ from cli_anything.obsidian.core.note import get_active+ mock_api.return_value = {"content": "# Active Note"}+ result = get_active("https://localhost:27124", "test-key")+ assert result["content"] == "# Active Note"++ @patch("cli_anything.obsidian.core.note.api_put")+ def test_open_note(self, mock_api):+ from cli_anything.obsidian.core.note import open_note+ mock_api.return_value = {"status": "ok"}+ result = open_note("https://localhost:27124", "test-key", "folder/note.md")+ assert result["status"] == "ok"+++class TestCommandModule:+ @patch("cli_anything.obsidian.core.command.api_get")+ def test_list_commands(self, mock_api):+ from cli_anything.obsidian.core.command import list_commands+ mock_api.return_value = {"commands": [{"id": "editor:toggle-bold", "name": "Bold"}]}+ result = list_commands("https://localhost:27124", "test-key")+ assert len(result["commands"]) == 1++ @patch("cli_anything.obsidian.core.command.api_post")+ def test_execute_command(self, mock_api):+ from cli_anything.obsidian.core.command import execute_command+ mock_api.return_value = {"status": "ok"}+ result = execute_command("https://localhost:27124", "test-key", "editor:toggle-bold")+ assert result["status"] == "ok"+ mock_api.assert_called_once_with(+ "https://localhost:27124", "/commands/editor:toggle-bold/", "test-key"+ )+++# ── CLI tests ────────────────────────────────────────────────────++from cli_anything.obsidian.obsidian_cli import cli+++def runner():+ return CliRunner()+++class TestCLIParsing:+ def test_help(self, runner):+ result = runner.invoke(cli, ["--help"])+ assert result.exit_code == 0+ assert "Obsidian CLI" in result.output++ def test_vault_help(self, runner):+ result = runner.invoke(cli, ["vault", "--help"])+ assert result.exit_code == 0+ assert "list" in result.output+ assert "read" in result.output+ assert "create" in result.output+ assert "update" in result.output+ assert "delete" in result.output+ assert "append" in result.output++ def test_search_help(self, runner):+ result = runner.invoke(cli, ["search", "--help"])+ assert result.exit_code == 0+ assert "query" in result.output+ assert "simple" in result.output++ def test_note_help(self, runner):+ result = runner.invoke(cli, ["note", "--help"])+ assert result.exit_code == 0+ assert "active" in result.output+ assert "open" in result.output++ def test_command_help(self, runner):+ result = runner.invoke(cli, ["command", "--help"])+ assert result.exit_code == 0+ assert "list" in result.output+ assert "execute" in result.output++ def test_server_help(self, runner):+ result = runner.invoke(cli, ["server", "--help"])+ assert result.exit_code == 0+ assert "status" in result.output++ def test_session_help(self, runner):+ result = runner.invoke(cli, ["session", "--help"])+ assert result.exit_code == 0+ assert "status" in result.output++ def test_json_flag(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", "test", "session", "status"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert "host" in data++ def test_api_key_flag(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", "my-key", "session", "status"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert data["api_key_set"] is True++ def test_host_flag(self, runner):+ result = runner.invoke(cli, ["--host", "https://example:1234", "--api-key", "k",+ "--json", "session", "status"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert data["host"] == "https://example:1234"+++class TestSessionState:+ def test_session_status_defaults(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", "test", "session", "status"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert data["api_key_set"] is True+++class TestVaultCommands:+ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_vault_list_json(self, mock_api, runner):+ mock_api.return_value = {"files": ["note1.md", "folder/note2.md"]}+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "list"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert "files" in data++ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_vault_read_json(self, mock_api, runner):+ mock_api.return_value = {"content": "# Hello"}+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "read", "note.md"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert data["content"] == "# Hello"++ @patch("cli_anything.obsidian.core.vault.api_put")+ def test_vault_create_json(self, mock_api, runner):+ mock_api.return_value = {"status": "ok"}+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "create",+ "new.md", "--content", "# New Note"])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert data["status"] == "ok"++ @patch("cli_anything.obsidian.core.vault.api_delete")+ def test_vault_delete_json(self, mock_api, runner):+ mock_api.return_value = {"status": "ok"}+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "delete", "old.md"])+ assert result.exit_code == 0++ @patch("cli_anything.obsidian.core.vault.api_put")+ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_vault_append_json(self, mock_get, mock_put, runner):+ mock_get.return_value = {"content": "existing"}+ mock_put.return_value = {"status": "ok"}+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "append",+ "note.md", "--content", "extra text"])+ assert result.exit_code == 0+++class TestSearchCommands:+ @patch("cli_anything.obsidian.core.search.api_post")+ def test_search_query_json(self, mock_api, runner):+ mock_api.return_value = [{"filename": "note.md", "score": 0.9}]+ result = runner.invoke(cli, ["--json", "--api-key", "k", "search", "query", "test"])+ assert result.exit_code == 0++ @patch("cli_anything.obsidian.core.search.api_post")+ def test_search_simple_json(self, mock_api, runner):+ mock_api.return_value = [{"filename": "note.md", "matches": []}]+ result = runner.invoke(cli, ["--json", "--api-key", "k", "search", "simple", "hello"])+ assert result.exit_code == 0+++class TestErrorHandling:+ @patch("cli_anything.obsidian.core.server.api_get")+ def test_server_status_error(self, mock_api, runner):+ mock_api.side_effect = RuntimeError("Cannot connect to Obsidian")+ result = runner.invoke(cli, ["--api-key", "k", "server", "status"])+ assert result.exit_code == 1++ @patch("cli_anything.obsidian.core.server.api_get")+ def test_server_status_error_json(self, mock_api, runner):+ mock_api.side_effect = RuntimeError("Cannot connect to Obsidian")+ result = runner.invoke(cli, ["--json", "--api-key", "k", "server", "status"])+ assert result.exit_code == 1+ data = json.loads(result.output)+ assert "error" in data++ def test_missing_api_key(self, runner):+ result = runner.invoke(cli, ["server", "status"])+ assert result.exit_code == 1++ @patch("cli_anything.obsidian.core.vault.api_get")+ def test_vault_list_error_json(self, mock_api, runner):+ mock_api.side_effect = RuntimeError("Cannot connect to Obsidian")+ result = runner.invoke(cli, ["--json", "--api-key", "k", "vault", "list"])+ assert result.exit_code == 1+ data = json.loads(result.output)+ assert "error" in datadiff --git a/obsidian/agent-harness/cli_anything/obsidian/tests/test_full_e2e.py b/obsidian/agent-harness/cli_anything/obsidian/tests/test_full_e2e.pynew file mode 100644index 000000000..1b674bd37--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/tests/test_full_e2e.py@@ -0,0 +1,93 @@+"""E2E tests for cli-anything-obsidian — requires Obsidian running with Local REST API plugin.++These tests interact with a real Obsidian instance. Skip if not available.++Usage:+ OBSIDIAN_API_KEY=your-key python -m pytest cli_anything/obsidian/tests/test_full_e2e.py -v+"""++import os+import pytest+from click.testing import CliRunner++from cli_anything.obsidian.utils.obsidian_backend import is_available, DEFAULT_BASE_URL+from cli_anything.obsidian.obsidian_cli import cli++API_KEY = os.environ.get("OBSIDIAN_API_KEY", "")++# Skip all tests if Obsidian REST API is not running+pytestmark = pytest.mark.skipif(+ not API_KEY or not is_available(API_KEY, DEFAULT_BASE_URL),+ reason="Obsidian REST API not available (set OBSIDIAN_API_KEY and ensure Obsidian is running)"+)++TEST_NOTE = "_cli_anything_test_note.md"+TEST_CONTENT = "# Test Note\n\nCreated by cli-anything-obsidian E2E tests."+++def runner():+ return CliRunner()+++class TestServerE2E:+ def test_server_status(self, runner):+ result = runner.invoke(cli, ["--api-key", API_KEY, "server", "status"])+ assert result.exit_code == 0++ def test_server_status_json(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "server", "status"])+ assert result.exit_code == 0+ import json+ data = json.loads(result.output)+ assert "status" in data or "authenticated" in data+++class TestVaultE2E:+ def test_vault_list(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "vault", "list"])+ assert result.exit_code == 0+ import json+ data = json.loads(result.output)+ assert "files" in data++ def test_vault_create_read_delete(self, runner):+ import json+ # Create+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "vault", "create",+ TEST_NOTE, "--content", TEST_CONTENT])+ assert result.exit_code == 0++ # Read+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "vault", "read", TEST_NOTE])+ assert result.exit_code == 0+ data = json.loads(result.output)+ assert "Test Note" in data.get("content", "")++ # Delete+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "vault", "delete", TEST_NOTE])+ assert result.exit_code == 0++ def test_vault_append(self, runner):+ import json+ # Create note first+ runner.invoke(cli, ["--api-key", API_KEY, "vault", "create",+ TEST_NOTE, "--content", TEST_CONTENT])+ # Append+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "vault", "append",+ TEST_NOTE, "--content", "\n\nAppended line."])+ assert result.exit_code == 0+ # Cleanup+ runner.invoke(cli, ["--api-key", API_KEY, "vault", "delete", TEST_NOTE])+++class TestSearchE2E:+ def test_search_simple(self, runner):+ result = runner.invoke(cli, ["--json", "--api-key", API_KEY, "search", "simple", "the"])+ assert result.exit_code == 0+++class TestCleanup:+ def test_cleanup_test_note(self, runner):+ """Clean up test note if it still exists."""+ runner.invoke(cli, ["--api-key", API_KEY, "vault", "delete", TEST_NOTE])diff --git a/obsidian/agent-harness/cli_anything/obsidian/utils/__init__.py b/obsidian/agent-harness/cli_anything/obsidian/utils/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/obsidian/agent-harness/cli_anything/obsidian/utils/obsidian_backend.py b/obsidian/agent-harness/cli_anything/obsidian/utils/obsidian_backend.pynew file mode 100644index 000000000..9be3275c8--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/utils/obsidian_backend.py@@ -0,0 +1,192 @@+"""Obsidian Local REST API wrapper — the single module that makes network requests.++Obsidian Local REST API plugin runs an HTTPS server (default: https://localhost:27124).+Authentication is via Bearer token configured in the plugin settings.+Uses self-signed certificate by default (verify=False).+"""++import requests+import urllib3+from typing import Any++# Suppress InsecureRequestWarning for self-signed certs+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)++# Default Obsidian Local REST API URL+DEFAULT_BASE_URL = "https://localhost:27124"+++def _headers(api_key: str, accept: str = "application/json",+ content_type: str | None = None) -> dict:+ """Build request headers with Bearer auth."""+ h = {"Authorization": f"Bearer {api_key}", "Accept": accept}+ if content_type:+ h["Content-Type"] = content_type+ return h+++def api_get(base_url: str, endpoint: str, api_key: str,+ params: dict | None = None, timeout: int = 30) -> Any:+ """Perform a GET request against the Obsidian REST API."""+ url = f"{base_url.rstrip('/')}{endpoint}"+ try:+ resp = requests.get(url, headers=_headers(api_key),+ params=params, timeout=timeout, verify=False)+ resp.raise_for_status()+ if resp.status_code == 204 or not resp.content:+ return {"status": "ok"}+ content_type = resp.headers.get("content-type", "")+ if "application/json" in content_type:+ return resp.json()+ return {"content": resp.text}+ except requests.exceptions.ConnectionError as e:+ raise RuntimeError(+ f"Cannot connect to Obsidian REST API at {base_url}. "+ "Is Obsidian running with the Local REST API plugin enabled?"+ ) from e+ except requests.exceptions.HTTPError as e:+ raise RuntimeError(+ f"Obsidian API error {resp.status_code} on GET {endpoint}: {resp.text}"+ ) from e+ except requests.exceptions.Timeout as e:+ raise RuntimeError(+ f"Request to Obsidian timed out: GET {endpoint}"+ ) from e+++def api_post(base_url: str, endpoint: str, api_key: str,+ data: dict | None = None, params: dict | None = None,+ timeout: int = 30) -> Any:+ """Perform a POST request against the Obsidian REST API."""+ url = f"{base_url.rstrip('/')}{endpoint}"+ try:+ resp = requests.post(url, headers=_headers(api_key),+ json=data, params=params,+ timeout=timeout, verify=False)+ resp.raise_for_status()+ if resp.status_code == 204 or not resp.content:+ return {"status": "ok"}+ content_type = resp.headers.get("content-type", "")+ if "application/json" in content_type:+ return resp.json()+ return {"content": resp.text}+ except requests.exceptions.ConnectionError as e:+ raise RuntimeError(+ f"Cannot connect to Obsidian REST API at {base_url}. "+ "Is Obsidian running with the Local REST API plugin enabled?"+ ) from e+ except requests.exceptions.HTTPError as e:+ raise RuntimeError(+ f"Obsidian API error {resp.status_code} on POST {endpoint}: {resp.text}"+ ) from e+ except requests.exceptions.Timeout as e:+ raise RuntimeError(+ f"Request to Obsidian timed out: POST {endpoint}"+ ) from e+++def api_put(base_url: str, endpoint: str, api_key: str,+ content: str = "", content_type: str = "text/markdown",+ timeout: int = 30) -> Any:+ """Perform a PUT request (sends raw text, not JSON)."""+ url = f"{base_url.rstrip('/')}{endpoint}"+ try:+ headers = _headers(api_key, content_type=content_type)+ resp = requests.put(url, headers=headers, data=content.encode("utf-8"),+ timeout=timeout, verify=False)+ resp.raise_for_status()+ if resp.status_code == 204 or not resp.content:+ return {"status": "ok"}+ ct = resp.headers.get("content-type", "")+ if "application/json" in ct:+ return resp.json()+ return {"status": "ok"}+ except requests.exceptions.ConnectionError as e:+ raise RuntimeError(+ f"Cannot connect to Obsidian REST API at {base_url}. "+ "Is Obsidian running with the Local REST API plugin enabled?"+ ) from e+ except requests.exceptions.HTTPError as e:+ raise RuntimeError(+ f"Obsidian API error {resp.status_code} on PUT {endpoint}: {resp.text}"+ ) from e+ except requests.exceptions.Timeout as e:+ raise RuntimeError(+ f"Request to Obsidian timed out: PUT {endpoint}"+ ) from e+++def api_delete(base_url: str, endpoint: str, api_key: str,+ timeout: int = 30) -> Any:+ """Perform a DELETE request."""+ url = f"{base_url.rstrip('/')}{endpoint}"+ try:+ resp = requests.delete(url, headers=_headers(api_key),+ timeout=timeout, verify=False)+ resp.raise_for_status()+ if resp.status_code == 204 or not resp.content:+ return {"status": "ok"}+ ct = resp.headers.get("content-type", "")+ if "application/json" in ct:+ return resp.json()+ return {"status": "ok"}+ except requests.exceptions.ConnectionError as e:+ raise RuntimeError(+ f"Cannot connect to Obsidian REST API at {base_url}. "+ "Is Obsidian running with the Local REST API plugin enabled?"+ ) from e+ except requests.exceptions.HTTPError as e:+ raise RuntimeError(+ f"Obsidian API error {resp.status_code} on DELETE {endpoint}: {resp.text}"+ ) from e+ except requests.exceptions.Timeout as e:+ raise RuntimeError(+ f"Request to Obsidian timed out: DELETE {endpoint}"+ ) from e+++def api_patch(base_url: str, endpoint: str, api_key: str,+ content: str = "", position: str = "end",+ timeout: int = 30) -> Any:+ """Perform a PATCH request for appending/prepending content."""+ url = f"{base_url.rstrip('/')}{endpoint}"+ try:+ headers = _headers(api_key, content_type="text/markdown")+ headers["Content-Insertion-Position"] = position+ resp = requests.patch(url, headers=headers,+ data=content.encode("utf-8"),+ timeout=timeout, verify=False)+ resp.raise_for_status()+ if resp.status_code == 204 or not resp.content:+ return {"status": "ok"}+ ct = resp.headers.get("content-type", "")+ if "application/json" in ct:+ return resp.json()+ return {"status": "ok"}+ except requests.exceptions.ConnectionError as e:+ raise RuntimeError(+ f"Cannot connect to Obsidian REST API at {base_url}. "+ "Is Obsidian running with the Local REST API plugin enabled?"+ ) from e+ except requests.exceptions.HTTPError as e:+ raise RuntimeError(+ f"Obsidian API error {resp.status_code} on PATCH {endpoint}: {resp.text}"+ ) from e+ except requests.exceptions.Timeout as e:+ raise RuntimeError(+ f"Request to Obsidian timed out: PATCH {endpoint}"+ ) from e+++def is_available(api_key: str, base_url: str = DEFAULT_BASE_URL) -> bool:+ """Check if Obsidian REST API is reachable."""+ try:+ resp = requests.get(+ f"{base_url.rstrip('/')}/",+ headers={"Authorization": f"Bearer {api_key}"},+ timeout=5,+ verify=False,+ )+ return resp.status_code == 200+ except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):+ return Falsediff --git a/obsidian/agent-harness/cli_anything/obsidian/utils/repl_skin.py b/obsidian/agent-harness/cli_anything/obsidian/utils/repl_skin.pynew file mode 100644index 000000000..b356cb835--- /dev/null+++ b/obsidian/agent-harness/cli_anything/obsidian/utils/repl_skin.py@@ -0,0 +1,500 @@+"""cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.++Copy this file into your CLI package at:+ cli_anything/<software>/utils/repl_skin.py++Usage:+ from cli_anything.<software>.utils.repl_skin import ReplSkin++ skin = ReplSkin("ollama", version="1.0.0")+ skin.print_banner()+ prompt_text = skin.prompt(project_name="llama3.2", modified=False)+ skin.success("Model pulled")+ skin.error("Connection failed")+ skin.warning("No models loaded")+ skin.info("Generating...")+ skin.status("Model", "llama3.2:latest")+ skin.table(headers, rows)+ skin.print_goodbye()+"""++import os+import sys++# ── ANSI color codes (no external deps for core styling) ──────────────++_RESET = "\033[0m"+_BOLD = "\033[1m"+_DIM = "\033[2m"+_ITALIC = "\033[3m"+_UNDERLINE = "\033[4m"++# Brand colors+_CYAN = "\033[38;5;80m" # cli-anything brand cyan+_CYAN_BG = "\033[48;5;80m"+_WHITE = "\033[97m"+_GRAY = "\033[38;5;245m"+_DARK_GRAY = "\033[38;5;240m"+_LIGHT_GRAY = "\033[38;5;250m"++# Software accent colors — each software gets a unique accent+_ACCENT_COLORS = {+ "gimp": "\033[38;5;214m", # warm orange+ "blender": "\033[38;5;208m", # deep orange+ "inkscape": "\033[38;5;39m", # bright blue+ "audacity": "\033[38;5;33m", # navy blue+ "libreoffice": "\033[38;5;40m", # green+ "obs_studio": "\033[38;5;55m", # purple+ "kdenlive": "\033[38;5;69m", # slate blue+ "shotcut": "\033[38;5;35m", # teal green+ "ollama": "\033[38;5;255m", # white (Ollama branding)+}+_DEFAULT_ACCENT = "\033[38;5;75m" # default sky blue++# Status colors+_GREEN = "\033[38;5;78m"+_YELLOW = "\033[38;5;220m"+_RED = "\033[38;5;196m"+_BLUE = "\033[38;5;75m"+_MAGENTA = "\033[38;5;176m"++# ── Brand icon ────────────────────────────────────────────────────────++# The cli-anything icon: a small colored diamond/chevron mark+_ICON = f"{_CYAN}{_BOLD}◆{_RESET}"+_ICON_SMALL = f"{_CYAN}▸{_RESET}"++# ── Box drawing characters ────────────────────────────────────────────++_H_LINE = "─"+_V_LINE = "│"+_TL = "╭"+_TR = "╮"+_BL = "╰"+_BR = "╯"+_T_DOWN = "┬"+_T_UP = "┴"+_T_RIGHT = "├"+_T_LEFT = "┤"+_CROSS = "┼"+++def _strip_ansi(text: str) -> str:+ """Remove ANSI escape codes for length calculation."""+ import re+ return re.sub(r"\033\[[^m]*m", "", text)+++def _visible_len(text: str) -> int:+ """Get visible length of text (excluding ANSI codes)."""+ return len(_strip_ansi(text))+++class ReplSkin:+ """Unified REPL skin for cli-anything CLIs.++ Provides consistent branding, prompts, and message formatting+ across all CLI harnesses built with the cli-anything methodology.+ """++ def __init__(self, software: str, version: str = "1.0.0",+ history_file: str | None = None):+ """Initialize the REPL skin.++ Args:+ software: Software name (e.g., "gimp", "shotcut", "ollama").+ version: CLI version string.+ history_file: Path for persistent command history.+ Defaults to ~/.cli-anything-<software>/history+ """+ self.software = software.lower().replace("-", "_")+ self.display_name = software.replace("_", " ").title()+ self.version = version+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)++ # History file+ if history_file is None:+ from pathlib import Path+ hist_dir = Path.home() / f".cli-anything-{self.software}"+ hist_dir.mkdir(parents=True, exist_ok=True)+ self.history_file = str(hist_dir / "history")+ else:+ self.history_file = history_file++ # Detect terminal capabilities+ self._color = self._detect_color_support()++ def _detect_color_support(self) -> bool:+ """Check if terminal supports color."""+ if os.environ.get("NO_COLOR"):+ return False+ if os.environ.get("CLI_ANYTHING_NO_COLOR"):+ return False+ if not hasattr(sys.stdout, "isatty"):+ return False+ return sys.stdout.isatty()++ def _c(self, code: str, text: str) -> str:+ """Apply color code if colors are supported."""+ if not self._color:+ return text+ return f"{code}{text}{_RESET}"++ # ── Banner ────────────────────────────────────────────────────────++ def print_banner(self):+ """Print the startup banner with branding."""+ inner = 54++ def _box_line(content: str) -> str:+ """Wrap content in box drawing, padding to inner width."""+ pad = inner - _visible_len(content)+ vl = self._c(_DARK_GRAY, _V_LINE)+ return f"{vl}{content}{' ' * max(0, pad)}{vl}"++ top = self._c(_DARK_GRAY, f"{_TL}{_H_LINE * inner}{_TR}")+ bot = self._c(_DARK_GRAY, f"{_BL}{_H_LINE * inner}{_BR}")++ # Title: ◆ cli-anything · Ollama+ icon = self._c(_CYAN + _BOLD, "◆")+ brand = self._c(_CYAN + _BOLD, "cli-anything")+ dot = self._c(_DARK_GRAY, "·")+ name = self._c(self.accent + _BOLD, self.display_name)+ title = f" {icon} {brand} {dot} {name}"++ ver = f" {self._c(_DARK_GRAY, f' v{self.version}')}"+ tip = f" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}"+ empty = ""++ print(top)+ print(_box_line(title))+ print(_box_line(ver))+ print(_box_line(empty))+ print(_box_line(tip))+ print(bot)+ print()++ # ── Prompt ────────────────────────────────────────────────────────++ def prompt(self, project_name: str = "", modified: bool = False,+ context: str = "") -> str:+ """Build a styled prompt string for prompt_toolkit or input().++ Args:+ project_name: Current project name (empty if none open).+ modified: Whether the project has unsaved changes.+ context: Optional extra context to show in prompt.++ Returns:+ Formatted prompt string.+ """+ parts = []++ # Icon+ if self._color:+ parts.append(f"{_CYAN}◆{_RESET} ")+ else:+ parts.append("> ")++ # Software name+ parts.append(self._c(self.accent + _BOLD, self.software))++ # Project context+ if project_name or context:+ ctx = context or project_name+ mod = "*" if modified else ""+ parts.append(f" {self._c(_DARK_GRAY, '[')}")+ parts.append(self._c(_LIGHT_GRAY, f"{ctx}{mod}"))+ parts.append(self._c(_DARK_GRAY, ']'))++ parts.append(self._c(_GRAY, " ❯ "))++ return "".join(parts)++ def prompt_tokens(self, project_name: str = "", modified: bool = False,+ context: str = ""):+ """Build prompt_toolkit formatted text tokens for the prompt.++ Use with prompt_toolkit's FormattedText for proper ANSI handling.++ Returns:+ list of (style, text) tuples for prompt_toolkit.+ """+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, "#5fafff")+ tokens = []++ tokens.append(("class:icon", "◆ "))+ tokens.append(("class:software", self.software))++ if project_name or context:+ ctx = context or project_name+ mod = "*" if modified else ""+ tokens.append(("class:bracket", " ["))+ tokens.append(("class:context", f"{ctx}{mod}"))+ tokens.append(("class:bracket", "]"))++ tokens.append(("class:arrow", " ❯ "))++ return tokens++ def get_prompt_style(self):+ """Get a prompt_toolkit Style object matching the skin.++ Returns:+ prompt_toolkit.styles.Style+ """+ try:+ from prompt_toolkit.styles import Style+ except ImportError:+ return None++ accent_hex = _ANSI_256_TO_HEX.get(self.accent, "#5fafff")++ return Style.from_dict({+ "icon": "#5fdfdf bold", # cyan brand color+ "software": f"{accent_hex} bold",+ "bracket": "#585858",+ "context": "#bcbcbc",+ "arrow": "#808080",+ # Completion menu+ "completion-menu.completion": "bg:#303030 #bcbcbc",+ "completion-menu.completion.current": f"bg:{accent_hex} #000000",+ "completion-menu.meta.completion": "bg:#303030 #808080",+ "completion-menu.meta.completion.current": f"bg:{accent_hex} #000000",+ # Auto-suggest+ "auto-suggest": "#585858",+ # Bottom toolbar+ "bottom-toolbar": "bg:#1c1c1c #808080",+ "bottom-toolbar.text": "#808080",+ })++ # ── Messages ──────────────────────────────────────────────────────++ def success(self, message: str):+ """Print a success message with green checkmark."""+ icon = self._c(_GREEN + _BOLD, "✓")+ print(f" {icon} {self._c(_GREEN, message)}")++ def error(self, message: str):+ """Print an error message with red cross."""+ icon = self._c(_RED + _BOLD, "✗")+ print(f" {icon} {self._c(_RED, message)}", file=sys.stderr)++ def warning(self, message: str):+ """Print a warning message with yellow triangle."""+ icon = self._c(_YELLOW + _BOLD, "⚠")+ print(f" {icon} {self._c(_YELLOW, message)}")++ def info(self, message: str):+ """Print an info message with blue dot."""+ icon = self._c(_BLUE, "●")+ print(f" {icon} {self._c(_LIGHT_GRAY, message)}")++ def hint(self, message: str):+ """Print a subtle hint message."""+ print(f" {self._c(_DARK_GRAY, message)}")++ def section(self, title: str):+ """Print a section header."""+ print()+ print(f" {self._c(self.accent + _BOLD, title)}")+ print(f" {self._c(_DARK_GRAY, _H_LINE * len(title))}")++ # ── Status display ────────────────────────────────────────────────++ def status(self, label: str, value: str):+ """Print a key-value status line."""+ lbl = self._c(_GRAY, f" {label}:")+ val = self._c(_WHITE, f" {value}")+ print(f"{lbl}{val}")++ def status_block(self, items: dict[str, str], title: str = ""):+ """Print a block of status key-value pairs.++ Args:+ items: Dict of label -> value pairs.+ title: Optional title for the block.+ """+ if title:+ self.section(title)++ max_key = max(len(k) for k in items) if items else 0+ for label, value in items.items():+ lbl = self._c(_GRAY, f" {label:<{max_key}}")+ val = self._c(_WHITE, f" {value}")+ print(f"{lbl}{val}")++ def progress(self, current: int, total: int, label: str = ""):+ """Print a simple progress indicator.++ Args:+ current: Current step number.+ total: Total number of steps.+ label: Optional label for the progress.+ """+ pct = int(current / total * 100) if total > 0 else 0+ bar_width = 20+ filled = int(bar_width * current / total) if total > 0 else 0+ bar = "█" * filled + "░" * (bar_width - filled)+ text = f" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}"+ if label:+ text += f" {self._c(_LIGHT_GRAY, label)}"+ print(text)++ # ── Table display ─────────────────────────────────────────────────++ def table(self, headers: list[str], rows: list[list[str]],+ max_col_width: int = 40):+ """Print a formatted table with box-drawing characters.++ Args:+ headers: Column header strings.+ rows: List of rows, each a list of cell strings.+ max_col_width: Maximum column width before truncation.+ """+ if not headers:+ return++ # Calculate column widths+ col_widths = [min(len(h), max_col_width) for h in headers]+ for row in rows:+ for i, cell in enumerate(row):+ if i < len(col_widths):+ col_widths[i] = min(+ max(col_widths[i], len(str(cell))), max_col_width+ )++ def pad(text: str, width: int) -> str:+ t = str(text)[:width]+ return t + " " * (width - len(t))++ # Header+ header_cells = [+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))+ for i, h in enumerate(headers)+ ]+ sep = self._c(_DARK_GRAY, f" {_V_LINE} ")+ header_line = f" {sep.join(header_cells)}"+ print(header_line)++ # Separator+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]+ sep_line = self._c(_DARK_GRAY, f" {'───'.join([_H_LINE * w for w in col_widths])}")+ print(sep_line)++ # Rows+ for row in rows:+ cells = []+ for i, cell in enumerate(row):+ if i < len(col_widths):+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))+ row_sep = self._c(_DARK_GRAY, f" {_V_LINE} ")+ print(f" {row_sep.join(cells)}")++ # ── Help display ──────────────────────────────────────────────────++ def help(self, commands: dict[str, str]):+ """Print a formatted help listing.++ Args:+ commands: Dict of command -> description pairs.+ """+ self.section("Commands")+ max_cmd = max(len(c) for c in commands) if commands else 0+ for cmd, desc in commands.items():+ cmd_styled = self._c(self.accent, f" {cmd:<{max_cmd}}")+ desc_styled = self._c(_GRAY, f" {desc}")+ print(f"{cmd_styled}{desc_styled}")+ print()++ # ── Goodbye ───────────────────────────────────────────────────────++ def print_goodbye(self):+ """Print a styled goodbye message."""+ print(f"\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\n")++ # ── Prompt toolkit session factory ────────────────────────────────++ def create_prompt_session(self):+ """Create a prompt_toolkit PromptSession with skin styling.++ Returns:+ A configured PromptSession, or None if prompt_toolkit unavailable.+ """+ try:+ from prompt_toolkit import PromptSession+ from prompt_toolkit.history import FileHistory+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory+ from prompt_toolkit.formatted_text import FormattedText++ style = self.get_prompt_style()++ session = PromptSession(+ history=FileHistory(self.history_file),+ auto_suggest=AutoSuggestFromHistory(),+ style=style,+ enable_history_search=True,+ )+ return session+ except ImportError:+ return None++ def get_input(self, pt_session, project_name: str = "",+ modified: bool = False, context: str = "") -> str:+ """Get input from user using prompt_toolkit or fallback.++ Args:+ pt_session: A prompt_toolkit PromptSession (or None).+ project_name: Current project name.+ modified: Whether project has unsaved changes.+ context: Optional context string.++ Returns:+ User input string (stripped).+ """+ if pt_session is not None:+ from prompt_toolkit.formatted_text import FormattedText+ tokens = self.prompt_tokens(project_name, modified, context)+ return pt_session.prompt(FormattedText(tokens)).strip()+ else:+ raw_prompt = self.prompt(project_name, modified, context)+ return input(raw_prompt).strip()++ # ── Toolbar builder ───────────────────────────────────────────────++ def bottom_toolbar(self, items: dict[str, str]):+ """Create a bottom toolbar callback for prompt_toolkit.++ Args:+ items: Dict of label -> value pairs to show in toolbar.++ Returns:+ A callable that returns FormattedText for the toolbar.+ """+ def toolbar():+ from prompt_toolkit.formatted_text import FormattedText+ parts = []+ for i, (k, v) in enumerate(items.items()):+ if i > 0:+ parts.append(("class:bottom-toolbar.text", " │ "))+ parts.append(("class:bottom-toolbar.text", f" {k}: "))+ parts.append(("class:bottom-toolbar", v))+ return FormattedText(parts)+ return toolbar+++# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────++_ANSI_256_TO_HEX = {+ "\033[38;5;33m": "#0087ff", # audacity navy blue+ "\033[38;5;35m": "#00af5f", # shotcut teal+ "\033[38;5;39m": "#00afff", # inkscape bright blue+ "\033[38;5;40m": "#00d700", # libreoffice green+ "\033[38;5;55m": "#5f00af", # obs purple+ "\033[38;5;69m": "#5f87ff", # kdenlive slate blue+ "\033[38;5;75m": "#5fafff", # default sky blue+ "\033[38;5;80m": "#5fd7d7", # brand cyan+ "\033[38;5;208m": "#ff8700", # blender deep orange+ "\033[38;5;214m": "#ffaf00", # gimp warm orange+ "\033[38;5;255m": "#eeeeee", # ollama white+}diff --git a/obsidian/agent-harness/setup.py b/obsidian/agent-harness/setup.pynew file mode 100644index 000000000..bf252a268--- /dev/null+++ b/obsidian/agent-harness/setup.py@@ -0,0 +1,55 @@+#!/usr/bin/env python3+"""+setup.py for cli-anything-obsidian++Install with: pip install -e .+"""++from setuptools import setup, find_namespace_packages++with open("cli_anything/obsidian/README.md", "r", encoding="utf-8") as fh:+ long_description = fh.read()++setup(+ name="cli-anything-obsidian",+ version="1.0.0",+ author="Doruk Ozgen",+ author_email="",+ description="CLI harness for Obsidian — Knowledge management and note-taking via Obsidian Local REST API. Recommended: Obsidian with Local REST API plugin enabled",+ long_description=long_description,+ long_description_content_type="text/markdown",+ url="https://github.com/HKUDS/CLI-Anything",+ packages=find_namespace_packages(include=["cli_anything.*"]),+ classifiers=[+ "Development Status :: 4 - Beta",+ "Intended Audience :: Developers",+ "Topic :: Software Development :: Libraries :: Python Modules",+ "License :: OSI Approved :: MIT License",+ "Programming Language :: Python :: 3",+ "Programming Language :: Python :: 3.10",+ "Programming Language :: Python :: 3.11",+ "Programming Language :: Python :: 3.12",+ ],+ python_requires=">=3.10",+ install_requires=[+ "click>=8.0.0",+ "prompt-toolkit>=3.0.0",+ "requests>=2.28.0",+ ],+ extras_require={+ "dev": [+ "pytest>=7.0.0",+ "pytest-cov>=4.0.0",+ ],+ },+ entry_points={+ "console_scripts": [+ "cli-anything-obsidian=cli_anything.obsidian.obsidian_cli:main",+ ],+ },+ package_data={+ "cli_anything.obsidian": ["skills/*.md"],+ },+ include_package_data=True,+ zip_safe=False,+)diff --git a/registry.json b/registry.jsonindex 3e8c9ea8b..13165f9e2 100644--- a/registry.json+++ b/registry.json@@ -592,6 +592,20 @@"category": "graphics","contributor": "rsasaki0109","contributor_url": "https://github.com/rsasaki0109"+ },+ {+ "name": "obsidian",+ "display_name": "Obsidian",+ "version": "1.0.0",+ "description": "Knowledge management and note-taking — manage notes, search vault, execute commands via Obsidian Local REST API",+ "requires": "Obsidian desktop app with Local REST API plugin enabled",+ "homepage": "https://obsidian.md",+ "install_cmd": "pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=obsidian/agent-harness",+ "entry_point": "cli-anything-obsidian",+ "skill_md": "obsidian/agent-harness/cli_anything/obsidian/skills/SKILL.md",+ "category": "knowledge",+ "contributor": "dorukozgen",+ "contributor_url": "https://github.com/dorukozgen"}]}