dendrite-rlm 0.1.0

package/.opencode/commands/decompose.md

@@ -0,0 +1,11 @@
+---
+description: Decompose a complex task into subtasks using RLM
+agent: build
+---
+
+Apply the RLM decomposition workflow to this task:
+
+$ARGUMENTS
+
+Follow your orchestrator protocol: recall -> assess -> decompose ->
+delegate -> compose -> persist.

package/.opencode/commands/recall.md

@@ -0,0 +1,7 @@
+---
+description: Search Trilium long-term memory
+agent: build
+---
+
+Use the rlm_recall tool to search for: $ARGUMENTS
+Summarize what was found and how it relates to the query.

package/.opencode/commands/setup-rlm.md

@@ -0,0 +1,9 @@
+---
+description: Create RLM note hierarchy in Trilium (one-time setup)
+agent: build
+---
+
+Run the rlm-setup tool to create the RLM note hierarchy in Trilium.
+If it already exists, it will check for and create any missing children.
+
+$ARGUMENTS

package/.opencode/commands/status.md

@@ -0,0 +1,7 @@
+---
+description: Show status of RLM tasks
+agent: build
+---
+
+Use the rlm_status tool to show all active and recent tasks.
+Summarize what's in progress, what's pending, and what's done.

package/.opencode/lib/rlm-config.ts

@@ -0,0 +1,141 @@
+// Shared Trilium ETAPI configuration
+// Set TRILIUM_API_URL to your Trilium ETAPI endpoint
+// Set TRILIUM_ETAPI_TOKEN to your ETAPI token (Options > ETAPI > Create Token)
+
+export const TRILIUM_URL =
+  process.env.TRILIUM_API_URL || ""
+export const TRILIUM_TOKEN = process.env.TRILIUM_ETAPI_TOKEN || ""
+
+if (!TRILIUM_TOKEN) {
+  console.warn(
+    "[rlm] TRILIUM_ETAPI_TOKEN not set. " +
+    "Generate one in Trilium: Options > ETAPI > Create Token"
+  )
+}
+
+/**
+ * Make an authenticated ETAPI request.
+ * Throws on non-2xx responses with the error body.
+ */
+export async function etapi(
+  path: string,
+  options: RequestInit = {}
+): Promise<any> {
+  const res = await fetch(`${TRILIUM_URL}${path}`, {
+    ...options,
+    headers: {
+      Authorization: TRILIUM_TOKEN,
+      "Content-Type": "application/json",
+      ...(options.headers || {}),
+    },
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => "")
+    throw new Error(`ETAPI ${res.status} ${path}: ${body}`)
+  }
+  const text = await res.text()
+  return text ? JSON.parse(text) : null
+}
+
+/**
+ * Search notes using Trilium's search syntax.
+ */
+export async function searchNotes(query: string): Promise<any[]> {
+  const result = await etapi(
+    `/notes?search=${encodeURIComponent(query)}`
+  )
+  return result?.results || []
+}
+
+/**
+ * Get a note with its content.
+ */
+export async function getNoteWithContent(noteId: string): Promise<{
+  noteId: string
+  title: string
+  content: string
+  attributes: any[]
+}> {
+  const [note, content] = await Promise.all([
+    etapi(`/notes/${noteId}`),
+    fetch(`${TRILIUM_URL}/notes/${noteId}/content`, {
+      headers: { Authorization: TRILIUM_TOKEN },
+    }).then((r) => r.text()),
+  ])
+  return { ...note, content }
+}
+
+/**
+ * Create a note with attributes in one call.
+ * Returns the new noteId.
+ */
+export async function createNoteWithAttrs(
+  parentId: string,
+  title: string,
+  content: string,
+  attrs: Record<string, string> = {}
+): Promise<string> {
+  const created = await etapi("/create-note", {
+    method: "POST",
+    body: JSON.stringify({
+      parentNoteId: parentId,
+      title,
+      type: "text",
+      content,
+    }),
+  })
+  const noteId = created.note.noteId
+
+  await Promise.all(
+    Object.entries(attrs).map(([name, value]) =>
+      etapi("/attributes", {
+        method: "POST",
+        body: JSON.stringify({
+          noteId,
+          type: "label",
+          name,
+          value,
+        }),
+      })
+    )
+  )
+
+  return noteId
+}
+
+/**
+ * Overwrite a note's content.
+ */
+export async function updateNoteContent(
+  noteId: string,
+  content: string
+): Promise<void> {
+  await fetch(`${TRILIUM_URL}/notes/${noteId}/content`, {
+    method: "PUT",
+    headers: {
+      Authorization: TRILIUM_TOKEN,
+      "Content-Type": "text/plain",
+    },
+    body: content,
+  })
+}
+
+/**
+ * Update a label attribute's value on a note.
+ */
+export async function updateAttribute(
+  noteId: string,
+  attrName: string,
+  newValue: string
+): Promise<void> {
+  const note = await etapi(`/notes/${noteId}`)
+  const attr = (note.attributes || []).find(
+    (a: any) => a.type === "label" && a.name === attrName
+  )
+  if (attr) {
+    await etapi(`/attributes/${attr.attributeId}`, {
+      method: "PATCH",
+      body: JSON.stringify({ value: newValue }),
+    })
+  }
+}

