obsidian-agent-cli 0.1.0__py3-none-any.whl

obsidian_cli/commands/canvas.py

@@ -0,0 +1,123 @@
+import json
+import click
+from pathlib import Path
+from ..config import load_config
+from ..transport import Transport
+from ..canvas_builder import CanvasBuilder
+
+
+@click.group()
+def canvas():
+    """Canvas creation and management."""
+
+
+@canvas.command()
+@click.argument("name")
+@click.option("--folder", default=None, help="Vault path for canvas (default: AI Workspace/)")
+def create(name, folder):
+    cfg = load_config()
+    if folder is None:
+        folder = cfg.workspace_path
+    vault_path = f"{folder}/{name}.canvas"
+    abs_path = Path(cfg.vault_path) / vault_path
+    abs_path.parent.mkdir(parents=True, exist_ok=True)
+    abs_path.write_text(json.dumps({"nodes": [], "edges": []}, indent=2), encoding="utf-8")
+    click.echo(json.dumps({"ok": True, "path": vault_path}))
+
+
+@canvas.command()
+@click.argument("canvas_path")
+def read(canvas_path):
+    cfg = load_config()
+    abs_path = Path(cfg.vault_path) / canvas_path
+    if not abs_path.exists():
+        click.echo(json.dumps({"error": True, "message": f"Not found: {canvas_path}"}))
+        return
+    data = json.loads(abs_path.read_text(encoding="utf-8"))
+    click.echo(json.dumps(data))
+
+
+@canvas.command("add-node")
+@click.argument("canvas_path")
+@click.option("--type", "node_type", required=True,
+              type=click.Choice(["text", "file", "link", "group"]))
+@click.option("--text", default="")
+@click.option("--file", "file_path", default="")
+@click.option("--url", default="")
+@click.option("--label", default="")
+@click.option("--color", default="")
+def add_node(canvas_path, node_type, text, file_path, url, label, color):
+    cfg = load_config()
+    abs_path = Path(cfg.vault_path) / canvas_path
+    if not abs_path.exists():
+        click.echo(json.dumps({"error": True, "message": f"Canvas not found: {canvas_path}"}))
+        return
+    data = json.loads(abs_path.read_text(encoding="utf-8"))
+    cb = CanvasBuilder()
+    cb._nodes = data["nodes"]
+    cb._edges = data["edges"]
+    if node_type == "text":
+        nid = cb.add_text_node(text, color=color)
+    elif node_type == "file":
+        nid = cb.add_file_node(file_path, color=color)
+    elif node_type == "link":
+        nid = cb.add_link_node(url, color=color)
+    elif node_type == "group":
+        nid = cb.add_group_node(label=label, color=color)
+    else:
+        click.echo(json.dumps({"error": True, "message": f"Unknown node type: {node_type}"}))
+        return
+    abs_path.write_text(cb.to_json(), encoding="utf-8")
+    click.echo(json.dumps({"ok": True, "node_id": nid}))
+
+
+@canvas.command("add-edge")
+@click.argument("canvas_path")
+@click.argument("from_id")
+@click.argument("to_id")
+@click.option("--label", default="")
+@click.option("--color", default="")
+def add_edge(canvas_path, from_id, to_id, label, color):
+    cfg = load_config()
+    abs_path = Path(cfg.vault_path) / canvas_path
+    if not abs_path.exists():
+        click.echo(json.dumps({"error": True, "message": f"Canvas not found: {canvas_path}"}))
+        return
+    data = json.loads(abs_path.read_text(encoding="utf-8"))
+    cb = CanvasBuilder()
+    cb._nodes = data["nodes"]
+    cb._edges = data["edges"]
+    eid = cb.add_edge(from_id, to_id, label=label, color=color)
+    abs_path.write_text(cb.to_json(), encoding="utf-8")
+    click.echo(json.dumps({"ok": True, "edge_id": eid}))
+
+
+@canvas.command()
+@click.argument("name")
+@click.option("--spec", required=True, help="JSON spec string")
+@click.option("--folder", default=None)
+def build(name, spec, folder):
+    cfg = load_config()
+    if folder is None:
+        folder = cfg.workspace_path
+    try:
+        spec_data = json.loads(spec)
+    except json.JSONDecodeError as e:
+        click.echo(json.dumps({"error": True, "message": f"Invalid JSON spec: {e}"}))
+        return
+    cb = CanvasBuilder.from_spec(spec_data)
+    vault_path = f"{folder}/{name}.canvas"
+    abs_path = Path(cfg.vault_path) / vault_path
+    abs_path.parent.mkdir(parents=True, exist_ok=True)
+    abs_path.write_text(cb.to_json(), encoding="utf-8")
+    click.echo(json.dumps({"ok": True, "path": vault_path,
+                            "nodes": len(cb._nodes), "edges": len(cb._edges)}))
+
+
+@canvas.command("open")
+@click.argument("canvas_path")
+def open_canvas(canvas_path):
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.open_in_obsidian(canvas_path)
+    click.echo(json.dumps(result))

