@shnitzel/plugscout 0.3.1

package/dist/catalog/adapters/claude-connectors-scrape-v1.js

@@ -0,0 +1,107 @@
+import { dedupe, sanitizeUrl, slugify, stripHtml } from './shared.js';
+const TRUSTED_HOSTS = ['claude.com', 'www.claude.com', 'anthropic.com', 'www.anthropic.com'];
+const CONNECTOR_PATH_PATTERN = /(?:https:\/\/claude\.com)?\/connectors\/([a-z0-9-]+)/gi;
+export function adaptClaudeConnectorsScrapeEntries(sourceId, entries) {
+    const html = entries.find((entry) => typeof entry === 'string');
+    if (typeof html !== 'string' || html.trim().length === 0) {
+        return [];
+    }
+    const connectorSlugs = collectConnectorSlugs(html);
+    const mapped = [];
+    const seen = new Set();
+    for (const slug of connectorSlugs) {
+        const id = `claude-connector:${slug}`;
+        if (seen.has(id)) {
+            continue;
+        }
+        const snippet = extractAnchorSnippet(html, slug);
+        const label = stripHtml(snippet, 120);
+        const name = titleizeSlug(label.length >= 3 ? label : slug);
+        const link = sanitizeUrl(`https://claude.com/connectors/${slug}`, TRUSTED_HOSTS);
+        if (!link) {
+            continue;
+        }
+        seen.add(id);
+        mapped.push({
+            id,
+            kind: 'claude-connector',
+            provider: 'anthropic',
+            name: sanitizeText(name, 120),
+            description: sanitizeText(`Connector listed on Claude Connectors for ${name}. Verify connector permissions before enabling.`, 320),
+            capabilities: inferCapabilities(name, slug),
+            compatibility: ['claude', 'mcp'],
+            source: sourceId,
+            install: {
+                kind: 'manual',
+                instructions: 'Enable this connector from Claude Connectors.',
+                url: link
+            },
+            adoptionSignal: 52,
+            maintenanceSignal: 60,
+            provenanceSignal: 72,
+            freshnessSignal: 65,
+            securitySignals: {
+                knownVulnerabilities: 0,
+                suspiciousPatterns: 1,
+                injectionFindings: 0,
+                exfiltrationSignals: 0,
+                integrityAlerts: 0
+            },
+            metadata: {
+                catalogType: 'connector',
+                sourcePage: 'https://claude.com/connectors',
+                scrapedAt: new Date().toISOString(),
+                sourceConfidence: 'scraped'
+            }
+        });
+    }
+    return mapped;
+}
+function collectConnectorSlugs(html) {
+    const slugs = new Set();
+    let match;
+    while ((match = CONNECTOR_PATH_PATTERN.exec(html)) !== null) {
+        const slug = slugify(match[1] ?? '');
+        if (!slug) {
+            continue;
+        }
+        slugs.add(slug);
+    }
+    return Array.from(slugs).sort((a, b) => a.localeCompare(b));
+}
+function extractAnchorSnippet(html, slug) {
+    const pattern = new RegExp(`<a[^>]+href="(?:https:\\/\\/claude\\.com)?\\/connectors\\/${slug}"[^>]*>([\\s\\S]{0,500}?)<\\/a>`, 'i');
+    const match = html.match(pattern);
+    if (!match || typeof match[1] !== 'string') {
+        return '';
+    }
+    return match[1];
+}
+function sanitizeText(value, maxLength) {
+    return stripHtml(value, maxLength).slice(0, maxLength);
+}
+function titleizeSlug(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/g)
+        .filter((segment) => segment.length > 0)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+function inferCapabilities(name, slug) {
+    const text = `${name} ${slug}`.toLowerCase();
+    const capabilities = [];
+    if (/(jira|linear|asana|clickup|trello|task)/.test(text)) {
+        capabilities.push('tickets');
+    }
+    if (/(github|gitlab|bitbucket|repo|code)/.test(text)) {
+        capabilities.push('code-scanning');
+    }
+    if (/(drive|dropbox|box|sharepoint|doc|notion|confluence)/.test(text)) {
+        capabilities.push('docs');
+    }
+    if (/(salesforce|hubspot|crm|zendesk|intercom)/.test(text)) {
+        capabilities.push('search');
+    }
+    capabilities.push('automation');
+    return dedupe(capabilities);
+}

