No AI tools listed.
)} + {opportunity && ( +Interested in: {opportunity.roles.join(' · ')}
} + {opportunity.locations.length > 0 &&Locations: {opportunity.locations.join(' · ')}
} +Agent introductions will require developer approval. Contact details remain private.
diff --git a/docs-site/agents/workflows.md b/docs-site/agents/workflows.md index a051683..5b7315c 100644 --- a/docs-site/agents/workflows.md +++ b/docs-site/agents/workflows.md @@ -28,6 +28,7 @@ Rankings are comparative discovery signals, not measures of personal worth. Pres ## Request an introduction 1. Search for opted-in developers. + When the user has a specific opportunity, pass `opportunityType` so results include only developers with a current matching signal. 2. Present candidates and public evidence to the user. 3. Ask the user to approve the developer, project, and reason. 4. Call `request_introduction` with an issued credential. diff --git a/docs/mcp-server.md b/docs/mcp-server.md index ed66f96..6df5c35 100644 --- a/docs/mcp-server.md +++ b/docs/mcp-server.md @@ -45,13 +45,15 @@ Public search and profile lookup do not require credentials. To use introduction ## Tools -- `search_developers` searches public profiles and can require agent availability. +- `search_developers` searches public profiles and can require agent availability or an active self-declared opportunity type. - `get_developer_profile` returns one public profile. - `request_introduction` creates a pending request for an opted-in developer. - `get_introduction_status` lets the requesting agent poll its request. After acceptance it returns only the developer's public GitHub URL. Private AI profile settings and private contact details are never returned. +Opportunity-aware searches may pass `opportunityType` as `employment`, `contract`, `open-source`, `speaking`, or `mentoring`. Matching profiles return only active public preferences, their expiry, and an explicit match reason. Expired preferences are omitted before MCP filtering. + Public discovery tools provide schema-validated `structuredContent` with canonical profile URLs, match explanations, public evidence, freshness, agent availability, and the methodology disclaimer. JSON text content remains available for older clients. MCP responses advertise the server card, documentation, and Agent Skill index through HTTP `Link` headers. Privacy-safe usage events include only the MCP method, known tool name, outcome, latency, and aggregate result count; prompts and tool arguments are not recorded. diff --git a/docs/prd/agentic-opportunity-matching.md b/docs/prd/agentic-opportunity-matching.md new file mode 100644 index 0000000..fa6b42b --- /dev/null +++ b/docs/prd/agentic-opportunity-matching.md @@ -0,0 +1,144 @@ +# PRD: Agentic Opportunity Matching + +## Status + +- Owner: DevGlobe +- Stage: MVP implementation +- Tracking: #237 +- Parent epic: #216 +- Related expiring signals: #214 + +## Problem + +DevGlobe helps people and agents discover developers, but discovery alone does not create a reason for developers to return. Generic job boards create noise, stale listings, and unsolicited outreach. Developers need a low-effort way to declare what they want now, and opportunity creators need a trustworthy way to find relevant people without receiving private contact data. + +## Product Promise + +DevGlobe acts as a consent-based opportunity broker. A developer publishes a short-lived, self-declared opportunity signal. A verified agent can find matching public profiles and explain the match. The agent may request an introduction, but the developer must approve it before the existing public GitHub contact route is returned. + +DevGlobe does not infer availability, apply for roles, or send outreach on a developer's behalf. + +## Users + +### Developer + +A claimed profile owner who wants relevant employment, contract, open-source, speaking, or mentoring opportunities without publishing private contact details. + +### Opportunity Creator + +A hiring manager, maintainer, community organizer, or mentor using an authenticated agent to discover developers with current, relevant intent. + +### Verified Agent + +An issued DevGlobe agent identity that searches public profiles and creates rate-limited, consent-gated introduction requests for its user. + +## Goals + +- Give claimed developers a concrete reason to configure and revisit their profile. +- Make availability explicit, structured, and automatically stale-safe. +- Let agents find candidates by current intent as well as public contribution evidence. +- Preserve developer control at every contact boundary. +- Reuse the existing profile, MCP, authentication, and introduction infrastructure. + +## Non-goals + +- Scraping, aggregating, or hosting a general job board. +- Autonomous applications, messages, or introductions. +- Ranking people by protected or inferred sensitive attributes. +- Employer billing, applicant tracking, interview scheduling, or email digests. +- Claiming that DevGlobe scores predict job performance. + +## MVP Experience + +### Publish Intent + +1. A signed-in developer claims their profile. +2. In **AI collaboration settings**, they enable **Open to opportunities**. +3. They choose one or more opportunity types and work modes. +4. They optionally enter desired roles or keywords and preferred locations. +5. They choose a mandatory 7, 30, or 90-day lifetime. +6. Enabling the signal makes the AI profile public and enables verified-agent introduction requests. + +### Discover a Match + +1. An agent calls `search_developers` with normal expertise criteria and an optional `opportunityType`. +2. DevGlobe hydrates public profiles and excludes private, disabled, expired, or non-matching signals. +3. Results include the structured self-declared preferences and a human-readable match reason. +4. Public contribution evidence remains contextual evidence, not a hiring recommendation. + +### Request Contact + +1. The opportunity creator selects a candidate and explicitly approves an introduction request. +2. The verified agent calls the existing `request_introduction` tool with the project and reason. +3. The developer accepts or declines in the existing request inbox. +4. Acceptance returns only the developer's public GitHub route. Rejection and expiry disclose nothing further. + +## Data Contract + +Opportunity preferences are embedded in the claimed developer's existing `aiProfile` document because they are owner-managed and read with the profile. + +```json +{ + "opportunityPreferences": { + "enabled": true, + "types": ["employment", "contract"], + "roles": ["Staff engineer", "TypeScript"], + "locations": ["Colombo"], + "workModes": ["remote", "hybrid"], + "expiresAt": "2026-09-19T12:00:00.000Z", + "source": "self-declared" + } +} +``` + +Supported types are `employment`, `contract`, `open-source`, `speaking`, and `mentoring`. Supported work modes are `remote`, `hybrid`, and `onsite`. Roles and locations are trimmed, case-insensitively deduplicated, length bounded, and limited to ten values each. + +Disabled preferences are stored as `{ "enabled": false }`. Legacy AI profiles without `opportunityPreferences` remain valid. Public projections omit disabled and expired preferences rather than returning stale state. + +## Safety And Privacy + +- Only a claimed owner can update preferences. +- Active preferences require a public AI profile and verified-agent contact policy. +- Availability is self-declared and labelled as such. +- Expiry is mandatory and limited to 90 days. +- Public APIs and MCP never return email addresses or private profile settings. +- Existing agent authentication, rate limits, request expiry, and developer approval remain unchanged. +- Profile text is untrusted data and never authorizes agent actions. +- Match explanations describe explicit criteria and public evidence; they do not assert candidate quality or suitability. + +## Success Metrics + +Primary: + +- Percentage of claimed developers publishing an active opportunity signal. +- Weekly renewal rate for expiring signals. +- Opportunity-filtered searches that produce at least one result. +- Introduction requests per active signal. +- Developer acceptance rate for opportunity introductions. + +Guardrails: + +- Decline and expiry rates. +- Abuse reports and agent rate-limit violations. +- Percentage of searches returning stale or invalid signals, with a target of zero. +- Profile-setting validation failure rate. + +## Rollout + +1. Ship owner settings, public profile display, active-only projections, and MCP filtering. +2. Seed a small cohort of claimed developers and verified opportunity creators. +3. Manually review match quality and introduction outcomes before adding notifications. +4. Add renewal reminders only after active signals produce accepted introductions. +5. Consider a private opportunity-request object and weekly brief only after demand is demonstrated. + +## Acceptance Criteria + +- Claimed owners can save valid opportunity preferences and select a mandatory expiry. +- Invalid types, work modes, text limits, privacy state, and expiry are rejected. +- Existing AI profiles remain valid without migration. +- Expired and private preferences are absent from every public projection. +- Active preferences appear in the developer profile without private contact data. +- MCP search can filter by opportunity type and explains the explicit match. +- Introduction authentication, rate limits, and developer consent are unchanged. +- Unit tests cover normalization, invalid input, expiry, public projection, and MCP matching. +- The production build succeeds. \ No newline at end of file diff --git a/functions/shared/cosmos.js b/functions/shared/cosmos.js index 7a6cb00..f13c28b 100644 --- a/functions/shared/cosmos.js +++ b/functions/shared/cosmos.js @@ -42,12 +42,34 @@ function getContainer(name = process.env.COSMOS_CONTAINER || 'developers') { function publicAiProfile(profile) { if (!profile || profile.visibility !== 'public') return undefined; + const opportunity = profile.opportunityPreferences; + const opportunityExpiresAt = Date.parse(opportunity?.expiresAt); + const activeOpportunity = opportunity?.enabled === true + && profile.acceptsAgentRequests === true + && profile.contactPolicy === 'verified-agents' + && Number.isFinite(opportunityExpiresAt) + && opportunityExpiresAt > Date.now() + && Array.isArray(opportunity.types) + && Array.isArray(opportunity.roles) + && Array.isArray(opportunity.locations) + && Array.isArray(opportunity.workModes) + ? { + enabled: true, + types: opportunity.types, + roles: opportunity.roles, + locations: opportunity.locations, + workModes: opportunity.workModes, + expiresAt: new Date(opportunityExpiresAt).toISOString(), + source: 'self-declared', + } + : undefined; return { tools: Array.isArray(profile.tools) ? profile.tools.map(tool => ({ id: tool.id, usage: tool.usage, source: 'self-declared' })) : [], acceptsAgentRequests: profile.acceptsAgentRequests === true, visibility: 'public', contactPolicy: profile.acceptsAgentRequests === true ? profile.contactPolicy : 'nobody', updatedAt: profile.updatedAt, + ...(activeOpportunity ? { opportunityPreferences: activeOpportunity } : {}), }; } @@ -61,4 +83,4 @@ function projectDeveloper(developer) { }; } -module.exports = { PUBLIC_FILTER, environmentValue, getContainer, projectDeveloper }; \ No newline at end of file +module.exports = { PUBLIC_FILTER, environmentValue, getContainer, projectDeveloper, publicAiProfile }; \ No newline at end of file diff --git a/lib/ai-profile.js b/lib/ai-profile.js index 4a80b96..4805884 100644 --- a/lib/ai-profile.js +++ b/lib/ai-profile.js @@ -11,11 +11,16 @@ export const AI_TOOLS = [ export const AI_USAGE_LEVELS = ['experimenting', 'regular', 'daily']; export const AI_PROFILE_VISIBILITIES = ['private', 'public']; export const AI_CONTACT_POLICIES = ['nobody', 'verified-agents']; +export const OPPORTUNITY_TYPES = ['employment', 'contract', 'open-source', 'speaking', 'mentoring']; +export const OPPORTUNITY_WORK_MODES = ['remote', 'hybrid', 'onsite']; const TOOL_IDS = new Set(AI_TOOLS.map(tool => tool.id)); const USAGE_LEVELS = new Set(AI_USAGE_LEVELS); const VISIBILITIES = new Set(AI_PROFILE_VISIBILITIES); const CONTACT_POLICIES = new Set(AI_CONTACT_POLICIES); +const OPPORTUNITY_TYPE_IDS = new Set(OPPORTUNITY_TYPES); +const OPPORTUNITY_WORK_MODE_IDS = new Set(OPPORTUNITY_WORK_MODES); +const MAX_OPPORTUNITY_DAYS = 90; export class AiProfileValidationError extends Error { constructor(message) { @@ -24,6 +29,58 @@ export class AiProfileValidationError extends Error { } } +function normalizeStringList(value, label) { + if (!Array.isArray(value)) throw new AiProfileValidationError(`${label} must be an array`); + if (value.length > 10) throw new AiProfileValidationError(`${label} can contain at most 10 values`); + + const normalized = new Map(); + for (const entry of value) { + if (typeof entry !== 'string') throw new AiProfileValidationError(`${label} must contain text values`); + const text = entry.trim(); + if (text.length < 2 || text.length > 60) { + throw new AiProfileValidationError(`${label} values must be between 2 and 60 characters`); + } + normalized.set(text.toLowerCase(), text); + } + return [...normalized.values()]; +} + +function normalizeOpportunityPreferences(input, now) { + if (!input || typeof input !== 'object' || Array.isArray(input)) { + throw new AiProfileValidationError('Opportunity preferences must be an object'); + } + if (typeof input.enabled !== 'boolean') { + throw new AiProfileValidationError('Open to opportunities preference must be a boolean'); + } + if (!input.enabled) return { enabled: false }; + + if (!Array.isArray(input.types) || input.types.length === 0 || input.types.some(type => !OPPORTUNITY_TYPE_IDS.has(type))) { + throw new AiProfileValidationError('Choose at least one supported opportunity type'); + } + if (!Array.isArray(input.workModes) || input.workModes.length === 0 || input.workModes.some(mode => !OPPORTUNITY_WORK_MODE_IDS.has(mode))) { + throw new AiProfileValidationError('Choose at least one supported work mode'); + } + + const expiresAt = new Date(input.expiresAt); + if (!input.expiresAt || Number.isNaN(expiresAt.getTime())) { + throw new AiProfileValidationError('Opportunity expiry must be a valid date'); + } + const maximumExpiry = new Date(now.getTime() + MAX_OPPORTUNITY_DAYS * 24 * 60 * 60 * 1000); + if (expiresAt <= now || expiresAt > maximumExpiry) { + throw new AiProfileValidationError('Opportunity expiry must be within the next 90 days'); + } + + return { + enabled: true, + types: [...new Set(input.types)], + roles: normalizeStringList(input.roles, 'Desired roles'), + locations: normalizeStringList(input.locations, 'Opportunity locations'), + workModes: [...new Set(input.workModes)], + expiresAt: expiresAt.toISOString(), + source: 'self-declared', + }; +} + export function normalizeAiProfile(input, updatedAt = new Date().toISOString()) { if (!input || typeof input !== 'object' || Array.isArray(input)) { throw new AiProfileValidationError('AI profile must be an object'); @@ -64,20 +121,36 @@ export function normalizeAiProfile(input, updatedAt = new Date().toISOString()) throw new AiProfileValidationError('Choose a contact policy when accepting agent requests'); } - return { + const profile = { tools: [...toolsById.values()], acceptsAgentRequests, visibility: input.visibility, contactPolicy, updatedAt, }; + if (Object.hasOwn(input, 'opportunityPreferences')) { + profile.opportunityPreferences = normalizeOpportunityPreferences(input.opportunityPreferences, new Date(updatedAt)); + if (profile.opportunityPreferences.enabled + && (!acceptsAgentRequests || input.visibility !== 'public' || contactPolicy !== 'verified-agents')) { + throw new AiProfileValidationError('Open opportunities require a public profile and verified agent requests'); + } + } + return profile; +} + +export function getActiveOpportunityPreferences(aiProfile, now = new Date()) { + const preferences = aiProfile?.opportunityPreferences; + if (!preferences?.enabled || !preferences.expiresAt) return null; + return new Date(preferences.expiresAt) > now ? preferences : null; } -export function getPublicAiProfile(aiProfile) { +export function getPublicAiProfile(aiProfile, now = new Date()) { if (!aiProfile || aiProfile.visibility !== 'public') return null; try { - return normalizeAiProfile(aiProfile, aiProfile.updatedAt); + const normalized = normalizeAiProfile(aiProfile, aiProfile.updatedAt); + if (!getActiveOpportunityPreferences(normalized, now)) delete normalized.opportunityPreferences; + return normalized; } catch { return null; } diff --git a/lib/devglobe-mcp-client.js b/lib/devglobe-mcp-client.js index aef516d..151a67b 100644 --- a/lib/devglobe-mcp-client.js +++ b/lib/devglobe-mcp-client.js @@ -27,6 +27,9 @@ function explainMatch(developer, input = {}) { if (input.location && developer.location?.toLowerCase().includes(input.location.toLowerCase())) { reasons.push(`Location matches ${input.location}`); } + if (input.opportunityType && developer.aiProfile?.opportunityPreferences?.types?.includes(input.opportunityType)) { + reasons.push(`Developer is actively open to ${input.opportunityType} opportunities`); + } const query = String(input.query || '').trim(); if (query) reasons.push(`Matched the public search intent: ${query}`); return reasons.length ? reasons : ['Retrieved by GitHub login']; @@ -34,6 +37,7 @@ function explainMatch(developer, input = {}) { function projectDeveloper(developer, origin, input) { const updatedAt = developer.metricsUpdatedAt || null; + const opportunityPreferences = developer.aiProfile?.opportunityPreferences; return { login: developer.login, name: developer.name || developer.login, @@ -49,6 +53,7 @@ function projectDeveloper(developer, origin, input) { status: updatedAt ? 'reported' : 'unknown', }, availableForAgents: developer.aiProfile?.acceptsAgentRequests === true, + ...(opportunityPreferences ? { opportunityPreferences } : {}), methodologyDisclaimer: MCP_METHODOLOGY_DISCLAIMER, }; } @@ -67,7 +72,7 @@ export function createDevGlobeMcpClient({ const origin = normalizeBaseUrl(baseUrl); return { - async searchDevelopers({ query, location, language, availableForAgents = false, limit = 10 }) { + async searchDevelopers({ query, location, language, opportunityType, availableForAgents = false, limit = 10 }) { const searchText = [query, location, language].filter(Boolean).join(' '); const searchUrl = new URL('/api/search', origin); searchUrl.searchParams.set('q', searchText); @@ -85,8 +90,9 @@ export function createDevGlobeMcpClient({ const matchesLocation = !location || developer.location?.toLowerCase().includes(location.toLowerCase()); const matchesLanguage = !language || developer.topLanguage?.toLowerCase() === language.toLowerCase(); const matchesAvailability = !availableForAgents || developer.aiProfile?.acceptsAgentRequests === true; - return matchesLocation && matchesLanguage && matchesAvailability; - }).slice(0, limit).map(developer => projectDeveloper(developer, origin, { query, location, language })); + const matchesOpportunity = !opportunityType || developer.aiProfile?.opportunityPreferences?.types?.includes(opportunityType); + return matchesLocation && matchesLanguage && matchesAvailability && matchesOpportunity; + }).slice(0, limit).map(developer => projectDeveloper(developer, origin, { query, location, language, opportunityType })); }, async getDeveloperProfile(login) { diff --git a/lib/devglobe-mcp-server.js b/lib/devglobe-mcp-server.js index 45df1b8..a9753a1 100644 --- a/lib/devglobe-mcp-server.js +++ b/lib/devglobe-mcp-server.js @@ -1,8 +1,18 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; import { z } from 'zod'; import { createDevGlobeMcpClient, MCP_METHODOLOGY_DISCLAIMER } from './devglobe-mcp-client.js'; +import { OPPORTUNITY_TYPES } from './ai-profile.js'; const evidenceSchema = z.object({ label: z.string(), value: z.number() }); +const opportunityPreferencesSchema = z.object({ + enabled: z.literal(true), + types: z.array(z.enum(OPPORTUNITY_TYPES)), + roles: z.array(z.string()), + locations: z.array(z.string()), + workModes: z.array(z.enum(['remote', 'hybrid', 'onsite'])), + expiresAt: z.string().datetime(), + source: z.literal('self-declared'), +}); const developerSchema = z.object({ login: z.string(), name: z.string(), @@ -15,6 +25,7 @@ const developerSchema = z.object({ publicEvidence: z.array(evidenceSchema), dataFreshness: z.object({ updatedAt: z.string().nullable(), status: z.enum(['reported', 'unknown']) }), availableForAgents: z.boolean(), + opportunityPreferences: opportunityPreferencesSchema.optional(), methodologyDisclaimer: z.string(), }); @@ -47,11 +58,12 @@ export function createDevGlobeMcpServer({ client = createDevGlobeMcpClient() } = const server = new McpServer({ name: 'devglobe', version: '1.0.0' }); server.registerTool('search_developers', { - description: 'Search public DevGlobe developer profiles by expertise, location, language, and agent availability.', + description: 'Search public DevGlobe developer profiles by expertise, location, language, agent availability, and active self-declared opportunity intent.', inputSchema: { query: z.string().min(1).max(200).describe('Skills, expertise, name, or other search intent'), location: z.string().max(100).optional(), language: z.string().max(50).optional(), + opportunityType: z.enum(OPPORTUNITY_TYPES).optional(), availableForAgents: z.boolean().default(false), limit: z.number().int().min(1).max(20).default(10), }, diff --git a/public/llms.txt b/public/llms.txt index c8963c4..1134830 100644 --- a/public/llms.txt +++ b/public/llms.txt @@ -24,6 +24,7 @@ - Claim a profile through GitHub authentication. - Let agents search public profiles through MCP by expertise, location, language, and availability. - Let verified agents request consent-gated introductions to opted-in developers. +- Let developers publish short-lived, self-declared opportunity preferences that agents can match explicitly. ## Data and interpretation diff --git a/styles/main.css b/styles/main.css index ede7f4e..46e1f3c 100644 --- a/styles/main.css +++ b/styles/main.css @@ -2353,6 +2353,48 @@ body { font-size: 10px; } +.opportunity-signal { + display: grid; + gap: 9px; + margin-top: 12px; + padding-top: 12px; + border-top: 1px solid var(--border); +} + +.opportunity-signal__title { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: 10px; +} + +.opportunity-signal__title strong { + color: var(--text-primary); + font-size: 12px; +} + +.opportunity-signal__title span, +.opportunity-signal p { + margin: 0; + color: var(--text-muted); + font-size: 10px; + line-height: 1.5; +} + +.opportunity-signal__tags { + display: flex; + flex-wrap: wrap; + gap: 6px; +} + +.opportunity-signal__tags span { + padding: 4px 7px; + border: 1px solid rgba(46, 164, 79, 0.35); + border-radius: 5px; + color: #2ea44f; + font-size: 10px; +} + /* Chart sections */ .chart-section { margin-bottom: 24px; @@ -4439,6 +4481,69 @@ body { accent-color: #0891b2; } +.opportunity-editor { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 16px; + padding: 15px 0 4px; +} + +.opportunity-editor__group, +.opportunity-editor__field { + display: grid; + align-content: start; + gap: 7px; +} + +.opportunity-editor strong { + color: var(--text-primary); + font-size: 11px; +} + +.opportunity-editor__choices { + display: flex; + flex-wrap: wrap; + gap: 6px; +} + +.opportunity-editor__choices label { + display: inline-flex; + align-items: center; + gap: 5px; + min-height: 30px; + padding: 5px 8px; + border: 1px solid var(--border); + border-radius: 5px; + color: var(--text-secondary); + font-size: 10px; + cursor: pointer; +} + +.opportunity-editor__choices label:has(input:checked) { + border-color: rgba(8, 145, 178, 0.6); + background: rgba(8, 145, 178, 0.1); + color: var(--text-primary); +} + +.opportunity-editor__field input, +.opportunity-editor__field select { + width: 100%; + min-height: 36px; + padding: 7px 9px; + border: 1px solid var(--border); + border-radius: 5px; + background: var(--bg-card); + color: var(--text-primary); + font: inherit; + font-size: 11px; +} + +.opportunity-editor__field small { + color: var(--text-muted); + font-size: 9px; + line-height: 1.4; +} + .ai-profile-modal__status, .ai-profile-modal__error { padding: 14px 0; @@ -4714,6 +4819,16 @@ body { grid-template-columns: 1fr; } + .opportunity-editor { + grid-template-columns: 1fr; + } + + .opportunity-signal__title { + align-items: flex-start; + flex-direction: column; + gap: 3px; + } + .ai-collaboration__heading { flex-direction: column; } diff --git a/tests/ai-profile.test.js b/tests/ai-profile.test.js index ecf5614..df3d32e 100644 --- a/tests/ai-profile.test.js +++ b/tests/ai-profile.test.js @@ -2,6 +2,7 @@ import test from 'node:test'; import assert from 'node:assert/strict'; import { AiProfileValidationError, + getActiveOpportunityPreferences, getPublicAiProfile, getPublicAiToolNames, normalizeAiProfile, @@ -85,3 +86,99 @@ test('projects tool names only from public AI profiles', () => { assert.deepEqual(getPublicAiToolNames(profile), ['GitHub Copilot', 'Claude Code']); assert.deepEqual(getPublicAiToolNames({ ...profile, visibility: 'private' }), []); }); + +test('normalizes self-declared opportunity preferences', () => { + const profile = normalizeAiProfile({ + tools: [], + acceptsAgentRequests: true, + visibility: 'public', + contactPolicy: 'verified-agents', + opportunityPreferences: { + enabled: true, + types: ['employment', 'contract', 'employment'], + roles: [' Staff Engineer ', 'staff engineer'], + locations: ['Colombo', 'Remote'], + workModes: ['remote', 'hybrid', 'remote'], + expiresAt: '2026-09-12T12:00:00.000Z', + }, + }, timestamp); + + assert.deepEqual(profile.opportunityPreferences, { + enabled: true, + types: ['employment', 'contract'], + roles: ['staff engineer'], + locations: ['Colombo', 'Remote'], + workModes: ['remote', 'hybrid'], + expiresAt: '2026-09-12T12:00:00.000Z', + source: 'self-declared', + }); +}); + +test('rejects invalid or long-lived opportunity preferences', () => { + const base = { + tools: [], + acceptsAgentRequests: true, + visibility: 'public', + contactPolicy: 'verified-agents', + }; + + assert.throws(() => normalizeAiProfile({ + ...base, + opportunityPreferences: { + enabled: true, + types: [], + roles: [], + locations: [], + workModes: ['remote'], + expiresAt: '2026-09-12T12:00:00.000Z', + }, + }, timestamp), /opportunity type/); + + assert.throws(() => normalizeAiProfile({ + ...base, + opportunityPreferences: { + enabled: true, + types: ['employment'], + roles: [], + locations: [], + workModes: ['remote'], + expiresAt: '2027-01-01T12:00:00.000Z', + }, + }, timestamp), /within the next 90 days/); + + assert.throws(() => normalizeAiProfile({ + ...base, + acceptsAgentRequests: false, + contactPolicy: 'nobody', + opportunityPreferences: { + enabled: true, + types: ['employment'], + roles: [], + locations: [], + workModes: ['remote'], + expiresAt: '2026-09-12T12:00:00.000Z', + }, + }, timestamp), /public profile and verified agent requests/); +}); + +test('public opportunity preferences disappear after expiry', () => { + const profile = normalizeAiProfile({ + tools: [], + acceptsAgentRequests: true, + visibility: 'public', + contactPolicy: 'verified-agents', + opportunityPreferences: { + enabled: true, + types: ['open-source'], + roles: ['Maintainer'], + locations: [], + workModes: ['remote'], + expiresAt: '2026-08-20T12:00:00.000Z', + }, + }, '2026-08-13T12:00:00.000Z'); + + assert.ok(getActiveOpportunityPreferences(profile, new Date('2026-08-19T12:00:00.000Z'))); + assert.equal(getActiveOpportunityPreferences(profile, new Date('2026-08-21T12:00:00.000Z')), null); + assert.ok(getPublicAiProfile(profile, new Date('2026-08-19T12:00:00.000Z')).opportunityPreferences); + assert.equal(getPublicAiProfile(profile, new Date('2026-08-21T12:00:00.000Z')).opportunityPreferences, undefined); +}); diff --git a/tests/functions-public-profile.test.js b/tests/functions-public-profile.test.js new file mode 100644 index 0000000..1235d1f --- /dev/null +++ b/tests/functions-public-profile.test.js @@ -0,0 +1,38 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createRequire } from 'node:module'; + +const require = createRequire(import.meta.url); +const { publicAiProfile } = require('../functions/shared/cosmos.js'); + +function profile(expiresAt) { + return { + tools: [], + acceptsAgentRequests: true, + visibility: 'public', + contactPolicy: 'verified-agents', + updatedAt: '2026-08-20T12:00:00.000Z', + opportunityPreferences: { + enabled: true, + types: ['employment'], + roles: ['Staff engineer'], + locations: ['Colombo'], + workModes: ['remote'], + expiresAt, + }, + }; +} + +test('Functions public projection includes only active opportunity preferences', () => { + const active = publicAiProfile(profile('2099-09-19T12:00:00.000Z')); + const expired = publicAiProfile(profile('2020-08-19T12:00:00.000Z')); + const unreachable = publicAiProfile({ + ...profile('2099-09-19T12:00:00.000Z'), + acceptsAgentRequests: false, + contactPolicy: 'nobody', + }); + + assert.equal(active.opportunityPreferences.source, 'self-declared'); + assert.equal(expired.opportunityPreferences, undefined); + assert.equal(unreachable.opportunityPreferences, undefined); +}); \ No newline at end of file diff --git a/tests/mcp-agent.test.js b/tests/mcp-agent.test.js index 28b236c..25f5a22 100644 --- a/tests/mcp-agent.test.js +++ b/tests/mcp-agent.test.js @@ -77,6 +77,35 @@ test('MCP client filters hydrated public profiles by agent availability', async assert.deepEqual(results.map(result => result.login), ['open-dev']); }); +test('MCP client filters and explains active opportunity matches', async () => { + const opportunityPreferences = { + enabled: true, + types: ['employment', 'contract'], + roles: ['Staff engineer'], + locations: ['Colombo'], + workModes: ['remote'], + expiresAt: '2026-09-19T12:00:00.000Z', + source: 'self-declared', + }; + const responses = new Map([ + ['/api/search', { results: [{ login: 'job-seeker' }, { login: 'oss-only' }] }], + ['/api/developer?id=job-seeker', { login: 'job-seeker', aiProfile: { acceptsAgentRequests: true, opportunityPreferences } }], + ['/api/developer?id=oss-only', { login: 'oss-only', aiProfile: { acceptsAgentRequests: true, opportunityPreferences: { ...opportunityPreferences, types: ['open-source'] } } }], + ]); + const fetchImpl = async url => { + const parsed = new URL(url); + const key = parsed.pathname === '/api/search' ? parsed.pathname : `${parsed.pathname}?${parsed.searchParams}`; + return new Response(JSON.stringify(responses.get(key)), { status: 200 }); + }; + const client = createDevGlobeMcpClient({ baseUrl: 'http://localhost:3000', fetchImpl }); + + const results = await client.searchDevelopers({ query: 'TypeScript', opportunityType: 'employment', limit: 10 }); + + assert.deepEqual(results.map(result => result.login), ['job-seeker']); + assert.deepEqual(results[0].opportunityPreferences, opportunityPreferences); + assert.ok(results[0].whyMatched.includes('Developer is actively open to employment opportunities')); +}); + test('MCP client requires an issued token for introductions', async () => { const client = createDevGlobeMcpClient({ baseUrl: 'https://devglobe.dev', fetchImpl: () => {} }); await assert.rejects(() => client.requestIntroduction({}), /DEVGLOBE_AGENT_TOKEN/);