obsidian_cli/commands/config_cmd.py

@@ -0,0 +1,57 @@
+import json
+import click
+from ..config import load_config, save_config, Config
+
+
+@click.group("config")
+def config_cmd():
+    """View and update CLI configuration."""
+
+
+@config_cmd.command()
+def show():
+    cfg = load_config()
+    data = {
+        "vault_path": cfg.vault_path,
+        "workspace_path": cfg.workspace_path,
+        "teach_path": cfg.teach_path,
+        "api_url": cfg.api_url,
+        "api_key": "***" if cfg.api_key else "(not set)",
+        "api_verify_ssl": cfg.api_verify_ssl,
+    }
+    click.echo(json.dumps(data, indent=2))
+
+
+@config_cmd.command()
+@click.argument("key")
+@click.argument("value")
+def set(key, value):
+    cfg = load_config()
+    if not hasattr(cfg, key):
+        click.echo(json.dumps({"error": True, "message": f"Unknown key: {key}"}))
+        return
+    field_type = type(getattr(cfg, key))
+    if field_type == bool:
+        value = value.lower() in ("true", "1", "yes")
+    if key == "api_key":
+        click.echo("Warning: api_key set via CLI is visible in shell history. Use obsidian config init instead.", err=True)
+    setattr(cfg, key, value)
+    save_config(cfg)
+    click.echo(json.dumps({"ok": True, "key": key}))
+
+
+@config_cmd.command()
+def init():
+    """Interactive first-time setup."""
+    click.echo("Obsidian CLI Setup")
+    click.echo("------------------")
+    vault = click.prompt("Vault path (full path to your Obsidian vault folder)").lstrip("")
+    api_key = click.prompt("API key (from Obsidian Local REST API plugin settings)", default="").lstrip("")
+    api_url = click.prompt("API URL", default="http://127.0.0.1:27123").lstrip("")
+    cfg = Config(
+        vault_path=vault,
+        api_url=api_url,
+        api_key=api_key,
+    )
+    save_config(cfg)
+    click.echo(json.dumps({"ok": True, "message": "Config saved. Run: obsidian config show"}))

obsidian_cli/commands/core_cmd.py

@@ -0,0 +1,83 @@
+import json
+import click
+from ..config import load_config
+from ..transport import Transport
+
+
+@click.group("core")
+def core_cmd():
+    """Core Obsidian commands (open, search, settings, command palette)."""
+
+
+@core_cmd.command("open")
+@click.argument("note_path")
+def open_note(note_path):
+    """Open a note in the Obsidian UI."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command(f"app:open-file:{note_path}")
+    click.echo(json.dumps({**result, "note": note_path}))
+
+
+@core_cmd.command("palette")
+def command_palette():
+    """Open the Obsidian command palette."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("command-palette:open")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("search")
+def open_search():
+    """Open Obsidian global search."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("global-search:open")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("settings")
+def open_settings():
+    """Open Obsidian settings."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("app:open-settings")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("graph")
+def open_graph():
+    """Open Obsidian graph view."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("graph:open")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("new-tab")
+def new_tab():
+    """Open a new tab in Obsidian."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("workspace:new-tab")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("pin")
+def pin_tab():
+    """Pin/unpin the current tab."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("workspace:toggle-pin")
+    click.echo(json.dumps(result))
+
+
+@core_cmd.command("split")
+@click.argument("direction", type=click.Choice(["horizontal", "vertical"]))
+def split_view(direction):
+    """Split the current pane horizontally or vertically."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command(f"workspace:split-{direction}")
+    click.echo(json.dumps(result))

