@proofofwork-agency/toolpin 0.2.3

package/dist/tui/command.js

@@ -0,0 +1,50 @@
+import { TUI_COMMANDS } from "./constants.js";
+export function commandRequiresServer(commandId) {
+    return TUI_COMMANDS.find((command) => command.id === commandId)?.requiresServer === true;
+}
+export function commandLineFor(commandId, state, server) {
+    const source = `--source ${state.sourceMode}`;
+    const live = state.dataMode === "live" ? " --live" : "";
+    const serverName = server ? shellQuote(server.name) : "<server-name>";
+    switch (commandId) {
+        case "ingest":
+            return `toolpin ingest ${source} --pages 6`;
+        case "installed":
+            return "toolpin list --scope all --json";
+        case "sources":
+            return "toolpin registry list";
+        case "search":
+            return `toolpin search ${state.query.trim() ? shellQuote(state.query.trim()) : "<query>"} ${source}${live}`;
+        case "more-results":
+            return "toolpin tui # show more matching results";
+        case "reset-view":
+            return "toolpin tui # reset view defaults";
+        case "info":
+            return `toolpin info ${serverName} ${source}${live}`;
+        case "audit":
+            return `toolpin audit ${serverName} ${source}${live}`;
+        case "plan":
+            return `toolpin plan ${serverName} --client ${state.client} ${source}${live}`;
+        case "install":
+            return `toolpin install ${serverName} --client ${state.client} --scope ${state.installScope} ${source}${live}`;
+        case "remove":
+            return `toolpin remove ${serverName} --client ${state.client} --scope ${state.installScope} --file mcp-lock.json`;
+        case "doctor":
+            return `toolpin doctor --scope ${state.installScope} --file mcp-lock.json`;
+        case "ci":
+            return `toolpin ci --file mcp-lock.json ${source}${live}`;
+        case "test":
+            return `toolpin test ${serverName} ${source}${live} --timeout 15000`;
+        case "lock":
+            return `toolpin lock ${serverName} --client ${state.client} ${source}${live} --file mcp-lock.json`;
+        case "export-config":
+            return `toolpin export-config ${serverName} --client ${state.client} ${source}${live}`;
+        case "tui":
+            return "toolpin tui";
+        case "help":
+            return "toolpin help";
+    }
+}
+export function shellQuote(value) {
+    return /^[a-zA-Z0-9_./:@-]+$/.test(value) ? value : JSON.stringify(value);
+}

package/dist/tui/configSnippet.js

@@ -0,0 +1,11 @@
+import { codexTomlFromClientConfig } from "../codexToml.js";
+import { continueYamlFromClientConfig } from "../continueYaml.js";
+export function formatClientConfigSnippet(client, config) {
+    if (client === "codex") {
+        return { extension: "toml", content: `${codexTomlFromClientConfig(config)}\n` };
+    }
+    if (client === "continue") {
+        return { extension: "yaml", content: continueYamlFromClientConfig(config) };
+    }
+    return { extension: "json", content: `${JSON.stringify(config, null, 2)}\n` };
+}

package/dist/tui/constants.js