package/dist/catalog/adapters/claude-plugins-scrape-v1.js

@@ -0,0 +1,107 @@
+import { dedupe, sanitizeUrl, slugify, stripHtml } from './shared.js';
+const TRUSTED_HOSTS = ['claude.com', 'www.claude.com', 'anthropic.com', 'www.anthropic.com'];
+const PLUGIN_PATH_PATTERN = /(?:https:\/\/claude\.com)?\/plugins\/([a-z0-9-]+)/gi;
+export function adaptClaudePluginsScrapeEntries(sourceId, entries) {
+    const html = entries.find((entry) => typeof entry === 'string');
+    if (typeof html !== 'string' || html.trim().length === 0) {
+        return [];
+    }
+    const pluginSlugs = collectPluginSlugs(html);
+    const mapped = [];
+    const seen = new Set();
+    for (const slug of pluginSlugs) {
+        const id = `claude-plugin:${slug}`;
+        if (seen.has(id)) {
+            continue;
+        }
+        const snippet = extractAnchorSnippet(html, slug);
+        const label = stripHtml(snippet, 140);
+        const name = titleizeSlug(label.length >= 3 ? label : slug);
+        const link = sanitizeUrl(`https://claude.com/plugins/${slug}`, TRUSTED_HOSTS);
+        if (!link) {
+            continue;
+        }
+        seen.add(id);
+        mapped.push({
+            id,
+            kind: 'claude-plugin',
+            provider: 'anthropic',
+            name: sanitizeText(name, 140),
+            description: sanitizeText(`Plugin listed on Claude Plugins for ${name}. Review plugin behavior and permissions before enabling.`, 320),
+            capabilities: inferCapabilities(name, slug),
+            compatibility: ['claude', 'claude-code', 'cowork'],
+            source: sourceId,
+            install: {
+                kind: 'manual',
+                instructions: 'Enable this plugin from Claude Plugins.',
+                url: link
+            },
+            adoptionSignal: 58,
+            maintenanceSignal: 68,
+            provenanceSignal: 88,
+            freshnessSignal: 72,
+            securitySignals: {
+                knownVulnerabilities: 0,
+                suspiciousPatterns: 0,
+                injectionFindings: 0,
+                exfiltrationSignals: 0,
+                integrityAlerts: 0
+            },
+            metadata: {
+                catalogType: 'plugin',
+                sourcePage: 'https://claude.com/plugins',
+                scrapedAt: new Date().toISOString(),
+                sourceConfidence: 'scraped'
+            }
+        });
+    }
+    return mapped;
+}
+function collectPluginSlugs(html) {
+    const slugs = new Set();
+    let match;
+    while ((match = PLUGIN_PATH_PATTERN.exec(html)) !== null) {
+        const slug = slugify(match[1] ?? '');
+        if (!slug) {
+            continue;
+        }
+        slugs.add(slug);
+    }
+    return Array.from(slugs).sort((a, b) => a.localeCompare(b));
+}
+function extractAnchorSnippet(html, slug) {
+    const pattern = new RegExp(`<a[^>]+href="(?:https:\\/\\/claude\\.com)?\\/plugins\\/${slug}"[^>]*>([\\s\\S]{0,700}?)<\\/a>`, 'i');
+    const match = html.match(pattern);
+    if (!match || typeof match[1] !== 'string') {
+        return '';
+    }
+    return match[1];
+}
+function sanitizeText(value, maxLength) {
+    return stripHtml(value, maxLength).slice(0, maxLength);
+}
+function titleizeSlug(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/g)
+        .filter((segment) => segment.length > 0)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+function inferCapabilities(name, slug) {
+    const text = `${name} ${slug}`.toLowerCase();
+    const capabilities = [];
+    if (/(github|gitlab|repo|review|commit|code|playwright|lsp|semgrep|sentry|security)/.test(text)) {
+        capabilities.push('code-scanning');
+    }
+    if (/(asana|atlassian|linear|slack|notion|figma|product|operations|support)/.test(text)) {
+        capabilities.push('automation');
+    }
+    if (/(research|finance|legal|marketing|sales|enterprise-search|data)/.test(text)) {
+        capabilities.push('search');
+    }
+    if (/(design|brand|learning|output-style|creator|setup|management)/.test(text)) {
+        capabilities.push('prompting');
+    }
+    capabilities.push('automation');
+    return dedupe(capabilities);
+}

