@openviking/opencode-plugin 0.1.5

package/index.mjs

@@ -0,0 +1,84 @@
+import { dirname } from "path"
+import { fileURLToPath } from "url"
+import { initializeRuntime } from "./lib/runtime.mjs"
+import { createRepoContext } from "./lib/repo-context.mjs"
+import { createMemorySessionManager } from "./lib/memory-session.mjs"
+import { createCodeTools } from "./lib/code-tools.mjs"
+import { createMemoryTools } from "./lib/memory-tools.mjs"
+import { createMemoryRecall } from "./lib/memory-recall.mjs"
+import { createVikingUriGuard } from "./lib/viking-uri-guard.mjs"
+import { initLogger, loadConfig, log, resolveDataDir } from "./lib/utils.mjs"
+
+const pluginRoot = dirname(fileURLToPath(import.meta.url))
+
+/**
+ * @type {import('@opencode-ai/plugin').Plugin}
+ */
+export async function OpenVikingPlugin({ client, directory }) {
+  const config = loadConfig(pluginRoot, directory)
+  const dataDir = resolveDataDir(pluginRoot, config)
+  initLogger(dataDir)
+
+  if (!config.enabled) {
+    log("INFO", "plugin", "OpenViking plugin is disabled in configuration")
+    return {}
+  }
+
+  const repoContext = createRepoContext({ config })
+  const sessionManager = createMemorySessionManager({ config, pluginRoot: dataDir })
+  const recall = createMemoryRecall({ config })
+  const vikingUriGuard = createVikingUriGuard()
+  const tools = createMemoryTools({ config, sessionManager, projectDirectory: directory })
+  const codeTools = createCodeTools({ config })
+
+  await sessionManager.init()
+
+  Promise.resolve().then(async () => {
+    const ready = await initializeRuntime(config, client)
+    if (ready) await repoContext.refreshRepos({ force: true })
+  })
+
+  return {
+    event: async ({ event }) => {
+      await sessionManager.handleEvent(event)
+      if (event?.type === "session.created") {
+        await repoContext.refreshRepos({ force: true })
+      }
+    },
+
+    "tool.execute.before": vikingUriGuard,
+
+    tool: { ...tools, ...codeTools },
+
+    "experimental.chat.system.transform": (_input, output) => {
+      const prompt = repoContext.getRepoSystemPrompt()
+      if (prompt) output.system.push(prompt)
+    },
+
+    "chat.message": async (input, output) => {
+      try {
+        if (!config.autoRecall?.enabled) return
+        await recall.injectRelevantMemories(input, output)
+      } catch (error) {
+        log("WARN", "recall", "Auto recall failed", { error: error?.message ?? String(error) })
+      }
+    },
+
+    "experimental.session.compacting": async (input) => {
+      log("INFO", "compaction", "OpenCode session compacting", {
+        opencode_session: input.sessionID,
+      })
+      await sessionManager.flushSession(input.sessionID, {
+        commit: true,
+        reason: "experimental.session.compacting",
+      })
+    },
+
+    stop: async () => {
+      await sessionManager.flushAll({ commit: true })
+      log("INFO", "plugin", "OpenViking plugin stopped")
+    },
+  }
+}
+
+export default OpenVikingPlugin

package/lib/code-tools.mjs

