@resolveio/server-lib 22.3.221 → 22.3.223

package/src/ai/resolveio-platform-intelligence-memory.ts

@@ -1,325 +0,0 @@
-import {
-	buildResolveIOPlatformIntelligenceSystemPrompt,
-	getResolveIOPlatformDurableMemoryEntries,
-	getResolveIOPlatformIntelligenceRuleLines,
-	getResolveIOPlatformIntelligenceRuleSections
-} from './resolveio-platform-intelligence';
-import { getResolveIOPlatformSharedMemoryCorpus } from './resolveio-platform-intelligence-memory-corpus';
-import type {
-	ResolveIOPlatformDurableMemoryEntry,
-	ResolveIOPlatformIntelligenceMode,
-	ResolveIOPlatformIntelligenceRuleOptions,
-	ResolveIOPlatformIntelligenceRuleSection,
-	ResolveIOPlatformSharedMemoryEntry
-} from './resolveio-platform-intelligence-types';
-
-export type ResolveIOPlatformIntelligenceMemoryRuntimeOptions = {
-	limit?: number;
-	memoryFamilies?: string[];
-	contextText?: string[];
-	includeSharedCorpus?: boolean;
-};
-
-const DEFAULT_RUNTIME_MEMORY_LIMIT = 12;
-
-function normalizeString(value: any): string {
-	return String(value || '').trim();
-}
-
-function normalizeFamily(value: any): string {
-	return normalizeString(value)
-		.toLowerCase()
-		.replace(/[^a-z0-9_-]+/g, '-')
-		.replace(/-+/g, '-')
-		.replace(/^-|-$/g, '');
-}
-
-function normalizeTag(value: any): string {
-	return normalizeFamily(value);
-}
-
-function uniqueStrings(values: any[]): string[] {
-	const unique: string[] = [];
-	const seen = new Set<string>();
-	for (const value of values || []) {
-		const normalized = normalizeString(value);
-		if (!normalized || seen.has(normalized)) {
-			continue;
-		}
-		seen.add(normalized);
-		unique.push(normalized);
-	}
-	return unique;
-}
-
-function normalizeMode(value: any): ResolveIOPlatformIntelligenceMode | '' {
-	const normalized = normalizeString(value) as ResolveIOPlatformIntelligenceMode;
-	return ['assistant', 'support', 'builder', 'app_terminal'].includes(normalized) ? normalized : '';
-}
-
-function normalizeMemoryEntry(entry: ResolveIOPlatformDurableMemoryEntry | null | undefined): ResolveIOPlatformDurableMemoryEntry | null {
-	if (!entry) {
-		return null;
-	}
-	const family = normalizeFamily(entry.family);
-	const summary = normalizeString(entry.summary);
-	const kind = normalizeString(entry.kind) as ResolveIOPlatformDurableMemoryEntry['kind'];
-	if (!family || !summary || !['accepted_pattern', 'rejected_fix_shape', 'contract_violation'].includes(kind)) {
-		return null;
-	}
-	const modes = Array.isArray(entry.modes)
-		? entry.modes.map((mode) => normalizeMode(mode)).filter(Boolean) as ResolveIOPlatformIntelligenceMode[]
-		: [];
-	const tags = Array.isArray(entry.tags)
-		? entry.tags.map((tag) => normalizeTag(tag)).filter(Boolean)
-		: [];
-	return {
-		family,
-		kind,
-		summary,
-		modes,
-		tags
-	};
-}
-
-function normalizeSharedMemoryEntry(entry: ResolveIOPlatformSharedMemoryEntry): ResolveIOPlatformSharedMemoryEntry | null {
-	const durableEntry = normalizeMemoryEntry(entry);
-	if (!durableEntry) {
-		return null;
-	}
-	return {
-		...durableEntry,
-		matchTerms: Array.isArray(entry.matchTerms)
-			? uniqueStrings(entry.matchTerms.map((term) => normalizeString(term)).filter(Boolean))
-			: [],
-		priority: Number(entry.priority || 0)
-	};
-}
-
-function normalizeTextBlobs(values: string[]): string[] {
-	return uniqueStrings(
-		(values || [])
-			.map((value) => normalizeString(value).toLowerCase())
-			.filter(Boolean)
-	);
-}
-
-function buildProbeTerms(entry: ResolveIOPlatformSharedMemoryEntry): string[] {
-	return uniqueStrings([
-		entry.family,
-		entry.family.replace(/-/g, ' '),
-		...((entry.tags || []).map((tag) => normalizeTag(tag))),
-		...((entry.tags || []).map((tag) => normalizeTag(tag).replace(/-/g, ' '))),
-		...(Array.isArray(entry.matchTerms) ? entry.matchTerms.map((term) => normalizeString(term).toLowerCase()) : [])
-	]).filter(Boolean);
-}
-
-function scoreSharedMemoryEntry(
-	entry: ResolveIOPlatformSharedMemoryEntry,
-	mode: ResolveIOPlatformIntelligenceMode,
-	familySet: Set<string>,
-	contextBlobs: string[]
-): number {
-	const modes = Array.isArray(entry.modes) ? entry.modes : [];
-	if (modes.length && !modes.includes(mode)) {
-		return -1;
-	}
-	let score = Number(entry.priority || 0);
-	if (familySet.size) {
-		if (familySet.has(entry.family)) {
-			score += 200;
-		}
-		if ((entry.tags || []).some((tag) => familySet.has(normalizeTag(tag)))) {
-			score += 80;
-		}
-	}
-	if (contextBlobs.length) {
-		const probes = buildProbeTerms(entry);
-		for (const blob of contextBlobs) {
-			for (const probe of probes) {
-				if (!probe) {
-					continue;
-				}
-				if (blob.includes(probe)) {
-					score += probe.includes(' ') || probe.includes('[') || probe.includes('<') ? 18 : 9;
-				}
-			}
-		}
-	}
-	return score;
-}
-
-function sortEntries(
-	entries: ResolveIOPlatformSharedMemoryEntry[],
-	mode: ResolveIOPlatformIntelligenceMode,
-	families: string[],
-	contextBlobs: string[],
-	limit: number
-): ResolveIOPlatformDurableMemoryEntry[] {
-	const familySet = new Set(families.map((family) => normalizeFamily(family)).filter(Boolean));
-	const ranked = entries
-		.map((entry) => {
-			const normalized = normalizeSharedMemoryEntry(entry);
-			if (!normalized) {
-				return null;
-			}
-			return {
-				entry: normalized,
-				score: scoreSharedMemoryEntry(normalized, mode, familySet, contextBlobs)
-			};
-		})
-		.filter(Boolean)
-		.filter((candidate) => Number(candidate?.score) >= 0)
-		.sort((left, right) => Number(right?.score || 0) - Number(left?.score || 0));
-	const unique: ResolveIOPlatformDurableMemoryEntry[] = [];
-	const seen = new Set<string>();
-	for (const candidate of ranked) {
-		const normalizedEntry = normalizeMemoryEntry(candidate?.entry);
-		if (!normalizedEntry) {
-			continue;
-		}
-		const key = buildResolveIOPlatformIntelligenceMemorySignature(
-			normalizedEntry.family,
-			normalizedEntry.kind,
-			normalizedEntry.summary
-		);
-		if (seen.has(key)) {
-			continue;
-		}
-		if (familySet.size) {
-			const matchesFamily = familySet.has(normalizedEntry.family)
-				|| (normalizedEntry.tags || []).some((tag) => familySet.has(normalizeTag(tag)));
-			if (!matchesFamily && !contextBlobs.length) {
-				continue;
-			}
-		}
-		seen.add(key);
-		unique.push(normalizedEntry);
-		if (unique.length >= limit) {
-			break;
-		}
-	}
-	return unique;
-}
-
-export function buildResolveIOPlatformIntelligenceMemorySignature(
-	family: string,
-	kind: ResolveIOPlatformDurableMemoryEntry['kind'],
-	summary: string
-): string {
-	return `${normalizeFamily(family)}::${normalizeString(kind).toLowerCase()}::${normalizeString(summary).toLowerCase()}`;
-}
-
-export function inferResolveIOPlatformIntelligenceMemoryFamilies(
-	mode: ResolveIOPlatformIntelligenceMode,
-	contextText: string[] = []
-): string[] {
-	const contextBlobs = normalizeTextBlobs(contextText);
-	if (!contextBlobs.length) {
-		return [];
-	}
-	const corpus = getResolveIOPlatformSharedMemoryCorpus();
-	const familyScores = new Map<string, number>();
-	for (const entry of corpus) {
-		const normalizedEntry = normalizeSharedMemoryEntry(entry);
-		if (!normalizedEntry) {
-			continue;
-		}
-		const score = scoreSharedMemoryEntry(normalizedEntry, mode, new Set<string>(), contextBlobs);
-		if (score <= Number(normalizedEntry.priority || 0)) {
-			continue;
-		}
-		const current = familyScores.get(normalizedEntry.family) || 0;
-		familyScores.set(normalizedEntry.family, current + score);
-	}
-	return Array.from(familyScores.entries())
-		.sort((left, right) => right[1] - left[1])
-		.map(([family]) => family);
-}
-
-export function listResolveIOPlatformIntelligenceMemoryEntries(
-	options: ResolveIOPlatformIntelligenceMemoryRuntimeOptions & { mode: ResolveIOPlatformIntelligenceMode }
-): ResolveIOPlatformDurableMemoryEntry[] {
-	if (options.includeSharedCorpus === false) {
-		return [];
-	}
-	const mode = options.mode;
-	const contextBlobs = normalizeTextBlobs(Array.isArray(options.contextText) ? options.contextText : []);
-	const explicitFamilies = uniqueStrings(Array.isArray(options.memoryFamilies) ? options.memoryFamilies : [])
-		.map((family) => normalizeFamily(family))
-		.filter(Boolean);
-	const inferredFamilies = explicitFamilies.length
-		? []
-		: inferResolveIOPlatformIntelligenceMemoryFamilies(mode, Array.isArray(options.contextText) ? options.contextText : []);
-	const families = uniqueStrings([...explicitFamilies, ...inferredFamilies])
-		.map((family) => normalizeFamily(family))
-		.filter(Boolean);
-	const limit = Math.max(1, Number(options.limit || DEFAULT_RUNTIME_MEMORY_LIMIT));
-	return sortEntries(getResolveIOPlatformSharedMemoryCorpus(), mode, families, contextBlobs, limit);
-}
-
-export function hydrateResolveIOPlatformIntelligenceRuleOptions(
-	options: ResolveIOPlatformIntelligenceRuleOptions,
-	runtimeOptions: ResolveIOPlatformIntelligenceMemoryRuntimeOptions = {}
-): ResolveIOPlatformIntelligenceRuleOptions {
-	if (options.includeDefaultDurableMemory === false && !(options.durableMemoryEntries || []).length) {
-		return {
-			...options,
-			durableMemoryEntries: []
-		};
-	}
-	const sharedEntries = options.includeDefaultDurableMemory === false
-		? []
-		: listResolveIOPlatformIntelligenceMemoryEntries({
-			mode: options.mode,
-			...runtimeOptions
-		});
-	return {
-		...options,
-		includeDefaultDurableMemory: false,
-		durableMemoryEntries: [
-			...sharedEntries,
-			...(Array.isArray(options.durableMemoryEntries) ? options.durableMemoryEntries : [])
-		]
-	};
-}
-
-export function getResolveIOPlatformIntelligenceRuleLinesWithSharedMemory(
-	options: ResolveIOPlatformIntelligenceRuleOptions,
-	runtimeOptions: ResolveIOPlatformIntelligenceMemoryRuntimeOptions = {}
-): string[] {
-	return getResolveIOPlatformIntelligenceRuleLines(
-		hydrateResolveIOPlatformIntelligenceRuleOptions(options, runtimeOptions)
-	);
-}
-
-export function getResolveIOPlatformIntelligenceRuleSectionsWithSharedMemory(
-	options: ResolveIOPlatformIntelligenceRuleOptions,
-	runtimeOptions: ResolveIOPlatformIntelligenceMemoryRuntimeOptions = {}
-): ResolveIOPlatformIntelligenceRuleSection[] {
-	return getResolveIOPlatformIntelligenceRuleSections(
-		hydrateResolveIOPlatformIntelligenceRuleOptions(options, runtimeOptions)
-	);
-}
-
-export function buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory(
-	options: ResolveIOPlatformIntelligenceRuleOptions,
-	runtimeOptions: ResolveIOPlatformIntelligenceMemoryRuntimeOptions = {}
-): string {
-	return buildResolveIOPlatformIntelligenceSystemPrompt(
-		hydrateResolveIOPlatformIntelligenceRuleOptions(options, runtimeOptions)
-	);
-}
-
-export const getResolveIOPlatformIntelligenceRuleLinesWithPersistedMemory = getResolveIOPlatformIntelligenceRuleLinesWithSharedMemory;
-export const getResolveIOPlatformIntelligenceRuleSectionsWithPersistedMemory = getResolveIOPlatformIntelligenceRuleSectionsWithSharedMemory;
-export const buildResolveIOPlatformIntelligenceSystemPromptWithPersistedMemory = buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory;
-
-export function getResolveIOPlatformIntelligenceDefaultMemoryEntries(
-	mode: ResolveIOPlatformIntelligenceMode
-): ResolveIOPlatformDurableMemoryEntry[] {
-	return getResolveIOPlatformDurableMemoryEntries({
-		mode,
-		includeDefaultDurableMemory: true
-	});
-}