package/.opencode/plugins/rlm-compaction.ts

@@ -0,0 +1,60 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+const TRILIUM_URL =
+  process.env.TRILIUM_API_URL || "http://localhost:8080/etapi"
+const TRILIUM_TOKEN = process.env.TRILIUM_ETAPI_TOKEN || ""
+
+export const RLMCompaction: Plugin = async ({ client }) => {
+  return {
+    "experimental.session.compacting": async (_input, output) => {
+      try {
+        const [knowledge, activeTasks] = await Promise.all([
+          fetch(
+            `${TRILIUM_URL}/notes?search=${encodeURIComponent(
+              "#rlm-type=knowledge"
+            )}`,
+            { headers: { Authorization: TRILIUM_TOKEN } }
+          ).then((r) => r.json()),
+          fetch(
+            `${TRILIUM_URL}/notes?search=${encodeURIComponent(
+              "#rlm-status=in-progress"
+            )}`,
+            { headers: { Authorization: TRILIUM_TOKEN } }
+          ).then((r) => r.json()),
+        ])
+
+        const knowledgeList = (knowledge.results || [])
+          .slice(0, 15)
+          .map((n: any) => `- ${n.title} (${n.noteId})`)
+          .join("\n")
+
+        const taskList = (activeTasks.results || [])
+          .map((n: any) => `- ${n.title} (${n.noteId})`)
+          .join("\n")
+
+        output.context.push(
+          `## RLM — Trilium Long-term Memory\n\n` +
+            `You have a Trilium-backed long-term memory system.\n` +
+            `Use \`rlm_recall\` to retrieve detailed content for any entry below.\n` +
+            `Do NOT re-explore code already documented here.\n\n` +
+            `### Stored Knowledge\n${knowledgeList || "_(none yet)_"}\n\n` +
+            `### Active Tasks\n${taskList || "_(none)_"}\n\n` +
+            `### Available RLM Tools\n` +
+            `- \`rlm_recall\` — search memory\n` +
+            `- \`rlm_decompose\` — create subtasks\n` +
+            `- \`rlm_collect\` — gather worker results\n` +
+            `- \`rlm_persist\` — store new knowledge\n` +
+            `- \`rlm_status\` — check task status`
+        )
+      } catch (e) {
+        await client.app.log({
+          body: {
+            service: "rlm-compaction",
+            level: "warn",
+            message: `Failed to inject Trilium context: ${e}`,
+          },
+        })
+      }
+    },
+  }
+}

package/.opencode/plugins/rlm-persistence.ts