@@ -0,0 +1,134 @@
+import { tool } from "@opencode-ai/plugin"
+import { effectivePeerId, log, makeRequest, unwrapResponse, validateVikingUri } from "./utils.mjs"
+
+const z = tool.schema
+
+const CODE_TOOL_ENDPOINTS = {
+  search: "/api/v1/code/search",
+  outline: "/api/v1/code/outline",
+  expand: "/api/v1/code/expand",
+}
+
+function codeToolRequestOptions(kind, { uri, query, symbol, actorPeerId, abortSignal }) {
+  const body = { uri }
+  if (kind === "search") body.query = query
+  if (kind === "expand") body.symbol = symbol
+
+  return {
+    method: "POST",
+    endpoint: CODE_TOOL_ENDPOINTS[kind],
+    body,
+    abortSignal,
+    actorPeerId,
+  }
+}
+
+export function createCodeTools({ config }) {
+  const actorPeerId = effectivePeerId(config)
+  return {
+    codesearch: tool({
+      description:
+        "Search AST-supported symbol names (classes, functions, methods) by substring across a confirmed viking:// code repository or source subtree. " +
+        "Use only after you have evidence that the uri contains supported source files. " +
+        "Use when you do not know which file contains a symbol. " +
+        "Do not use for general memory search, documentation-only resources, plain text notes, chat/session history, or local filesystem paths. " +
+        "Returns structured results: symbol name, class context, file URI, line range. " +
+        "Typical workflow: verify code repo with ls/glob/add_resource output, then codesearch, codeoutline, codeexpand.",
+      args: {
+        query: z.string().describe("Symbol name substring to search for (case-insensitive)."),
+        uri: z
+          .string()
+          .describe(
+            "Viking URI for a confirmed ingested code repository or source subtree. Do not pass a local path or an unverified viking:// directory.",
+          ),
+      },
+      async execute(args, context) {
+        const validationError = validateVikingUri(args.uri, "codesearch")
+        if (validationError) return validationError
+        try {
+          const response = await makeRequest(config, {
+            ...codeToolRequestOptions("search", {
+              uri: args.uri,
+              query: args.query,
+              actorPeerId,
+              abortSignal: context.abort,
+            }),
+          })
+          return unwrapResponse(response)
+        } catch (error) {
+          log("ERROR", "codesearch", "Search failed", { error: error?.message, args })
+          return `Error: ${error.message}`
+        }
+      },
+    }),
+
+    codeoutline: tool({
+      description:
+        "Show the symbol structure of a confirmed viking:// source file: classes, functions, methods, and line spans. " +
+        "Use only for source files inside an ingested code repository, after you know the exact viking:// file URI. " +
+        "Do not use on directories, documentation-only files, plain text notes, or files that are not supported source code. " +
+        "Use read instead when you need the full file content.",
+      args: {
+        uri: z
+          .string()
+          .describe(
+            "Viking URI of a confirmed supported source file, e.g. viking://resources/myproject/src/main.py.",
+          ),
+      },
+      async execute(args, context) {
+        const validationError = validateVikingUri(args.uri, "codeoutline")
+        if (validationError) return validationError
+        try {
+          const response = await makeRequest(config, {
+            ...codeToolRequestOptions("outline", {
+              uri: args.uri,
+              actorPeerId,
+              abortSignal: context.abort,
+            }),
+          })
+          return unwrapResponse(response)
+        } catch (error) {
+          log("ERROR", "codeoutline", "Outline failed", { error: error?.message, uri: args.uri })
+          return `Error: ${error.message}`
+        }
+      },
+    }),
+
+    codeexpand: tool({
+      description:
+        "Return the full source of one named symbol from a confirmed viking:// source file. " +
+        "Use only after codeoutline or other evidence shows the symbol exists in that file. " +
+        "Do not use for broad exploration, non-code files, documentation, chat/session history, or unverified viking:// resources. " +
+        "Accepts 'bar' (top-level function or class) or 'Foo.bar' (method inside class Foo). " +
+        "For multiple symbols from the same file, read may be more efficient.",
+      args: {
+        uri: z
+          .string()
+          .describe("Viking URI of the confirmed supported source file containing the symbol."),
+        symbol: z
+          .string()
+          .describe(
+            "Symbol name: 'foo' for top-level, 'Foo.bar' for a method inside class Foo.",
+          ),
+      },
+      async execute(args, context) {
+        const validationError = validateVikingUri(args.uri, "codeexpand")
+        if (validationError) return validationError
+        try {
+          const response = await makeRequest(config, {
+            ...codeToolRequestOptions("expand", {
+              uri: args.uri,
+              symbol: args.symbol,
+              actorPeerId,
+              abortSignal: context.abort,
+            }),
+          })
+          return unwrapResponse(response)
+        } catch (error) {
+          log("ERROR", "codeexpand", "Expand failed", { error: error?.message, args })
+          return `Error: ${error.message}`
+        }
+      },
+    }),
+  }
+}

package/lib/memadd-local.mjs

