@hoverlover/cc-discord 0.1.0

package/memory/core/MemoryStore.ts

@@ -0,0 +1,72 @@
+/**
+ * Base class for memory stores.
+ * Implementations should override all async methods.
+ */
+export class MemoryStore {
+  id: string;
+  caps: { atomicBatch: boolean; fullTextSearch: boolean; vectorSearch: boolean; bidirectionalSync: boolean };
+
+  /**
+   * @param {string} id
+   * @param {{ atomicBatch: boolean, fullTextSearch: boolean, vectorSearch: boolean, bidirectionalSync: boolean }} caps
+   */
+  constructor(
+    id: string,
+    caps: { atomicBatch: boolean; fullTextSearch: boolean; vectorSearch: boolean; bidirectionalSync: boolean },
+  ) {
+    this.id = id;
+    this.caps = caps;
+  }
+
+  async init(): Promise<void> {
+    throw new Error("MemoryStore.init() not implemented");
+  }
+
+  async health(): Promise<any> {
+    throw new Error("MemoryStore.health() not implemented");
+  }
+
+  async writeBatch(_batch: any): Promise<any> {
+    throw new Error("MemoryStore.writeBatch() not implemented");
+  }
+
+  async readSessionSnapshot(_sessionKey: any): Promise<any> {
+    throw new Error("MemoryStore.readSessionSnapshot() not implemented");
+  }
+
+  async listTurns(_input: any): Promise<any> {
+    throw new Error("MemoryStore.listTurns() not implemented");
+  }
+
+  async listRecentTurns(_input: any): Promise<any> {
+    throw new Error("MemoryStore.listRecentTurns() not implemented");
+  }
+
+  async queryCards(_input: any): Promise<any> {
+    throw new Error("MemoryStore.queryCards() not implemented");
+  }
+
+  async readCompactionState(_sessionKey: any): Promise<any> {
+    throw new Error("MemoryStore.readCompactionState() not implemented");
+  }
+
+  async getTurnById(_input: any): Promise<any> {
+    throw new Error("MemoryStore.getTurnById() not implemented");
+  }
+
+  async readRuntimeState(_sessionKey: any): Promise<any> {
+    throw new Error("MemoryStore.readRuntimeState() not implemented");
+  }
+
+  async upsertRuntimeState(_input: any): Promise<any> {
+    throw new Error("MemoryStore.upsertRuntimeState() not implemented");
+  }
+
+  async bumpRuntimeContext(_input: any): Promise<any> {
+    throw new Error("MemoryStore.bumpRuntimeContext() not implemented");
+  }
+
+  async close(): Promise<void> {
+    // Optional for stores that keep sockets or db handles
+  }
+}

package/memory/core/session-key.ts

@@ -0,0 +1,14 @@
+/**
+ * Build a deterministic memory session key for a Claude route.
+ *
+ * @param {{ sessionId?: string, agentId?: string, channelId?: string }} input
+ */
+export function buildMemorySessionKey(input: { sessionId?: string; agentId?: string; channelId?: string } = {}) {
+  const sessionId = String(input.sessionId || "default").trim() || "default";
+  const agentId = String(input.agentId || "claude").trim() || "claude";
+  const channelId = input.channelId ? String(input.channelId).trim() : "";
+  if (channelId) {
+    return `discord:${sessionId}:${agentId}:ch-${channelId}`;
+  }
+  return `discord:${sessionId}:${agentId}`;
+}

package/memory/core/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Canonical memory model helpers (store-agnostic).
+ *
+ * This file intentionally uses plain JS + JSDoc so the project can stay
+ * lightweight without a TypeScript build step.
+ */
+
+export const MemoryScopes = Object.freeze({
+  SESSION: "session",
+  USER: "user",
+  GLOBAL: "global",
+});
+
+export const MemoryCardTypes = Object.freeze({
+  DECISION: "decision",
+  CONSTRAINT: "constraint",
+  PREFERENCE: "preference",
+  TODO: "todo",
+  CONTEXT: "context",
+});
+
+/**
+ * @param {unknown} value
+ * @param {any} fallback
+ */
+export function safeJsonParse(value: unknown, fallback: unknown) {
+  if (value === null || value === undefined || value === "") return fallback;
+  if (typeof value !== "string") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} fallback
+ */
+export function safeJsonStringify(value: unknown, fallback: string = "null") {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return fallback;
+  }
+}
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+/**
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ */
+export function clamp(value: number, min: number, max: number) {
+  return Math.max(min, Math.min(max, value));
+}

package/memory/index.ts

@@ -0,0 +1,19 @@
+export { MemoryCoordinator } from "./core/MemoryCoordinator.ts";
+export { MemoryStore } from "./core/MemoryStore.ts";
+export { buildMemorySessionKey } from "./core/session-key.ts";
+export {
+  clamp,
+  MemoryCardTypes,
+  MemoryScopes,
+  nowIso,
+  safeJsonParse,
+  safeJsonStringify,
+} from "./core/types.ts";
+
+/**
+ * Lazy-load sqlite provider to avoid forcing sqlite initialization on all imports.
+ */
+export async function loadSqliteMemoryStore() {
+  const mod = await import("./providers/sqlite/SqliteMemoryStore.ts");
+  return mod.SqliteMemoryStore;
+}