obsidian-wikilinks 0.2.2 → 0.2.3-dev.pr5.34775183233.1

package/README.md

@@ -157,6 +157,49 @@ The whole vault is walked, notes and folders alike, with two exclusions:
 
 A note inside a hidden folder will therefore never resolve.
 
+## OpenCode sidebar: did the agent read my notes?
+
+Resolving a link only tells the agent where a note is. It does not prove the
+note was read. On OpenCode the plugin adds an **Obsidian notes** section to the
+session sidebar that answers that for every note you linked:
+
+```text
+▼ Obsidian notes  ✓ 2  ○ 1
+  ✓ Website Redesign
+  ○ Weekly
+  ✓ Meetings/ (2 read)
+  ✗ Nope (no match)
+  also read
+  · Research/AI Agents.md
+```
+
+- `✓` the agent read the note (for a folder link: at least one note inside it)
+- `○` linked, but not read yet
+- `✗` the link matched nothing in the vault
+- *also read*: vault files the agent read without you linking them
+
+Reads are taken from OpenCode's `read` tool calls. A note the agent only reaches
+through `bash` (`cat`, `grep`) or an MCP server is not detected. A read also
+proves the agent opened the note, not that it used it.
+
+OpenCode loads sidebar plugins from `tui.json`, separately from the `plugin`
+list in `opencode.json`. Add the package there too
+(`~/.config/opencode/tui.json`):
+
+```json
+{
+  "plugin": ["obsidian-wikilinks"]
+}
+```
+
+From a local checkout, list the checkout directory instead:
+`"file:/Users/you/src/obsidian-wikilinks"`.
+
+The section appears once a prompt in the session contains a wikilink. Each
+session's links and reads are logged to
+`~/.local/state/obsidian-wikilinks/sessions/<session>.ndjson`, which the sidebar
+watches.
+
 ## Vault selection
 
 Vault path resolution order:
@@ -197,6 +240,7 @@ The plugin itself is identical on every device.
 | `OBSIDIAN_WIKILINKS_RESOLVER`   | Path to `wikilink-resolver.py` (OpenCode only)                                                                                      |
 | `OBSIDIAN_WIKILINKS_PYTHON`     | Python interpreter to use (default `python3`, OpenCode only)                                                                        |
 | `OBSIDIAN_WIKILINKS_TIMEOUT_MS` | Resolver timeout in ms (default `10000`, OpenCode only)                                                                             |
+| `OBSIDIAN_WIKILINKS_STATE_DIR`  | Where the sidebar's per-session logs live (default `$XDG_STATE_HOME/obsidian-wikilinks/sessions`, OpenCode only)                    |
 
 ## Troubleshooting
 

package/hooks/wikilink-resolver.py

@@ -178,27 +178,38 @@ def main():
 
     index = build_index(vault)
     lines = []
+    links = []
     for target in dict.fromkeys(targets):  # dedupe, keep order
         hits = resolve(target, index)
+        paths = [h[2] for h in hits]
         if not hits:
+            status = "missing"
             lines.append(f"[[{target}]] -> no match found in vault {vault}")
         elif len(hits) == 1:
+            status = "resolved"
             lines.append(f"[[{target}]] -> {hits[0][2]}")
         else:
-            opts = ", ".join(h[2] for h in hits)
+            status = "ambiguous"
+            opts = ", ".join(paths)
             lines.append(f"[[{target}]] -> ambiguous, candidates: {opts}")
+        links.append({"target": target.strip(), "status": status, "paths": paths})
 
     context = (
         "Obsidian wikilink resolution (vault: " + vault + "):\n"
         + "\n".join(lines)
         + "\nRead the resolved file(s) when their content is relevant to the request."
     )
