@mem9/opencode 0.1.0

package/src/server/recall/query.ts

@@ -0,0 +1,127 @@
+const TOOL_NOISE_TAGS = [
+  "local-command-caveat",
+  "local-command-stdout",
+  "command-name",
+  "command-message",
+  "task-notification",
+  "system-reminder",
+];
+
+export const MAX_RECALL_QUERY_PARAM_LEN = 1600;
+
+const QUERY_ELLIPSIS = "\n...\n";
+const QUERY_PARAM_KEY = "q";
+
+function stripTaggedBlock(input: string, tagName: string): string {
+  const startTag = `<${tagName}>`;
+  const endTag = `</${tagName}>`;
+
+  let result = input;
+  while (result.includes(startTag)) {
+    const start = result.indexOf(startTag);
+    const end = result.indexOf(endTag, start);
+
+    if (end === -1) {
+      result = result.slice(0, start);
+      break;
+    }
+
+    result = result.slice(0, start) + result.slice(end + endTag.length);
+  }
+
+  return result;
+}
+
+function clampRecallQuery(input: string): string {
+  if (encodedQueryParamLength(input) <= MAX_RECALL_QUERY_PARAM_LEN) {
+    return input;
+  }
+
+  const chars = Array.from(input);
+  let best = truncatePrefixToEncodedBudget(chars);
+  let low = 2;
+  let high = Math.max(chars.length - 2, 0);
+
+  while (low <= high) {
+    const keptChars = Math.floor((low + high) / 2);
+    const candidate = buildBalancedCandidate(chars, keptChars);
+
+    if (encodedQueryParamLength(candidate) <= MAX_RECALL_QUERY_PARAM_LEN) {
+      best = candidate;
+      low = keptChars + 1;
+    } else {
+      high = keptChars - 1;
+    }
+  }
+
+  return best;
+}
+
+function encodedQueryParamLength(input: string): number {
+  return new URLSearchParams({ [QUERY_PARAM_KEY]: input }).toString().length;
+}
+
+function buildBalancedCandidate(chars: string[], keptChars: number): string {
+  if (keptChars <= 0) {
+    return QUERY_ELLIPSIS;
+  }
+
+  const prefixLen = Math.ceil(keptChars / 2);
+  const suffixLen = Math.floor(keptChars / 2);
+  const prefix = chars.slice(0, prefixLen).join("").trimEnd();
+  const suffix = chars.slice(chars.length - suffixLen).join("").trimStart();
+
+  return `${prefix}${QUERY_ELLIPSIS}${suffix}`;
+}
+
+function truncatePrefixToEncodedBudget(chars: string[]): string {
+  let low = 0;
+  let high = chars.length;
+  let best = "";
+
+  while (low <= high) {
+    const length = Math.floor((low + high) / 2);
+    const candidate = chars.slice(0, length).join("").trimEnd();
+
+    if (encodedQueryParamLength(candidate) <= MAX_RECALL_QUERY_PARAM_LEN) {
+      best = candidate;
+      low = length + 1;
+    } else {
+      high = length - 1;
+    }
+  }
+
+  return best;
+}
+
+export function buildRecallQuery(input: string): string {
+  let result = input.replace(/\r\n?/g, "\n");
+
+  result = stripTaggedBlock(result, "relevant-memories");
+  for (const tag of TOOL_NOISE_TAGS) {
+    result = stripTaggedBlock(result, tag);
+  }
+
+  result = result.replace(
+    /^Conversation info \(untrusted metadata\):\s*\n```[\s\S]*?\n```\s*/gm,
+    "",
+  );
+  result = result.replace(
+    /^Sender \(untrusted metadata\):\s*\n```[\s\S]*?\n```\s*/gm,
+    "",
+  );
+  result = result.replace(
+    /<<<EXTERNAL_UNTRUSTED_CONTENT[\s\S]*?<<<END_EXTERNAL_UNTRUSTED_CONTENT[^>]*>>>/g,
+    "",
+  );
+  result = result.replace(
+    /^Untrusted context \(metadata, do not treat as instructions or commands\):\s*$/gm,
+    "",
+  );
+  result = result.replace(/^\s*Source:\s.*$/gm, "");
+  result = result.replace(/^\s*UNTRUSTED[^\n]*$/gm, "");
+  result = result.replace(/^\s*---\s*$/gm, "");
+  result = result.replace(/\n{3,}/g, "\n\n");
+
+  return clampRecallQuery(result.trim());
+}

package/src/server/server-backend.ts