@@ -0,0 +1,118 @@
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+import {
+  ensureRemoteUrl,
+  makeMultipartRequest,
+  makeRequest,
+  unwrapResponse,
+} from "./utils.mjs"
+
+export const MEMADD_LOCAL_FILE_ONLY_ERROR = "Error: memadd local upload currently supports files only."
+
+const ADD_RESOURCE_KEYS = [
+  "to",
+  "parent",
+  "reason",
+  "instruction",
+  "wait",
+  "timeout",
+  "watch_interval",
+]
+
+export function resolveMemaddSource(inputPath, projectDirectory = process.cwd()) {
+  if (ensureRemoteUrl(inputPath)) {
+    return { kind: "remote", path: inputPath }
+  }
+
+  let filePath
+  try {
+    filePath = resolveLocalPath(inputPath, projectDirectory)
+  } catch (error) {
+    return { kind: "error", error: `Error: ${error.message}` }
+  }
+
+  let stat
+  try {
+    stat = fs.statSync(filePath)
+  } catch (error) {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") {
+      return { kind: "error", error: `Error: Local file not found: ${filePath}` }
+    }
+    return { kind: "error", error: `Error: Unable to access local file: ${filePath}: ${error.message}` }
+  }
+
+  if (!stat.isFile()) {
+    return { kind: "error", error: MEMADD_LOCAL_FILE_ONLY_ERROR }
+  }
+
+  return { kind: "local", path: filePath, filename: path.basename(filePath) }
+}
+
+export function resolveLocalPath(inputPath, projectDirectory = process.cwd()) {
+  if (typeof inputPath !== "string" || inputPath.trim() === "") {
+    throw new Error("memadd path is required.")
+  }
+
+  let localPath = inputPath
+  if (isFileUrl(inputPath)) {
+    localPath = fileURLToPath(inputPath)
+  }
+
+  if (path.isAbsolute(localPath)) return path.normalize(localPath)
+  return path.resolve(projectDirectory || process.cwd(), localPath)
+}
+
+export function buildAddResourceBody(args, source, tempFileId) {
+  const body = source.kind === "remote" ? { path: source.path } : { temp_file_id: tempFileId }
+  for (const key of ADD_RESOURCE_KEYS) {
+    if (args[key] !== undefined) body[key] = args[key]
+  }
+  return body
+}
+
+export async function uploadLocalResource(config, source, abortSignal, actorPeerId) {
+  const bytes = await fs.promises.readFile(source.path)
+  const form = new FormData()
+  form.append("file", new Blob([bytes], { type: "application/octet-stream" }), source.filename)
+
+  const uploadResponse = await makeMultipartRequest(config, {
+    method: "POST",
+    endpoint: "/api/v1/resources/temp_upload",
+    body: form,
+    abortSignal,
+    actorPeerId,
+  })
+  const tempFileId = unwrapResponse(uploadResponse)?.temp_file_id
+  if (!tempFileId) {
+    throw new Error("OpenViking temp upload did not return temp_file_id")
+  }
+  return tempFileId
+}
+
+export async function addMemaddResource(config, args, projectDirectory, abortSignal, actorPeerId) {
+  const source = resolveMemaddSource(args.path, projectDirectory)
+  if (source.kind === "error") return { error: source.error }
+
+  const tempFileId = source.kind === "local"
+    ? await uploadLocalResource(config, source, abortSignal, actorPeerId)
+    : undefined
+  const body = buildAddResourceBody(args, source, tempFileId)
+  const addResponse = await makeRequest(config, {
+    method: "POST",
+    endpoint: "/api/v1/resources",
+    body,
+    abortSignal,
+    timeoutMs: args.wait ? Math.max(config.timeoutMs, (args.timeout ?? 300) * 1000) : config.timeoutMs,
+    actorPeerId,
+  })
+  return { addResponse, source }
+}
+
+function isFileUrl(value) {
+  try {
+    return new URL(value).protocol === "file:"
+  } catch {
+    return false
+  }
+}

package/lib/memory-recall.mjs