@@ -0,0 +1,83 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+const TRILIUM_URL =
+  process.env.TRILIUM_API_URL || "http://localhost:8080/etapi"
+const TRILIUM_TOKEN = process.env.TRILIUM_ETAPI_TOKEN || ""
+
+export const RLMPersistence: Plugin = async ({ client }) => {
+  const persisted = new Set<string>()
+
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.idle") return
+
+      const sessionId = (event.properties as any)?.sessionID
+      if (!sessionId || persisted.has(sessionId)) return
+
+      try {
+        const session = await client.session.get({
+          path: { id: sessionId },
+        })
+        const title = (session as any)?.data?.title || "untitled"
+
+        const messages = await client.session.messages({
+          path: { id: sessionId },
+        })
+        const msgCount = (messages as any)?.data?.length || 0
+
+        if (msgCount < 6) return
+
+        const res = await fetch(
+          `${TRILIUM_URL}/notes?search=${encodeURIComponent(
+            "#rlm-type=sessions"
+          )}`,
+          { headers: { Authorization: TRILIUM_TOKEN } }
+        )
+        const parents = await res.json()
+        if (!parents.results?.length) return
+
+        const date = new Date().toISOString().split("T")[0]
+        const time = new Date().toTimeString().slice(0, 5)
+
+        await fetch(`${TRILIUM_URL}/create-note`, {
+          method: "POST",
+          headers: {
+            Authorization: TRILIUM_TOKEN,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            parentNoteId: parents.results[0].noteId,
+            title: `session: ${date} ${time} - ${title}`,
+            type: "text",
+            content: [
+              `# Session: ${title}`,
+              `- **Date**: ${date} ${time}`,
+              `- **Messages**: ${msgCount}`,
+              `- **Session ID**: ${sessionId}`,
+              "",
+              "_Auto-persisted by RLM plugin._",
+            ].join("\n"),
+          }),
+        })
+
+        persisted.add(sessionId)
+
+        await client.app.log({
+          body: {
+            service: "rlm-persistence",
+            level: "info",
+            message: `Persisted session: ${title}`,
+          },
+        })
+      } catch (e) {
+        await client.app.log({
+          body: {
+            service: "rlm-persistence",
+            level: "warn",
+            message: `Failed to persist session: ${e}`,
+          },
+        })
+      }
+    },
+  }
+}

package/.opencode/prompts/orchestrator.md

@@ -0,0 +1,75 @@
+You are an RLM (Recursive Language Model) orchestrator. You decompose
+complex tasks into focused subtasks, delegate to specialized workers,
+and compose their results. You have Trilium-backed long-term memory.
+
+## Your Custom Tools
+
+- `rlm_recall` — search prior knowledge + session history (use FIRST)
+- `rlm_decompose` — batch-create subtask notes in Trilium
+- `rlm_collect` — batch-read worker results from Trilium
+- `rlm_persist` — store decisions/context/errors/patterns to memory
+- `rlm_status` — check active task status
+
+## Workflow
+
+### 1. RECALL (always do this first for non-trivial tasks)
+Call `rlm_recall` with keywords from the user's request.
+Use prior context to inform your plan. Do not re-discover documented knowledge.
+
+### 2. ASSESS
+Decide if the task needs decomposition:
+- **Skip decomposition** if: single file, < 5 tool calls, straightforward
+- **Decompose** if: multi-file, multi-concern, would exceed comfortable context
+
+### 3. DECOMPOSE (if needed)
+Call `rlm_decompose` with 2-5 subtasks. Each task spec must include:
+- **Objective**: 1-2 sentences of what to do
+- **Scope**: which files/areas to work on
+- **Constraints**: what NOT to touch, boundaries with other tasks
+- **Output**: what the result should contain
+
+Assign appropriate workers:
+- `worker-code` — implementation, writing code, making changes
+- `worker-analyze` — read-only analysis, review, exploration
+- `worker-debug` — investigating and fixing bugs
+
+### 4. DELEGATE
+Use the Task tool to invoke each worker. Pass this prompt format:
+
+  "Your task noteId is: <noteId>. Call rlm-worker_start to read your
+  spec, then execute the task, then call rlm-worker_complete with
+  your results. Return a one-paragraph summary."
+
+Launch INDEPENDENT subtasks in PARALLEL.
+Launch DEPENDENT subtasks SEQUENTIALLY.
+
+### 5. COMPOSE
+Call `rlm_collect` with all task noteIds.
+Read results. Check for consistency. Handle any errors or gaps.
+Synthesize the final answer for the user.
+
+### 6. PERSIST
+Call `rlm_persist` for any new:
+- Architectural decisions and rationale
+- Codebase context/patterns discovered
+- Error resolutions worth remembering
+
+## Decomposition Strategies
+
+**Feature implementation**: Split by layer (data -> API -> UI -> tests).
+  Include interface contracts between layers in specs.
+
+**Codebase refactoring**: Split by module/file group.
+  Include transformation pattern + examples in each spec.
+
+**Complex debugging**: Split as reproduce -> isolate -> fix -> verify.
+  These are sequential — each reads prior worker's result.
+
+**Code review**: Split by concern (security, performance, correctness).
+  These are parallel — each reviews the same code.
+
+## Rules
+- Do NOT hold large code blocks in your own context. Delegate reading.
+- Prefer 3-4 subtasks. More than 5 = the task should be split by the user.
+- Always recall before working.
+- After composing, always persist worthwhile knowledge.

package/.opencode/prompts/worker-analyze.md

