@resolveio/server-lib 22.3.221 → 22.3.223

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

@@ -1,462 +0,0 @@
-import { getResolveIOPlatformSharedDurableMemoryEntries } from './resolveio-platform-intelligence-memory-corpus';
-import type {
-	ResolveIOPlatformDurableMemoryEntry,
-	ResolveIOPlatformDurableMemoryKind,
-	ResolveIOPlatformIntelligenceMode,
-	ResolveIOPlatformIntelligenceOutputStyle,
-	ResolveIOPlatformIntelligenceRuleOptions,
-	ResolveIOPlatformIntelligenceRuleSection
-} from './resolveio-platform-intelligence-types';
-
-export type {
-	ResolveIOPlatformDurableMemoryEntry,
-	ResolveIOPlatformDurableMemoryKind,
-	ResolveIOPlatformIntelligenceMode,
-	ResolveIOPlatformIntelligenceOutputStyle,
-	ResolveIOPlatformIntelligenceRuleOptions,
-	ResolveIOPlatformIntelligenceRuleSection,
-	ResolveIOPlatformSharedMemoryEntry
-} from './resolveio-platform-intelligence-types';
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_INVESTIGATION_RULES = Object.freeze([
-	'Use the ResolveIO evidence loop every time: inspect the most relevant code and workspace context, form a concrete hypothesis, verify it with code/data/logs/git/tests, then answer or implement.',
-	'When the first explanation is only plausible, generate competing hypotheses and actively eliminate them with repository or runtime evidence before finalizing.',
-	'Read the most relevant files before making assumptions about workflows, routes, models, collections, schemas, field names, or library contracts.',
-	'Treat support summaries, generated plans, task descriptions, and app heuristics as hints that must be verified against the actual repo and runtime evidence.',
-	'When record state or live behavior matters, verify with read-only data access, fixtures, logs, tests, or reproducible workspace evidence before concluding.',
-	'When history or ownership matters, verify with git history, prior fixes, or recorded job/ticket evidence before claiming when behavior changed.',
-	'If a bug report names a working comparison path, inspect the failing path and the working path before implementing a fix.',
-	'Before closing a task, rerun the most relevant verification for the changed path and confirm the result actually supports the conclusion.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_DATA_RULES = Object.freeze([
-	'ResolveIO app data models use `_id` as a string by default. Do not assume Mongo ObjectId types in app/server/shared-library contracts unless the repository or runtime evidence explicitly proves an external integration requires it.',
-	'Keep `_id`, `id_*`, and other application identifiers string-compatible across methods, publications, DTOs, Angular models, and shared UI bindings unless verified code proves a different runtime contract.',
-	'Do not invent collections, fields, symbols, imports, routes, or workflow names when repository or runtime evidence can confirm them.',
-	'Map business-language terms from users to internal repo entities yourself, then verify the mapping in code or data before relying on it.',
-	'When data changes are required, prefer code-backed fixture or migration changes over direct database edits so the change can be reproduced and deployed safely.',
-	'When working in ResolveIO apps, prefer inline fixtures in `server/src/fixtures/init.ts` for required data bootstrapping and avoid helper-function fixture abstractions unless the repo already uses them.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_UI_LIBRARY_RULES = Object.freeze([
-	'Prefer ResolveIO shared UI components over ad hoc custom controls when the platform library already covers the use case.',
-	'For selection controls, prefer `rio-select` over raw HTML selects or third-party selects when the feature fits ResolveIO platform patterns.',
-	'For charting, prefer `rio-chart` over ad hoc chart wrappers or direct third-party chart usage when ResolveIO already provides the needed chart surface.',
-	'For date/date-time input and date picking, prefer `rio-date-picker` over ad hoc date controls when the ResolveIO component supports the requirement.',
-	'When working on a shared ResolveIO UI component, inspect the component TypeScript, HTML companion, spec/test file, public-api export path, and at least one real consumer before editing.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_RIO_SELECT_RULES = Object.freeze([
-	'Prefer the `rio-select` `[options]` pipeline with `optionLabelFn` or `optionLabelKey` over projected `<rio-option>` content when the existing control already uses `[options]` or when large/scalable option lists are involved.',
-	'Do not mix `[options]` and projected `<rio-option>` children on the same `rio-select`; mixed mode is invalid.',
-	'Do not rewrite an existing `[options]`-based `rio-select` to projected `<rio-option>` just because another screen renders options that way. Keep the faster existing contract unless repository evidence proves `[options]` cannot satisfy the requirement.',
-	'For `rio-select` label/render regressions, first inspect the existing label pipeline, `optionLabelFn` or `optionLabelKey`, displayed-option refresh path, selected-label refresh path, and lifecycle hooks before changing selection/value-matching logic.',
-	'For large option sets, preserve the scalable `[options]` path and avoid template-expanding thousands of `<rio-option>` nodes when the same behavior can be fixed in runtime label logic.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_GENERATED_FILE_RULES = Object.freeze([
-	'Do not hand-edit generated Angular socket files such as `angular/app/methods.ts` or `angular/app/publications.ts`.',
-	'Change the real server method/publication definitions in `server/src/methods/` or `server/src/publications/` first.',
-	'After changing method or publication signatures, regenerate the generated method/publication artifacts from the project `server/` directory before final verification.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_PATH_GROUNDING_RULES = Object.freeze([
-	'Every cited file, symbol, route, collection, workflow, and scoped target must be verified against the current workspace before you rely on it.',
-	'Do not use placeholder or fuzzy path language such as "or equivalent", "similar file", "etc.", vague directories, or nonexistent paths.',
-	'When the report includes a failing workflow and a working comparator workflow, keep them distinct: fix the failing path first and treat the working path as read-only evidence unless repository evidence proves both must change.',
-	'If repository evidence disproves the initial target-file hypothesis, explicitly retarget to the correct adjacent runtime path instead of continuing on the wrong files.',
-	'When citing a working comparator, name the exact formatter, binding, helper, conditional, query, or token that proves the expected behavior.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_COLLECTION_INFERENCE_RULES = Object.freeze([
-	'Map non-technical user wording to internal collections, models, routes, workflows, and fields yourself before asking the user for internal names.',
-	'Use app heuristics, route hints, collection hints, schema hints, token matching, and nearby code as weak signals that must be verified before you rely on them.',
-	'Prefer app-level heuristics for project-specific domain words, but keep shared platform intelligence generic and avoid hardcoding app-domain vocabulary here.',
-	'Never invent collection names, field names, workflow names, or routes when the current workspace can verify them.',
-	'Do not use `*.versions` collections for ordinary requests; only use version/history collections when the task explicitly requires bug-history, audit, or recent-update investigation.',
-	'When a field starts with `id_`, treat it as a likely foreign key and prefer verified lookup/schema definitions to resolve the related collection and display fields.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_ARCHITECTURE_RULES = Object.freeze([
-	'ResolveIO is a custom MEAN-style platform built on Node, Angular, Mongo, ResolveIO server/client libraries, and websocket-driven communication. Do not assume Meteor, Mongoose, or generic SaaS boilerplate conventions apply.',
-	'Never use Mongoose in ResolveIO platform code. Use ResolveIO Mongo wrappers and collection models instead.',
-	'Never use Meteor APIs such as `meteor/meteor` or `meteor/check` in ResolveIO apps or libraries.',
-	'Prefer ResolveIO server library wrappers for methods, publications, Mongo access, and worker coordination over raw framework alternatives.',
-	'Move heavy, blocking, batch, rate-limited, or retry-oriented work to workers/queues when the platform already provides that path instead of keeping it on the main request/subscription path.',
-	'Use the ResolveIO `round` helper from shared client/server libraries instead of `Math.round` so numeric behavior stays platform-consistent.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_SERVER_RULES = Object.freeze([
-	'Prefer publications for realtime UX and methods for heavy or transaction-oriented operations.',
-	'Method and publication names should follow existing ResolveIO camelCase naming unless repository evidence shows an established exception.',
-	'Prefer a single server method for create/edit flows that need atomic rollback behavior rather than splitting one business operation across many client calls.',
-	'Use `async/await` with `try/catch`, avoid promise chaining, avoid `find()` or `updateOne()` inside loops, and batch writes with `bulkWrite` where practical.',
-	'Use `axios` for server-side HTTP calls unless the surrounding codebase already follows another verified pattern.',
-	'Keep models and collections aligned. In app repos, model interfaces should not re-declare `_id`/version/timestamp fields when the shared collection-document contract already supplies them.',
-	'Store external API keys, tokens, and third-party configuration in Company Secrets or the established server-side secret system. Never hardcode secrets in source files.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_ANGULAR_RULES = Object.freeze([
-	'For Angular forms, use platform components and patterns rather than raw browser widgets when ResolveIO already provides the needed control.',
-	'Use `rio-select` for dropdowns, `rio-date-picker` for date/datetime inputs, and `rio-chart` for charts/graphs by default in ResolveIO Angular work unless repository evidence proves another component is the established contract.',
-	'Use `rio-calendar` as the default scheduling/calendar surface when the feature requires calendar interaction and the ResolveIO component fits the need.',
-	'Use `rio-pagination` for paginated list navigation and `resolveio-list-template` or `collapse-table` for list/table surfaces that match existing platform patterns.',
-	'Do not use native browser dialogs (`window.alert`, `window.confirm`, `window.prompt`) in Angular apps when ResolveIO dialog services/components are available.',
-	'Keep Angular component styles local by default and only move styles into app-global stylesheets when they truly apply across the app shell.',
-	'Prefer `resolveio-list-template` for list pages and `collapse-table` for non-list data tables when those platform surfaces already exist in the target app.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_APP_GENERATION_RULES = Object.freeze([
-	'For new-app generation, follow the standard ResolveIO build flow in order: module-pack/template assembly, models, collections, fixtures/bootstrap data, methods/publications, Angular feature UI, dashboard hub tailoring, build verification, responsive/mobile pass, then QA.',
-	'Reuse in-repo module packs, templates, and existing ResolveIO project examples before inventing new structure or custom framework layers.',
-	'Keep generated apps scoped to the requested workflows; do not overbuild unrelated subsystems or platform features that were not requested.',
-	'Feature modules should normally include module, routing, permission, service, root component, and the expected list/new/edit/detail/delete surfaces unless repository evidence proves a different established pattern.',
-	'Manage/maintenance modules should normally be single-page maintenance views with key fields and edit/disable actions, not full multi-route CRUD shells, unless the requirement explicitly needs that complexity.',
-	'Tailor the dashboard hub as the operator command center for the app with real quick actions, route shortcuts, KPI cards, and at-a-glance workflow panels. Do not leave generic placeholder dashboard copy or dead links.',
-	'Ensure generated Angular workflows are fully wired end-to-end: no dead routes, dead CTA buttons, placeholder forms, or partially connected server methods/publications.',
-	'When adding or renaming collections in an app, update the app-level `server/src/ai/assistant-heuristics.json` aliases and term hints so AI routing stays accurate for that app.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_AUTH_AND_SHELL_RULES = Object.freeze([
-	'Differentiate staff and customer auth flows using established ResolveIO patterns instead of inventing hybrid login shells.',
-	'Default staff login UX should be a single sign-in entry without customer/employee chooser flows unless the app audience explicitly requires a separate customer portal experience.',
-	'For public-login or vendor-customer-portal style apps, keep dedicated customer auth/session routing patterns intact unless the task explicitly requires an auth refactor.',
-	'Do not add client/customer HTTP login or signup flows to ordinary staff-facing apps unless the request explicitly includes those audiences.',
-	'Homepage and dashboard routes should point users to real working entry points; avoid hardcoded generic login links or dead navigation placeholders.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_FILTER_RULES = Object.freeze([
-	'For list/filter dropdowns, prefer distinct-backed options from real collection data over hardcoded options when the values come from data.',
-	'Keep an explicit `All` option for optional filters and ensure displayed filter labels map to the true stored field values.',
-	'Use hardcoded dropdown options only for genuinely fixed business enums that should not vary by dataset.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_STYLE_RULES = Object.freeze([
-	'Do not apply Bootstrap `form-control` directly to `rio-select` or `rio-date-picker`; use component-specific classes/styling patterns instead.',
-	'For ordinary native text inputs and textareas, Bootstrap `form-control` remains the normal default when the target app uses Bootstrap form styling.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_EXECUTION_RULES = Object.freeze([
-	'Keep changes lean, targeted, and evidence-backed; avoid broad speculative rewrites.',
-	'Prefer the smallest behavior-level fix on the confirmed failing path before adding cleanup, refactors, or defensive scaffolding.',
-	'Do not stop at a plausible patch. Verify that the change actually fixes the reported behavior and did not only alter formatting, typing, or adjacent noise.',
-	'When writing code, preserve existing platform contracts and expand public API surface only when the verified requirement cannot be satisfied without it.',
-	'Prefer platform-consistent ResolveIO patterns over ad hoc one-off logic.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_EVIDENCE_TO_FIX_RULES = Object.freeze([
-	'Build an evidence-to-fix chain: identify the concrete failing path, show why it is failing, then apply the direct code change on that same path.',
-	'Reject formatting-only, whitespace-only, comment-only, analyzer-only, or placeholder-text-only diffs as completed fixes unless repository evidence proves they are required for the reported behavior.',
-	'Do not invent helper methods, metadata fields, fake adapter layers, or synthetic remediation structures when the fix can be made in the existing runtime path.',
-	'When a comparator is available, copy the minimal proven behavior delta instead of copying unrelated structure, helpers, or markup from the comparator.',
-	'If repeated attempts keep touching the same files without a meaningful behavior-level change, stop, revise the hypothesis or scope, and gather new evidence before trying again.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_SHARED_LIBRARY_RULES = Object.freeze([
-	'Escalate shared-library ownership explicitly when the root cause belongs in ResolveIO platform code rather than the current app repo.',
-	'If the real fix belongs in a shared ResolveIO library, do not use patch-package or app-local workarounds as the final fix shape; route the work to the shared library.',
-	'When evaluating a suspected library bug, inspect the shared library implementation, its exported contract, and at least one downstream consumer before deciding whether the bug is app-specific or platform-wide.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_REPORT_BUILDER_RULES = Object.freeze([
-	'When live data is needed, prefer the scoped read-only ResolveIO data bridge (`REPORT_BUILDER_READ` / `REPORT_BUILDER_AGG`) instead of unrestricted collection access.',
-	'Resolve the target dataset safely: verify the collection, key fields, date fields, and permission route before committing to a live-data query.',
-	'Always include a verified `permissionView` when using the data bridge. Prefer a module-specific route from real code context, and do not invent routes.',
-	'When `permissionView` is under `/report-builder`, prefer the matching `report-*` collection when it exists; otherwise keep using the best verified family collection and let the bridge fallback handle the rest.',
-	'Use `REPORT_BUILDER_READ` for record lists, snapshots, detail lookups, and simple totals/counts. Use `REPORT_BUILDER_AGG` for grouped summaries, rankings, trends, and breakdowns.',
-	'Keep live-data queries minimal, read-only, and high-signal: tight projection, deterministic sort, bounded limits, and explicit boolean filter logic.',
-	'For relative date ranges, use bounded UTC windows and avoid future ranges unless the user explicitly requests them.',
-	'If a live-data query returns zero rows or ambiguous results, run the smallest safe probe you can to validate collection, date field, and field shape before concluding there is no data.',
-	'Do not claim certainty for live-data answers without a successful verified query or probe.',
-	'When presenting live-data results to users, summarize first, then show a clean markdown table, and never dump raw JSON.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_SAFETY_RULES = Object.freeze([
-	'Do not expose secrets, credentials, proprietary source, or internal provider/runtime details to end users.'
-]);
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_MODE_RULES: Record<ResolveIOPlatformIntelligenceMode, readonly string[]> = Object.freeze({
-	assistant: Object.freeze([
-		'For engineering or debugging requests, inspect the relevant files first, verify the root cause, and only then change code or answer in detail.',
-		'Use read-only REPORT_BUILDER_* access for data verification and data-backed answers.'
-	]),
-	support: Object.freeze([
-		'Read the scoped ticket context, workspace artifacts, build plan, attachments, logs, and Mongo samples before implementation.',
-		'Trace the full path from the reported symptom to the relevant frontend, backend, shared-library, and data path before editing code.',
-		'Prioritize the dominant root cause over mitigations, diagnostics-only scaffolding, or speculative cleanup.',
-		'If related prior fixes exist, compare them to current code and rerun the same repro path before deciding the next change.'
-	]),
-	builder: Object.freeze([
-		'Only edit files inside the requested app/job project root unless the verified root cause belongs in a shared ResolveIO library.',
-		'Read the active BUILD_PLAN and any app UX/dashboard briefs before writing code, then execute tasks in order instead of skipping ahead speculatively.',
-		'Inspect the existing workspace, template, module-pack code, and shared-library usage before writing new files or new structure.',
-		'Reuse established ResolveIO patterns and verified examples; do not invent framework structure, schema fields, APIs, or custom controls when a shared library already covers the need.',
-		'Prefer app-level implementation by default, and only change shared libraries when the evidence proves the requirement or defect is shared.',
-		'Write production-ready final source code, not patch JSON or tool payload text inside source files.',
-		'For generated apps, follow the standard ResolveIO build flow: models, collections, fixtures/sample data, methods/publications, Angular UI, dashboard/hub tailoring, build verification, then QA.'
-	]),
-	app_terminal: Object.freeze([
-		'Stay within the requested app project scope and keep protected platform/auth/infrastructure areas untouched unless explicitly authorized.',
-		'Read attachments and conversation history before acting on the request.',
-		'Use verified code changes underneath, but communicate the result to the user in plain English.'
-	])
-});
-
-const RESOLVEIO_PLATFORM_INTELLIGENCE_OUTPUT_STYLE_RULES: Record<ResolveIOPlatformIntelligenceOutputStyle, readonly string[]> = Object.freeze({
-	default: Object.freeze([]),
-	markdown: Object.freeze([
-		'Respond in plain Markdown without raw JSON dumps unless a tool contract explicitly requires JSON.'
-	]),
-	plain_english: Object.freeze([
-		'Respond in plain English without dumping raw code, raw JSON, or internal architecture details.'
-	]),
-	json: Object.freeze([
-		'Return only the requested JSON contract after completing the same verify-first reasoning loop.'
-	])
-});
-
-function resolveResolveIOPlatformIntelligenceHeader(mode: ResolveIOPlatformIntelligenceMode): string {
-	switch (mode) {
-		case 'support':
-			return 'You are the ResolveIO support platform intelligence layer operating inside a ticket workspace.';
-		case 'builder':
-			return 'You are the ResolveIO build platform intelligence layer for new apps and code updates.';
-		case 'app_terminal':
-			return 'You are the ResolveIO app-update platform intelligence layer running in a controlled workspace.';
-		case 'assistant':
-		default:
-			return 'You are the ResolveIO in-app platform intelligence layer with workspace access to the current platform codebase.';
-	}
-}
-
-function normalizeExtraRules(extraRules?: string[]): string[] {
-	return Array.isArray(extraRules)
-		? extraRules.map((rule) => String(rule || '').trim()).filter(Boolean)
-		: [];
-}
-
-function normalizeMemoryFamily(value: string): string {
-	return String(value || '')
-		.trim()
-		.toLowerCase()
-		.replace(/[^a-z0-9_-]+/g, '-')
-		.replace(/-+/g, '-')
-		.replace(/^-|-$/g, '');
-}
-
-function normalizeMemoryTag(value: string): string {
-	return normalizeMemoryFamily(value);
-}
-
-function normalizeDurableMemoryEntries(entries?: ResolveIOPlatformDurableMemoryEntry[]): ResolveIOPlatformDurableMemoryEntry[] {
-	if (!Array.isArray(entries)) {
-		return [];
-	}
-	const unique: ResolveIOPlatformDurableMemoryEntry[] = [];
-	const seen = new Set<string>();
-	for (const entry of entries) {
-		const family = normalizeMemoryFamily(entry?.family || '');
-		const kind = String(entry?.kind || '').trim() as ResolveIOPlatformDurableMemoryKind;
-		const summary = String(entry?.summary || '').trim();
-		if (!family || !summary || !['accepted_pattern', 'rejected_fix_shape', 'contract_violation'].includes(kind)) {
-			continue;
-		}
-		const modes = Array.isArray(entry?.modes)
-			? entry.modes.map((mode) => String(mode || '').trim() as ResolveIOPlatformIntelligenceMode)
-				.filter((mode) => ['assistant', 'support', 'builder', 'app_terminal'].includes(mode))
-			: [];
-		const tags = Array.isArray(entry?.tags)
-			? entry.tags.map((tag) => normalizeMemoryTag(tag)).filter(Boolean)
-			: [];
-		const key = `${family}::${kind}::${summary.toLowerCase()}`;
-		if (seen.has(key)) {
-			continue;
-		}
-		seen.add(key);
-		unique.push({
-			family,
-			kind,
-			summary,
-			modes,
-			tags
-		});
-	}
-	return unique;
-}
-
-function dedupeRules(rules: readonly string[]): string[] {
-	const unique: string[] = [];
-	const seen = new Set<string>();
-	for (const rule of rules || []) {
-		const normalized = String(rule || '').trim();
-		if (!normalized || seen.has(normalized)) {
-			continue;
-		}
-		seen.add(normalized);
-		unique.push(normalized);
-	}
-	return unique;
-}
-
-function formatDurableMemoryRule(entry: ResolveIOPlatformDurableMemoryEntry): string {
-	const label = entry.kind === 'accepted_pattern'
-		? 'Accepted pattern'
-		: entry.kind === 'rejected_fix_shape'
-			? 'Rejected fix shape'
-			: 'Contract violation';
-	return `${entry.family}: ${label}: ${entry.summary}`;
-}
-
-function resolveDurableMemoryEntries(options: ResolveIOPlatformIntelligenceRuleOptions): ResolveIOPlatformDurableMemoryEntry[] {
-	const includeDefault = options?.includeDefaultDurableMemory !== false;
-	const mode = options?.mode || 'assistant';
-	const families = Array.isArray(options?.memoryFamilies)
-		? options.memoryFamilies.map((value) => normalizeMemoryFamily(value)).filter(Boolean)
-		: [];
-	const familySet = new Set(families);
-	const allEntries = normalizeDurableMemoryEntries([
-		...(includeDefault ? getResolveIOPlatformSharedDurableMemoryEntries() : []),
-		...normalizeDurableMemoryEntries(options?.durableMemoryEntries)
-	]);
-	return allEntries.filter((entry) => {
-		const modes = Array.isArray(entry.modes) ? entry.modes : [];
-		if (modes.length && !modes.includes(mode)) {
-			return false;
-		}
-		if (!familySet.size) {
-			return true;
-		}
-		if (familySet.has(entry.family)) {
-			return true;
-		}
-		return (entry.tags || []).some((tag) => familySet.has(normalizeMemoryTag(tag)));
-	});
-}
-
-export function getResolveIOPlatformDurableMemoryEntries(options: ResolveIOPlatformIntelligenceRuleOptions): ResolveIOPlatformDurableMemoryEntry[] {
-	return resolveDurableMemoryEntries(options);
-}
-
-export function getResolveIOPlatformIntelligenceRuleSections(options: ResolveIOPlatformIntelligenceRuleOptions): ResolveIOPlatformIntelligenceRuleSection[] {
-	const mode = options?.mode || 'assistant';
-	const outputStyle = options?.outputStyle || 'default';
-	const extraRules = normalizeExtraRules(options?.extraRules);
-	const durableMemoryEntries = resolveDurableMemoryEntries(options);
-	const acceptedPatterns = durableMemoryEntries
-		.filter((entry) => entry.kind === 'accepted_pattern')
-		.map(formatDurableMemoryRule);
-	const rejectedFixShapes = durableMemoryEntries
-		.filter((entry) => entry.kind === 'rejected_fix_shape')
-		.map(formatDurableMemoryRule);
-	const contractViolations = durableMemoryEntries
-		.filter((entry) => entry.kind === 'contract_violation')
-		.map(formatDurableMemoryRule);
-	return [
-		{
-			title: 'Investigation Loop',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_INVESTIGATION_RULES)
-		},
-		{
-			title: 'Data And ID Contracts',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_DATA_RULES)
-		},
-		{
-			title: 'Generated Files',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_GENERATED_FILE_RULES)
-		},
-		{
-			title: 'Path Grounding And Scope',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_PATH_GROUNDING_RULES)
-		},
-		{
-			title: 'Collection And Workflow Inference',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_COLLECTION_INFERENCE_RULES)
-		},
-		{
-			title: 'Platform Architecture',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_ARCHITECTURE_RULES)
-		},
-		{
-			title: 'Server Implementation',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_SERVER_RULES)
-		},
-		{
-			title: 'ResolveIO UI Libraries',
-			rules: dedupeRules([
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_UI_LIBRARY_RULES,
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_RIO_SELECT_RULES,
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_ANGULAR_RULES,
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_FILTER_RULES,
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_STYLE_RULES
-			])
-		},
-		{
-			title: 'App Generation And UX',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_APP_GENERATION_RULES)
-		},
-		{
-			title: 'Auth And Shell',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_AUTH_AND_SHELL_RULES)
-		},
-		{
-			title: 'Execution Quality',
-			rules: dedupeRules([
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_EXECUTION_RULES,
-				...RESOLVEIO_PLATFORM_INTELLIGENCE_EVIDENCE_TO_FIX_RULES
-			])
-		},
-		{
-			title: 'Shared Library Ownership',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_SHARED_LIBRARY_RULES)
-		},
-		{
-			title: 'Live Data And Report Builder',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_REPORT_BUILDER_RULES)
-		},
-		{
-			title: 'Durable Memory: Accepted Patterns',
-			rules: dedupeRules(acceptedPatterns)
-		},
-		{
-			title: 'Durable Memory: Rejected Fix Shapes',
-			rules: dedupeRules(rejectedFixShapes)
-		},
-		{
-			title: 'Durable Memory: Contract Violations',
-			rules: dedupeRules(contractViolations)
-		},
-		{
-			title: 'Mode Rules',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_MODE_RULES[mode] || [])
-		},
-		{
-			title: 'Output Style',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_OUTPUT_STYLE_RULES[outputStyle] || [])
-		},
-		{
-			title: 'Safety',
-			rules: dedupeRules(RESOLVEIO_PLATFORM_INTELLIGENCE_SAFETY_RULES)
-		},
-		{
-			title: 'Extra Rules',
-			rules: dedupeRules(extraRules)
-		}
-	].filter((section) => section.rules.length > 0);
-}
-
-export function getResolveIOPlatformIntelligenceRuleLines(options: ResolveIOPlatformIntelligenceRuleOptions): string[] {
-	return getResolveIOPlatformIntelligenceRuleSections(options)
-		.flatMap((section) => section.rules);
-}
-
-export function buildResolveIOPlatformIntelligenceSystemPrompt(options: ResolveIOPlatformIntelligenceRuleOptions): string {
-	const sections = getResolveIOPlatformIntelligenceRuleSections(options);
-	return [
-		resolveResolveIOPlatformIntelligenceHeader(options?.mode || 'assistant'),
-		'Core rules:',
-		...sections.flatMap((section) => [
-			`${section.title}:`,
-			...section.rules.map((rule) => `- ${rule}`)
-		])
-	].join('\n');
-}

