@xfxstudio/claworld 0.2.12 → 0.2.14

package/src/product-shell/matching/matchmaking-service.js

@@ -1,395 +0,0 @@
-import { buildCandidateFeed, normalizeCandidateFeedLimit, projectCandidateFeedModel } from '../contracts/candidate-feed.js';
-import { WORLD_ACTIONS } from '../worlds/world-authorization.js';
-
-const DATING_DEMO_SCORING_SIGNALS = Object.freeze([
-  {
-    signalId: 'intent_exact_match',
-    label: 'Intent Exact Match',
-    weight: 50,
-    sourceFieldIds: ['intent'],
-    summary: 'Add 50 points when both active memberships declare the same normalized intent.',
-  },
-  {
-    signalId: 'same_location',
-    label: 'Same Location',
-    weight: 30,
-    sourceFieldIds: ['location'],
-    summary: 'Add 30 points when both active memberships declare the same normalized location.',
-  },
-  {
-    signalId: 'shared_interests',
-    label: 'Shared Interests',
-    weight: 20,
-    sourceFieldIds: ['interests'],
-    summary: 'Add 10 points per shared normalized interest, capped at 20 points.',
-  },
-]);
-
-function createConfigurationError() {
-  const error = new Error('membership_store_unavailable');
-  error.code = 'membership_store_unavailable';
-  error.status = 500;
-  return error;
-}
-
-function createAgentNotFoundError(agentId) {
-  const error = new Error(`agent_not_found:${agentId}`);
-  error.code = 'agent_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createInvalidCandidateFeedRequestError(fieldId, message = `${fieldId} is required`) {
-  const error = new Error(`invalid_candidate_feed_request:${fieldId}`);
-  error.code = 'invalid_candidate_feed_request';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'candidate feed request is missing required fields',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function createCandidateFeedMembershipNotActiveError(worldId, agentId) {
-  const error = new Error(`candidate_feed_membership_not_active:${worldId}:${agentId}`);
-  error.code = 'candidate_feed_membership_not_active';
-  error.status = 409;
-  error.responseBody = {
-    error: error.code,
-    message: 'agent must have an active world membership before requesting candidate feed',
-    worldId,
-    agentId,
-    requiredMembershipStatus: 'active',
-  };
-  return error;
-}
-
-function normalizeAgentId(agentId) {
-  const normalized = String(agentId || '').trim();
-  return normalized || null;
-}
-
-function normalizeText(value) {
-  return String(value || '').trim().toLowerCase();
-}
-
-function normalizeStringList(value) {
-  if (!Array.isArray(value)) return [];
-  return [...new Set(
-    value
-      .map((item) => normalizeText(item))
-      .filter(Boolean),
-  )].sort((left, right) => left.localeCompare(right));
-}
-
-function projectScoringSignals(worldId) {
-  if (worldId !== 'dating-demo-world') return [];
-  return DATING_DEMO_SCORING_SIGNALS.map((signal) => ({ ...signal }));
-}
-
-function buildStrategy(world) {
-  return {
-    worldId: world.worldId,
-    mode: world.matching.mode,
-    cadence: world.matching.cadence,
-    strategySummary: world.matching.strategySummary,
-    candidateSources: world.matching.candidateSources,
-    inputFields: world.joinSchema.requiredFields.map((field) => field.fieldId),
-    candidateFeedModel: projectCandidateFeedModel(world),
-    scoringSignals: projectScoringSignals(world.worldId),
-    status: world.worldId === 'dating-demo-world' ? 'candidate_scoring_ready' : 'scaffold_ready',
-  };
-}
-
-function buildInterestBreakdown(requesterInterests, candidateInterests) {
-  const sharedValues = requesterInterests.filter((interest) => candidateInterests.includes(interest));
-  const contribution = Math.min(sharedValues.length * 10, 20);
-
-  return {
-    signalId: 'shared_interests',
-    label: 'Shared Interests',
-    weight: 20,
-    sourceFieldIds: ['interests'],
-    matched: sharedValues.length > 0,
-    requesterValue: requesterInterests,
-    candidateValue: candidateInterests,
-    sharedValues,
-    overlapCount: sharedValues.length,
-    contribution,
-  };
-}
-
-function buildDatingDemoScoreDetails(viewerMembership, candidateMembership) {
-  const viewerIntent = normalizeText(viewerMembership.profileSnapshot?.intent);
-  const candidateIntent = normalizeText(candidateMembership.profileSnapshot?.intent);
-  const viewerLocation = normalizeText(viewerMembership.profileSnapshot?.location);
-  const candidateLocation = normalizeText(candidateMembership.profileSnapshot?.location);
-  const viewerInterests = normalizeStringList(viewerMembership.profileSnapshot?.interests);
-  const candidateInterests = normalizeStringList(candidateMembership.profileSnapshot?.interests);
-
-  const scoreBreakdown = [
-    {
-      signalId: 'intent_exact_match',
-      label: 'Intent Exact Match',
-      weight: 50,
-      sourceFieldIds: ['intent'],
-      matched: viewerIntent !== '' && viewerIntent === candidateIntent,
-      requesterValue: viewerIntent,
-      candidateValue: candidateIntent,
-      contribution: viewerIntent !== '' && viewerIntent === candidateIntent ? 50 : 0,
-    },
-    {
-      signalId: 'same_location',
-      label: 'Same Location',
-      weight: 30,
-      sourceFieldIds: ['location'],
-      matched: viewerLocation !== '' && viewerLocation === candidateLocation,
-      requesterValue: viewerLocation,
-      candidateValue: candidateLocation,
-      contribution: viewerLocation !== '' && viewerLocation === candidateLocation ? 30 : 0,
-    },
-    buildInterestBreakdown(viewerInterests, candidateInterests),
-  ];
-
-  return {
-    joinedAt: candidateMembership.joinedAt,
-    score: scoreBreakdown.reduce((sum, signal) => sum + signal.contribution, 0),
-    scoreBreakdown,
-    scoringInputs: {
-      requester: {
-        intent: viewerIntent,
-        location: viewerLocation,
-        interests: viewerInterests,
-      },
-      candidate: {
-        intent: candidateIntent,
-        location: candidateLocation,
-        interests: candidateInterests,
-      },
-      overlap: {
-        sharedInterests: scoreBreakdown[2].sharedValues,
-      },
-    },
-  };
-}
-
-function compareRankedCandidates(left, right) {
-  if (right.score !== left.score) return right.score - left.score;
-
-  const rightSharedInterestCount = right.scoringInputs.overlap.sharedInterests.length;
-  const leftSharedInterestCount = left.scoringInputs.overlap.sharedInterests.length;
-  if (rightSharedInterestCount !== leftSharedInterestCount) {
-    return rightSharedInterestCount - leftSharedInterestCount;
-  }
-
-  if (left.joinedAt !== right.joinedAt) {
-    return String(left.joinedAt).localeCompare(String(right.joinedAt));
-  }
-
-  return String(left.sourceMembershipId).localeCompare(String(right.sourceMembershipId));
-}
-
-function buildViewerContext({ world, membershipStore, normalizedAgentId, worldAuthorizationService }) {
-  const viewerAgent = membershipStore.getAgent(normalizedAgentId);
-  if (!viewerAgent) {
-    throw createAgentNotFoundError(normalizedAgentId);
-  }
-
-  const authorization = worldAuthorizationService.evaluateWorldAction({
-    worldId: world.worldId,
-    actorAgentId: normalizedAgentId,
-    action: WORLD_ACTIONS.VIEW_CANDIDATE_FEED,
-  });
-
-  if (!authorization.allowed || authorization.membership?.status !== 'active') {
-    throw createCandidateFeedMembershipNotActiveError(world.worldId, normalizedAgentId);
-  }
-
-  return {
-    viewerAgent,
-    viewerMembership: authorization.membership,
-  };
-}
-
-function buildBaseFeed({
-  world,
-  membershipStore,
-  normalizedAgentId,
-  limit,
-  worldAuthorizationService,
-  resolvePresence,
-}) {
-  const { viewerAgent, viewerMembership } = buildViewerContext({
-    world,
-    membershipStore,
-    normalizedAgentId,
-    worldAuthorizationService,
-  });
-  const activeMemberships = membershipStore.listMemberships({
-    worldId: world.worldId,
-    status: 'active',
-  });
-  const normalizedLimit = normalizeCandidateFeedLimit(limit);
-  const nowMs = typeof membershipStore.nowMs === 'function' ? membershipStore.nowMs() : Date.now();
-  const baseFeed = buildCandidateFeed({
-    world,
-    viewerMembership,
-    viewerAgent,
-    candidateMemberships: activeMemberships,
-    getAgent: (candidateAgentId) => membershipStore.getAgent(candidateAgentId),
-    getPresence: (candidateAgentId) => resolvePresence(candidateAgentId),
-    nowMs,
-    limit: activeMemberships.length,
-  });
-
-  return {
-    viewerMembership,
-    activeMemberships,
-    normalizedLimit,
-    baseFeed,
-  };
-}
-
-function buildDatingDemoFeed({
-  world,
-  membershipStore,
-  normalizedAgentId,
-  limit,
-  worldAuthorizationService,
-  resolvePresence,
-  conversationFeedbackService = null,
-}) {
-  const { viewerMembership, activeMemberships, normalizedLimit, baseFeed } = buildBaseFeed({
-    world,
-    membershipStore,
-    normalizedAgentId,
-    limit,
-    worldAuthorizationService,
-    resolvePresence,
-  });
-  const membershipById = new Map(activeMemberships.map((membership) => [membership.membershipId, membership]));
-  const rankedCandidates = baseFeed.candidates
-    .map((candidate) => {
-      const candidateMembership = membershipById.get(candidate.sourceMembershipId);
-      return {
-        ...candidate,
-        worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
-          worldId: world.worldId,
-          agentId: candidate.targetAgentId,
-        }) || {
-          likesReceived: 0,
-          dislikesReceived: 0,
-        },
-        ...buildDatingDemoScoreDetails(viewerMembership, candidateMembership),
-      };
-    })
-    .sort(compareRankedCandidates);
-
-  const candidates = rankedCandidates
-    .slice(0, normalizedLimit)
-    .map((candidate, index) => ({
-      ...candidate,
-      rank: index + 1,
-    }));
-
-  return {
-    ...baseFeed,
-    agentId: normalizedAgentId,
-    limit: normalizedLimit,
-    candidateSource: 'active_memberships_online',
-    strategy: buildStrategy(world),
-    totalCandidates: rankedCandidates.length,
-    candidates,
-  };
-}
-
-export function createMatchmakingService({
-  worldService,
-  worldAuthorizationService,
-  store = null,
-  presence = null,
-  conversationFeedbackService = null,
-} = {}) {
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  function resolvePresence(agentId) {
-    if (!presence) {
-      return {
-        online: true,
-        connectedAt: null,
-        lastHeartbeatAt: null,
-      };
-    }
-    return presence.getPresence(agentId);
-  }
-
-  return {
-    describeStrategy(worldId) {
-      const world = worldService.requireWorld(worldId);
-      return buildStrategy(world);
-    },
-    listCandidateFeed({ worldId, agentId, limit } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const membershipStore = assertStore();
-      const normalizedAgentId = normalizeAgentId(agentId);
-
-      if (!normalizedAgentId) {
-        throw createInvalidCandidateFeedRequestError('agentId');
-      }
-
-      if (world.worldId === 'dating-demo-world') {
-        return buildDatingDemoFeed({
-          world,
-          membershipStore,
-          normalizedAgentId,
-          limit,
-          worldAuthorizationService,
-          resolvePresence,
-          conversationFeedbackService,
-        });
-      }
-
-      const { normalizedLimit, baseFeed } = buildBaseFeed({
-        world,
-        membershipStore,
-        normalizedAgentId,
-        limit,
-        worldAuthorizationService,
-        resolvePresence,
-      });
-
-      return {
-        ...baseFeed,
-        agentId: normalizedAgentId,
-        limit: normalizedLimit,
-        candidateSource: 'active_memberships_online',
-        strategy: buildStrategy(world),
-        totalCandidates: baseFeed.candidates.length,
-        candidates: baseFeed.candidates
-          .slice(0, normalizedLimit)
-          .map((candidate) => ({
-            ...candidate,
-            worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
-              worldId: world.worldId,
-              agentId: candidate.targetAgentId,
-            }) || {
-              likesReceived: 0,
-              dislikesReceived: 0,
-            },
-          })),
-      };
-    },
-    listCandidates(options = {}) {
-      return this.listCandidateFeed(options);
-    },
-  };
-}

