@shnitzel/plugscout 0.3.1

package/dist/ingestion/skills.js

@@ -0,0 +1,76 @@
+import { loadSourcesConfig } from '../config/sources.js';
+import { readJsonFile, writeJsonFile } from '../lib/json.js';
+import { logger } from '../lib/logger.js';
+import { getStatePath } from '../lib/paths.js';
+import { SkillSchema } from '../models/records.js';
+const OUTPUT_PATH = getStatePath('data/curated/skills.json');
+export async function ingestSkills() {
+    const { skills } = await loadSourcesConfig();
+    const records = await loadSkillRecords(skills);
+    const merged = mergeSkillRecords(records);
+    await writeJsonFile(OUTPUT_PATH, merged);
+    logger.info(`Wrote ${merged.length} skills to ${OUTPUT_PATH}`);
+    return merged;
+}
+async function loadSkillRecords(descriptors) {
+    const perSource = await Promise.all(descriptors.map(async (descriptor) => {
+        const payload = await readJsonFile(descriptor.file);
+        return payload.map((record) => ({
+            source: descriptor,
+            record: SkillSchema.parse(record)
+        }));
+    }));
+    return perSource.flat();
+}
+function mergeSkillRecords(records) {
+    const state = new Map();
+    for (const entry of records) {
+        const existing = state.get(entry.record.id);
+        if (!existing) {
+            state.set(entry.record.id, { priority: entry.source.priority, record: entry.record });
+            continue;
+        }
+        const preferIncoming = shouldPreferIncoming(entry, existing);
+        if (preferIncoming) {
+            state.set(entry.record.id, {
+                priority: entry.source.priority,
+                record: mergeSkill(entry.record, existing.record)
+            });
+        }
+        else {
+            state.set(entry.record.id, {
+                priority: existing.priority,
+                record: mergeSkill(existing.record, entry.record)
+            });
+        }
+    }
+    return Array.from(state.values())
+        .map((entry) => entry.record)
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+function shouldPreferIncoming(entry, existing) {
+    if (entry.source.priority !== existing.priority) {
+        return entry.source.priority > existing.priority;
+    }
+    return entry.record.lastValidated >= existing.record.lastValidated;
+}
+function mergeSkill(primary, secondary) {
+    const mergedProficiencyLevels = dedupeStrings([
+        ...primary.proficiencyLevels,
+        ...secondary.proficiencyLevels
+    ]);
+    return {
+        ...primary,
+        description: secondary.description.length > primary.description.length ? secondary.description : primary.description,
+        aliases: dedupeStrings([...primary.aliases, ...secondary.aliases]),
+        proficiencyLevels: mergedProficiencyLevels.length > 0
+            ? mergedProficiencyLevels
+            : primary.proficiencyLevels,
+        taxonomyPath: primary.taxonomyPath.length ? primary.taxonomyPath : secondary.taxonomyPath,
+        lastValidated: primary.lastValidated >= secondary.lastValidated ? primary.lastValidated : secondary.lastValidated
+    };
+}
+function dedupeStrings(values) {
+    return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+}
+export { mergeSkillRecords, mergeSkill, dedupeStrings };

package/dist/install/dependencies.js

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
+export function hasBinary(name) {
+    const result = spawnSync('which', [name], { encoding: 'utf8' });
+    return result.status === 0;
+}
+export function resolveSkillsRuntime() {
+    if (hasBinary('skills')) {
+        return {
+            binary: 'skills',
+            prefixArgs: [],
+            label: 'skills'
+        };
+    }
+    if (hasBinary('npx')) {
+        return {
+            binary: 'npx',
+            prefixArgs: ['-y', 'skills'],
+            label: 'npx skills'
+        };
+    }
+    return null;
+}
+export function hasLegacySkillSh() {
+    return hasBinary('skill.sh');
+}
+export async function installToolkitDependencies() {
+    const installed = [];
+    if (!hasBinary('skills')) {
+        if (!hasBinary('npm')) {
+            throw new Error('npm is required to install the skills CLI automatically.');
+        }
+        if (process.env.SKILLS_MCPS_DEP_INSTALL_DRY_RUN === '1') {
+            installed.push('skills');
+            return installed;
+        }
+        await runCommand('npm', ['install', '-g', 'skills'], 'npm install -g skills');
+        installed.push('skills');
+    }
+    return installed;
+}
+async function runCommand(binary, args, label) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            stdio: 'inherit'
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to execute ${label}: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if ((code ?? 1) !== 0) {
+                reject(new Error(`${label} exited with code ${code ?? 1}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/install/review-state.js

@@ -0,0 +1,70 @@
+import { readJsonFile, writeJsonFile } from '../lib/json.js';
+import { getStatePath } from '../lib/paths.js';
+const REVIEW_STATE_PATH = getStatePath('data/system/review-state.json');
+const REVIEW_TTL_MS = 24 * 60 * 60 * 1000;
+export async function recordItemReview(id, via) {
+    const state = await loadReviewState();
+    state.reviews[id] = {
+        reviewedAt: new Date().toISOString(),
+        via
+    };
+    await writeJsonFile(REVIEW_STATE_PATH, state);
+}
+export async function hasRecentReview(id, now = Date.now()) {
+    const receipt = await getReviewReceipt(id);
+    if (!receipt) {
+        return false;
+    }
+    const reviewedAtMs = Date.parse(receipt.reviewedAt);
+    if (Number.isNaN(reviewedAtMs)) {
+        return false;
+    }
+    return now - reviewedAtMs <= REVIEW_TTL_MS;
+}
+export async function assertRecentReview(id) {
+    if (await hasRecentReview(id)) {
+        return;
+    }
+    throw new Error(`Review required before install for ${id}. Run \`plugscout show --id ${id}\` or \`plugscout assess --id ${id}\`, then retry. Use --override-review only if you intentionally want to bypass this safeguard.`);
+}
+export function getReviewStatePath() {
+    return REVIEW_STATE_PATH;
+}
+async function getReviewReceipt(id) {
+    const state = await loadReviewState();
+    return state.reviews[id] ?? null;
+}
+async function loadReviewState() {
+    try {
+        const raw = await readJsonFile(REVIEW_STATE_PATH);
+        if (!raw || typeof raw !== 'object') {
+            return { reviews: {} };
+        }
+        const reviews = raw.reviews;
+        if (!reviews || typeof reviews !== 'object') {
+            return { reviews: {} };
+        }
+        const normalized = {};
+        Object.entries(reviews).forEach(([id, value]) => {
+            if (!value || typeof value !== 'object') {
+                return;
+            }
+            const reviewedAt = typeof value.reviewedAt === 'string'
+                ? value.reviewedAt
+                : null;
+            const via = value.via;
+            if (!reviewedAt || (via !== 'show' && via !== 'assess')) {
+                return;
+            }
+            normalized[id] = { reviewedAt, via };
+        });
+        return { reviews: normalized };
+    }
+    catch (error) {
+        const maybeFsError = error;
+        if (maybeFsError.code === 'ENOENT') {
+            return { reviews: {} };
+        }
+        throw error;
+    }
+}

package/dist/install/skillsh.js

@@ -0,0 +1,245 @@
+import { spawn } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
+import { loadSecurityPolicy } from '../config/runtime.js';
+import { loadCatalogItemById } from '../catalog/repository.js';
+import { logger } from '../lib/logger.js';
+import { writeJsonFile } from '../lib/json.js';
+import { getStatePath } from '../lib/paths.js';
+import { InstallAuditSchema } from '../lib/validation/contracts.js';
+import { buildAssessment, isBlockedTier, isWarnTier } from '../security/assessment.js';
+import { hasLegacySkillSh, resolveSkillsRuntime } from './dependencies.js';
+import { assertRecentReview } from './review-state.js';
+export async function installWithSkillSh(options) {
+    const record = await loadCatalogItemById(options.id);
+    if (!record) {
+        throw new Error(`Catalog entry not found: ${options.id}`);
+    }
+    if (!options.overrideReview) {
+        await assertRecentReview(options.id);
+    }
+    const policy = await loadSecurityPolicy();
+    const assessment = buildAssessment(record, policy);
+    if (isBlockedTier(assessment.riskTier, policy) && !options.overrideRisk) {
+        await persistAudit({
+            id: options.id,
+            requestedAt: new Date().toISOString(),
+            policyDecision: 'blocked',
+            overrideUsed: false,
+            installer: record.install.kind,
+            exitCode: 1
+        });
+        throw new Error(`Blocked by security policy (${assessment.riskTier}, score=${assessment.riskScore}). Use --override-risk to force.`);
+    }
+    if (isWarnTier(assessment.riskTier, policy)) {
+        logger.warn(`Security warning for ${options.id}: ${assessment.riskTier} (${assessment.riskScore})`);
+    }
+    const { exitCode, installer } = await executeInstall(record, options.yes);
+    return persistAudit({
+        id: options.id,
+        requestedAt: new Date().toISOString(),
+        policyDecision: options.overrideRisk ? 'override-allowed' : 'allowed',
+        overrideUsed: options.overrideRisk,
+        installer,
+        exitCode
+    });
+}
+async function executeInstall(item, yes) {
+    const install = item.install;
+    if (install.kind === 'manual') {
+        logger.info(`Manual install required: ${install.instructions}${install.url ? ` (${install.url})` : ''}`);
+        return { exitCode: 0, installer: 'manual' };
+    }
+    if (install.kind === 'skill.sh') {
+        const plan = resolvePreferredInstallPlan(item, yes);
+        if (plan) {
+            const exitCode = await executeCommand(plan.binary, plan.args, plan.label);
+            return { exitCode, installer: plan.installer };
+        }
+        ensureLegacySkillShAvailable(item.id);
+        const commandArgs = buildSkillShInstallArgs(install.target, install.args, yes);
+        const exitCode = await executeCommand('skill.sh', commandArgs, 'skill.sh');
+        return { exitCode, installer: 'skill.sh' };
+    }
+    ensureBinaryAvailable('gh', 'gh CLI is required for gh-cli installers. Install it and verify with: gh --version');
+    const commandArgs = buildGhInstallArgs(install.target, install.args, yes);
+    const exitCode = await executeCommand('gh', commandArgs, 'gh');
+    return { exitCode, installer: 'gh-cli' };
+}
+export function buildSkillShInstallArgs(target, args, yes) {
+    const commandArgs = ['install', target, ...args];
+    if (yes) {
+        commandArgs.push('--yes');
+    }
+    return commandArgs;
+}
+export function buildGhInstallArgs(target, args, yes) {
+    const commandArgs = [...args];
+    if (commandArgs.length === 0) {
+        commandArgs.push(target);
+    }
+    if (yes) {
+        commandArgs.push('--yes');
+    }
+    return commandArgs;
+}
+export function resolvePreferredInstallPlan(item, yes) {
+    if (item.install.kind !== 'skill.sh') {
+        return null;
+    }
+    const modernSkillPlan = buildModernSkillsInstallArgs(item, yes);
+    if (modernSkillPlan) {
+        return modernSkillPlan;
+    }
+    const directMcpPlan = buildDirectMcpInstallArgs(item);
+    if (directMcpPlan) {
+        return directMcpPlan;
+    }
+    return null;
+}
+function buildModernSkillsInstallArgs(item, yes) {
+    if (item.kind !== 'skill' || item.install.kind !== 'skill.sh') {
+        return null;
+    }
+    const runtime = resolveSkillsRuntime();
+    if (!runtime) {
+        return null;
+    }
+    const metadata = item.metadata;
+    const registryId = typeof metadata.sourceRegistryId === 'string'
+        ? metadata.sourceRegistryId
+        : typeof metadata.marketplaceRegistry === 'string'
+            ? metadata.marketplaceRegistry
+            : '';
+    const githubUrl = typeof metadata.githubUrl === 'string' ? metadata.githubUrl : '';
+    const repoUrl = resolveSkillsRepoUrl(registryId, githubUrl);
+    if (!repoUrl) {
+        return null;
+    }
+    const slug = resolveSkillSlug(item.id, metadata);
+    if (!slug) {
+        return null;
+    }
+    const args = runtime.prefixArgs.concat(['add', repoUrl, '--skill', slug, '--agent', '*']);
+    if (yes) {
+        args.push('--yes');
+    }
+    return {
+        binary: runtime.binary,
+        args,
+        label: runtime.label,
+        installer: 'skills'
+    };
+}
+function buildDirectMcpInstallArgs(item) {
+    if (item.kind !== 'mcp' || item.install.kind !== 'skill.sh') {
+        return null;
+    }
+    const target = item.install.target;
+    if (isDockerTarget(target)) {
+        return {
+            binary: 'docker',
+            args: ['pull', target],
+            label: 'docker',
+            installer: 'docker'
+        };
+    }
+    if (isNodePackageTarget(item, target)) {
+        return {
+            binary: 'npm',
+            args: ['install', '-g', target],
+            label: 'npm',
+            installer: 'npm'
+        };
+    }
+    return null;
+}
+function resolveSkillsRepoUrl(registryId, githubUrl) {
+    if (registryId === 'openai-skills-curated' || githubUrl.includes('github.com/openai/skills')) {
+        return 'https://github.com/openai/skills';
+    }
+    if (registryId === 'anthropic-skills' || githubUrl.includes('github.com/anthropics/skills')) {
+        return 'https://github.com/anthropics/skills';
+    }
+    return null;
+}
+function resolveSkillSlug(id, metadata) {
+    const prefixed = id.startsWith('skill:') ? id.slice('skill:'.length) : id;
+    if (prefixed.length > 0) {
+        return prefixed;
+    }
+    const githubPath = typeof metadata.githubPath === 'string' ? metadata.githubPath : '';
+    if (githubPath.length > 0) {
+        return githubPath.split('/').at(-1) ?? null;
+    }
+    const bundledSkillPath = typeof metadata.bundledSkillPath === 'string' ? metadata.bundledSkillPath : '';
+    if (bundledSkillPath.length > 0) {
+        return bundledSkillPath.split('/').at(-1) ?? null;
+    }
+    return null;
+}
+function isDockerTarget(target) {
+    return /^(docker\.io\/|ghcr\.io\/)/.test(target) || (/^[\w.-]+\/[\w./-]+:[\w.-]+$/.test(target) && target.includes('/'));
+}
+function isNodePackageTarget(item, target) {
+    if (!/^(@[a-z0-9_.-]+\/[a-z0-9_.-]+|[a-z0-9][a-z0-9._-]*)$/i.test(target)) {
+        return false;
+    }
+    const metadata = item.metadata;
+    const registryType = typeof metadata.packageRegistryType === 'string' ? metadata.packageRegistryType.toLowerCase() : '';
+    const runtime = typeof metadata.packageRuntime === 'string' ? metadata.packageRuntime.toLowerCase() : '';
+    if (registryType.includes('npm') || runtime.includes('node')) {
+        return true;
+    }
+    return item.compatibility.includes('node');
+}
+async function executeCommand(binary, args, label) {
+    if (process.env.SKILLS_MCPS_INSTALL_DRY_RUN === '1') {
+        logger.info(`Dry-run ${label} ${args.join(' ')}`);
+        return 0;
+    }
+    if (binary === 'docker') {
+        ensureBinaryAvailable('docker', 'Docker is required for container-backed MCP installs. Install Docker Desktop or a compatible docker runtime.');
+    }
+    if (binary === 'npm') {
+        ensureBinaryAvailable('npm', 'npm is required for Node package installs. Install Node.js and verify with: npm --version');
+    }
+    if (binary === 'skills') {
+        ensureBinaryAvailable('skills', 'skills CLI is required. Run `plugscout doctor --install-deps` to install it.');
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            stdio: 'inherit'
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to execute ${label}: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+function ensureBinaryAvailable(binary, suggestion) {
+    if (process.env.SKILLS_MCPS_INSTALL_DRY_RUN === '1') {
+        return;
+    }
+    const result = spawnSync('which', [binary], { encoding: 'utf8' });
+    if (result.status !== 0) {
+        throw new Error(`${binary} is not available in PATH. ${suggestion}`);
+    }
+}
+function ensureLegacySkillShAvailable(id) {
+    if (process.env.SKILLS_MCPS_INSTALL_DRY_RUN === '1') {
+        return;
+    }
+    if (hasLegacySkillSh()) {
+        return;
+    }
+    throw new Error(`skill.sh is not available in PATH. This item (${id}) still requires the legacy skill.sh installer. Run \`plugscout doctor --install-deps\` to bootstrap the modern skills CLI for supported skill installs, or install skill.sh manually for legacy skill.sh items.`);
+}
+async function persistAudit(record) {
+    const parsed = InstallAuditSchema.parse(record);
+    const stamp = parsed.requestedAt.replace(/[:.]/g, '-');
+    const file = getStatePath(`data/security-reports/audits/${stamp}-${parsed.id.replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+    await writeJsonFile(file, parsed);
+    return parsed;
+}

package/dist/interfaces/cli/doctor.js

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { getStaleRegistries, loadSyncState } from '../../catalog/sync-state.js';
+import { loadCatalogItems } from '../../catalog/repository.js';
+import { hasLegacySkillSh, resolveSkillsRuntime } from '../../install/dependencies.js';
+export async function runDoctorChecks(projectPath = '.') {
+    const checks = [];
+    checks.push(checkSkillsRuntime());
+    checks.push(hasLegacySkillSh()
+        ? { name: 'Legacy skill.sh', status: 'pass', message: 'skill.sh available' }
+        : {
+            name: 'Legacy skill.sh',
+            status: 'warn',
+            message: 'skill.sh not found',
+            suggestion: 'Optional: some legacy MCP installs still expect skill.sh. Official skills can install through the modern skills CLI.'
+        });
+    checks.push(checkBinary('gh'));
+    const nodeMajor = Number(process.versions.node.split('.')[0]);
+    checks.push(nodeMajor >= 18
+        ? { name: 'Node version', status: 'pass', message: `Node ${process.versions.node}` }
+        : {
+            name: 'Node version',
+            status: 'fail',
+            message: `Node ${process.versions.node}`,
+            suggestion: 'Upgrade to Node >=18.17'
+        });
+    try {
+        const items = await loadCatalogItems();
+        checks.push(items.length > 0
+            ? { name: 'Catalog', status: 'pass', message: `${items.length} items loaded` }
+            : { name: 'Catalog', status: 'warn', message: 'Catalog is empty', suggestion: 'Run: npm run sync' });
+    }
+    catch {
+        checks.push({ name: 'Catalog', status: 'fail', message: 'Catalog unreadable', suggestion: 'Run: npm run sync' });
+    }
+    const syncState = await loadSyncState();
+    const stale = getStaleRegistries(syncState);
+    checks.push(stale.length === 0
+        ? { name: 'Sync freshness', status: 'pass', message: 'No stale registries' }
+        : {
+            name: 'Sync freshness',
+            status: 'warn',
+            message: `${stale.length} stale registries`,
+            suggestion: 'Run: npm run sync'
+        });
+    const configPath = path.resolve(projectPath, '.skills-mcps.json');
+    try {
+        const raw = await fs.readFile(configPath, 'utf8');
+        JSON.parse(raw);
+        checks.push({ name: 'Local config', status: 'pass', message: '.skills-mcps.json is valid' });
+    }
+    catch {
+        checks.push({
+            name: 'Local config',
+            status: 'warn',
+            message: '.skills-mcps.json missing or invalid',
+            suggestion: 'Run: npm run dev -- init'
+        });
+    }
+    return checks;
+}
+function checkSkillsRuntime() {
+    const runtime = resolveSkillsRuntime();
+    if (runtime) {
+        return {
+            name: 'Skills CLI',
+            status: 'pass',
+            message: `${runtime.label} available`
+        };
+    }
+    return {
+        name: 'Skills CLI',
+        status: 'fail',
+        message: 'skills CLI not found',
+        suggestion: 'Run: plugscout doctor --install-deps'
+    };
+}
+function checkBinary(name, options = {}) {
+    const result = spawnSync('which', [name], { encoding: 'utf8' });
+    if (result.status === 0) {
+        return { name, status: 'pass', message: `${name} available` };
+    }
+    return {
+        name,
+        status: options.required ? 'fail' : 'warn',
+        message: `${name} not found`,
+        suggestion: options.suggestion ?? `Install ${name}`
+    };
+}

package/dist/interfaces/cli/formatters/colors.js

@@ -0,0 +1,24 @@
+const enabled = process.env.NO_COLOR !== '1';
+function wrap(code, value) {
+    if (!enabled) {
+        return value;
+    }
+    return `\u001b[${code}m${value}\u001b[0m`;
+}
+export const colors = {
+    green: (value) => wrap(32, value),
+    yellow: (value) => wrap(33, value),
+    red: (value) => wrap(31, value),
+    cyan: (value) => wrap(36, value),
+    gray: (value) => wrap(90, value),
+    bold: (value) => wrap(1, value)
+};
+export function colorRisk(tier, value) {
+    if (tier === 'low') {
+        return colors.green(value);
+    }
+    if (tier === 'medium') {
+        return colors.yellow(value);
+    }
+    return colors.red(value);
+}

package/dist/interfaces/cli/formatters/csv.js

@@ -0,0 +1,10 @@
+export function renderCsv(headers, rows) {
+    const lines = [headers, ...rows].map((line) => line.map(escapeCell).join(','));
+    return `${lines.join('\n')}\n`;
+}
+function escapeCell(value) {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+        return `"${value.replaceAll('"', '""')}"`;
+    }
+    return value;
+}

package/dist/interfaces/cli/formatters/json.js

@@ -0,0 +1,3 @@
+export function renderJson(value) {
+    return JSON.stringify(value, null, 2);
+}

package/dist/interfaces/cli/formatters/markdown.js

@@ -0,0 +1,6 @@
+export function renderMarkdown(headers, rows) {
+    const head = `| ${headers.join(' | ')} |`;
+    const divider = `| ${headers.map(() => '---').join(' | ')} |`;
+    const body = rows.map((row) => `| ${row.join(' | ')} |`).join('\n');
+    return `${head}\n${divider}\n${body}\n`;
+}

package/dist/interfaces/cli/formatters/table.js

@@ -0,0 +1,82 @@
+import { colorRisk, colors } from './colors.js';
+export function scoreBar(score, size = 10) {
+    const clamped = Math.max(0, Math.min(100, score));
+    const filled = Math.round((clamped / 100) * size);
+    return `${'█'.repeat(filled)}${'░'.repeat(size - filled)}`;
+}
+export function renderTable(columns, rows, options = {}) {
+    const header = columns
+        .map((column) => pad(column.header, column.width))
+        .join('  ');
+    const divider = columns
+        .map((column) => '-'.repeat(column.width))
+        .join('  ');
+    const body = rows.flatMap((row) => renderRow(columns, row, options));
+    return [colors.bold(header), colors.gray(divider), ...body].join('\n');
+}
+function renderRow(columns, row, options) {
+    if (!options.wrap) {
+        return [
+            columns
+                .map((column) => {
+                const value = String(row[column.key] ?? '');
+                const clipped = clip(value, column.width);
+                if (options.riskKey && column.key === options.riskKey) {
+                    return pad(colorRisk(value.toLowerCase(), clipped), column.width);
+                }
+                return pad(clipped, column.width);
+            })
+                .join('  ')
+        ];
+    }
+    const wrappedCells = columns.map((column) => {
+        const value = String(row[column.key] ?? '');
+        return wrapToWidth(value, column.width);
+    });
+    const rowHeight = wrappedCells.reduce((max, cell) => Math.max(max, cell.length), 1);
+    const lines = [];
+    for (let line = 0; line < rowHeight; line += 1) {
+        lines.push(columns
+            .map((column, index) => {
+            const raw = wrappedCells[index][line] ?? '';
+            if (options.riskKey && column.key === options.riskKey) {
+                return pad(colorRisk(String(row[column.key] ?? '').toLowerCase(), raw), column.width);
+            }
+            return pad(raw, column.width);
+        })
+            .join('  '));
+    }
+    return lines;
+}
+function clip(value, width) {
+    if (value.length <= width) {
+        return value;
+    }
+    if (width <= 1) {
+        return value.slice(0, width);
+    }
+    return `${value.slice(0, width - 1)}…`;
+}
+function pad(value, width) {
+    if (value.length >= width) {
+        return value;
+    }
+    return `${value}${' '.repeat(width - value.length)}`;
+}
+function wrapToWidth(value, width) {
+    if (value.length <= width) {
+        return [value];
+    }
+    const output = [];
+    let remaining = value;
+    while (remaining.length > width) {
+        let cut = remaining.lastIndexOf(' ', width);
+        if (cut <= 0) {
+            cut = width;
+        }
+        output.push(remaining.slice(0, cut));
+        remaining = remaining.slice(cut).trimStart();
+    }
+    output.push(remaining);
+    return output;
+}