@oh-my-pi/pi-mnemosyne 15.6.0

package/src/config.ts

@@ -0,0 +1,326 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+	type Env,
+	envBool,
+	envDisabled,
+	envFloat,
+	envInt,
+	envOneOf,
+	envOptionalString,
+	envString,
+	envTruthy,
+} from "./util/env";
+
+export type { Env };
+export { envBool, envDisabled, envFloat, envInt, envOneOf, envOptionalString, envString, envTruthy };
+
+export const DEFAULT_DATA_DIR = join(homedir(), ".hermes", "mnemosyne", "data");
+export const DEFAULT_DB_FILENAME = "mnemosyne.db";
+export const FASTEMBED_CACHE_DIR = join(homedir(), ".hermes", "cache", "fastembed");
+export const MODEL_CACHE_DIR = join(homedir(), ".hermes", "mnemosyne", "models");
+
+export const DEFAULT_EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5";
+export const DEFAULT_EMBEDDING_API_URL = "https://openrouter.ai/api/v1";
+export const DEFAULT_LLM_MODEL_REPO = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF";
+export const DEFAULT_LLM_MODEL_FILE = "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf";
+export const HOST_LLM_TIMEOUT_SECONDS = 15.0;
+
+export type VecType = "float32" | "int8" | "bit";
+
+export const EMBEDDING_DIMS: Readonly<Record<string, number>> = {
+	"BAAI/bge-small-en-v1.5": 384,
+	"BAAI/bge-base-en-v1.5": 768,
+	"BAAI/bge-large-en-v1.5": 1024,
+	"BAAI/bge-small-zh-v1.5": 512,
+	"BAAI/bge-base-zh-v1.5": 768,
+	"BAAI/bge-large-zh-v1.5": 1024,
+	"intfloat/multilingual-e5-small": 384,
+	"intfloat/multilingual-e5-base": 768,
+	"intfloat/multilingual-e5-large": 1024,
+	"BAAI/bge-m3": 1024,
+	"BAAI/bge-multilingual-gemma2": 3584,
+	"openai/text-embedding-3-small": 1536,
+	"openai/text-embedding-3-large": 3072,
+	"text-embedding-3-small": 1536,
+	"text-embedding-3-large": 3072,
+	"jina-embeddings-v5-omni-nano": 768,
+	"jina-embeddings-v5-omni-small": 1024,
+};
+
+export const VERACITY_WEIGHT_DEFAULTS = {
+	stated: 1.0,
+	inferred: 0.7,
+	tool: 0.5,
+	imported: 0.6,
+	unknown: 0.8,
+} as const;
+
+export function dataDir(env: Env = process.env): string {
+	return envOptionalString("MNEMOSYNE_DATA_DIR", env) ?? DEFAULT_DATA_DIR;
+}
+
+export function dbPath(env: Env = process.env): string {
+	return join(dataDir(env), DEFAULT_DB_FILENAME);
+}
+
+export function beamOptimizationsEnabled(env: Env = process.env): boolean {
+	return envTruthy("MNEMOSYNE_BEAM_OPTIMIZATIONS", env);
+}
+
+export function embeddingModel(env: Env = process.env): string {
+	return envString("MNEMOSYNE_EMBEDDING_MODEL", DEFAULT_EMBEDDING_MODEL, env);
+}
+
+export function embeddingDim(env: Env = process.env): number {
+	const explicit = envInt("MNEMOSYNE_EMBEDDING_DIM", NaN, env);
+	if (Number.isFinite(explicit)) return explicit;
+	return EMBEDDING_DIMS[embeddingModel(env)] ?? 384;
+}
+
+export function embeddingApiKey(env: Env = process.env): string {
+	return envString(
+		"MNEMOSYNE_EMBEDDING_API_KEY",
+		envString("OPENROUTER_API_KEY", envString("OPENAI_API_KEY", "", env), env),
+		env,
+	);
+}
+
+export function embeddingApiUrl(env: Env = process.env): string {
+	return envString(
+		"MNEMOSYNE_EMBEDDING_API_URL",
+		envString("OPENROUTER_BASE_URL", DEFAULT_EMBEDDING_API_URL, env),
+		env,
+	);
+}
+
+export function embeddingsViaApi(env: Env = process.env): boolean {
+	return envTruthy("MNEMOSYNE_EMBEDDINGS_VIA_API", env);
+}
+
+export function embeddingsDisabled(env: Env = process.env): boolean {
+	return envString("MNEMOSYNE_NO_EMBEDDINGS", "", env) !== "";
+}
+
+export function isApiEmbeddingModel(model = embeddingModel(), env: Env = process.env): boolean {
+	if (model.startsWith("openai/") || model.includes("text-embedding") || model.startsWith("text-embedding"))
+		return true;
+	const baseUrl = envString("MNEMOSYNE_EMBEDDING_API_URL", envString("OPENROUTER_BASE_URL", "", env), env);
+	if (baseUrl && !baseUrl.includes("openrouter.ai")) return true;
+	return embeddingsViaApi(env);
+}
+
+export function apiEmbeddingsAvailable(env: Env = process.env): boolean {
+	if (embeddingsDisabled(env)) return false;
+	if (!isApiEmbeddingModel(embeddingModel(env), env)) return false;
+	const baseUrl = envString("MNEMOSYNE_EMBEDDING_API_URL", envString("OPENROUTER_BASE_URL", "", env), env);
+	return Boolean(baseUrl && !baseUrl.includes("openrouter.ai")) || Boolean(embeddingApiKey(env));
+}
+
+export function workingMemoryMaxItems(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_WM_MAX_ITEMS", 10000, env);
+}
+
+export function workingMemoryTtlHours(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_WM_TTL_HOURS", 24, env);
+}
+
+export function episodicRecallLimit(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_EP_LIMIT", 50000, env);
+}
+
+export function sleepBatchSize(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_SLEEP_BATCH", 5000, env);
+}
+
+export function scratchpadMaxItems(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_SP_MAX", 1000, env);
+}
+
+export function recencyHalflifeHours(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_RECENCY_HALFLIFE", 168, env);
+}
+
+export function tier2Days(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_TIER2_DAYS", 30, env);
+}
+
+export function tier3Days(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_TIER3_DAYS", 180, env);
+}
+
+export function tier1Weight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_TIER1_WEIGHT", 1.0, env);
+}
+
+export function tier2Weight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_TIER2_WEIGHT", 0.5, env);
+}
+
+export function tier3Weight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_TIER3_WEIGHT", 0.25, env);
+}
+
+export function degradeBatchSize(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_DEGRADE_BATCH", 100, env);
+}
+
+export function smartCompressEnabled(env: Env = process.env): boolean {
+	return !envDisabled("MNEMOSYNE_SMART_COMPRESS", env);
+}
+
+export function tier3MaxChars(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_TIER3_MAX_CHARS", 300, env);
+}
+
+export function statedWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_STATED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.stated, env);
+}
+
+export function inferredWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_INFERRED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.inferred, env);
+}
+
+export function toolWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_TOOL_WEIGHT", VERACITY_WEIGHT_DEFAULTS.tool, env);
+}
+
+export function importedWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_IMPORTED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.imported, env);
+}
+
+export function unknownWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_UNKNOWN_WEIGHT", VERACITY_WEIGHT_DEFAULTS.unknown, env);
+}
+
+export function veracityWeightOverrides(env: Env = process.env): string[] {
+	const names = [
+		"MNEMOSYNE_STATED_WEIGHT",
+		"MNEMOSYNE_INFERRED_WEIGHT",
+		"MNEMOSYNE_TOOL_WEIGHT",
+		"MNEMOSYNE_IMPORTED_WEIGHT",
+		"MNEMOSYNE_UNKNOWN_WEIGHT",
+	];
+	const overrides: string[] = [];
+	for (const name of names) {
+		if (env[name]?.trim()) overrides.push(name);
+	}
+	return overrides;
+}
+
+export function vecType(env: Env = process.env): VecType {
+	return envOneOf("MNEMOSYNE_VEC_TYPE", ["float32", "int8", "bit"] as const, "int8", env);
+}
+
+export function vectorWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_VEC_WEIGHT", 0.5, env);
+}
+
+export function ftsWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_FTS_WEIGHT", 0.3, env);
+}
+
+export function importanceWeight(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_IMPORTANCE_WEIGHT", 0.2, env);
+}
+
+export function normalizedRecallWeights(
+	vec = vectorWeight(),
+	fts = ftsWeight(),
+	importance = importanceWeight(),
+): readonly [number, number, number] {
+	const vw = Math.max(0, vec);
+	const fw = Math.max(0, fts);
+	const iw = Math.max(0, importance);
+	const total = vw + fw + iw;
+	if (total === 0) {
+		return [0.5, 0.3, 0.2];
+	}
+	const epsilon = 1e-10;
+	if (Math.abs(total - 1) < epsilon) {
+		return [vw, fw, iw];
+	}
+	return [vw / total, fw / total, iw / total];
+}
+
+export function autoMigrateEnabled(env: Env = process.env): boolean {
+	return envString("MNEMOSYNE_AUTO_MIGRATE", "1", env) !== "0";
+}
+
+export function proactiveLinkingEnabled(env: Env = process.env): boolean {
+	return envString("MNEMOSYNE_PROACTIVE_LINKING", "0", env) === "1";
+}
+
+export function polyphonicRecallEnabled(env: Env = process.env): boolean {
+	return envString("MNEMOSYNE_POLYPHONIC_RECALL", "0", env) === "1";
+}
+
+export function temporalHalflifeHours(env: Env = process.env): number {
+	return envFloat("MNEMOSYNE_TEMPORAL_HALFLIFE_HOURS", 24, env);
+}
+
+export function enhancedRecallEnabled(env: Env = process.env): boolean {
+	return envString("MNEMOSYNE_ENHANCED_RECALL", "0", env) === "1";
+}
+
+export function llmEnabled(env: Env = process.env): boolean {
+	return envBool("MNEMOSYNE_LLM_ENABLED", true, env);
+}
+
+export function llmMaxTokens(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_LLM_MAX_TOKENS", 2048, env);
+}
+
+export function llmThreads(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_LLM_N_THREADS", 4, env);
+}
+
+export function llmContext(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_LLM_N_CTX", 2048, env);
+}
+
+export function llmRepo(env: Env = process.env): string {
+	return envString("MNEMOSYNE_LLM_REPO", DEFAULT_LLM_MODEL_REPO, env);
+}
+
+export function llmFile(env: Env = process.env): string {
+	return envString("MNEMOSYNE_LLM_FILE", DEFAULT_LLM_MODEL_FILE, env);
+}
+
+export function llmModelFiles(env: Env = process.env): readonly [repo: string, file: string] {
+	const repo = envOptionalString("MNEMOSYNE_LLM_REPO", env);
+	const file = envOptionalString("MNEMOSYNE_LLM_FILE", env);
+	return repo && file ? [repo, file] : [DEFAULT_LLM_MODEL_REPO, DEFAULT_LLM_MODEL_FILE];
+}
+
+export function llmBaseUrl(env: Env = process.env): string {
+	return envString("MNEMOSYNE_LLM_BASE_URL", "", env).replace(/\/+$/, "");
+}
+
+export function llmApiKey(env: Env = process.env): string {
+	return envString("MNEMOSYNE_LLM_API_KEY", "", env);
+}
+
+export function llmModel(env: Env = process.env): string {
+	return envString("MNEMOSYNE_LLM_MODEL", "", env);
+}
+
+export function hostLlmEnabled(env: Env = process.env): boolean {
+	return envBool("MNEMOSYNE_HOST_LLM_ENABLED", false, env);
+}
+
+export function hostLlmProvider(env: Env = process.env): string | undefined {
+	return envOptionalString("MNEMOSYNE_HOST_LLM_PROVIDER", env);
+}
+
+export function hostLlmModel(env: Env = process.env): string | undefined {
+	return envOptionalString("MNEMOSYNE_HOST_LLM_MODEL", env);
+}
+
+export function hostLlmContext(env: Env = process.env): number {
+	return envInt("MNEMOSYNE_HOST_LLM_N_CTX", 32000, env);
+}
+
+export function sleepPrompt(env: Env = process.env): string {
+	return envString("MNEMOSYNE_SLEEP_PROMPT", "", env).trim();
+}