package/dist/catalog/adapters/claude-plugins-v0.1.js

@@ -0,0 +1,48 @@
+import { dedupe, extractStringArray, readNestedString, readString, toCount, toScore } from './shared.js';
+export function adaptClaudePluginsEntries(sourceId, entries) {
+    return entries
+        .map((entry) => mapClaudePluginEntry(sourceId, entry))
+        .filter((entry) => entry !== null);
+}
+function mapClaudePluginEntry(sourceId, entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return null;
+    }
+    const record = entry;
+    const slug = readString(record, ['slug', 'id', 'name']);
+    if (!slug) {
+        return null;
+    }
+    const name = readString(record, ['title', 'name']) ?? slug;
+    const description = readString(record, ['description', 'summary']) ?? `Claude plugin ${name}`;
+    const capabilities = dedupe(extractStringArray(record, ['capabilities', 'tools']).concat(extractStringArray(record, ['tags'])));
+    const compatibility = dedupe(extractStringArray(record, ['compatibility', 'targets']).concat(['claude']));
+    const installUrl = readNestedString(record, ['install', 'url']) ?? readString(record, ['url']);
+    const instructions = readNestedString(record, ['install', 'instructions']) ?? 'Enable from Claude plugin catalog.';
+    return {
+        id: slug.startsWith('claude-plugin:') ? slug : `claude-plugin:${slug}`,
+        kind: 'claude-plugin',
+        provider: 'anthropic',
+        name,
+        description,
+        capabilities,
+        compatibility,
+        source: sourceId,
+        install: {
+            kind: 'manual',
+            instructions,
+            ...(installUrl ? { url: installUrl } : {})
+        },
+        adoptionSignal: toScore(record.adoptionSignal),
+        maintenanceSignal: toScore(record.maintenanceSignal),
+        provenanceSignal: toScore(record.provenanceSignal, 95),
+        freshnessSignal: toScore(record.freshnessSignal, 65),
+        securitySignals: {
+            knownVulnerabilities: toCount(record.knownVulnerabilities),
+            suspiciousPatterns: toCount(record.suspiciousPatterns),
+            injectionFindings: toCount(record.injectionFindings),
+            exfiltrationSignals: toCount(record.exfiltrationSignals),
+            integrityAlerts: toCount(record.integrityAlerts)
+        }
+    };
+}

package/dist/catalog/adapters/copilot-extensions-v0.1.js

@@ -0,0 +1,48 @@
+import { dedupe, extractStringArray, readNestedStringArray, readString, toCount, toScore } from './shared.js';
+export function adaptCopilotExtensionsEntries(sourceId, entries) {
+    return entries
+        .map((entry) => mapCopilotExtensionEntry(sourceId, entry))
+        .filter((entry) => entry !== null);
+}
+function mapCopilotExtensionEntry(sourceId, entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return null;
+    }
+    const record = entry;
+    const slug = readString(record, ['slug', 'id', 'name']);
+    if (!slug) {
+        return null;
+    }
+    const name = readString(record, ['title', 'name']) ?? slug;
+    const description = readString(record, ['description', 'summary']) ?? `Copilot extension ${name}`;
+    const capabilities = dedupe(extractStringArray(record, ['capabilities', 'tools']).concat(extractStringArray(record, ['tags'])));
+    const compatibility = dedupe(extractStringArray(record, ['compatibility', 'targets']).concat(['copilot', 'github']));
+    const installTarget = readString(record, ['installId', 'name']) ?? slug;
+    const installArgs = readNestedStringArray(record, ['install', 'args']);
+    return {
+        id: slug.startsWith('copilot-extension:') ? slug : `copilot-extension:${slug}`,
+        kind: 'copilot-extension',
+        provider: 'github',
+        name,
+        description,
+        capabilities,
+        compatibility,
+        source: sourceId,
+        install: {
+            kind: 'gh-cli',
+            target: 'copilot-extension',
+            args: installArgs.length > 0 ? installArgs : ['install', installTarget]
+        },
+        adoptionSignal: toScore(record.adoptionSignal),
+        maintenanceSignal: toScore(record.maintenanceSignal),
+        provenanceSignal: toScore(record.provenanceSignal, 96),
+        freshnessSignal: toScore(record.freshnessSignal, 70),
+        securitySignals: {
+            knownVulnerabilities: toCount(record.knownVulnerabilities),
+            suspiciousPatterns: toCount(record.suspiciousPatterns),
+            injectionFindings: toCount(record.injectionFindings),
+            exfiltrationSignals: toCount(record.exfiltrationSignals),
+            integrityAlerts: toCount(record.integrityAlerts)
+        }
+    };
+}