@@ -0,0 +1,37 @@
+import { ALL_CLIENTS } from "../config.js";
+export const VIEWS = ["discover", "installed", "sources", "details", "plan", "config", "help"];
+export const SERVER_VIEWS = new Set(["details", "plan", "config"]);
+export const CLIENTS = [...ALL_CLIENTS.filter((client) => client !== "generic"), "all"];
+export const TUI_COMMANDS = [
+    { id: "ingest", label: "Ingest registries", description: "Fetch registry metadata and refresh .toolpin/registry-cache.json." },
+    { id: "installed", label: "Installed servers", description: "Show installed MCP servers, lock drift, versions, updates, and lifecycle actions." },
+    { id: "sources", label: "Registry sources", description: "Show usable sources, disabled integrations, auth, and cache coverage." },
+    { id: "search", label: "Search servers", description: "Edit the current search query." },
+    { id: "more-results", label: "Show more results", description: "Increase the TUI result window by 50 matches." },
+    { id: "reset-view", label: "Reset view defaults", description: "Reset search/source/result count/client/scope to defaults." },
+    { id: "info", label: "Server info", description: "Open selected server metadata and trust summary.", requiresServer: true },
+    { id: "audit", label: "Audit trust", description: "Show selected server tier, evidence, score, badges, and issues.", requiresServer: true },
+    { id: "plan", label: "Install plan", description: "Preview target, trust, secrets, and config writes.", requiresServer: true },
+    { id: "install", label: "Install server", description: "Open the install wizard: choose scope and client, then write config + lockfile.", requiresServer: true },
+    { id: "remove", label: "Remove server", description: "Delete selected server from active client config and lockfile.", requiresServer: true },
+    { id: "doctor", label: "Check config drift", description: "Compare mcp-lock.json against active-scope client configs." },
+    { id: "test", label: "Test server", description: "Connect and run MCP tools/list.", requiresServer: true },
+    { id: "ci", label: "Frozen lock check", description: "Re-resolve lockfile entries and reject metadata drift." },
+    { id: "lock", label: "Write lockfile", description: "Write selected server to mcp-lock.json.", requiresServer: true },
+    { id: "export-config", label: "Export config", description: "Save client config snippets under .toolpin/.", requiresServer: true },
+    { id: "tui", label: "Open TUI", description: "Current interactive session." },
+    { id: "help", label: "Help", description: "Open keyboard and command reference." },
+];
+export const BLUE = "#8aa7ff";
+export const ACCENT = "#22d3ee";
+export const MUTED = "#8b8b94";
+export const CHROME = "#52525b";
+export const SURFACE = "#252525";
+export const SURFACE_2 = "#202023";
+export const OK = "#4ade80";
+export const WARN = "#fbbf24";
+export const ERR = "#f87171";
+export const MENU_ROW = 6;
+export const LIST_ROW_START = 8;
+export const DEFAULT_RESULT_LIMIT = 50;
+export const RESULT_LIMIT_STEP = 50;

package/dist/tui/format.js