package/src/core/aaak.ts

@@ -0,0 +1,142 @@
+export const CATEGORY_MAP = {
+	PREFERENCE: "PREF",
+	TRAIT: "TRAIT",
+	STATUS: "STAT",
+	INSTRUCTION: "INST",
+	PROJECT: "PROJ",
+	LOCATION: "LOC",
+	FAMILY: "FAM",
+	OCCUPATION: "OCC",
+	DECISION: "DEC",
+	EVENT: "EVT",
+	TOOL: "TOOL",
+	FACT: "FACT",
+	OPINION: "OPN",
+} as const;
+
+export const PHRASE_MAP = {
+	"User asked ": "ASK ",
+	"User wants ": "WANT ",
+	"User prefers ": "PREF ",
+	"User likes ": "LIKE ",
+	"User dislikes ": "DISLIKE ",
+	"User is ": "IS ",
+	"User has ": "HAS ",
+	"User built ": "BUILT ",
+	"User asked for ": "ASK ",
+	"User requested ": "REQ ",
+	"Married to ": "MARRIED→",
+	"Email: ": "@",
+	"GitHub: ": "GH:",
+	"Location: ": "LOC:",
+	"Phone: ": "PH:",
+	"User email is ": "@",
+	"User voice message ": "VM ",
+	"User stack: ": "STACK|",
+	"Full-stack developer": "FSDEV",
+	"Software Developer": "SDEV",
+	"AI Systems Engineer": "AIENG",
+	"real-time": "RT",
+	"Real-time": "RT",
+	bilingual: "bi",
+	Bilingual: "bi",
+	"self-hosted": "selfhost",
+	automation: "auto",
+	transcription: "transc",
+	translation: "transl",
+} as const;
+
+export const STRUCTURAL_REPLACEMENTS: readonly (readonly [pattern: string, replacement: string])[] = [
+	[" - ", " | "],
+	[" -- ", " | "],
+	[" | ", " | "],
+	[", ", " | "],
+	[" and ", "+"],
+	[" or ", "/"],
+	[" for ", "→"],
+	[" to ", "→"],
+	[" with ", " w/ "],
+	[" over ", ">"],
+	[" instead of ", "!>"],
+	[" because of ", "∵"],
+	[" due to ", "∵"],
+	[" using ", "→"],
+	[" built ", "→"],
+	[" in ", ":"],
+	[" at ", "@"],
+	[" on ", "@"],
+	[" from ", "<-"],
+];
+
+function reverseMap<const T extends Readonly<Record<string, string>>>(source: T): Record<T[keyof T], keyof T & string> {
+	const reversed = Object.create(null) as Record<T[keyof T], keyof T & string>;
+	for (const rawKey in source) {
+		const key = rawKey as keyof T & string;
+		const value = source[key];
+		reversed[value] = key;
+	}
+	return reversed;
+}
+
+export const REV_CATEGORY = reverseMap(CATEGORY_MAP);
+
+const SORTED_PHRASES = Object.entries(PHRASE_MAP).sort(([left], [right]) => right.length - left.length);
+export const REV_PHRASE = reverseMap(PHRASE_MAP);
+
+function replaceAllLiteral(text: string, pattern: string, replacement: string): string {
+	return text.replaceAll(pattern, replacement);
+}
+
+export function applyCategoryPrefixes(text: string): string {
+	for (const rawFull in CATEGORY_MAP) {
+		const full = rawFull as keyof typeof CATEGORY_MAP;
+		const prefix = `${full}: `;
+		if (text.startsWith(prefix)) {
+			return text.replace(prefix, `${CATEGORY_MAP[full]}|`);
+		}
+	}
+	return text;
+}
+
+export function applyPhrases(text: string): string {
+	let result = text;
+	for (const [phrase, shorthand] of SORTED_PHRASES) {
+		result = replaceAllLiteral(result, phrase, shorthand);
+	}
+	return result;
+}
+
+export function applyStructural(text: string): string {
+	let result = text;
+	for (const [pattern, replacement] of STRUCTURAL_REPLACEMENTS) {
+		result = replaceAllLiteral(result, pattern, replacement);
+	}
+	return result;
+}
+
+export function compactParens(text: string): string {
+	return text.replace(/\(\s*/g, "(").replaceAll(" )", ")");
+}
+
+export function encode(text: string): string {
+	if (text.length === 0) {
+		return text;
+	}
+
+	if (text.includes("|") && text.trim().split(/\s+/).length <= 3) {
+		return text;
+	}
+
+	let result = text.trim();
+	result = applyCategoryPrefixes(result);
+	result = applyPhrases(result);
+	result = applyStructural(result);
+	result = compactParens(result);
+	result = result.replaceAll("working correctly", "OK");
+	result = result.replaceAll("working", "OK");
+	result = result.replaceAll("complete", "DONE");
+	result = result.replaceAll("completed", "DONE");
+	return result.trim();
+}
+
+export const aaakEncode = encode;