@resolveio/server-lib 22.3.220 → 22.3.221

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

@@ -0,0 +1,325 @@
+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
+	});
+}

package/{ai/resolveio-platform-intelligence-types.d.ts → src/ai/resolveio-platform-intelligence-types.ts}

@@ -1,26 +1,31 @@
 export type ResolveIOPlatformIntelligenceMode = 'assistant' | 'support' | 'builder' | 'app_terminal';
 export type ResolveIOPlatformIntelligenceOutputStyle = 'default' | 'markdown' | 'plain_english' | 'json';
+
 export type ResolveIOPlatformDurableMemoryKind = 'accepted_pattern' | 'rejected_fix_shape' | 'contract_violation';
+
 export type ResolveIOPlatformDurableMemoryEntry = {
-    family: string;
-    kind: ResolveIOPlatformDurableMemoryKind;
-    summary: string;
-    modes?: ResolveIOPlatformIntelligenceMode[];
-    tags?: string[];
+	family: string;
+	kind: ResolveIOPlatformDurableMemoryKind;
+	summary: string;
+	modes?: ResolveIOPlatformIntelligenceMode[];
+	tags?: string[];
 };
+
 export type ResolveIOPlatformSharedMemoryEntry = ResolveIOPlatformDurableMemoryEntry & {
-    matchTerms?: string[];
-    priority?: number;
+	matchTerms?: string[];
+	priority?: number;
 };
+
 export type ResolveIOPlatformIntelligenceRuleOptions = {
-    mode: ResolveIOPlatformIntelligenceMode;
-    outputStyle?: ResolveIOPlatformIntelligenceOutputStyle;
-    extraRules?: string[];
-    includeDefaultDurableMemory?: boolean;
-    durableMemoryEntries?: ResolveIOPlatformDurableMemoryEntry[];
-    memoryFamilies?: string[];
+	mode: ResolveIOPlatformIntelligenceMode;
+	outputStyle?: ResolveIOPlatformIntelligenceOutputStyle;
+	extraRules?: string[];
+	includeDefaultDurableMemory?: boolean;
+	durableMemoryEntries?: ResolveIOPlatformDurableMemoryEntry[];
+	memoryFamilies?: string[];
 };
+
 export type ResolveIOPlatformIntelligenceRuleSection = {
-    title: string;
-    rules: readonly string[];
+	title: string;
+	rules: readonly string[];
 };