package/dist/catalog/adapters/copilot-plugin-marketplace-v1.js

@@ -0,0 +1,117 @@
+import { dedupe, readString, sanitizeUrl, slugify, stripHtml, toCount, toScore } from './shared.js';
+const TRUSTED_HOSTS = ['github.com', 'raw.githubusercontent.com'];
+export function adaptCopilotPluginMarketplaceEntries(sourceId, entries) {
+    const seen = new Set();
+    const mapped = [];
+    for (const entry of entries) {
+        const candidate = mapCopilotMarketplaceEntry(sourceId, entry);
+        if (!candidate) {
+            continue;
+        }
+        const candidateId = candidate.id;
+        if (typeof candidateId !== 'string') {
+            continue;
+        }
+        if (seen.has(candidateId)) {
+            continue;
+        }
+        seen.add(candidateId);
+        mapped.push(candidate);
+    }
+    return mapped;
+}
+function mapCopilotMarketplaceEntry(sourceId, entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return null;
+    }
+    const record = entry;
+    const rawName = readString(record, ['name', 'title', 'id']);
+    if (!rawName) {
+        return null;
+    }
+    const slug = slugify(rawName);
+    if (!slug) {
+        return null;
+    }
+    const description = stripHtml(readString(record, ['description']) ?? `Copilot extension plugin ${rawName}`, 320) ||
+        `Copilot extension plugin ${rawName}`;
+    const source = sanitizeUrl(readString(record, ['source', 'url', 'homepage']), TRUSTED_HOSTS);
+    const version = readString(record, ['version']);
+    const skills = extractSkills(record.skills);
+    const capabilities = dedupe(extractTags(record)
+        .concat(skills)
+        .concat(['automation']));
+    return {
+        id: `copilot-extension:${slug}`,
+        kind: 'copilot-extension',
+        provider: 'github',
+        name: rawName.trim().slice(0, 120),
+        description,
+        capabilities,
+        compatibility: ['copilot', 'github'],
+        source: sourceId,
+        install: {
+            kind: 'manual',
+            instructions: 'Enable this plugin from GitHub Copilot marketplace settings.',
+            ...(source ? { url: source } : {})
+        },
+        adoptionSignal: toScore(record.adoptionSignal, 62),
+        maintenanceSignal: toScore(record.maintenanceSignal, version ? 76 : 68),
+        provenanceSignal: toScore(record.provenanceSignal, 88),
+        freshnessSignal: toScore(record.freshnessSignal, version ? 74 : 64),
+        securitySignals: {
+            knownVulnerabilities: toCount(record.knownVulnerabilities),
+            suspiciousPatterns: toCount(record.suspiciousPatterns),
+            injectionFindings: toCount(record.injectionFindings),
+            exfiltrationSignals: toCount(record.exfiltrationSignals),
+            integrityAlerts: toCount(record.integrityAlerts)
+        },
+        metadata: {
+            catalogType: 'plugin',
+            sourceRepo: sourceId.includes('awesome') ? 'github/awesome-copilot' : 'github/copilot-plugins',
+            rawVersion: version ?? 'unknown',
+            sourceConfidence: sourceId.includes('awesome') ? 'vetted-curated' : 'official'
+        }
+    };
+}
+function extractTags(record) {
+    const tags = [];
+    const raw = record.tags;
+    if (Array.isArray(raw)) {
+        for (const tag of raw) {
+            if (typeof tag === 'string' && tag.trim().length > 0) {
+                tags.push(tag.trim().toLowerCase());
+            }
+        }
+    }
+    const category = readString(record, ['category']);
+    if (category) {
+        tags.push(category.toLowerCase());
+    }
+    return dedupe(tags);
+}
+function extractSkills(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const skills = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const record = item;
+        const name = readString(record, ['name']);
+        if (name) {
+            skills.push(name.toLowerCase());
+        }
+        const commands = record.commands;
+        if (Array.isArray(commands)) {
+            for (const command of commands) {
+                if (typeof command === 'string' && command.trim().length > 0) {
+                    skills.push(command.trim().toLowerCase());
+                }
+            }
+        }
+    }
+    return dedupe(skills);
+}