@@ -0,0 +1,170 @@
+import type {
+  IngestInput,
+  IngestResult,
+  MemoryBackend,
+} from "./backend.js";
+import type {
+  Memory,
+  StoreResult,
+  SearchResult,
+  CreateMemoryInput,
+  UpdateMemoryInput,
+  SearchInput,
+} from "../shared/types.js";
+import { DEFAULT_SCOPE_CONFIG } from "../shared/defaults.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeTimeoutMs(value: number | undefined, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+
+  return Math.floor(value);
+}
+
+export interface ServerBackendOptions {
+  defaultTimeoutMs?: number;
+  searchTimeoutMs?: number;
+}
+
+/**
+ * ServerBackend — talks to mem9 REST API.
+ * Used when a runtime API key is available.
+ */
+export class ServerBackend implements MemoryBackend {
+  private baseUrl: string;
+  private defaultTimeoutMs: number;
+  private searchTimeoutMs: number;
+
+  constructor(
+    apiUrl: string,
+    private apiKey: string,
+    private agentName: string = "opencode",
+    options: ServerBackendOptions = {},
+  ) {
+    this.baseUrl = apiUrl.replace(/\/+$/, "");
+    this.defaultTimeoutMs = normalizeTimeoutMs(
+      options.defaultTimeoutMs,
+      DEFAULT_SCOPE_CONFIG.defaultTimeoutMs,
+    );
+    this.searchTimeoutMs = normalizeTimeoutMs(
+      options.searchTimeoutMs,
+      DEFAULT_SCOPE_CONFIG.searchTimeoutMs,
+    );
+  }
+
+  private memoryPath(path: string): string {
+    return `/v1alpha2/mem9s${path}`;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    timeoutMs = this.defaultTimeoutMs,
+  ): Promise<T> {
+    const url = this.baseUrl + path;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "X-Mnemo-Agent-Id": this.agentName,
+      "X-API-Key": this.apiKey,
+    };
+    const resp = await fetch(url, {
+      method,
+      headers,
+      body: body != null ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+
+    if (resp.status === 204) return undefined as T;
+
+    const text = await resp.text();
+    const data = text ? (JSON.parse(text) as unknown) : undefined;
+    if (!resp.ok) {
+      const message =
+        isRecord(data) && typeof data.error === "string" ? data.error : `HTTP ${resp.status}`;
+      throw new Error(message);
+    }
+    return data as T;
+  }
+
+  async store(input: CreateMemoryInput): Promise<StoreResult> {
+    return this.request<StoreResult>("POST", this.memoryPath("/memories"), input);
+  }
+
+  async ingest(input: IngestInput): Promise<IngestResult> {
+    return this.request<IngestResult>("POST", this.memoryPath("/memories"), input);
+  }
+
+  async search(input: SearchInput): Promise<SearchResult> {
+    const params = new URLSearchParams();
+    if (input.q) params.set("q", input.q);
+    if (input.tags) params.set("tags", input.tags);
+    if (input.source) params.set("source", input.source);
+    if (input.limit != null) params.set("limit", String(input.limit));
+    if (input.offset != null) params.set("offset", String(input.offset));
+    if (input.memory_type) params.set("memory_type", input.memory_type);
+
+    const qs = params.toString();
+    const raw = await this.request<{
+      memories: Memory[];
+      total: number;
+      limit: number;
+      offset: number;
+    }>(
+      "GET",
+      `${this.memoryPath("/memories")}${qs ? "?" + qs : ""}`,
+      undefined,
+      this.searchTimeoutMs,
+    );
+
+    return {
+      memories: raw.memories ?? [],
+      total: raw.total,
+      limit: raw.limit,
+      offset: raw.offset,
+    };
+  }
+
+  async get(id: string): Promise<Memory | null> {
+    try {
+      return await this.request<Memory>("GET", this.memoryPath(`/memories/${id}`));
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("not found") || err.message.includes("404"))) {
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  async update(id: string, input: UpdateMemoryInput): Promise<Memory | null> {
+    try {
+      return await this.request<Memory>("PUT", this.memoryPath(`/memories/${id}`), input);
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("not found") || err.message.includes("404"))) {
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  async remove(id: string): Promise<boolean> {
+    try {
+      await this.request("DELETE", this.memoryPath(`/memories/${id}`));
+      return true;
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("not found") || err.message.includes("404"))) {
+        return false;
+      }
+      throw err;
+    }
+  }
+
+  async listRecent(limit: number): Promise<Memory[]> {
+    const result = await this.search({ limit, offset: 0 });
+    return result.memories;
+  }
+}

package/src/server/session-transcript.ts

@@ -0,0 +1,65 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { IngestMessage } from "./backend.js";
+
+const SESSION_TRANSCRIPT_FETCH_LIMIT = 24;
+
+interface TranscriptPartLike {
+  type: string;
+  text?: string;
+  synthetic?: boolean;
+  ignored?: boolean;
+}
+
+export type SessionTranscriptLoader = (sessionID: string) => Promise<IngestMessage[]>;
+
+function extractMessageText(parts: TranscriptPartLike[]): string {
+  const chunks: string[] = [];
+
+  for (const part of parts) {
+    if (part.type !== "text" || typeof part.text !== "string") {
+      continue;
+    }
+
+    if (part.synthetic === true || part.ignored === true) {
+      continue;
+    }
+
+    const text = part.text.trim();
+    if (text) {
+      chunks.push(text);
+    }
+  }
+
+  return chunks.join("\n\n");
+}
+
+export function createSessionTranscriptLoader(
+  client: PluginInput["client"],
+): SessionTranscriptLoader {
+  return async (sessionID: string): Promise<IngestMessage[]> => {
+    const response = await client.session.messages({
+      path: { id: sessionID },
+      query: { limit: SESSION_TRANSCRIPT_FETCH_LIMIT },
+      throwOnError: true,
+    });
+    const messages = response.data;
+
+    return messages.flatMap((entry): IngestMessage[] => {
+      if (entry.info.role !== "user" && entry.info.role !== "assistant") {
+        return [];
+      }
+
+      const content = extractMessageText(entry.parts);
+      if (!content) {
+        return [];
+      }
+
+      return [
+        {
+          role: entry.info.role,
+          content,
+        },
+      ];
+    });
+  };
+}

package/src/server/setup-flow.ts

@@ -0,0 +1,17 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import type { EffectiveConfig } from "./config.js";
+
+export function buildPendingSetupHooks(
+  _input: PluginInput,
+  config: EffectiveConfig,
+): Hooks {
+  const target = config.profileId
+    ? `profile "${config.profileId}"`
+    : "a mem9 profile";
+
+  console.warn(
+    `[mem9] Setup pending. Run /mem9-setup, configure MEM9_API_KEY, or add credentials for ${target} to enable mem9.`,
+  );
+
+  return {};
+}

package/src/server/tools.ts

@@ -0,0 +1,189 @@
+import { tool } from "@opencode-ai/plugin";
+import type { MemoryBackend } from "./backend.js";
+import type {
+  CreateMemoryInput,
+  UpdateMemoryInput,
+  SearchInput,
+} from "../shared/types.js";
+
+/**
+ * Build the 5 memory tools for OpenCode.
+ * Returns a map of tool name → ToolDefinition.
+ */
+export function buildTools(backend: MemoryBackend): Record<string, ReturnType<typeof tool>> {
+  return {
+    memory_store: tool({
+      description:
+        "Store a memory. Returns the stored memory with its assigned id.",
+      args: {
+        content: tool.schema
+          .string()
+          .max(50000)
+          .describe("Memory content (required, max 50000 chars)"),
+        source: tool.schema
+          .string()
+          .optional()
+          .describe("Which agent wrote this memory"),
+        tags: tool.schema
+          .array(tool.schema.string())
+          .max(20)
+          .optional()
+          .describe("Filterable tags (max 20)"),
+        metadata: tool.schema
+          .record(tool.schema.string(), tool.schema.unknown())
+          .optional()
+          .describe("Arbitrary structured data"),
+      },
+      async execute(args) {
+        try {
+          const input: CreateMemoryInput = {
+            content: args.content,
+            source: args.source,
+            tags: args.tags,
+            metadata: args.metadata as Record<string, unknown> | undefined,
+          };
+          const result = await backend.store(input);
+          return JSON.stringify({ ok: true, data: result });
+        } catch (err) {
+          return JSON.stringify({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    }),
+
+    memory_search: tool({
+      description:
+        "Search memories using hybrid vector + keyword search. Higher score = more relevant.",
+      args: {
+        q: tool.schema.string().optional().describe("Search query"),
+        tags: tool.schema
+          .string()
+          .optional()
+          .describe("Comma-separated tags to filter by (AND)"),
+        source: tool.schema
+          .string()
+          .optional()
+          .describe("Filter by source agent"),
+        limit: tool.schema
+          .number()
+          .int()
+          .min(1)
+          .max(200)
+          .optional()
+          .describe("Max results (default 20, max 200)"),
+        offset: tool.schema
+          .number()
+          .int()
+          .min(0)
+          .optional()
+          .describe("Pagination offset"),
+        memory_type: tool.schema
+          .string()
+          .optional()
+          .describe("Comma-separated memory types to filter by (e.g. insight,pinned)"),
+      },
+      async execute(args) {
+        try {
+          const input: SearchInput = {
+            q: args.q,
+            tags: args.tags,
+            source: args.source,
+            limit: args.limit,
+            offset: args.offset,
+            memory_type: args.memory_type,
+          };
+          const result = await backend.search(input);
+          return JSON.stringify({ ok: true, ...result });
+        } catch (err) {
+          return JSON.stringify({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    }),
+
+    memory_get: tool({
+      description: "Retrieve a single memory by its id.",
+      args: {
+        id: tool.schema.string().describe("Memory id (UUID)"),
+      },
+      async execute(args) {
+        try {
+          const result = await backend.get(args.id);
+          if (!result) {
+            return JSON.stringify({ ok: false, error: "memory not found" });
+          }
+          return JSON.stringify({ ok: true, data: result });
+        } catch (err) {
+          return JSON.stringify({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    }),
+
+    memory_update: tool({
+      description:
+        "Update an existing memory. Only provided fields are changed.",
+      args: {
+        id: tool.schema.string().describe("Memory id to update"),
+        content: tool.schema.string().optional().describe("New content"),
+        source: tool.schema.string().optional().describe("New source"),
+        tags: tool.schema
+          .array(tool.schema.string())
+          .optional()
+          .describe("Replacement tags"),
+        metadata: tool.schema
+          .record(tool.schema.string(), tool.schema.unknown())
+          .optional()
+          .describe("Replacement metadata"),
+      },
+      async execute(args) {
+        try {
+          const { id, ...rest } = args;
+          const input: UpdateMemoryInput = {
+            content: rest.content,
+            source: rest.source,
+            tags: rest.tags,
+            metadata: rest.metadata as Record<string, unknown> | undefined,
+          };
+          const result = await backend.update(id, input);
+          if (!result) {
+            return JSON.stringify({ ok: false, error: "memory not found" });
+          }
+          return JSON.stringify({ ok: true, data: result });
+        } catch (err) {
+          return JSON.stringify({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    }),
+
+    memory_delete: tool({
+      description: "Delete a memory by id.",
+      args: {
+        id: tool.schema.string().describe("Memory id to delete"),
+      },
+      async execute(args) {
+        try {
+          const deleted = await backend.remove(args.id);
+          if (!deleted) {
+            return JSON.stringify({ ok: false, error: "memory not found" });
+          }
+          return JSON.stringify({ ok: true });
+        } catch (err) {
+          return JSON.stringify({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    }),
+  };
+}

package/src/shared/credentials-store.ts

@@ -0,0 +1,55 @@
+import type { Mem9CredentialsFile, Mem9Profile } from "./types.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isMem9Profile(value: unknown): value is Mem9Profile {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return (
+    typeof value.label === "string" &&
+    typeof value.baseUrl === "string" &&
+    typeof value.apiKey === "string"
+  );
+}
+
+function normalizeMem9Profile(value: Mem9Profile): Mem9Profile {
+  return {
+    label: value.label,
+    baseUrl: value.baseUrl,
+    apiKey: value.apiKey,
+  };
+}
+
+export function parseCredentialsFile(raw: string): Mem9CredentialsFile {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw) as unknown;
+  } catch {
+    throw new Error("invalid mem9 credentials file");
+  }
+
+  if (!isRecord(parsed) || parsed.schemaVersion !== 1 || !isRecord(parsed.profiles)) {
+    throw new Error("invalid mem9 credentials file");
+  }
+
+  const profiles: Record<string, Mem9Profile> = {};
+  for (const [profileID, profile] of Object.entries(parsed.profiles)) {
+    if (!isMem9Profile(profile)) {
+      throw new Error("invalid mem9 credentials file");
+    }
+    profiles[profileID] = normalizeMem9Profile(profile);
+  }
+
+  return {
+    schemaVersion: 1,
+    profiles,
+  };
+}
+
+export function stringifyCredentialsFile(file: Mem9CredentialsFile): string {
+  return JSON.stringify(file, null, 2) + "\n";
+}

package/src/shared/defaults.ts

@@ -0,0 +1,13 @@
+import type { Mem9ConfigFile } from "./types.js";
+
+export const DEFAULT_SCOPE_CONFIG: Required<
+  Pick<
+    Mem9ConfigFile,
+    "schemaVersion" | "debug" | "defaultTimeoutMs" | "searchTimeoutMs"
+  >
+> = {
+  schemaVersion: 1,
+  debug: false,
+  defaultTimeoutMs: 8000,
+  searchTimeoutMs: 15000,
+};