@@ -0,0 +1,14 @@
+You are a focused read-only analysis worker in an RLM system.
+You CANNOT modify files.
+
+## Protocol
+1. Call `rlm-worker_start` with the task noteId from your instructions.
+2. Analyze the code as specified.
+3. Call `rlm-worker_complete` with your findings.
+4. Return a one-paragraph summary.
+
+## Rules
+- Reference specific file paths and line numbers.
+- Categorize findings by severity if doing a review.
+- Stay focused on what the spec asks — do not expand scope.
+- Keep findings under 500 words.

package/.opencode/prompts/worker-code.md

@@ -0,0 +1,16 @@
+You are a focused code implementation worker in an RLM system.
+
+## Protocol
+1. Call `rlm-worker_start` with the task noteId from your instructions
+   to read your spec and mark yourself in-progress.
+2. Execute the task. Stay strictly within your defined scope.
+3. When done, call `rlm-worker_complete` with your result summary.
+4. Return a one-paragraph summary to the orchestrator.
+
+## Rules
+- Do NOT modify files outside your assigned scope.
+- If you discover a dependency on another subtask, note it in your
+  result and flag it — do not attempt the other task.
+- Your result summary should include: files changed, key decisions,
+  any issues encountered.
+- Keep result under 300 words.

package/.opencode/prompts/worker-debug.md

@@ -0,0 +1,15 @@
+You are a focused debugging worker in an RLM system.
+
+## Protocol
+1. Call `rlm-worker_start` with the task noteId from your instructions.
+2. Investigate the issue within your defined scope.
+3. If spec says fix: implement the fix.
+   If spec says analyze only: document root cause without fixing.
+4. Call `rlm-worker_complete` with root cause + fix/analysis.
+5. Return a one-paragraph summary.
+
+## Rules
+- Include: root cause, evidence, fix applied (if any), how to verify.
+- If the issue spans beyond your scope, document what you found and
+  flag the dependency.
+- Keep result under 300 words.

package/.opencode/tools/rlm-setup.ts