@@ -0,0 +1,31 @@
+export function unique(values) {
+    return [...new Set(values)];
+}
+export function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function safeJson(factory) {
+    try {
+        return factory();
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function safeFileName(value) {
+    return value.replace(/[^a-z0-9._-]+/gi, "_");
+}
+export function shortPath(value) {
+    const home = process.env.HOME;
+    const pathValue = home && value.startsWith(home) ? `~${value.slice(home.length)}` : value;
+    const parts = pathValue.split("/");
+    return parts.length > 4 ? `.../${parts.slice(-3).join("/")}` : pathValue;
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export function truncate(value, maxLength) {
+    if (maxLength <= 0)
+        return "";
+    return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength - 3))}...` : value;
+}

package/dist/tui/installedState.js

@@ -0,0 +1,23 @@
+export { installedId, loadInstalledServerStates } from "../installed.js";
+export function installedViewReducer(state, action) {
+    switch (action.type) {
+        case "loading":
+            return { ...state, loading: true };
+        case "loaded":
+            return {
+                ...state,
+                rows: action.rows,
+                selected: clamp(state.selected, 0, Math.max(0, action.rows.length - 1)),
+                loading: false,
+            };
+        case "select":
+            return { ...state, selected: clamp(action.selected, 0, Math.max(0, state.rows.length - 1)) };
+        case "move":
+            return { ...state, selected: clamp(state.selected + action.delta, 0, Math.max(0, state.rows.length - 1)) };
+        case "scope":
+            return { ...state, scope: action.scope, selected: 0, loading: true };
+    }
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/tui/layout.js

@@ -0,0 +1,65 @@
+import { LIST_ROW_START, MENU_ROW } from "./constants.js";
+import { truncate } from "./format.js";
+export function buildTuiHitZones({ width, listHeight, selectedIndex, resultCount, hasSelection, selectedLabel, listActive, }) {
+    const visibleCount = Math.max(2, listHeight - 2);
+    const listStart = listWindowStart(selectedIndex, visibleCount, resultCount);
+    const menuLayout = computeMenuLayout({ width, hasSelection, selectedLabel });
+    return {
+        menuY: MENU_ROW,
+        menu: menuLayout.segments,
+        list: listActive ? {
+            fromY: LIST_ROW_START,
+            toY: LIST_ROW_START + visibleCount - 1,
+            start: listStart,
+            total: resultCount,
+        } : undefined,
+    };
+}
+export function computeMenuLayout({ width, hasSelection, selectedLabel }) {
+    const contentStart = 3;
+    const helpLabel = "Help";
+    const helpTo = Math.max(contentStart + helpLabel.length - 1, width - 2);
+    const helpFrom = Math.max(contentStart, helpTo - helpLabel.length + 1);
+    const labelWidth = Math.max(4, Math.min(28, width - 78));
+    const chosenLabel = truncate(selectedLabel || "select a server", labelWidth);
+    const segments = [];
+    let cursor = contentStart;
+    const push = (view, label, enabled) => {
+        segments.push({ view, label, from: cursor, to: cursor + label.length - 1, enabled });
+        cursor += label.length;
+    };
+    push("discover", "Browse", true);
+    cursor += "  ".length;
+    push("installed", "Installed", true);
+    cursor += "  |  ".length;
+    cursor += "Selected: ".length;
+    const selectedFrom = cursor;
+    const selectedTo = cursor + chosenLabel.length - 1;
+    cursor += chosenLabel.length;
+    if (hasSelection) {
+        cursor += "  |  ".length;
+        push("details", "Overview", true);
+        cursor += "  ".length;
+        push("plan", "Install", true);
+        cursor += "  ".length;
+        push("config", "Config", true);
+    }
+    segments.push({ view: "help", label: helpLabel, from: helpFrom, to: helpTo, enabled: true });
+    return { selectedLabel: chosenLabel, selectedFrom, selectedTo, segments };
+}
+export function hitTestTui(x, y, zones) {
+    if (y === zones.menuY) {
+        const zone = zones.menu.find((entry) => x >= entry.from && x <= entry.to);
+        return zone?.enabled ? { kind: "view", view: zone.view } : undefined;
+    }
+    if (zones.list && y >= zones.list.fromY && y <= zones.list.toY) {
+        const index = zones.list.start + (y - zones.list.fromY);
+        return index < zones.list.total ? { kind: "server", index } : undefined;
+    }
+    return undefined;
+}
+export function listWindowStart(selected, visibleCount, total) {
+    const maxStart = Math.max(0, total - visibleCount);
+    const preferred = selected < visibleCount ? 0 : selected - visibleCount + 1;
+    return Math.max(0, Math.min(preferred, maxStart));
+}

package/dist/tui/selectors.js

@@ -0,0 +1,282 @@
+import { clientsForScope, PROJECT_CLIENTS } from "../config.js";
+import { clientSupportBlock, clientSupportFor } from "../clientSupport.js";
+import { resolveConfigTarget } from "../install.js";
+import { lockKey } from "../plan.js";
+import { compareRegistrySources, latestOnly, normalizeEntries, registrySourceIdRank } from "../registry.js";
+import { searchServers } from "../search.js";
+import { scoreServer, trustRankingScore } from "../trust.js";
+import { compareVersionStatus, knownVersions } from "../versions.js";
+import { CLIENTS, RESULT_LIMIT_STEP, VIEWS } from "./constants.js";
+import { asObject, safeJson, shortPath, unique } from "./format.js";
+export function nextView(view) {
+    return VIEWS[(VIEWS.indexOf(view) + 1) % VIEWS.length] ?? "discover";
+}
+export function switchView(state, view) {
+    const commandLog = commandLogBelongsToView(state.commandLog, view) ? state.commandLog : undefined;
+    return {
+        ...state,
+        view,
+        commandLog,
+    };
+}
+export function commandLogForView(state) {
+    return commandLogBelongsToView(state.commandLog, state.view) ? state.commandLog : undefined;
+}
+export function commandLogBelongsToView(log, view) {
+    if (!log)
+        return false;
+    if (view === "installed")
+        return ["installed", "remove", "install", "update", "adopt", "test", "doctor", "versions"].includes(log.title);
+    if (view === "sources")
+        return ["sources", "ingest", "search", "results", "reset"].includes(log.title);
+    if (view === "details")
+        return ["info", "audit", "test", "versions"].includes(log.title);
+    if (view === "plan")
+        return ["install", "lock", "plan", "versions"].includes(log.title);
+    if (view === "config")
+        return ["export-config", "config", "versions"].includes(log.title);
+    if (view === "discover")
+        return ["ingest", "search", "results", "reset"].includes(log.title);
+    return log.title === "help";
+}
+export function nextClient(client) {
+    return CLIENTS[(CLIENTS.indexOf(client) + 1) % CLIENTS.length] ?? "claude";
+}
+export function selectedClients(client) {
+    return client === "all" ? PROJECT_CLIENTS : [client];
+}
+export function selectedClientsForScope(client, scope) {
+    return client === "all" ? clientsForScope(scope) : [client];
+}
+export function installClientChoicesForScope(scope, preferredClient) {
+    const choices = [...clientsForScope(scope), "all"];
+    if (!choices.includes(preferredClient))
+        return choices;
+    return [preferredClient, ...choices.filter((client) => client !== preferredClient)];
+}
+export function installClientChoicesForServerScope(scope, preferredClient, server) {
+    const clients = directInstallClientsForServerScope(scope, server);
+    const choices = [...clients, ...(clients.length > 1 ? ["all"] : [])];
+    if (!choices.includes(preferredClient))
+        return choices;
+    return [preferredClient, ...choices.filter((client) => client !== preferredClient)];
+}
+export function nextClientForServerScope(client, scope, server) {
+    const supported = supportedClientsForServerScope(scope, server);
+    const choices = supported.length
+        ? [...supported, ...(supported.length > 1 ? ["all"] : [])]
+        : installClientChoicesForScope(scope, client);
+    return choices[(choices.indexOf(client) + 1) % choices.length] ?? nextClient(client);
+}
+export function selectedInstallClientsForServerScope(client, scope, server) {
+    const installable = directInstallClientsForServerScope(scope, server);
+    if (client === "all")
+        return installable;
+    return installable.includes(client) ? [client] : [];
+}
+export function directInstallClientsForServerScope(scope, server) {
+    const candidates = clientsForScope(scope);
+    if (!server || !clientSupportBlock(server))
+        return candidates;
+    return candidates.filter((client) => clientSupportFor(server, client)?.status === "toolpin-installable");
+}
+export function supportedClientsForServerScope(scope, server) {
+    const candidates = clientsForScope(scope);
+    if (!server || !clientSupportBlock(server))
+        return candidates;
+    return candidates.filter((client) => clientSupportFor(server, client)?.status !== "unsupported");
+}
+export function clientSupportSummary(server, scope) {
+    if (!clientSupportBlock(server))
+        return "not declared; ToolPin will try standard MCP config";
+    const clients = clientsForScope(scope);
+    const groups = {};
+    for (const client of clients) {
+        const status = clientSupportFor(server, client)?.status ?? "unsupported";
+        groups[status] = [...(groups[status] ?? []), client];
+    }
+    return [
+        groups["toolpin-installable"]?.length ? `direct ${groups["toolpin-installable"].join(", ")}` : "",
+        groups["external-setup"]?.length ? `external ${groups["external-setup"].join(", ")}` : "",
+        groups.unsupported?.length ? `unsupported ${groups.unsupported.join(", ")}` : "",
+    ].filter(Boolean).join("; ");
+}
+export function selectedServerVersion(servers, defaultServer, selectedVersion) {
+    if (!selectedVersion || selectedVersion === defaultServer.version)
+        return defaultServer;
+    return servers.find((server) => server.name === defaultServer.name && server.version === selectedVersion) ?? defaultServer;
+}
+export function initialInstallVersionIndex(versions, selectedVersion) {
+    return Math.max(0, versions.findIndex((entry) => entry.version === selectedVersion));
+}
+export function pruneVersionSelections(selections, servers) {
+    const available = new Set(servers.map((server) => `${server.name}@${server.version}`));
+    return Object.fromEntries(Object.entries(selections).filter(([name, version]) => available.has(`${name}@${version}`)));
+}
+export function buildTuiVersionInfo(servers, serverName, selectedVersion, lockfile, client, installScope) {
+    const entries = knownVersions(servers, serverName);
+    const latestVersion = entries[0]?.version ?? "unknown";
+    const targetClients = selectedClientsForScope(client, installScope);
+    const lockedEntries = targetClients
+        .map((targetClient) => {
+        const keyed = lockfile?.servers[lockKey(serverName, targetClient)];
+        const legacy = lockfile?.servers[serverName];
+        return keyed ?? (legacy?.client === targetClient ? legacy : undefined);
+    })
+        .filter((entry) => Boolean(entry?.name === serverName));
+    const lockedVersions = unique(lockedEntries.map((entry) => entry.version));
+    const lockedLabel = lockedVersions.length === 0
+        ? "none"
+        : lockedVersions.length === 1
+            ? lockedVersions[0]
+            : `mixed ${lockedVersions.join(", ")}`;
+    let status;
+    if (!entries.length) {
+        status = "unknown";
+    }
+    else if (!lockedVersions.length) {
+        status = "not locked";
+    }
+    else if (lockedVersions.some((lockedVersion) => compareVersionStatus(latestVersion, lockedVersion) === undefined)) {
+        status = "unknown";
+    }
+    else if (lockedVersions.some((lockedVersion) => (compareVersionStatus(latestVersion, lockedVersion) ?? 0) > 0)) {
+        status = "update available";
+    }
+    else if (lockedVersions.some((lockedVersion) => (compareVersionStatus(latestVersion, lockedVersion) ?? 0) < 0)) {
+        status = "ahead of registry";
+    }
+    else {
+        status = "current";
+    }
+    return {
+        selectedVersion,
+        latestVersion,
+        lockedLabel,
+        status,
+        versions: entries.map((entry) => entry.version),
+    };
+}
+export function installClientLabel(client, targetClients) {
+    return client === "all" ? `all supported clients (${targetClients.join(", ")})` : `client ${targetClients[0] ?? client}`;
+}
+export function scopeLabel(scope) {
+    return scope === "project" ? "project scope (this folder)" : "global scope (current user)";
+}
+export function formatVersionChoices(versionInfo, limit) {
+    const versions = versionInfo.versions.slice(0, limit).map((version) => {
+        const suffix = version === versionInfo.latestVersion ? " latest" : "";
+        return version === versionInfo.selectedVersion ? `[${version}${suffix}]` : `${version}${suffix}`;
+    });
+    const remaining = Math.max(0, versionInfo.versions.length - versions.length);
+    return remaining ? `${versions.join(", ")} +${remaining} more` : versions.join(", ");
+}
+export function configTargetLabel(client, scope) {
+    const target = safeJson(() => resolveConfigTarget(client, scope));
+    if ("error" in asObject(target))
+        return String(asObject(target).error);
+    return shortPath(target.file);
+}
+export function nextSource(source, registrySources = []) {
+    const enabled = registrySources
+        .filter((entry) => entry.enabled)
+        .sort(compareRegistrySources)
+        .map((entry) => entry.id);
+    const sources = ["all", ...(enabled.length ? enabled : ["toolpin", "official", "docker"])];
+    return sources[(sources.indexOf(source) + 1) % sources.length] ?? "all";
+}
+const BROWSE_SORT_MODES = ["source-first", "alpha-asc", "alpha-desc", "source-last", "relevance"];
+export function nextBrowseSortMode(mode) {
+    return BROWSE_SORT_MODES[(BROWSE_SORT_MODES.indexOf(mode) + 1) % BROWSE_SORT_MODES.length] ?? "source-first";
+}
+export function browseSortLabel(mode) {
+    if (mode === "source-first")
+        return "source-first";
+    if (mode === "alpha-asc")
+        return "alpha A-Z";
+    if (mode === "alpha-desc")
+        return "alpha Z-A";
+    if (mode === "source-last")
+        return "source-last";
+    return "relevance";
+}
+export function filterBySource(servers, source) {
+    return source === "all" ? servers : servers.filter((server) => server.registrySource === source);
+}
+export function filterByEnabledSources(servers, source, sources) {
+    const enabled = new Set(sources.filter((entry) => entry.enabled).map((entry) => entry.id));
+    return filterBySource(servers, source).filter((server) => source === "all" ? enabled.has(server.registrySource) : true);
+}
+const CACHE_COVERED_EMPTY_STATUSES = new Set(["auth-missing", "stale", "fetch-error", "disabled"]);
+export function cacheCoverage(entries, source, registrySources = []) {
+    const entrySources = new Set(normalizeEntries(entries).map((server) => server.registrySource));
+    const sourcesById = new Map(registrySources.map((entry) => [entry.id, entry]));
+    const enabledSources = registrySources.length
+        ? registrySources.filter((entry) => entry.enabled).map((entry) => entry.id)
+        : ["official", "docker"];
+    const expected = source === "all" ? enabledSources : [source];
+    const missing = expected.filter((sourceId) => {
+        if (entrySources.has(sourceId))
+            return false;
+        const sourceInfo = sourcesById.get(sourceId);
+        return !(sourceInfo?.cacheEntries === 0 && sourceInfo.status && CACHE_COVERED_EMPTY_STATUSES.has(sourceInfo.status));
+    });
+    return { covered: missing.length === 0, missing };
+}
+export function cacheHasSource(entries, source, registrySources = []) {
+    return cacheCoverage(entries, source, registrySources).covered;
+}
+export function browseSearchResults(servers, query, browseVersionMode, browseSortMode = "source-first") {
+    const candidates = browseVersionMode === "all" ? servers : latestOnly(servers);
+    if (!query.trim()) {
+        return sortBrowseResults(candidates.map((server) => ({ server, relevance: 0, trust: scoreServer(server) })), browseSortMode);
+    }
+    return sortBrowseResults(searchServers(candidates, query, candidates.length), browseSortMode);
+}
+export function sortBrowseResults(results, mode) {
+    return [...results].sort((left, right) => compareBrowseResult(left, right, mode));
+}
+function compareBrowseResult(left, right, mode) {
+    if (mode === "source-first") {
+        return sourceRank(left) - sourceRank(right)
+            || relevanceRank(right) - relevanceRank(left)
+            || compareBrowseName(left, right);
+    }
+    if (mode === "source-last") {
+        return sourceRank(right) - sourceRank(left)
+            || relevanceRank(right) - relevanceRank(left)
+            || compareBrowseName(left, right);
+    }
+    if (mode === "alpha-asc") {
+        return compareBrowseName(left, right)
+            || sourceRank(left) - sourceRank(right)
+            || relevanceRank(right) - relevanceRank(left);
+    }
+    if (mode === "alpha-desc") {
+        return compareBrowseName(right, left)
+            || sourceRank(left) - sourceRank(right)
+            || relevanceRank(right) - relevanceRank(left);
+    }
+    return relevanceRank(right) - relevanceRank(left)
+        || sourceRank(left) - sourceRank(right)
+        || compareBrowseName(left, right);
+}
+function sourceRank(result) {
+    return registrySourceIdRank(result.server.registrySource);
+}
+function relevanceRank(result) {
+    return result.relevance + trustRankingScore(result.trust) / 100;
+}
+function compareBrowseName(left, right) {
+    const leftLabel = left.server.title || left.server.name;
+    const rightLabel = right.server.title || right.server.name;
+    return leftLabel.localeCompare(rightLabel)
+        || left.server.name.localeCompare(right.server.name)
+        || left.server.version.localeCompare(right.server.version);
+}
+export function nextResultLimit(currentLimit, totalMatches) {
+    return Math.min(Math.max(totalMatches, currentLimit), currentLimit + RESULT_LIMIT_STEP);
+}
+export function persistentRefreshOptions(source) {
+    return { source, limit: 500, maxPages: 25 };
+}

package/dist/tui/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/ui/trust.js

@@ -0,0 +1,77 @@
+import { classifyTrust, trustTier } from "../../trust.js";
+export function trustBand(score) {
+    if (score >= 70)
+        return "high";
+    if (score >= 40)
+        return "medium";
+    return "low";
+}
+export function riskTone(score) {
+    const band = trustBand(score);
+    if (band === "high")
+        return { label: "COMPLETE", band };
+    if (band === "medium")
+        return { label: "REVIEW", band };
+    return { label: "INCOMPLETE", band };
+}
+export function trustRiskTone(report) {
+    const tier = trustTier(report);
+    if (tier === "verified")
+        return { label: "EVIDENCE OK", band: "high", tier };
+    if (tier === "conditional")
+        return { label: "REVIEW", band: "medium", tier };
+    if (tier === "unverified")
+        return { label: "UNVERIFIED", band: "low", tier };
+    return { label: "BLOCKED", band: "low", tier };
+}
+export function trustTierScore(report) {
+    const tier = trustTier(report);
+    if (tier === "verified")
+        return 100;
+    if (tier === "conditional")
+        return 67;
+    if (tier === "unverified")
+        return 34;
+    return 0;
+}
+export const TRUST_BAR_CELLS = 9;
+export function trustBarCells(score) {
+    const filled = Math.max(0, Math.min(TRUST_BAR_CELLS, Math.round((score / 100) * TRUST_BAR_CELLS)));
+    return { filled, empty: TRUST_BAR_CELLS - filled };
+}
+export function trustDimensions(report) {
+    if (report.pillars) {
+        return [
+            dimension("provenance", report.pillars.provenance),
+            dimension("integrity", report.pillars.integrity),
+            dimension("reputation", report.pillars.reputation),
+            dimension("metadata", report.pillars.metadataCompleteness),
+        ];
+    }
+    const classified = classifyTrust(report.score, report.issues, report.evidence);
+    const gates = report.gates ?? classified.gates;
+    const gatedBy = report.gatedBy ?? classified.gatedBy;
+    const hasRepo = report.badges.includes("source repo");
+    const hasDeclaredAttestation = report.badges.some((badge) => badge.endsWith("-declared"));
+    const hasCapabilityPin = report.badges.includes("capability-pinned");
+    const hasPassedEvidence = (report.evidence ?? []).some((entry) => entry.status === "passed");
+    const hasFailedEvidence = (report.evidence ?? []).some((entry) => entry.status === "failed");
+    const integrityBlocked = gates.some((gate) => ["no_install_target", "insecure_remote", "invalid_remote_url"].includes(gate.code))
+        || gatedBy.some((code) => ["no_install_target", "insecure_remote", "invalid_remote_url"].includes(code));
+    const integrityUnverified = gates.length > 0 || gatedBy.length > 0 || hasFailedEvidence;
+    const hasIntegritySignal = hasPassedEvidence || report.badges.some((badge) => ["digest-pinned", "fileSha256", "https remote", "pinned version"].includes(badge));
+    const provenanceScore = hasRepo ? (hasCapabilityPin || hasDeclaredAttestation ? 100 : 80) : 30;
+    const integrityScore = integrityBlocked ? 0 : integrityUnverified ? 25 : hasIntegritySignal ? 85 : 50;
+    const reputationScore = report.badges.includes("description-scan-advisory") ? 45 : 60;
+    const metadataScore = report.metadataCompleteness ?? report.score;
+    return [
+        dimension("provenance", provenanceScore),
+        dimension("integrity", integrityScore),
+        dimension("reputation", reputationScore),
+        dimension("metadata", metadataScore),
+    ];
+}
+function dimension(label, score) {
+    const normalized = Math.max(0, Math.min(100, Math.round(score)));
+    return { label, score: normalized, tone: trustBand(normalized) };
+}