package/src/client-server-app.ts

@@ -1,12 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-const settingsPath = path.join(__dirname, 'settings.json');
-const serverConfig = fs.existsSync(settingsPath)
-	? require(settingsPath)
-	: { ...process.env };
-import { ResolveIOServer } from './resolveio-server-app';
-
-setImmediate(async () => {
-	await ResolveIOServer.create(serverConfig, [], 'ResolveIO Server Library', __dirname);
-});

package/src/collections/ai-run.collection.ts

@@ -1,117 +0,0 @@
-import { MongoManagerModel } from '../managers/mongo.manager';
-import { AIRunModel } from '../models/ai-run.model';
-
-const schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	source: {
-		type: String
-	},
-	sourceIds: {
-		type: Object,
-		blackbox: true
-	},
-	title: {
-		type: String,
-		optional: true
-	},
-	status: {
-		type: String,
-		optional: true
-	},
-	phase: {
-		type: String,
-		optional: true
-	},
-	startedAt: {
-		type: Date,
-		optional: true
-	},
-	completedAt: {
-		type: Date,
-		optional: true
-	},
-	outcome: {
-		type: String
-	},
-	events: {
-		type: Array,
-		optional: true
-	},
-	'events.$': {
-		type: Object,
-		blackbox: true
-	},
-	gates: {
-		type: Array,
-		optional: true
-	},
-	'gates.$': {
-		type: Object,
-		blackbox: true
-	},
-	qa: {
-		type: Object,
-		optional: true,
-		blackbox: true
-	},
-	cost: {
-		type: Object,
-		optional: true,
-		blackbox: true
-	},
-	nextAction: {
-		type: String,
-		optional: true
-	},
-	warnings: {
-		type: Array,
-		optional: true
-	},
-	'warnings.$': {
-		type: String
-	},
-	metadata: {
-		type: Object,
-		optional: true,
-		blackbox: true
-	}
-};
-
-const model = MongoManagerModel.create<AIRunModel>({
-	collectionName: 'ai-runs',
-	schema,
-	useVersionCollection: true,
-	useReportBuilder: false,
-	reportBuilderLookupTables: [],
-	timestamps: true,
-	createLogs: true,
-	checkSchema: true,
-	collectionOptions: null
-});
-
-export const AIRuns = model.collection_main;
-export const AIRunVersions = model.collection_version;
-
-setTimeout(async () => {
-	await AIRuns.createIndex({ source: 1, outcome: 1, updatedAt: -1 });
-	await AIRuns.createIndex({ 'sourceIds.ticketNumber': 1, updatedAt: -1 });
-	await AIRuns.createIndex({ 'sourceIds.ticketId': 1, updatedAt: -1 });
-	await AIRuns.createIndex({ 'sourceIds.appId': 1, updatedAt: -1 });
-	await AIRuns.createIndex({ 'sourceIds.jobId': 1, updatedAt: -1 });
-	await AIRuns.createIndex({ 'sourceIds.conversationId': 1, updatedAt: -1 });
-}, 5000);