package/dist/catalog/adapters/mcp-registry-v0.1.js

@@ -0,0 +1,211 @@
+import { dedupe, extractStringArray, readNestedString, readString } from './shared.js';
+export function adaptMcpRegistryEntries(sourceId, entries) {
+    return entries
+        .map((entry) => mapMcpRegistryEntry(sourceId, entry))
+        .filter((entry) => entry !== null);
+}
+function mapMcpRegistryEntry(sourceId, entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return null;
+    }
+    const record = entry;
+    const server = resolveServerRecord(record);
+    const name = readString(server, ['name', 'id']);
+    if (!name) {
+        return null;
+    }
+    const title = readString(server, ['title', 'displayName']) ?? name;
+    const description = readString(server, ['description']) ?? `MCP server ${name}`;
+    const packages = Array.isArray(server.packages) ? server.packages : [];
+    const remotes = Array.isArray(server.remotes) ? server.remotes : [];
+    const packageRecords = packages
+        .filter((pkg) => pkg && typeof pkg === 'object' && !Array.isArray(pkg))
+        .map((pkg) => pkg);
+    const remoteRecords = remotes
+        .filter((remote) => remote && typeof remote === 'object' && !Array.isArray(remote))
+        .map((remote) => remote);
+    const firstPackage = packageRecords[0] ?? {};
+    const firstRemote = remoteRecords[0] ?? {};
+    const transport = normalizeTransport(readNestedString(firstPackage, ['transport', 'type']) ?? readString(firstPackage, ['transport'])) ??
+        normalizeTransport(readString(firstRemote, ['type'])) ??
+        normalizeTransport(readString(server, ['transport'])) ??
+        'stdio';
+    const authModel = normalizeAuthModel(readString(server, ['authModel', 'auth'])) ?? inferAuthModel(firstPackage, remoteRecords);
+    const compatibility = dedupe(packageRecords
+        .flatMap((pkg) => detectCompatibilityFromPackage(pkg))
+        .concat(detectCompatibilityFromRemotes(remoteRecords))
+        .concat(['general']));
+    const capabilities = dedupe(extractStringArray(server, ['capabilities', 'tools'])
+        .concat(extractStringArray(server, ['tags']))
+        .concat(extractStringArray(record, ['tags'])));
+    const target = readNestedString(firstPackage, ['identifier']) ??
+        readNestedString(firstPackage, ['name']) ??
+        readString(server, ['name']) ??
+        name;
+    const installUrl = readString(server, ['websiteUrl']) ?? readNestedString(server, ['repository', 'url']);
+    const install = packageRecords.length > 0
+        ? {
+            kind: 'skill.sh',
+            target,
+            args: []
+        }
+        : {
+            kind: 'manual',
+            instructions: 'Configure using the MCP server repository or hosted remote endpoint.',
+            url: installUrl
+        };
+    const publishedAt = readNestedString(record, ['_meta', 'io.modelcontextprotocol.registry/official', 'publishedAt']);
+    const freshnessSignal = scoreFreshness(publishedAt);
+    return {
+        id: `mcp:${name}`,
+        kind: 'mcp',
+        provider: 'mcp',
+        name: title,
+        description,
+        transport,
+        authModel,
+        capabilities,
+        compatibility,
+        source: sourceId,
+        install,
+        adoptionSignal: 50,
+        maintenanceSignal: 65,
+        provenanceSignal: 90,
+        freshnessSignal,
+        securitySignals: {
+            knownVulnerabilities: 0,
+            suspiciousPatterns: 0,
+            injectionFindings: 0,
+            exfiltrationSignals: 0,
+            integrityAlerts: 0
+        },
+        metadata: {
+            websiteUrl: readString(server, ['websiteUrl']),
+            repositoryUrl: readNestedString(server, ['repository', 'url']),
+            packageIdentifier: readNestedString(firstPackage, ['identifier']) ?? readNestedString(firstPackage, ['name']),
+            packageRegistryType: readString(firstPackage, ['registryType']),
+            packageRuntime: readString(firstPackage, ['runtime']),
+            version: readString(server, ['version']),
+            publishedAt
+        }
+    };
+}
+function resolveServerRecord(entry) {
+    const nested = entry.server;
+    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+        return nested;
+    }
+    return entry;
+}
+function normalizeTransport(value) {
+    const normalized = value?.toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'http') {
+        return 'http';
+    }
+    if (normalized === 'streamable-http') {
+        return 'http';
+    }
+    if (normalized === 'sse') {
+        return 'sse';
+    }
+    if (normalized === 'websocket' || normalized === 'ws') {
+        return 'websocket';
+    }
+    if (normalized === 'stdio') {
+        return 'stdio';
+    }
+    return undefined;
+}
+function normalizeAuthModel(value) {
+    const normalized = value?.toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'none' || normalized === 'noauth') {
+        return 'none';
+    }
+    if (normalized === 'api_key' || normalized === 'apikey' || normalized === 'bearer') {
+        return 'api_key';
+    }
+    if (normalized === 'oauth' || normalized === 'oauth2') {
+        return 'oauth';
+    }
+    return undefined;
+}
+function inferAuthModel(firstPackage, remotes) {
+    const envVars = Array.isArray(firstPackage.environmentVariables) ? firstPackage.environmentVariables : [];
+    const hasSecretEnv = envVars.some((envVar) => {
+        if (!envVar || typeof envVar !== 'object' || Array.isArray(envVar)) {
+            return false;
+        }
+        return envVar.isSecret === true;
+    });
+    if (hasSecretEnv) {
+        return 'api_key';
+    }
+    if (remotes.length > 0) {
+        return 'custom';
+    }
+    return 'none';
+}
+function detectCompatibilityFromPackage(pkg) {
+    const words = [
+        readString(pkg, ['registryType']) ?? '',
+        readString(pkg, ['runtime']) ?? '',
+        readString(pkg, ['name']) ?? '',
+        readString(pkg, ['identifier']) ?? ''
+    ]
+        .join(' ')
+        .toLowerCase();
+    const tags = [];
+    if (words.includes('npm') || words.includes('node')) {
+        tags.push('node');
+    }
+    if (words.includes('pypi') || words.includes('python')) {
+        tags.push('python');
+    }
+    if (words.includes('docker') || words.includes('container')) {
+        tags.push('container');
+    }
+    return tags;
+}
+function detectCompatibilityFromRemotes(remotes) {
+    const tags = new Set();
+    remotes.forEach((remote) => {
+        const remoteType = readString(remote, ['type'])?.toLowerCase() ?? '';
+        if (remoteType.includes('http') || remoteType === 'sse') {
+            tags.add('network');
+        }
+        if (remoteType === 'websocket' || remoteType === 'ws') {
+            tags.add('network');
+        }
+    });
+    return Array.from(tags);
+}
+function scoreFreshness(publishedAt) {
+    if (!publishedAt) {
+        return 60;
+    }
+    const stamp = Date.parse(publishedAt);
+    if (!Number.isFinite(stamp)) {
+        return 60;
+    }
+    const ageMs = Date.now() - stamp;
+    const ageDays = ageMs / (24 * 60 * 60 * 1000);
+    if (ageDays <= 7) {
+        return 95;
+    }
+    if (ageDays <= 30) {
+        return 85;
+    }
+    if (ageDays <= 90) {
+        return 75;
+    }
+    if (ageDays <= 180) {
+        return 65;
+    }
+    return 55;
+}