@@ -0,0 +1,228 @@
+import { tool } from "@opencode-ai/plugin"
+import { searchNotes, createNoteWithAttrs } from "../lib/rlm-config"
+
+export default tool({
+  description:
+    "One-time setup: Create the RLM note hierarchy in Trilium. " +
+    "Creates RLM root, tasks, knowledge (decisions/context/errors/patterns), " +
+    "and sessions containers with proper labels. Idempotent — safe to run multiple times.",
+  args: {
+    parentNoteId: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Trilium noteId to create RLM root under. " +
+          "Defaults to 'root' (top level). " +
+          "Use a specific noteId to nest under an existing note."
+      ),
+  },
+  async execute(args) {
+    const rootParent = args.parentNoteId || "root"
+    const report: string[] = []
+
+    // Check if RLM root already exists
+    const existingRoot = await searchNotes("#rlm")
+    if (existingRoot.length > 0) {
+      report.push(
+        `RLM root already exists: "${existingRoot[0].title}" (${existingRoot[0].noteId})`
+      )
+      report.push("Checking for missing children...")
+
+      const rlmRootId = existingRoot[0].noteId
+
+      const requiredChildren = [
+        {
+          label: "rlm-type",
+          value: "tasks",
+          title: "tasks",
+          content: "Container for RLM task coordination notes.",
+          children: [] as { label: string; value: string; title: string; content: string }[],
+        },
+        {
+          label: "rlm-type",
+          value: "knowledge",
+          title: "knowledge",
+          content: "Persistent knowledge base.",
+          children: [
+            {
+              label: "rlm-kb",
+              value: "decisions",
+              title: "decisions",
+              content: "Architectural decisions and rationale.",
+            },
+            {
+              label: "rlm-kb",
+              value: "context",
+              title: "context",
+              content: "Codebase context summaries.",
+            },
+            {
+              label: "rlm-kb",
+              value: "errors",
+              title: "errors",
+              content: "Error resolutions worth remembering.",
+            },
+            {
+              label: "rlm-kb",
+              value: "patterns",
+              title: "patterns",
+              content: "Code patterns and conventions discovered.",
+            },
+          ],
+        },
+        {
+          label: "rlm-type",
+          value: "sessions",
+          title: "sessions",
+          content: "Session summaries for cross-session continuity.",
+          children: [] as { label: string; value: string; title: string; content: string }[],
+        },
+      ]
+
+      for (const child of requiredChildren) {
+        const existing = await searchNotes(`#${child.label}=${child.value}`)
+        if (existing.length > 0) {
+          report.push(`  [exists] ${child.title} (${existing[0].noteId})`)
+
+          if (child.children.length > 0) {
+            for (const grandchild of child.children) {
+              const gExisting = await searchNotes(
+                `#${grandchild.label}=${grandchild.value}`
+              )
+              if (gExisting.length > 0) {
+                report.push(
+                  `    [exists] ${grandchild.title} (${gExisting[0].noteId})`
+                )
+              } else {
+                const gId = await createNoteWithAttrs(
+                  existing[0].noteId,
+                  grandchild.title,
+                  grandchild.content,
+                  { [grandchild.label]: grandchild.value }
+                )
+                report.push(
+                  `    [created] ${grandchild.title} (${gId})`
+                )
+              }
+            }
+          }
+        } else {
+          const childId = await createNoteWithAttrs(
+            rlmRootId,
+            child.title,
+            child.content,
+            { [child.label]: child.value }
+          )
+          report.push(`  [created] ${child.title} (${childId})`)
+
+          if (child.children.length > 0) {
+            for (const grandchild of child.children) {
+              const gId = await createNoteWithAttrs(
+                childId,
+                grandchild.title,
+                grandchild.content,
+                { [grandchild.label]: grandchild.value }
+              )
+              report.push(
+                `    [created] ${grandchild.title} (${gId})`
+              )
+            }
+          }
+        }
+      }
+
+      return report.join("\n")
+    }
+
+    // Create fresh RLM hierarchy
+    report.push("Creating RLM note hierarchy...")
+
+    // Root
+    const rlmRootId = await createNoteWithAttrs(
+      rootParent,
+      "RLM",
+      "Recursive Language Model — shared state and long-term memory.\n\n" +
+        "This hierarchy is managed automatically by OpenCode RLM tools.\n" +
+        "Do not rename or delete these notes.",
+      { rlm: "" }
+    )
+    report.push(`[created] RLM root (${rlmRootId})`)
+
+    // Tasks
+    const tasksId = await createNoteWithAttrs(
+      rlmRootId,
+      "tasks",
+      "Container for RLM task coordination notes.\n" +
+        "Subtask specs and results are stored here during decomposition.",
+      { "rlm-type": "tasks" }
+    )
+    report.push(`[created] tasks (${tasksId})`)
+
+    // Knowledge
+    const knowledgeId = await createNoteWithAttrs(
+      rlmRootId,
+      "knowledge",
+      "Persistent knowledge base.\n" +
+        "Organized by category: decisions, context, errors, patterns.",
+      { "rlm-type": "knowledge" }
+    )
+    report.push(`[created] knowledge (${knowledgeId})`)
+
+    // Knowledge subcategories
+    const categories = [
+      {
+        title: "decisions",
+        value: "decisions",
+        content: "Architectural decisions and rationale.",
+      },
+      {
+        title: "context",
+        value: "context",
+        content: "Codebase context summaries.",
+      },
+      {
+        title: "errors",
+        value: "errors",
+        content: "Error resolutions worth remembering.",
+      },
+      {
+        title: "patterns",
+        value: "patterns",
+        content: "Code patterns and conventions discovered.",
+      },
+    ]
+
+    for (const cat of categories) {
+      const catId = await createNoteWithAttrs(
+        knowledgeId,
+        cat.title,
+        cat.content,
+        { "rlm-kb": cat.value }
+      )
+      report.push(`  [created] ${cat.title} (${catId})`)
+    }
+
+    // Sessions
+    const sessionsId = await createNoteWithAttrs(
+      rlmRootId,
+      "sessions",
+      "Session summaries for cross-session continuity.\n" +
+        "Auto-populated by the RLM persistence plugin.",
+      { "rlm-type": "sessions" }
+    )
+    report.push(`[created] sessions (${sessionsId})`)
+
+    report.push("")
+    report.push("RLM setup complete. Hierarchy:")
+    report.push(`RLM (${rlmRootId}) #rlm`)
+    report.push(`├── tasks (${tasksId}) #rlm-type=tasks`)
+    report.push(`├── knowledge (${knowledgeId}) #rlm-type=knowledge`)
+    report.push(`│   ├── decisions #rlm-kb=decisions`)
+    report.push(`│   ├── context  #rlm-kb=context`)
+    report.push(`│   ├── errors   #rlm-kb=errors`)
+    report.push(`│   └── patterns #rlm-kb=patterns`)
+    report.push(`└── sessions (${sessionsId}) #rlm-type=sessions`)
+
+    return report.join("\n")
+  },
+})