@@ -0,0 +1,214 @@
+import { effectivePeerId, log, makeRequest, unwrapResponse } from "./utils.mjs"
+
+const AUTO_RECALL_TIMEOUT_MS = 5000
+const RECALL_STOPWORDS = new Set([
+  "what", "when", "where", "which", "who", "whom", "whose", "why", "how",
+  "did", "does", "is", "are", "was", "were", "the", "and", "for", "with",
+  "from", "that", "this", "your", "you",
+])
+const RECALL_TOKEN_RE = /[a-z0-9]{2,}/gi
+const PREFERENCE_QUERY_RE = /prefer|preference|favorite|favourite|like|偏好|喜欢|爱好|更倾向/i
+const TEMPORAL_QUERY_RE = /when|what time|date|day|month|year|yesterday|today|tomorrow|last|next|什么时候|何时|哪天|几月|几年|昨天|今天|明天|上周|下周|上个月|下个月|去年|明年/i
+
+export function createMemoryRecall({ config }) {
+  async function injectRelevantMemories(input, output) {
+    if (!config.autoRecall?.enabled) return
+    const query = extractCurrentUserText(output.parts ?? [])
+    if (!query) return
+
+    const rawResults = await performRecallSearch(query)
+    if (rawResults.length === 0) return
+
+    const ranked = pickMemoriesForInjection(
+      rawResults,
+      config.autoRecall.limit,
+      query,
+      config.autoRecall.scoreThreshold,
+    )
+    if (ranked.length === 0) return
+
+    const processed = postProcessMemories(
+      ranked,
+      config.autoRecall.maxContentChars,
+      config.autoRecall.preferAbstract,
+    )
+    const block = formatMemoryBlock(processed, config.autoRecall.tokenBudget)
+    if (!block) return
+
+    if (prependSyntheticRecallPart(input, output, block)) {
+      log("INFO", "recall", `Injected ${processed.length} memories`)
+    }
+  }
+
+  async function performRecallSearch(query) {
+    try {
+      const body = { query: query.slice(0, 4000), limit: 20 }
+      const response = await makeRequest(config, {
+        method: "POST",
+        endpoint: "/api/v1/search/find",
+        body,
+        timeoutMs: AUTO_RECALL_TIMEOUT_MS,
+        actorPeerId: effectivePeerId(config),
+      })
+      const result = unwrapResponse(response)
+      return result?.memories ?? result?.results ?? []
+    } catch {
+      return []
+    }
+  }
+
+  return { injectRelevantMemories }
+}
+
+function extractCurrentUserText(parts) {
+  const texts = []
+  for (const part of parts) {
+    if (part.type !== "text" || typeof part.text !== "string") continue
+    if (part.text.includes("<relevant-memories>")) return null
+    if (!part.synthetic && !part.ignored) texts.push(part.text)
+  }
+  const joined = texts.join(" ").trim()
+  return joined || null
+}
+
+function buildRecallQueryProfile(query) {
+  const text = query.trim()
+  const allTokens = text.toLowerCase().match(RECALL_TOKEN_RE) ?? []
+  return {
+    tokens: allTokens.filter((token) => !RECALL_STOPWORDS.has(token)),
+    wantsPreference: PREFERENCE_QUERY_RE.test(text),
+    wantsTemporal: TEMPORAL_QUERY_RE.test(text),
+  }
+}
+
+function recallClampScore(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return 0
+  return Math.max(0, Math.min(1, value))
+}
+
+function lexicalOverlapBoost(tokens, text) {
+  if (tokens.length === 0 || !text) return 0
+  const haystack = ` ${text.toLowerCase()} `
+  let matched = 0
+  for (const token of tokens.slice(0, 8)) {
+    if (haystack.includes(` ${token} `) || haystack.includes(token)) matched += 1
+  }
+  return Math.min(0.2, (matched / Math.min(tokens.length, 4)) * 0.2)
+}
+
+function isEventMemory(item) {
+  const category = (item.category ?? "").toLowerCase()
+  return category === "events" || item.uri?.includes("/events/")
+}
+
+function isPreferencesMemory(item) {
+  return item.category === "preferences" || item.uri?.includes("/preferences/") || item.uri?.endsWith("/preferences")
+}
+
+function isLeafLikeMemory(item) {
+  return item.level === 2 || item.is_leaf === true
+}
+
+function rankForInjection(item, query) {
+  const baseScore = recallClampScore(item.score)
+  const abstract = (item.abstract ?? item.overview ?? "").trim()
+  const leafBoost = isLeafLikeMemory(item) ? 0.12 : 0
+  const eventBoost = query.wantsTemporal && isEventMemory(item) ? 0.1 : 0
+  const preferenceBoost = query.wantsPreference && isPreferencesMemory(item) ? 0.08 : 0
+  const overlapBoost = lexicalOverlapBoost(query.tokens, `${item.uri} ${abstract}`)
+  return baseScore + leafBoost + eventBoost + preferenceBoost + overlapBoost
+}
+
+function normalizeDedupeText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim()
+}
+
+function isEventOrCaseMemory(item) {
+  const category = (item.category ?? "").toLowerCase()
+  const uri = (item.uri ?? "").toLowerCase()
+  return category === "events" || category === "cases" || uri.includes("/events/") || uri.includes("/cases/")
+}
+
+function getMemoryDedupeKey(item) {
+  const abstract = normalizeDedupeText(item.abstract ?? item.overview ?? "")
+  const category = (item.category ?? "").toLowerCase() || "unknown"
+  if (abstract && !isEventOrCaseMemory(item)) return `abstract:${category}:${abstract}`
+  return `uri:${item.uri}`
+}
+
+function pickMemoriesForInjection(items, limit, queryText, scoreThreshold = 0) {
+  const query = buildRecallQueryProfile(queryText)
+  const sorted = [...items].sort((a, b) => rankForInjection(b, query) - rankForInjection(a, query))
+  const deduped = []
+  const seen = new Set()
+
+  for (const item of sorted) {
+    const key = getMemoryDedupeKey(item)
+    if (seen.has(key)) continue
+    seen.add(key)
+    deduped.push(item)
+  }
+
+  const leaves = deduped.filter((item) => isLeafLikeMemory(item))
+  if (leaves.length >= limit) return leaves.slice(0, limit)
+
+  const picked = [...leaves]
+  const used = new Set(leaves.map((item) => item.uri))
+  for (const item of deduped) {
+    if (picked.length >= limit) break
+    if (used.has(item.uri)) continue
+    if (recallClampScore(item.score) < scoreThreshold) continue
+    picked.push(item)
+  }
+  return picked
+}
+
+function postProcessMemories(items, maxContentChars, preferAbstract) {
+  return items.map((item) => {
+    const abstract = (item.abstract ?? "").trim()
+    const content = (item.content ?? "").trim()
+    let displayContent = ""
+    if (preferAbstract && abstract) displayContent = abstract
+    else if (content) displayContent = content
+    else if (abstract) displayContent = abstract
+    if (displayContent.length > maxContentChars) displayContent = `${displayContent.slice(0, maxContentChars)}...`
+    return { ...item, content: displayContent, abstract: abstract || undefined }
+  })
+}
+
+function formatMemoryBlock(items, tokenBudget) {
+  if (items.length === 0) return ""
+  const maxBlockChars = tokenBudget * 4
+  let usedChars = 0
+  const lines = ["<relevant-memories>"]
+
+  for (const item of items) {
+    const title = item.title ? `${item.title}\n` : ""
+    const content = item.content ?? ""
+    const entry = `<memory uri="${item.uri}">\n${title}${content}\n</memory>`
+    if (usedChars + entry.length + 1 > maxBlockChars) break
+    lines.push(entry)
+    usedChars += entry.length + 1
+  }
+
+  if (usedChars === 0) return ""
+  lines.push("</relevant-memories>")
+  lines.push('Use `memread` with a memory URI and level="overview" or level="read" for more details.')
+  return lines.join("\n")
+}
+
+function prependSyntheticRecallPart(input, output, injection) {
+  const sessionID = input.sessionID ?? output.message?.sessionID
+  const messageID = input.messageID ?? output.message?.id
+  if (!sessionID || !messageID) return false
+
+  output.parts.unshift({
+    id: `prt-ov-recall-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    type: "text",
+    text: injection,
+    synthetic: true,
+    sessionID,
+    messageID,
+  })
+  return true
+}