package/src/product-shell/membership/membership-service.js

@@ -1,284 +0,0 @@
-import { buildResolvedWorldJoinOrchestration } from '../contracts/world-orchestration.js';
-import { buildParticipantContextText } from '../worlds/world-text.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function createConfigurationError() {
-  const error = new Error('membership_store_unavailable');
-  error.code = 'membership_store_unavailable';
-  error.status = 500;
-  return error;
-}
-
-function createAgentNotFoundError(agentId) {
-  const error = new Error(`agent_not_found:${agentId}`);
-  error.code = 'agent_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createInvalidJoinRequestError(fieldId, message = `${fieldId} is required`) {
-  const error = new Error(`invalid_join_request:${fieldId}`);
-  error.code = 'invalid_join_request';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'join request is missing required fields',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function normalizeAgentId(agentId) {
-  const normalized = String(agentId || '').trim();
-  return normalized || null;
-}
-
-function normalizeProfileSnapshot(profileSnapshot = null, participantContextText = null) {
-  const base = profileSnapshot && typeof profileSnapshot === 'object' && !Array.isArray(profileSnapshot)
-    ? { ...profileSnapshot }
-    : {};
-  const normalizedParticipantContextText = normalizeText(
-    participantContextText,
-    normalizeText(base.participantContextText, null),
-  );
-  if (normalizedParticipantContextText) {
-    base.participantContextText = normalizedParticipantContextText;
-  }
-  return base;
-}
-
-function buildNextStageSummary() {
-  return {
-    stage: 'candidate_review',
-    summary:
-      'Review the backend-authored candidate feed or use world search, then choose one target agent and create a world-scoped chat request.',
-  };
-}
-
-export function createMembershipService({ worldService, store = null, publicIdentityService = null } = {}) {
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  function resolveNormalizedParticipantContextText({ participantContextText = null, profileSnapshot = null, agent = null, world = null } = {}) {
-    return buildParticipantContextText({
-      world,
-      agent,
-      participantContextText,
-      profileSnapshot,
-    });
-  }
-
-  return {
-    evaluateJoin({ worldId, participantContextText = null, profile = null, profileSnapshot = null } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
-        world,
-        participantContextText,
-        profileSnapshot: profileSnapshot || profile,
-      });
-      const accepted = Boolean(normalizedParticipantContextText);
-
-      return {
-        worldId: world.worldId,
-        accepted,
-        status: accepted ? 'eligible' : 'needs_profile',
-        participantContextText: normalizedParticipantContextText,
-        missingFields: accepted
-          ? []
-          : [
-            {
-              fieldId: 'participantContextText',
-              label: 'Entry Profile',
-              description: 'A short text describing who you are in this world and what context you bring into it.',
-            },
-          ],
-        nextMissingField: accepted
-          ? null
-          : {
-            fieldId: 'participantContextText',
-            label: 'Entry Profile',
-            description: 'A short text describing who you are in this world and what context you bring into it.',
-          },
-        missingFieldGuidance: {
-          mode: accepted ? 'complete' : 'single_text_field',
-          orderedMissingFields: accepted
-            ? []
-            : [
-              {
-                fieldId: 'participantContextText',
-                label: 'Entry Profile',
-                description: 'A short text describing who you are in this world and what context you bring into it.',
-              },
-            ],
-          orderedMissingFieldIds: accepted ? [] : ['participantContextText'],
-          nextMissingField: accepted
-            ? null
-            : {
-              fieldId: 'participantContextText',
-              label: 'Entry Profile',
-              description: 'A short text describing who you are in this world and what context you bring into it.',
-            },
-          remainingRequiredFieldCount: accepted ? 0 : 1,
-        },
-        nextAction: accepted ? 'call_join_world' : 'retry_join_world_after_profile_update',
-      };
-    },
-
-    async createMembership({ worldId, agentId, participantContextText, profile = null, profileSnapshot = null } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const membershipStore = assertStore();
-      const normalizedAgentId = normalizeAgentId(agentId);
-      if (!normalizedAgentId) throw createInvalidJoinRequestError('agentId');
-
-      const agent = membershipStore.getAgent(normalizedAgentId);
-      if (!agent) throw createAgentNotFoundError(normalizedAgentId);
-
-      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
-        world,
-        agent,
-        participantContextText,
-        profileSnapshot: profileSnapshot || profile,
-      });
-      if (!normalizedParticipantContextText) {
-        throw createInvalidJoinRequestError(
-          'participantContextText',
-          'participantContextText is required',
-        );
-      }
-
-      const existingMembership = membershipStore.listMemberships({
-        worldId,
-        agentId: normalizedAgentId,
-      })[0] || null;
-
-      if (existingMembership) {
-        return { membership: existingMembership, created: false };
-      }
-
-      const membership = await membershipStore.createMembership({
-        worldId,
-        agentId: normalizedAgentId,
-        status: 'joined',
-        profileSnapshot: normalizeProfileSnapshot(profileSnapshot || profile, normalizedParticipantContextText),
-        participantContextText: normalizedParticipantContextText,
-      });
-
-      return { membership, created: true };
-    },
-
-    async joinWorld({
-      worldId,
-      agentId,
-      participantContextText,
-      profile = null,
-      profileSnapshot = null,
-    } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const membershipStore = assertStore();
-      const normalizedAgentId = normalizeAgentId(agentId);
-
-      if (!normalizedAgentId) throw createInvalidJoinRequestError('agentId');
-
-      const agent = membershipStore.getAgent(normalizedAgentId);
-      if (!agent) throw createAgentNotFoundError(normalizedAgentId);
-      publicIdentityService?.assertPublicIdentityReady?.({
-        agentId: normalizedAgentId,
-        capability: 'join world',
-      });
-
-      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
-        world,
-        agent,
-        participantContextText,
-        profileSnapshot: profileSnapshot || profile,
-      });
-      if (!normalizedParticipantContextText) {
-        throw createInvalidJoinRequestError(
-          'participantContextText',
-          'participantContextText is required',
-        );
-      }
-
-      const existingMembership = membershipStore.listMemberships({
-        worldId: world.worldId,
-        agentId: normalizedAgentId,
-      })[0] || null;
-
-      const membership = existingMembership
-        ? await membershipStore.updateMembership(existingMembership.membershipId, {
-          status: 'active',
-          profileSnapshot: normalizeProfileSnapshot(
-            {
-              ...(existingMembership.profileSnapshot && typeof existingMembership.profileSnapshot === 'object'
-                ? existingMembership.profileSnapshot
-                : {}),
-              ...((profileSnapshot || profile) && typeof (profileSnapshot || profile) === 'object' && !Array.isArray(profileSnapshot || profile)
-                ? (profileSnapshot || profile)
-                : {}),
-            },
-            normalizedParticipantContextText,
-          ),
-          participantContextText: normalizedParticipantContextText,
-        })
-        : await membershipStore.createMembership({
-          worldId: world.worldId,
-          agentId: normalizedAgentId,
-          status: 'active',
-          profileSnapshot: normalizeProfileSnapshot(profileSnapshot || profile, normalizedParticipantContextText),
-          participantContextText: normalizedParticipantContextText,
-        });
-
-      const joinResult = {
-        status: 'joined',
-        worldId: world.worldId,
-        membership,
-        membershipStatus: membership.status,
-        created: !existingMembership,
-        participantContextText: normalizedParticipantContextText,
-        nextAction: 'review_candidate_feed',
-        nextStageSummary: buildNextStageSummary(),
-      };
-
-      return {
-        ...joinResult,
-        orchestration: buildResolvedWorldJoinOrchestration({
-          joinResult,
-          candidateDelivery: null,
-        }) || null,
-      };
-    },
-
-    getMembership({ worldId, agentId, includeDisabled = false } = {}) {
-      const normalizedAgentId = normalizeAgentId(agentId);
-      if (!normalizedAgentId) return null;
-      worldService.requireWorld(worldId, { includeDisabled });
-      return assertStore().listMemberships({ worldId, agentId: normalizedAgentId })[0] || null;
-    },
-
-    listMemberships({ worldId, agentId = null, status = null, includeDisabled = false } = {}) {
-      worldService.requireWorld(worldId, { includeDisabled });
-      return assertStore().listMemberships({ worldId, agentId, status });
-    },
-
-    listMembershipsAcrossWorlds({ agentId = null, status = null } = {}) {
-      return assertStore().listMemberships({ agentId, status });
-    },
-
-    countMemberships({ worldId, agentId = null, status = null, includeDisabled = false } = {}) {
-      worldService.requireWorld(worldId, { includeDisabled });
-      return assertStore().countMemberships({ worldId, agentId, status });
-    },
-  };
-}