obsidian_cli/commands/excalidraw.py

@@ -0,0 +1,146 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+from urllib.parse import quote
+import click
+from ..config import load_config
+from ..transport import Transport
+from ..excalidraw_builder import ExcalidrawBuilder
+
+
+@click.group()
+def excalidraw():
+    """Excalidraw whiteboard diagrams (.excalidraw files)."""
+
+
+@excalidraw.command()
+@click.argument("path")
+def create(path):
+    """Create a new empty Excalidraw drawing."""
+    cfg = load_config()
+    t = Transport(cfg)
+    eb = ExcalidrawBuilder()
+    result = t.write_file(path, eb.to_json())
+    if "ok" in result:
+        result["path"] = path
+    click.echo(json.dumps(result))
+
+
+@excalidraw.command("add-shape")
+@click.argument("path")
+@click.option("--type", "shape_type",
+              type=click.Choice(["rectangle", "ellipse", "diamond", "text"]),
+              default="rectangle")
+@click.option("--label", default="", help="Shape label or text content")
+@click.option("--stroke-color", default="#1e1e2e")
+@click.option("--background-color", default="transparent")
+@click.option("--width", default=200, type=int)
+@click.option("--height", default=100, type=int)
+def add_shape(path, shape_type, label, stroke_color, background_color, width, height):
+    """Add a shape to an existing Excalidraw drawing."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    data = json.loads(raw["content"])
+    eb = ExcalidrawBuilder()
+    eb._elements = data.get("elements", [])
+    if shape_type == "rectangle":
+        nid = eb.add_rectangle(label, stroke_color=stroke_color,
+                               background_color=background_color, width=width, height=height)
+    elif shape_type == "ellipse":
+        nid = eb.add_ellipse(label, stroke_color=stroke_color,
+                             background_color=background_color, width=width, height=height)
+    elif shape_type == "diamond":
+        nid = eb.add_diamond(label, stroke_color=stroke_color,
+                             background_color=background_color, width=width, height=height)
+    else:
+        nid = eb.add_text(label)
+    data["elements"] = eb._elements
+    result = t.write_file(path, json.dumps(data, indent=2))
+    if "ok" in result:
+        result["element_id"] = nid
+    click.echo(json.dumps(result))
+
+
+@excalidraw.command("add-arrow")
+@click.argument("path")
+@click.argument("from_id")
+@click.argument("to_id")
+@click.option("--label", default="")
+@click.option("--stroke-color", default="#1e1e2e")
+def add_arrow(path, from_id, to_id, label, stroke_color):
+    """Add an arrow between two elements in an Excalidraw drawing."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    data = json.loads(raw["content"])
+    eb = ExcalidrawBuilder()
+    eb._elements = data.get("elements", [])
+    arrow_id = eb.add_arrow(from_id, to_id, label=label, stroke_color=stroke_color)
+    data["elements"] = eb._elements
+    result = t.write_file(path, json.dumps(data, indent=2))
+    if "ok" in result:
+        result["arrow_id"] = arrow_id
+    click.echo(json.dumps(result))
+
+
+@excalidraw.command()
+@click.argument("path")
+def read(path):
+    """Read an Excalidraw drawing and return its elements as JSON."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    data = json.loads(raw["content"])
+    click.echo(json.dumps({
+        "elements": data.get("elements", []),
+        "element_count": len(data.get("elements", [])),
+        "transport": raw["transport"],
+    }))
+
+
+@excalidraw.command()
+@click.argument("path")
+@click.option("--spec", required=True, help="JSON spec: {elements: [...], arrows: [...]}")
+def build(path, spec):
+    """Build a complete Excalidraw drawing from a JSON spec in one shot."""
+    try:
+        spec_data = json.loads(spec)
+    except json.JSONDecodeError as e:
+        click.echo(json.dumps({"error": True, "message": f"Invalid JSON spec: {e}"}))
+        return
+    cfg = load_config()
+    t = Transport(cfg)
+    eb = ExcalidrawBuilder.from_spec(spec_data)
+    shape_count = sum(1 for e in eb._elements if e["type"] not in ("arrow", "line"))
+    arrow_count = sum(1 for e in eb._elements if e["type"] in ("arrow", "line"))
+    result = t.write_file(path, eb.to_json())
+    if "ok" in result:
+        result.update({"path": path, "elements": shape_count, "arrows": arrow_count})
+    click.echo(json.dumps(result))
+
+
+@excalidraw.command("open")
+@click.argument("path")
+def open_drawing(path):
+    """Open an Excalidraw drawing in Obsidian."""
+    cfg = load_config()
+    vault_name = Path(cfg.vault_path).name
+    uri = f"obsidian://open?vault={quote(vault_name)}&file={quote(path)}"
+    if sys.platform == "win32":
+        subprocess.Popen(["cmd", "/c", "start", uri], shell=False)
+    elif sys.platform == "darwin":
+        subprocess.Popen(["open", uri])
+    else:
+        subprocess.Popen(["xdg-open", uri])
+    click.echo(json.dumps({"ok": True, "uri": uri, "transport": "uri"}))

obsidian_cli/commands/export_cmd.py

@@ -0,0 +1,40 @@
+import json
+from pathlib import Path
+from datetime import datetime
+import click
+from ..config import load_config
+
+
+@click.group("export")
+def export_cmd():
+    """Export vault notes to portable formats."""
+
+
+@export_cmd.command("bundle")
+@click.argument("output", default=None, required=False)
+@click.option("--folder", default="AI Workspace", help="Vault folder to bundle")
+@click.option("--separator", default="\n\n---\n\n", help="Separator between notes")
+def export_bundle(output, folder, separator):
+    """Concatenate notes into a single markdown file (useful for AI context)."""
+    cfg = load_config()
+    vault = Path(cfg.vault_path)
+    base = vault / folder if folder else vault
+    if not base.exists():
+        click.echo(json.dumps({"error": True, "message": f"Folder not found: {folder}"}))
+        return
+
+    if output is None:
+        ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+        label = folder.replace("/", "-") or "vault"
+        output = str(vault.parent / f"obsidian-bundle-{label}-{ts}.md")
+
+    sections = []
+    for p in sorted(base.rglob("*.md")):
+        if ".obsidian" in p.parts:
+            continue
+        rel = str(p.relative_to(vault)).replace("\\", "/")
+        content = p.read_text(encoding="utf-8", errors="ignore")
+        sections.append(f"<!-- source: {rel} -->\n{content}")
+
+    Path(output).write_text(separator.join(sections), encoding="utf-8")
+    click.echo(json.dumps({"ok": True, "output": output, "files": len(sections)}))

obsidian_cli/commands/git_cmd.py

@@ -0,0 +1,112 @@
+import json
+import click
+from ..config import load_config
+from ..transport import Transport
+
+
+@click.group("git")
+def git_cmd():
+    """Obsidian Git plugin commands (requires Obsidian Git plugin)."""
+
+
+@git_cmd.command()
+@click.option("-m", "--message", default="", help="Commit message (enables commit-specified-message)")
+def sync(message):
+    """Commit all changes and push. Without -m uses auto message; with -m commits with specified message."""
+    cfg = load_config()
+    t = Transport(cfg)
+    if message:
+        result = t.run_command("obsidian-git:commit-push-specified-message")
+    else:
+        result = t.run_command("obsidian-git:push")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+@click.option("-m", "--message", default="", help="Commit message")
+def commit(message):
+    """Commit all changes."""
+    cfg = load_config()
+    t = Transport(cfg)
+    if message:
+        result = t.run_command("obsidian-git:commit-specified-message")
+    else:
+        result = t.run_command("obsidian-git:commit")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+def pull():
+    """Pull latest changes from remote."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:pull")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+def push():
+    """Push committed changes to remote."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:push2")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+def status():
+    """List changed files in Obsidian Git source control view."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:list-changed-files")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+def pause():
+    """Pause or resume Obsidian Git automatic routines."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:pause-automatic-routines")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.command()
+def fetch():
+    """Fetch from remote without merging."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:fetch")
+    click.echo(json.dumps(result))
+
+
+@git_cmd.group()
+def branch():
+    """Branch operations."""
+
+
+@branch.command("create")
+def branch_create():
+    """Create a new branch (opens Obsidian prompt)."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:create-branch")
+    click.echo(json.dumps(result))
+
+
+@branch.command("switch")
+def branch_switch():
+    """Switch to a branch (opens Obsidian branch picker)."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:switch-branch")
+    click.echo(json.dumps(result))
+
+
+@branch.command("delete")
+def branch_delete():
+    """Delete a branch (opens Obsidian branch picker)."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-git:delete-branch")
+    click.echo(json.dumps(result))

obsidian_cli/commands/kanban.py

@@ -0,0 +1,113 @@
+import json
+import click
+from ..config import load_config
+from ..transport import Transport
+from ..kanban_builder import KanbanBuilder
+
+
+@click.group()
+def kanban():
+    """Obsidian Kanban board management (requires Kanban plugin)."""
+
+
+@kanban.command()
+@click.argument("path")
+@click.option("--lanes", default="To Do,In Progress,Done",
+              help="Comma-separated lane names")
+def create(path, lanes):
+    """Create a new Kanban board with the given lanes."""
+    cfg = load_config()
+    t = Transport(cfg)
+    kb = KanbanBuilder()
+    for lane in lanes.split(","):
+        kb.add_lane(lane.strip())
+    result = t.write_file(path, kb.to_markdown())
+    if "ok" in result:
+        result["path"] = path
+        result["lanes"] = [l.strip() for l in lanes.split(",")]
+    click.echo(json.dumps(result))
+
+
+@kanban.command()
+@click.argument("path")
+def read(path):
+    """Read a Kanban board and return its lanes and cards."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    kb = KanbanBuilder.from_markdown(raw["content"])
+    click.echo(json.dumps({
+        "lanes": {
+            lane: kb._lanes[lane]
+            for lane in kb._lane_order
+        },
+        "transport": raw["transport"],
+    }))
+
+
+@kanban.group()
+def card():
+    """Card operations within a Kanban board."""
+
+
+@card.command("add")
+@click.argument("path")
+@click.argument("lane")
+@click.argument("text")
+@click.option("--done", is_flag=True, default=False, help="Mark card as done")
+def card_add(path, lane, text, done):
+    """Add a card to a lane in a Kanban board."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    kb = KanbanBuilder.from_markdown(raw["content"])
+    try:
+        kb.add_card(lane, text, done=done)
+    except ValueError as e:
+        click.echo(json.dumps({"error": True, "message": str(e)}))
+        return
+    result = t.write_file(path, kb.to_markdown())
+    if "ok" in result:
+        result["card"] = text
+        result["lane"] = lane
+    click.echo(json.dumps(result))
+
+
+@kanban.group()
+def lane():
+    """Lane operations within a Kanban board."""
+
+
+@lane.command("add")
+@click.argument("path")
+@click.argument("name")
+def lane_add(path, name):
+    """Add a new lane to an existing Kanban board."""
+    cfg = load_config()
+    t = Transport(cfg)
+    raw = t.read_file(path)
+    if "error" in raw:
+        click.echo(json.dumps(raw))
+        return
+    kb = KanbanBuilder.from_markdown(raw["content"])
+    kb.add_lane(name)
+    result = t.write_file(path, kb.to_markdown())
+    if "ok" in result:
+        result["lane"] = name
+    click.echo(json.dumps(result))
+
+
+@kanban.command()
+@click.argument("path")
+def archive(path):
+    """Archive completed cards (trigger Kanban plugin command)."""
+    cfg = load_config()
+    t = Transport(cfg)
+    result = t.run_command("obsidian-kanban:archive-completed-cards")
+    click.echo(json.dumps(result))