-    print(json.dumps({
+    output = {
         "hookSpecificOutput": {
             "hookEventName": "UserPromptSubmit",
             "additionalContext": context,
         }
-    }))
+    }
+    # Structured links for the OpenCode sidebar. Opt-in, so the Claude Code and
+    # Codex hook output stays exactly the documented shape.
+    if os.environ.get("OBSIDIAN_WIKILINKS_EMIT_LINKS"):
+        output["obsidianWikilinks"] = {"vault": vault, "links": links}
+    print(json.dumps(output))
     sys.exit(0)
 
 

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "obsidian-wikilinks",
-  "version": "0.2.2",
+  "version": "0.2.3-dev.pr5.34775183233.1",
   "description": "Resolve Obsidian [[wikilinks]] in coding-agent prompts to local vault paths and inject them as context.",
   "type": "module",
   "main": "plugin/obsidian-wikilinks.js",
   "exports": {
     ".": "./plugin/obsidian-wikilinks.js",
     "./server": "./plugin/obsidian-wikilinks.js",
+    "./tui": "./plugin/tui.js",
     "./package.json": "./package.json"
   },
+  "oc-plugin": [
+    "server",
+    "tui"
+  ],
   "scripts": {
     "test": "node test/smoke.mjs",
     "test:bun": "bun test/smoke.mjs",

package/plugin/lib/read-log.js

@@ -0,0 +1,159 @@
+/**
+ * Per-session log of the notes a prompt linked and the vault files the agent
+ * read, shared by the OpenCode server plugin (writer) and sidebar (reader).
+ *
+ * One NDJSON file per session, because the TUI and the server run the plugin
+ * in separate module instances and a file is the one thing both can see.
+ *
+ * Events:
+ *   {kind: "link", ts, vault, target, status: "resolved"|"ambiguous"|"missing", paths}
+ *   {kind: "read", ts, path}
+ *
+ * Only Node built-ins, so the server side stays install-free.
+ */
+import {appendFileSync, mkdirSync, readFileSync} from "node:fs"
+import {homedir} from "node:os"
+import path from "node:path"
+
+export function stateDir() {
+    const explicit = process.env.OBSIDIAN_WIKILINKS_STATE_DIR
+    if (explicit) {
+        return explicit
+    }
+    const base = process.env.XDG_STATE_HOME || path.join(homedir(), ".local", "state")
+    return path.join(base, "obsidian-wikilinks", "sessions")
+}
+
+export function logPath(sessionID) {
+    return path.join(stateDir(), `${String(sessionID).replace(/[^\w.-]/g, "_")}.ndjson`)
+}
+
+/** Append one event. Never throws: a broken log must not disturb the session. */
+export function append(sessionID, event) {
+    try {
+        mkdirSync(stateDir(), {recursive: true})
+        appendFileSync(logPath(sessionID), JSON.stringify(event) + "\n")
+    } catch {
+        // ignore
+    }
+}
+
+export function parse(text) {
+    const events = []
+    for (const line of text.split("\n")) {
+        if (!line.trim()) continue
+        try {
+            const event = JSON.parse(line)
+            if (event && (event.kind === "link" || event.kind === "read")) {
+                events.push(event)
+            }
+        } catch {
+            // skip a torn or foreign line
+        }
+    }
+    return events
+}
+
+export function readEvents(sessionID) {
+    try {
+        return parse(readFileSync(logPath(sessionID), "utf8"))
+    } catch {
+        return []
+    }
+}
+
+/** Folder links end in a separator and cover every file below them. */
+export function covers(linked, read) {
+    if (linked.endsWith(path.sep) || linked.endsWith("/")) {
+        return read.startsWith(linked)
+    }
+    return read === linked
+}
+
+export function insideVault(vault, file) {
+    const rel = path.relative(vault, file)
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
+}
+
+/**
+ * Fold a session's events into what the sidebar shows: every linked note with
+ * the reads that satisfy it, plus vault files read without being linked.
+ */
+export function buildView(events) {
+    const links = new Map()
+    const vaults = new Set()
+    const reads = []
+    for (const event of events) {
+        if (event.kind === "link") {
+            vaults.add(event.vault)
+            const paths = Array.isArray(event.paths) ? event.paths : []
+            const existing = links.get(event.target)
+            // Re-linking a note keeps its first position but takes the latest resolution.
+            links.set(event.target, {target: event.target, status: event.status, paths, vault: event.vault, ts: existing?.ts ?? event.ts})
+        } else if (typeof event.path === "string" && !reads.includes(event.path)) {
+            reads.push(event.path)
+        }
+    }
+
+    const claimed = new Set()
+    const items = [...links.values()].map((link) => {
+        const read = reads.filter((file) => link.paths.some((linked) => covers(linked, file)))
+        read.forEach((file) => claimed.add(file))
+        const state = link.status === "missing" ? "missing" : read.length ? "read" : "unread"
+        return {...link, read, state}
+    })
+    const other = reads.filter((file) => !claimed.has(file) && [...vaults].some((vault) => insideVault(vault, file)))
+    return {links: items, other, vaults: [...vaults]}
+}
+
+const ICON = {read: "✓", unread: "○", missing: "✗"}
+
+function fit(text, width) {
+    return text.length > width ? text.slice(0, Math.max(1, width - 1)) + "…" : text
+}
+
+function relative(vaults, file) {
+    const vault = vaults.find((v) => insideVault(v, file))
+    return vault ? path.relative(vault, file) : file
+}
+
+/**
+ * Sidebar rows for a view. Empty when the session linked nothing, so the
+ * section stays out of the way in sessions that never used a wikilink.
+ * Each row: {text, tone: "title"|"read"|"unread"|"missing"|"muted", toggle?}
+ */
+export function sidebarLines(view, {open = true, width = 30} = {}) {
+    if (!view.links.length) {
+        return []
+    }
+    const readCount = view.links.filter((l) => l.state === "read").length
+    const unreadCount = view.links.length - readCount
+    const rows = [{text: fit(`${open ? "▼" : "▶"} Obsidian notes  ✓ ${readCount}  ○ ${unreadCount}`, width), tone: "title", toggle: true}]
+    if (!open) {
+        return rows
+    }
+
+    for (const link of view.links) {
+        const label = link.paths.length === 1 && link.paths[0].endsWith(path.sep)
+            ? `${link.target}/`
+            : link.target
+        let suffix = ""
+        if (link.state === "missing") {
+            suffix = " (no match)"
+        }
+        else if (link.paths.length > 1 || label.endsWith("/")) {
+            suffix = link.read.length ? ` (${link.read.length} read)` : ""
+        }
+        if (link.status === "ambiguous" && !link.read.length) {
+            suffix = ` (${link.paths.length} candidates)`
+        }
+        rows.push({text: fit(`  ${ICON[link.state]} ${label}${suffix}`, width), tone: link.state})
+    }
+    if (view.other.length) {
+        rows.push({text: fit("  also read", width), tone: "muted"})
+        for (const file of view.other) {
+            rows.push({text: fit(`  · ${relative(view.vaults, file)}`, width), tone: "muted"})
+        }
+    }
+    return rows
+}

package/plugin/obsidian-wikilinks.js

@@ -12,6 +12,8 @@ import {homedir} from "node:os"
 import path from "node:path"
 import {fileURLToPath} from "node:url"
 
+import {append, insideVault, readEvents} from "./lib/read-log.js"
+
 const WIKILINK = /\[\[([^\]|#]+)(?:[#|][^\]]*)?\]\]/
 const PYTHON = process.env.OBSIDIAN_WIKILINKS_PYTHON || "python3"
 const TIMEOUT_MS = Number(process.env.OBSIDIAN_WIKILINKS_TIMEOUT_MS || 10000)
@@ -19,14 +21,18 @@ const TIMEOUT_MS = Number(process.env.OBSIDIAN_WIKILINKS_TIMEOUT_MS || 10000)
 /** Locate wikilink-resolver.py, whether the plugin is symlinked, copied, or installed by another host. */
 function findResolver() {
     const explicit = process.env.OBSIDIAN_WIKILINKS_RESOLVER
-    if (explicit) return existsSync(explicit) ? explicit : null
+    if (explicit) {
+        return existsSync(explicit) ? explicit : null
+    }
 
     const candidates = []
     const here = path.dirname(fileURLToPath(import.meta.url))
     // Repo layout: <root>/plugin/obsidian-wikilinks.js -> <root>/hooks/wikilink-resolver.py
     for (let dir = here, i = 0; i < 5; i++, dir = path.dirname(dir)) {
         candidates.push(path.join(dir, "hooks", "wikilink-resolver.py"))
-        if (dir === path.dirname(dir)) break
+        if (dir === path.dirname(dir)) {
+            break
+        }
     }
     // Copied next to the plugin file
     candidates.push(path.join(here, "wikilink-resolver.py"))
@@ -42,14 +48,17 @@ function findResolver() {
     return candidates.find(existsSync) || null
 }
 
-/** Run the resolver with the hook payload on stdin; resolve to its additionalContext, or null. */
+/**
+ * Run the resolver with the hook payload on stdin; resolve to
+ * `{context, vault, links}`, or null.
+ */
 function resolveWikilinks(script, prompt) {
     return new Promise((resolve) => {
         let child
         try {
             child = spawn(PYTHON, [script], {
                 stdio: ["pipe", "pipe", "ignore"],
-                env: {...process.env, OBSIDIAN_WIKILINKS_HOST: "opencode"},
+                env: {...process.env, OBSIDIAN_WIKILINKS_HOST: "opencode", OBSIDIAN_WIKILINKS_EMIT_LINKS: "1"},
             })
         } catch {
             return resolve(null)
@@ -69,8 +78,13 @@ function resolveWikilinks(script, prompt) {
         child.on("error", () => done(null))
         child.on("close", () => {
             try {
-                const context = JSON.parse(out).hookSpecificOutput?.additionalContext
-                done(typeof context === "string" && context ? context : null)
+                const payload = JSON.parse(out)
+                const context = payload.hookSpecificOutput?.additionalContext
+                if (typeof context !== "string" || !context) {
+                    return done(null)
+                }
+                const {vault = null, links = []} = payload.obsidianWikilinks || {}
+                done({context, vault, links})
             } catch {
                 done(null)
             }
@@ -91,30 +105,78 @@ function partID() {
     return `prt_wikilink_${stamp}${partCounter.toString(36)}${rand}`
 }
 
+/** Vaults each session has linked into; only reads inside them are logged. */
+const sessionVaults = new Map()
+
+function vaultsFor(sessionID) {
+    let vaults = sessionVaults.get(sessionID)
+    if (!vaults) {
+        // Rebuilt from the log so a restarted opencode keeps tracking old sessions.
+        vaults = new Set(readEvents(sessionID).filter((e) => e.kind === "link").map((e) => e.vault))
+        sessionVaults.set(sessionID, vaults)
+    }
+    return vaults
+}
+
 /** @type {import("@opencode-ai/plugin").Plugin} */
-export const ObsidianWikilinksPlugin = async () => {
+export const ObsidianWikilinksPlugin = async ({directory} = {}) => {
     return {
         "chat.message": async (_input, output) => {
             const prompt = output.parts
                 .filter((part) => part.type === "text" && !part.synthetic && part.text)
                 .map((part) => part.text)
                 .join("\n")
-            if (!prompt || !WIKILINK.test(prompt)) return
+            if (!prompt || !WIKILINK.test(prompt)) {
+                return
+            }
 
             const script = findResolver()
-            if (!script) return
+            if (!script) {
+                return
+            }
 
-            const context = await resolveWikilinks(script, prompt)
-            if (!context) return
+            const result = await resolveWikilinks(script, prompt)
+            if (!result) {
+                return
+            }
 
+            const sessionID = output.message.sessionID
             output.parts.push({
                 id: partID(),
-                sessionID: output.message.sessionID,
+                sessionID,
                 messageID: output.message.id,
                 type: "text",
-                text: context,
+                text: result.context,
                 synthetic: true,
             })
+
+            if (!result.vault || !result.links.length) {
+                return
+            }
+            vaultsFor(sessionID).add(result.vault)
+            const ts = new Date().toISOString()
+            for (const link of result.links) {
+                append(sessionID, {kind: "link", ts, vault: result.vault, ...link})
+            }
+        },
+
+        "tool.execute.after": async ({tool, sessionID, args}) => {
+            if (tool !== "read") {
+                return
+            }
+            const file = args?.filePath
+            if (typeof file !== "string" || !file) {
+                return
+            }
+            const vaults = vaultsFor(sessionID)
+            if (!vaults.size) {
+                return
+            }
+            const abs = path.resolve(directory || process.cwd(), file)
+            if (![...vaults].some((vault) => insideVault(vault, abs))) {
+                return
+            }
+            append(sessionID, {kind: "read", ts: new Date().toISOString(), path: abs})
         },
     }
 }

package/plugin/tui.js

@@ -0,0 +1,130 @@
+/**
+ * OpenCode TUI plugin: an "Obsidian notes" sidebar section listing every note
+ * the session's prompts linked with [[wikilinks]], marked ✓ read or ○ not read.
+ *
+ * Reads the per-session log the server plugin writes (lib/read-log.js).
+ * `@opentui/solid` and `solid-js` are provided by opencode at runtime.
+ */
+import {mkdirSync, statSync, watch} from "node:fs"
+
+import {createElement, insert, setProp} from "@opentui/solid"
+import {createSignal, onCleanup} from "solid-js"
+
+import {buildView, logPath, readEvents, sidebarLines, stateDir} from "./lib/read-log.js"
+
+/** Below opencode's own sidebar content. */
+const ORDER = 810
+const DEFAULT_WIDTH = 30
+
+function element(tag, props, children = []) {
+    const node = createElement(tag)
+    for (const [key, value] of Object.entries(props)) {
+        if (value !== undefined) {
+            setProp(node, key, value)
+        }
+    }
+    for (const child of children) {
+        insert(node, child)
+    }
+    return node
+}
+
+function color(theme, tone) {
+    if (tone === "title") {
+        return theme.text
+    }
+    if (tone === "read") {
+        return theme.success
+    }
+    if (tone === "unread") {
+        return theme.warning
+    }
+    if (tone === "missing") {
+        return theme.error
+    }
+    return theme.textMuted
+}
+
+function mtime(file) {
+    try {
+        return statSync(file).mtimeMs
+    } catch {
+        return 0
+    }
+}
+
+/**
+ * Call `onChange` when the session's log changes. Watches the directory, since
+ * the file only appears with the first link; polling covers filesystems where
+ * fs.watch is unreliable.
+ */
+function watchLog(sessionID, onChange) {
+    const file = logPath(sessionID)
+    let last = mtime(file)
+    const check = () => {
+        const current = mtime(file)
+        if (current === last) {
+            return
+        }
+        last = current
+        onChange()
+    }
+    let watcher
+    try {
+        mkdirSync(stateDir(), {recursive: true})
+        watcher = watch(stateDir(), check)
+    } catch {
+        watcher = undefined
+    }
+    const poll = setInterval(check, 2000)
+    return () => {
+        clearInterval(poll)
+        watcher?.close()
+    }
+}
+
+function Section(api, sessionID, width) {
+    const [view, setView] = createSignal(buildView(readEvents(sessionID)))
+    const [open, setOpen] = createSignal(true)
+    const redraw = () => api.renderer.requestRender()
+
+    onCleanup(
+        watchLog(sessionID, () => {
+            setView(buildView(readEvents(sessionID)))
+            redraw()
+        }),
+    )
+
+    const rows = () =>
+        sidebarLines(view(), {open: open(), width}).map((row) =>
+            element(
+                "text",
+                {
+                    fg: color(api.theme.current, row.tone),
+                    onMouseDown: row.toggle
+                        ? () => {
+                              setOpen((value) => !value)
+                              redraw()
+                          }
+                        : undefined,
+                },
+                [row.text],
+            ),
+        )
+
+    return element("box", {width: "100%", flexDirection: "column"}, [rows])
+}
+
+/** @type {import("@opencode-ai/plugin/tui").TuiPlugin} */
+export const tui = async (api, options) => {
+    const width = typeof options?.width === "number" ? options.width : DEFAULT_WIDTH
+    api.slots.register({
+        order: ORDER,
+        slots: {sidebar_content: (_ctx, props) => Section(api, props.session_id, width)},
+    })
+}
+
+export default {
+    id: "obsidian-wikilinks",
+    tui,
+}