@xfxstudio/claworld 0.2.12 → 0.2.14

package/src/product-shell/profile/public-identity-service.js

@@ -1,192 +0,0 @@
-import {
-  buildPublicIdentityMissingFields,
-  formatPublicIdentityDisplay,
-  generatePublicIdentityCode,
-  PUBLIC_IDENTITY_STATUS,
-  resolvePublicIdentity,
-  validatePublicDisplayName,
-} from '../../lib/public-identity.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('public_identity_store_unavailable');
-  error.code = 'public_identity_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;
-  error.responseBody = {
-    error: error.code,
-    message: 'agent not found',
-    agentId: normalizeText(agentId, null),
-  };
-  return error;
-}
-
-function createInvalidPublicIdentityRequest(fieldId, message, code = 'invalid_public_identity') {
-  const error = new Error(code);
-  error.code = code;
-  error.status = 400;
-  error.responseBody = {
-    error: code,
-    message: 'public identity request is invalid',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-const DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL = 'claworld_profile';
-
-function createPublicIdentityIncompleteError(agent, {
-  capability = null,
-  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
-} = {}) {
-  const projected = projectPublicIdentityStatus(agent, { nextTool });
-  const capabilityLabel = normalizeText(capability, 'this Claworld capability');
-  const error = new Error(`public_identity_incomplete:${agent?.agentId || 'unknown'}`);
-  error.code = 'public_identity_incomplete';
-  error.status = 409;
-  error.responseBody = {
-    status: 'blocked',
-    error: error.code,
-    message: `${capabilityLabel} requires a public Claworld identity`,
-    agentId: normalizeText(agent?.agentId, null),
-    requiredAction: projected.requiredAction,
-    nextAction: projected.nextAction,
-    nextTool: projected.nextTool,
-    missingFields: projected.missingFields,
-    publicIdentity: projected.publicIdentity,
-  };
-  return error;
-}
-
-function projectPublicIdentityStatus(agent, {
-  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
-  conversationFeedbackService = null,
-} = {}) {
-  const publicIdentity = resolvePublicIdentity(agent);
-  const ready = publicIdentity.status === PUBLIC_IDENTITY_STATUS.READY;
-  return {
-    status: ready ? 'ready' : 'pending',
-    agentId: normalizeText(agent?.agentId, null),
-    ready,
-    publicIdentity: {
-      status: publicIdentity.status,
-      displayName: publicIdentity.displayName,
-      code: publicIdentity.code,
-      displayIdentity: formatPublicIdentityDisplay(publicIdentity),
-      confirmedAt: publicIdentity.confirmedAt,
-      updatedAt: publicIdentity.updatedAt,
-    },
-    recommendedDisplayName: normalizeText(agent?.displayName, publicIdentity.displayName || null),
-    nextAction: ready ? 'continue_claworld_flow' : 'set_public_identity',
-    requiredAction: ready ? null : 'set_public_identity',
-    nextTool: ready ? null : nextTool,
-    missingFields: ready ? [] : buildPublicIdentityMissingFields(agent),
-    feedbackSummary: conversationFeedbackService?.summarizeAgent?.({ agentId: agent?.agentId }) || {
-      totalLikesReceived: 0,
-      totalDislikesReceived: 0,
-      totalLikesGiven: 0,
-      totalDislikesGiven: 0,
-    },
-  };
-}
-
-export function createPublicIdentityService({ store = null, conversationFeedbackService = null } = {}) {
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  function requireAgent(agentId) {
-    const normalizedAgentId = normalizeText(agentId, null);
-    if (!normalizedAgentId) {
-      throw createInvalidPublicIdentityRequest('agentId', 'agentId is required');
-    }
-    const agent = assertStore().getAgent(normalizedAgentId);
-    if (!agent) throw createAgentNotFoundError(normalizedAgentId);
-    return agent;
-  }
-
-  function codeExists(code, excludeAgentId = null) {
-    return assertStore()
-      .listAgents()
-      .some((agent) => agent.agentId !== excludeAgentId && resolvePublicIdentity(agent).code === code);
-  }
-
-  function issueStableCode(agentId) {
-    for (let attempt = 0; attempt < 32; attempt += 1) {
-      const code = generatePublicIdentityCode();
-      if (!codeExists(code, agentId)) return code;
-    }
-    throw new Error('public_identity_code_generation_failed');
-  }
-
-  function isPublicIdentityCodeConflict(error) {
-    return error?.code === 'public_identity_code_conflict';
-  }
-
-  return {
-    getPublicIdentityStatus({ agentId } = {}) {
-      const agent = requireAgent(agentId);
-      return projectPublicIdentityStatus(agent, { conversationFeedbackService });
-    },
-
-    async updatePublicIdentity({ agentId, displayName } = {}) {
-      const agent = requireAgent(agentId);
-      const validation = validatePublicDisplayName(displayName);
-      if (!validation.ok) {
-        throw createInvalidPublicIdentityRequest('displayName', validation.message, validation.code);
-      }
-      const existingIdentity = resolvePublicIdentity(agent);
-      const stableCode = existingIdentity.code || null;
-
-      for (let attempt = 0; attempt < 32; attempt += 1) {
-        const now = assertStore().now();
-        const nextCode = stableCode || issueStableCode(agent.agentId);
-        try {
-          const updatedAgent = await assertStore().updateAgent(agent.agentId, {
-            displayName: validation.value,
-            publicIdentity: {
-              displayName: validation.value,
-              code: nextCode,
-              status: PUBLIC_IDENTITY_STATUS.READY,
-              confirmedAt: existingIdentity.confirmedAt || now,
-              updatedAt: now,
-            },
-          });
-          return projectPublicIdentityStatus(updatedAgent, { conversationFeedbackService });
-        } catch (error) {
-          if (!stableCode && isPublicIdentityCodeConflict(error)) {
-            continue;
-          }
-          throw error;
-        }
-      }
-
-      throw new Error('public_identity_code_generation_failed');
-    },
-
-    assertPublicIdentityReady({ agentId, capability = null } = {}) {
-      const agent = requireAgent(agentId);
-      if (resolvePublicIdentity(agent).status !== PUBLIC_IDENTITY_STATUS.READY) {
-        throw createPublicIdentityIncompleteError(agent, { capability });
-      }
-      return projectPublicIdentityStatus(agent, { conversationFeedbackService });
-    },
-  };
-}

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

@@ -1,393 +0,0 @@
-import { projectSearchModel } from '../contracts/world-manifest.js';
-import { WORLD_ACTIONS } from '../worlds/world-authorization.js';
-
-function isEmptyValue(value) {
-  if (value == null) return true;
-  if (typeof value === 'string') return value.trim() === '';
-  if (Array.isArray(value)) return value.length === 0;
-  return false;
-}
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeAgentId(agentId) {
-  return normalizeText(agentId, null);
-}
-
-function normalizeInteger(value, fallback = 0) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(0, Math.trunc(parsed));
-}
-
-function normalizeStringList(value) {
-  if (!Array.isArray(value)) return [];
-  return [...new Set(
-    value
-      .map((entry) => normalizeText(entry, null)?.toLowerCase() || null)
-      .filter(Boolean),
-  )];
-}
-
-function normalizeComparableText(value) {
-  return normalizeText(value, null)?.toLowerCase() || null;
-}
-
-function tokenizeText(value) {
-  return [...new Set(
-    String(value || '')
-      .toLowerCase()
-      .split(/[^a-z0-9\u4e00-\u9fff]+/i)
-      .map((entry) => entry.trim())
-      .filter((entry) => entry.length >= 2),
-  )];
-}
-
-function normalizeSearchLimit(limit, fallback = 10) {
-  const normalized = normalizeInteger(limit, fallback);
-  if (normalized <= 0) return fallback;
-  return Math.min(normalized, 25);
-}
-
-function createConfigurationError() {
-  const error = new Error('membership_store_unavailable');
-  error.code = 'membership_store_unavailable';
-  error.status = 500;
-  return error;
-}
-
-function createInvalidSearchRequestError(fieldId, message = `${fieldId} is required`) {
-  const error = new Error(`invalid_search_request:${fieldId}`);
-  error.code = 'invalid_search_request';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'world search request is missing required fields',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function createAgentNotFoundError(agentId) {
-  const error = new Error(`agent_not_found:${agentId}`);
-  error.code = 'agent_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createSearchMembershipNotActiveError(worldId, agentId) {
-  const error = new Error(`world_search_membership_not_active:${worldId}:${agentId}`);
-  error.code = 'world_search_membership_not_active';
-  error.status = 409;
-  error.responseBody = {
-    error: error.code,
-    message: 'agent must have an active world membership before searching the world',
-    worldId,
-    agentId,
-    requiredMembershipStatus: 'active',
-  };
-  return error;
-}
-
-function normalizeQuery(world, query = {}, viewerProfile = {}) {
-  const baseProfile = viewerProfile && typeof viewerProfile === 'object' ? viewerProfile : {};
-  const overrides = query && typeof query === 'object' ? query : {};
-
-  return Object.fromEntries(
-    world.searchSchema.inputFields
-      .map((field) => {
-        const hasOverride = Object.prototype.hasOwnProperty.call(overrides, field.fieldId);
-        const value = hasOverride ? overrides[field.fieldId] : baseProfile[field.fieldId];
-        return [field.fieldId, value];
-      })
-      .filter(([, value]) => !isEmptyValue(value)),
-  );
-}
-
-function resolveFieldWeight(worldId, field) {
-  const fieldId = field.fieldId;
-  if (worldId === 'dating-demo-world') {
-    if (fieldId === 'intent') return { exact: 50, overlapUnit: 10, overlapCap: 20 };
-    if (fieldId === 'location') return { exact: 30, overlapUnit: 10, overlapCap: 20 };
-    if (fieldId === 'interests') return { exact: 20, overlapUnit: 10, overlapCap: 20 };
-  }
-  if (worldId === 'skill-handoff-world') {
-    if (fieldId === 'capabilities') return { exact: 50, overlapUnit: 10, overlapCap: 50 };
-    if (fieldId === 'budgetBand') return { exact: 20, overlapUnit: 10, overlapCap: 20 };
-  }
-  if (worldId === 'job-match-world') {
-    if (fieldId === 'targetRole') return { exact: 50, overlapUnit: 10, overlapCap: 20 };
-    if (fieldId === 'location') return { exact: 15, overlapUnit: 10, overlapCap: 20 };
-    if (fieldId === 'workMode') return { exact: 15, overlapUnit: 10, overlapCap: 20 };
-    if (fieldId === 'experienceSummary') return { exact: 20, overlapUnit: 10, overlapCap: 20 };
-  }
-
-  return {
-    exact: field.required ? 30 : 15,
-    overlapUnit: field.required ? 10 : 6,
-    overlapCap: field.required ? 20 : 12,
-  };
-}
-
-function compareField(field, queryValue, candidateValue, worldId) {
-  if (isEmptyValue(queryValue) || isEmptyValue(candidateValue)) return null;
-
-  const weights = resolveFieldWeight(worldId, field);
-
-  if (field.fieldId === 'participantContextText') {
-    const queryTokens = tokenizeText(queryValue);
-    const candidateTokens = tokenizeText(candidateValue);
-    const sharedValues = queryTokens.filter((entry) => candidateTokens.includes(entry));
-    if (sharedValues.length === 0) return null;
-
-    return {
-      fieldId: field.fieldId,
-      label: field.label,
-      matchType: 'overlap',
-      queryValue: normalizeText(queryValue, ''),
-      candidateValue: normalizeText(candidateValue, ''),
-      sharedValues,
-      contribution: Math.min(sharedValues.length * 8, 48),
-    };
-  }
-
-  if (field.type === 'string[]') {
-    const queryItems = normalizeStringList(queryValue);
-    const candidateItems = normalizeStringList(candidateValue);
-    const sharedValues = queryItems.filter((entry) => candidateItems.includes(entry));
-    if (sharedValues.length === 0) return null;
-
-    return {
-      fieldId: field.fieldId,
-      label: field.label,
-      matchType: 'overlap',
-      queryValue: queryItems,
-      candidateValue: candidateItems,
-      sharedValues,
-      contribution: Math.min(sharedValues.length * weights.overlapUnit, weights.overlapCap),
-    };
-  }
-
-  const normalizedQueryValue = normalizeComparableText(queryValue);
-  const normalizedCandidateValue = normalizeComparableText(candidateValue);
-  if (!normalizedQueryValue || !normalizedCandidateValue) return null;
-  if (normalizedQueryValue !== normalizedCandidateValue) return null;
-
-  return {
-    fieldId: field.fieldId,
-    label: field.label,
-    matchType: 'exact',
-    queryValue: normalizeText(queryValue, ''),
-    candidateValue: normalizeText(candidateValue, ''),
-    sharedValues: [],
-    contribution: weights.exact,
-  };
-}
-
-function projectSummaryField(field, profile = {}) {
-  const value = profile[field.fieldId];
-  if (isEmptyValue(value)) return null;
-
-  return {
-    fieldId: field.fieldId,
-    label: field.label,
-    value: Array.isArray(value) ? value : normalizeText(value, null),
-  };
-}
-
-function projectProfileSummary(world, profile = {}, agent = null) {
-  return {
-    displayName: normalizeText(agent?.displayName, null),
-    headline: normalizeText(profile.participantContextText, normalizeText(profile.headline, null)),
-    requiredFields: world.joinSchema.requiredFields
-      .map((field) => projectSummaryField(field, profile))
-      .filter(Boolean),
-    optionalFields: world.joinSchema.optionalFields
-      .map((field) => projectSummaryField(field, profile))
-      .filter(Boolean),
-  };
-}
-
-function resolveSearchResultAgentId(item = {}, fallback = null) {
-  return normalizeText(item.agentId, normalizeText(item.playerId, fallback));
-}
-
-function compareSearchResults(left, right) {
-  if (right.score !== left.score) return right.score - left.score;
-  if (right.matchedFieldIds.length !== left.matchedFieldIds.length) {
-    return right.matchedFieldIds.length - left.matchedFieldIds.length;
-  }
-  if (left.joinedAt !== right.joinedAt) {
-    return String(left.joinedAt).localeCompare(String(right.joinedAt));
-  }
-  return String(resolveSearchResultAgentId(left, '')).localeCompare(String(resolveSearchResultAgentId(right, '')));
-}
-
-function compareRecentFallbackResults(left, right) {
-  if (left.lastHeartbeatAt !== right.lastHeartbeatAt) {
-    return String(right.lastHeartbeatAt || '').localeCompare(String(left.lastHeartbeatAt || ''));
-  }
-  if (left.joinedAt !== right.joinedAt) {
-    return String(right.joinedAt || '').localeCompare(String(left.joinedAt || ''));
-  }
-  return String(resolveSearchResultAgentId(left, '')).localeCompare(String(resolveSearchResultAgentId(right, '')));
-}
-
-function summarizeMatchedFields(matchedFields = []) {
-  if (matchedFields.length === 0) {
-    return 'Recently active online world member with no direct profile overlap in the current query.';
-  }
-
-  return `Matched on ${matchedFields.map((field) => field.label).join(', ')}.`;
-}
-
-export function createWorldSearchService({
-  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);
-  }
-
-  function buildViewerContext(world, membershipStore, normalizedAgentId) {
-    const viewerAgent = membershipStore.getAgent(normalizedAgentId);
-    if (!viewerAgent) {
-      throw createAgentNotFoundError(normalizedAgentId);
-    }
-
-    const authorization = worldAuthorizationService.evaluateWorldAction({
-      worldId: world.worldId,
-      actorAgentId: normalizedAgentId,
-      action: WORLD_ACTIONS.SEARCH,
-    });
-
-    if (!authorization.allowed || authorization.membership?.status !== 'active') {
-      throw createSearchMembershipNotActiveError(world.worldId, normalizedAgentId);
-    }
-
-    return {
-      viewerAgent,
-      viewerMembership: authorization.membership,
-    };
-  }
-
-  return {
-    describeSearch(worldId) {
-      const world = worldService.requireWorld(worldId);
-      return projectSearchModel(world);
-    },
-    searchWorld({ worldId, agentId, query = {}, limit = null } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const membershipStore = assertStore();
-      const normalizedAgentId = normalizeAgentId(agentId);
-      if (!normalizedAgentId) {
-        throw createInvalidSearchRequestError('agentId');
-      }
-
-      const { viewerAgent, viewerMembership } = buildViewerContext(world, membershipStore, normalizedAgentId);
-      const searchInput = normalizeQuery(world, query, viewerMembership.profileSnapshot || viewerAgent.profile || {});
-      const normalizedLimit = normalizeSearchLimit(limit, world.searchSchema.defaultLimit);
-      const onlineOnly = world.searchSchema.onlineOnly;
-      const activeMemberships = membershipStore.listMemberships({
-        worldId: world.worldId,
-        status: 'active',
-      });
-
-      const items = activeMemberships
-        .filter((membership) => membership.agentId !== normalizedAgentId)
-        .map((membership) => {
-          const candidateAgent = membershipStore.getAgent(membership.agentId);
-          if (!candidateAgent) return null;
-
-          const presenceState = resolvePresence(candidateAgent.agentId);
-          if (onlineOnly && presenceState.online !== true) return null;
-
-          const matchedFields = world.searchSchema.inputFields
-            .map((field) => compareField(
-              field,
-              searchInput[field.fieldId],
-              membership.profileSnapshot?.[field.fieldId],
-              world.worldId,
-            ))
-            .filter(Boolean);
-
-          return {
-            agentId: candidateAgent.agentId,
-            playerId: candidateAgent.agentId,
-            membershipId: membership.membershipId,
-            worldId: world.worldId,
-            displayName: normalizeText(candidateAgent.displayName, candidateAgent.agentId),
-            headline: normalizeText(membership.profileSnapshot?.headline, null),
-            online: presenceState.online === true,
-            connectedAt: presenceState.connectedAt,
-            lastHeartbeatAt: presenceState.lastHeartbeatAt,
-            score: matchedFields.reduce((sum, field) => sum + field.contribution, 0),
-            matchedFieldIds: matchedFields.map((field) => field.fieldId),
-            matchedFields,
-            resultType: matchedFields.length > 0 ? 'matched' : 'fallback',
-            reasonSummary: summarizeMatchedFields(matchedFields),
-            joinedAt: membership.joinedAt,
-            profileSummary: projectProfileSummary(world, membership.profileSnapshot || {}, candidateAgent),
-            worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
-              worldId: world.worldId,
-              agentId: candidateAgent.agentId,
-            }) || {
-              likesReceived: 0,
-              dislikesReceived: 0,
-            },
-          };
-        })
-        .filter(Boolean);
-
-      const matchedItems = items
-        .filter((item) => item.resultType === 'matched')
-        .sort(compareSearchResults);
-      const fallbackItems = items
-        .filter((item) => item.resultType === 'fallback')
-        .sort(compareRecentFallbackResults);
-      const orderedItems = [...matchedItems, ...fallbackItems];
-
-      return {
-        worldId: world.worldId,
-        agentId: normalizedAgentId,
-        viewerMembershipId: viewerMembership.membershipId,
-        searchModel: projectSearchModel(world),
-        searchInput,
-        onlineOnly,
-        candidateSource: onlineOnly ? 'active_memberships_online' : 'active_memberships',
-        limit: normalizedLimit,
-        totalMatches: orderedItems.length,
-        items: orderedItems.slice(0, normalizedLimit),
-        nextAction: orderedItems.length > 0 ? 'request_chat_with_selected_candidate' : 'broaden_search_or_wait',
-        status: orderedItems.length > 0 ? 'search_ready' : 'no_matches',
-      };
-    },
-    searchPlayers(options = {}) {
-      return this.searchWorld(options);
-    },
-  };
-}