import { normalizeSkillIndexName } from "../skills/discovery/skill-index.js";

import type { SkillStatusEntry, SkillStatusReport } from "../skills/discovery/status.js";

import {

resolveSkillStatusEntry,

type SkillStatusEntry,

type SkillStatusReport,

} from "../skills/discovery/status.js";

import { sanitizeForLog, stripAnsi } from "../terminal/ansi.js";

import { decorativeEmoji, decorativePrefix } from "../terminal/decorative-emoji.js";

import { getTerminalTableWidth, renderTable } from "../terminal/table.js";

return missing.join("; ");

}

function normalizeSkillLookupToken(value: string): string {

return normalizeSkillIndexName(value);

}

function resolveSkillByName(

report: SkillStatusReport,

requestedName: string,

): SkillStatusEntry | null {

const raw = requestedName.trim();

if (!raw) {

return null;

}

const direct = report.skills.find((s) => s.name === raw || s.skillKey === raw);

if (direct) {

return direct;

}

const lower = raw.toLowerCase();

const caseInsensitiveMatches = report.skills.filter(

(s) => s.name.toLowerCase() === lower || s.skillKey.toLowerCase() === lower,

);

if (caseInsensitiveMatches.length === 1) {

return caseInsensitiveMatches[0] ?? null;

}

if (caseInsensitiveMatches.length > 1) {

return null;

}

const normalized = normalizeSkillLookupToken(raw);

if (!normalized) {

return null;

}

const normalizedMatches = report.skills.filter(

(s) =>

normalizeSkillLookupToken(s.name) === normalized ||

normalizeSkillLookupToken(s.skillKey) === normalized,

);

if (normalizedMatches.length !== 1) {

return null;

}

return normalizedMatches[0] ?? null;

}

export function formatSkillsList(report: SkillStatusReport, opts: SkillsListOptions): string {

const isReadyForAgent = (skill: SkillStatusEntry) =>

skill.eligible && !skill.blockedByAgentFilter;

): string {

const requestedName = skillName.trim();

const safeRequestedName = sanitizeJsonString(sanitizeForLog(requestedName));

const skill = resolveSkillByName(report, requestedName);

const skill = resolveSkillStatusEntry(report.skills, requestedName);

if (!skill) {

if (opts.json) {

SkillsInstallPreferences,

} from "../types.js";

import { resolveEffectiveAgentSkillFilter } from "./agent-filter.js";

import { buildSkillIndexEntries, type SkillIndexEntry } from "./skill-index.js";

import {

buildSkillIndexEntries,

normalizeSkillIndexName,

type SkillIndexEntry,

} from "./skill-index.js";

export type SkillStatusConfigCheck = RequirementConfigCheck;

skills: SkillStatusEntry[];

};

export function resolveSkillStatusEntry(

skills: readonly SkillStatusEntry[],

requestedName: string,

): SkillStatusEntry | null {

const raw = requestedName.trim();

if (!raw) {

return null;

}

const lower = raw.toLowerCase();

const normalized = normalizeSkillIndexName(raw);

let caseInsensitiveMatch: SkillStatusEntry | null = null;

let caseInsensitiveMatches = 0;

let normalizedMatch: SkillStatusEntry | null = null;

let normalizedMatches = 0;

for (const skill of skills) {

if (skill.name === raw || skill.skillKey === raw) {

return skill;

}

const nameLower = skill.name.toLowerCase();

const keyLower = skill.skillKey.toLowerCase();

if (nameLower === lower || keyLower === lower) {

caseInsensitiveMatch = skill;

caseInsensitiveMatches += 1;

continue;

}

if (

normalized &&

(normalizeSkillIndexName(skill.name) === normalized ||

normalizeSkillIndexName(skill.skillKey) === normalized)

) {

normalizedMatch = skill;

normalizedMatches += 1;

}

}

if (caseInsensitiveMatches > 1) {

return null;

}

if (caseInsensitiveMatches === 1) {

return caseInsensitiveMatch;

}

if (normalizedMatches === 1) {

return normalizedMatch;

}

return null;

}

function selectPreferredInstallSpec(

install: SkillInstallSpec[],

prefs: SkillsInstallPreferences,