nymor 1.0.1

package/dist/commands/doctor.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const glob_1 = require("glob");
+const yaml_1 = __importDefault(require("yaml"));
+const targets_1 = require("../agents/targets");
+const compile_1 = require("./compile");
+const paths_1 = require("../utils/paths");
+const skills_1 = require("../utils/skills");
+const VALID_AGENTS = targets_1.AGENT_TARGETS.map((target) => target.id);
+async function doctorCommand() {
+    const projectRoot = process.cwd();
+    const results = [];
+    await checkManifest(projectRoot, results);
+    const frontmatters = await checkSkillFrontmatter(projectRoot, results);
+    await checkGlobExistence(projectRoot, frontmatters, results);
+    checkDuplicateNames(projectRoot, frontmatters, results);
+    await checkCompiledOutput(projectRoot, results);
+    for (const result of results) {
+        const status = result.warn ? "WARN" : result.ok ? "PASS" : "FAIL";
+        console.log(`${status} ${result.label} - ${result.filePath}${result.message ? ` - ${result.message}` : ""}`);
+    }
+    if (results.some((result) => !result.ok && !result.warn)) {
+        process.exitCode = 1;
+    }
+}
+async function checkManifest(projectRoot, results) {
+    const manifestPath = (0, paths_1.getManifestPath)(projectRoot);
+    try {
+        const manifest = (await fs_extra_1.default.readJson(manifestPath));
+        const errors = [];
+        if (manifest.version !== "1") {
+            errors.push('version must be "1"');
+        }
+        const invalidAgents = (manifest.agents ?? []).filter((agent) => !VALID_AGENTS.includes(agent));
+        if (invalidAgents.length > 0) {
+            errors.push(`invalid agents: ${invalidAgents.join(", ")}`);
+        }
+        results.push({
+            ok: errors.length === 0,
+            label: "Manifest sanity",
+            filePath: manifestPath,
+            message: errors.join("; ")
+        });
+        return errors.length === 0 ? normalizeManifest(manifest) : null;
+    }
+    catch (err) {
+        results.push({
+            ok: false,
+            label: "Manifest sanity",
+            filePath: manifestPath,
+            message: err instanceof Error ? err.message : String(err)
+        });
+        return null;
+    }
+}
+async function checkSkillFrontmatter(projectRoot, results) {
+    const skillsDir = (0, paths_1.getSkillsDir)(projectRoot);
+    const skillDirs = await (0, skills_1.listSkillDirectories)(skillsDir);
+    const parsed = [];
+    for (const id of skillDirs) {
+        const skillPath = path_1.default.join(skillsDir, id, "SKILL.md");
+        const errors = [];
+        let frontmatter = {};
+        if (!(await fs_extra_1.default.pathExists(skillPath))) {
+            errors.push("missing SKILL.md");
+        }
+        else {
+            try {
+                frontmatter = parseFrontmatter(await fs_extra_1.default.readFile(skillPath, "utf8"));
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err.message : String(err));
+            }
+        }
+        if (!frontmatter.name) {
+            errors.push("missing name");
+        }
+        if (frontmatter.globs !== undefined && !Array.isArray(frontmatter.globs)) {
+            errors.push("globs must be an array");
+        }
+        const isValid = errors.length === 0;
+        results.push({
+            ok: isValid,
+            label: "Frontmatter validity",
+            filePath: skillPath,
+            message: errors.join("; ")
+        });
+        parsed.push({
+            id,
+            filePath: skillPath,
+            name: typeof frontmatter.name === "string" ? frontmatter.name : "",
+            globs: Array.isArray(frontmatter.globs) ? frontmatter.globs.map(String) : [],
+            alwaysApply: Boolean(frontmatter.alwaysApply),
+            valid: isValid
+        });
+    }
+    return parsed;
+}
+async function checkGlobExistence(projectRoot, frontmatters, results) {
+    for (const skill of frontmatters) {
+        if (!skill.valid || skill.alwaysApply || skill.globs.length === 0) {
+            continue;
+        }
+        const missing = [];
+        for (const pattern of skill.globs) {
+            const matches = await (0, glob_1.glob)(pattern, {
+                cwd: projectRoot,
+                nodir: true,
+                dot: true,
+                ignore: ["**/node_modules/**", "**/.git/**", "**/.nymor/**"]
+            });
+            if (matches.length === 0) {
+                missing.push(pattern);
+            }
+        }
+        results.push({
+            ok: missing.length === 0,
+            label: "Glob existence",
+            filePath: skill.filePath,
+            message: missing.length > 0 ? `no matches: ${missing.join(", ")}` : ""
+        });
+    }
+}
+function checkDuplicateNames(projectRoot, frontmatters, results) {
+    const seen = new Map();
+    for (const skill of frontmatters.filter((item) => item.valid)) {
+        const previous = seen.get(skill.name);
+        if (previous) {
+            results.push({
+                ok: false,
+                label: "Duplicate names",
+                filePath: skill.filePath,
+                message: `duplicates ${previous.filePath}`
+            });
+        }
+        else {
+            seen.set(skill.name, skill);
+        }
+    }
+    if (![...seen.values()].some((skill) => hasDuplicate(skill.name, frontmatters))) {
+        results.push({
+            ok: true,
+            label: "Duplicate names",
+            filePath: (0, paths_1.getSkillsDir)(projectRoot),
+            message: ""
+        });
+    }
+}
+async function checkCompiledOutput(projectRoot, results) {
+    try {
+        const planned = await (0, compile_1.planCompileOutputs)(projectRoot);
+        const stale = [];
+        for (const file of planned) {
+            if (!(await fs_extra_1.default.pathExists(file.path))) {
+                stale.push(file.path);
+                continue;
+            }
+            const actual = await fs_extra_1.default.readFile(file.path);
+            if (!actual.equals(file.content)) {
+                stale.push(file.path);
+            }
+        }
+        results.push({
+            ok: stale.length === 0,
+            label: "Compiled output staleness",
+            filePath: projectRoot,
+            message: stale.length > 0 ? "run `nymor compile`" : ""
+        });
+    }
+    catch (err) {
+        results.push({
+            ok: false,
+            label: "Compiled output staleness",
+            filePath: projectRoot,
+            message: err instanceof Error ? err.message : String(err)
+        });
+    }
+}
+function parseFrontmatter(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        throw new Error("missing frontmatter");
+    }
+    const endIndex = lines.slice(1).findIndex((line) => line.trim() === "---");
+    if (endIndex === -1) {
+        throw new Error("frontmatter is not closed");
+    }
+    return (yaml_1.default.parse(lines.slice(1, endIndex + 1).join("\n")) ?? {});
+}
+function normalizeManifest(manifest) {
+    return {
+        version: manifest.version,
+        agents: manifest.agents ?? [],
+        local: manifest.local ?? []
+    };
+}
+function hasDuplicate(name, frontmatters) {
+    return frontmatters.filter((skill) => skill.valid && skill.name === name).length > 1;
+}

package/dist/commands/init.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const targets_1 = require("../agents/targets");
+const compile_1 = require("./compile");
+const agents_1 = require("../detector/agents");
+const nymor_json_1 = require("../templates/nymor-json");
+const manifest_1 = require("../utils/manifest");
+const paths_1 = require("../utils/paths");
+const AGENT_CHOICES = targets_1.AGENT_TARGETS.map((target) => ({
+    name: `${target.label} (${target.description})`,
+    value: target.id,
+    short: target.short
+}));
+async function initCommand() {
+    const projectRoot = process.cwd();
+    const nymorDir = (0, paths_1.getNymorDir)(projectRoot);
+    const skillsDir = (0, paths_1.getSkillsDir)(projectRoot);
+    const mode = await resolveInitMode(nymorDir);
+    if (!mode) {
+        return;
+    }
+    if (mode === "reinit") {
+        await fs_extra_1.default.remove(nymorDir);
+    }
+    const manifestPath = (0, paths_1.getManifestPath)(projectRoot);
+    const existingManifest = (await fs_extra_1.default.pathExists(manifestPath)) ? await (0, manifest_1.readManifest)(projectRoot) : null;
+    const manifest = (0, nymor_json_1.createDefaultManifest)();
+    manifest.agents = await selectAgentTargets(projectRoot, existingManifest?.agents);
+    manifest.local = mode === "reinit" ? [] : existingManifest?.local ?? [];
+    await (0, manifest_1.writeManifest)(projectRoot, manifest);
+    await fs_extra_1.default.ensureDir(skillsDir);
+    await (0, compile_1.compileCommand)();
+    printSummary(manifest.agents);
+}
+async function resolveInitMode(nymorDir) {
+    if (!(await fs_extra_1.default.pathExists(nymorDir))) {
+        return "new";
+    }
+    if (!process.stdin.isTTY) {
+        return "update";
+    }
+    const { action } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "action",
+            message: "Nymor already initialized. What do you want to do?",
+            choices: [
+                { name: "Update agent targets", value: "update" },
+                { name: "Reinitialize (overwrites .nymor/)", value: "reinit" },
+                { name: "Cancel", value: "cancel" }
+            ]
+        }
+    ]);
+    return action === "cancel" ? null : action;
+}
+async function selectAgentTargets(projectRoot, existingAgents) {
+    const detectedAgents = await detectExistingAgentTargets(projectRoot);
+    const defaults = existingAgents && existingAgents.length > 0 ? existingAgents : detectedAgents;
+    if (!process.stdin.isTTY) {
+        return defaults.length > 0 ? defaults : [...targets_1.DEFAULT_AGENT_TARGETS];
+    }
+    const { agents } = await inquirer_1.default.prompt([
+        {
+            type: "checkbox",
+            name: "agents",
+            message: "Which agent outputs should Nymor manage?",
+            choices: AGENT_CHOICES,
+            default: defaults.length > 0 ? defaults : targets_1.DEFAULT_AGENT_TARGETS
+        }
+    ]);
+    return agents;
+}
+async function detectExistingAgentTargets(projectRoot) {
+    const detected = await (0, agents_1.detectAgents)(projectRoot);
+    return targets_1.AGENT_TARGETS.filter((target) => detected[target.id]).map((target) => target.id);
+}
+function printSummary(agents) {
+    const checkMark = "\u2713";
+    console.log("");
+    console.log(`${checkMark} Nymor initialized`);
+    console.log("");
+    console.log("Skills directory: .nymor/skills/");
+    console.log("Index created:    .nymor/index.md");
+    console.log(`Agent outputs:    ${formatAgentSummary(agents)}`);
+}
+function formatAgentSummary(agents) {
+    if (agents.length === 0) {
+        return "none selected";
+    }
+    const labels = new Map(AGENT_CHOICES.map((choice) => [choice.value, choice.short]));
+    return agents.map((agent) => labels.get(agent) ?? agent).join(", ");
+}

package/dist/commands/inject.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectCommand = injectCommand;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const skills_1 = require("../utils/skills");
+async function injectCommand() {
+    const skillsDir = path_1.default.join(process.cwd(), ".cicada", "skills");
+    if (!(await fs_extra_1.default.pathExists(skillsDir))) {
+        console.log("No skills found. Run cicada init first.");
+        process.exitCode = 1;
+        return;
+    }
+    const files = (await (0, skills_1.listMarkdownFiles)(skillsDir)).sort();
+    const contents = [];
+    for (const file of files) {
+        const content = await fs_extra_1.default.readFile(path_1.default.join(skillsDir, file), "utf8");
+        contents.push(content.trimEnd());
+    }
+    process.stdout.write(contents.join("\n---\n"));
+}

package/dist/commands/learn.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.learnCommand = learnCommand;
+exports.slugifyRule = slugifyRule;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const yaml_1 = __importDefault(require("yaml"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const compile_1 = require("./compile");
+const manifest_1 = require("../utils/manifest");
+const paths_1 = require("../utils/paths");
+async function learnCommand(rule, options = {}) {
+    const projectRoot = process.cwd();
+    const slug = slugifyRule(options.id ?? rule);
+    const skillDir = path_1.default.join((0, paths_1.getSkillsDir)(projectRoot), slug);
+    const skillPath = path_1.default.join(skillDir, "SKILL.md");
+    if (await fs_extra_1.default.pathExists(skillPath)) {
+        throw new Error(`A local skill already exists at ${skillPath}`);
+    }
+    const answers = await promptForSkill(rule, slug, options);
+    const frontmatter = yaml_1.default.stringify({
+        name: answers.name,
+        description: answers.description,
+        globs: parseGlobs(answers.globs),
+        alwaysApply: answers.alwaysApply
+    });
+    const content = [
+        "---",
+        frontmatter.trimEnd(),
+        "---",
+        "",
+        `# Skill: ${answers.name}`,
+        "",
+        "## Rule",
+        rule,
+        "",
+        "## Why",
+        answers.why,
+        "",
+        "## Example",
+        answers.example,
+        ""
+    ].join("\n");
+    await fs_extra_1.default.ensureDir(skillDir);
+    await fs_extra_1.default.writeFile(skillPath, content, "utf8");
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    if (!manifest.local.includes(slug)) {
+        manifest.local.push(slug);
+    }
+    await (0, manifest_1.writeManifest)(projectRoot, manifest);
+    await (0, compile_1.compileCommand)();
+    console.log("");
+    console.log(`${picocolors_1.default.green("✓")} Created local skill: ${skillPath}`);
+}
+function slugifyRule(rule) {
+    const slug = rule
+        .toLowerCase()
+        .replace(/['"]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 50)
+        .replace(/-+$/g, "");
+    return slug || "new-skill";
+}
+function parseGlobs(value) {
+    return value
+        .split(",")
+        .map((glob) => glob.trim())
+        .filter(Boolean);
+}
+function titleCase(value) {
+    return value
+        .split("-")
+        .filter(Boolean)
+        .map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`)
+        .join(" ");
+}
+async function promptForSkill(rule, slug, options) {
+    const defaults = {
+        name: options.name ?? titleCase(slug),
+        description: options.description ?? rule,
+        globs: options.globs ?? "**/*",
+        alwaysApply: options.alwaysApply ?? false,
+        why: options.why ?? "TBD - describe why",
+        example: options.example ?? "TBD - add an example"
+    };
+    if (!process.stdin.isTTY) {
+        return defaults;
+    }
+    const questions = [];
+    if (options.name === undefined) {
+        questions.push({
+            type: "input",
+            name: "name",
+            message: "Skill name",
+            default: defaults.name
+        });
+    }
+    if (options.description === undefined) {
+        questions.push({
+            type: "input",
+            name: "description",
+            message: "Description",
+            default: defaults.description
+        });
+    }
+    if (options.globs === undefined) {
+        questions.push({
+            type: "input",
+            name: "globs",
+            message: "Globs",
+            default: defaults.globs
+        });
+    }
+    if (options.alwaysApply === undefined) {
+        questions.push({
+            type: "confirm",
+            name: "alwaysApply",
+            message: "Always apply?",
+            default: defaults.alwaysApply
+        });
+    }
+    if (options.why === undefined) {
+        questions.push({
+            type: "input",
+            name: "why",
+            message: "Why",
+            default: defaults.why
+        });
+    }
+    if (options.example === undefined) {
+        questions.push({
+            type: "input",
+            name: "example",
+            message: "Example",
+            default: defaults.example
+        });
+    }
+    const answers = questions.length > 0 ? await inquirer_1.default.prompt(questions) : {};
+    return { ...defaults, ...answers };
+}

package/dist/commands/list.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const paths_1 = require("../utils/paths");
+const skills_1 = require("../utils/skills");
+const manifest_1 = require("../utils/manifest");
+async function listCommand() {
+    const projectRoot = process.cwd();
+    const skillsDir = (0, paths_1.getSkillsDir)(projectRoot);
+    const indexJsonPath = (0, paths_1.getIndexJsonPath)(projectRoot);
+    if (!(await fs_extra_1.default.pathExists(skillsDir))) {
+        console.log("No skills found. Run nymor init first.");
+        return;
+    }
+    let entries = [];
+    if (await fs_extra_1.default.pathExists(indexJsonPath)) {
+        const index = await fs_extra_1.default.readJson(indexJsonPath);
+        entries = Array.isArray(index.skills) ? index.skills : [];
+    }
+    else {
+        const skills = await (0, skills_1.loadSkills)(skillsDir);
+        entries = skills.map((skill) => ({
+            id: skill.id,
+            name: skill.frontmatter.name,
+            description: skill.frontmatter.description ?? "",
+            globs: skill.frontmatter.globs ?? [],
+            alwaysApply: Boolean(skill.frontmatter.alwaysApply)
+        }));
+    }
+    console.log(`Nymor Skills (${entries.length})`);
+    console.log("");
+    if (entries.length === 0) {
+        return;
+    }
+    const arrow = "\u2192";
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    const rows = entries.map((entry) => ({
+        entry,
+        source: manifest.local.includes(entry.id) ? "local" : "unknown"
+    }));
+    const skillWidth = Math.max("Skill".length, ...rows.map((row) => row.entry.id.length));
+    const sourceWidth = Math.max("Source".length, ...rows.map((row) => row.source.length));
+    console.log(`  ${"Skill".padEnd(skillWidth)}  ${"Source".padEnd(sourceWidth)}  Description`);
+    console.log(`  ${"-".repeat(skillWidth)}  ${"-".repeat(sourceWidth)}  -----------`);
+    rows.forEach(({ entry, source }) => {
+        const slug = entry.id.padEnd(skillWidth, " ");
+        const sourceColumn = source.padEnd(sourceWidth, " ");
+        const description = entry.description || entry.name || "(no description)";
+        console.log(`  ${slug}  ${sourceColumn}  ${arrow} ${description}`);
+    });
+}

package/dist/commands/remove.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCommand = removeCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const compile_1 = require("./compile");
+const add_1 = require("./add");
+const manifest_1 = require("../utils/manifest");
+const paths_1 = require("../utils/paths");
+async function removeCommand(skill) {
+    const projectRoot = process.cwd();
+    const parsed = (0, add_1.parseRegistrySkill)(skill);
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    if (!manifest.skills[parsed.packageName]) {
+        throw new Error(`Skill ${parsed.packageName} is not installed.`);
+    }
+    await fs_extra_1.default.remove(path_1.default.join((0, paths_1.getSkillsDir)(projectRoot), parsed.folderName));
+    await removeCompiledOutputs(projectRoot, parsed.folderName);
+    delete manifest.skills[parsed.packageName];
+    await (0, manifest_1.writeManifest)(projectRoot, manifest);
+    const lockfile = (await (0, manifest_1.readLockfile)(projectRoot)) ?? (0, add_1.createEmptyLockfile)();
+    delete lockfile.skills[parsed.packageName];
+    await (0, manifest_1.writeLockfile)(projectRoot, lockfile);
+    await (0, compile_1.compileCommand)();
+    console.log(`${picocolors_1.default.green("✓")} Removed ${parsed.packageName}`);
+}
+async function removeCompiledOutputs(projectRoot, folderName) {
+    await Promise.all([
+        fs_extra_1.default.remove(path_1.default.join(projectRoot, ".claude", "skills", folderName)),
+        fs_extra_1.default.remove(path_1.default.join(projectRoot, ".cursor", "rules", `cicada-${folderName}.mdc`)),
+        fs_extra_1.default.remove(path_1.default.join(projectRoot, ".github", "instructions", `cicada-${folderName}.instructions.md`)),
+        fs_extra_1.default.remove(path_1.default.join(projectRoot, ".kiro", "steering", `cicada-${folderName}.md`))
+    ]);
+}

package/dist/commands/update.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCommand = updateCommand;
+const semver_1 = __importDefault(require("semver"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const compile_1 = require("./compile");
+const add_1 = require("./add");
+const client_1 = require("../registry/client");
+const cache_1 = require("../registry/cache");
+const resolver_1 = require("../registry/resolver");
+const manifest_1 = require("../utils/manifest");
+const INDEX_TTL_MS = 60 * 60 * 1000;
+async function updateCommand(skill, options = {}) {
+    const projectRoot = process.cwd();
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    const lockfile = (await (0, manifest_1.readLockfile)(projectRoot)) ?? (0, add_1.createEmptyLockfile)();
+    const targets = skill ? [skill] : Object.keys(manifest.skills);
+    const rows = [];
+    let changed = false;
+    if (targets.length === 0) {
+        console.log("No registry skills installed.");
+        return;
+    }
+    for (const target of targets) {
+        const parsed = (0, add_1.parseRegistrySkill)(target);
+        const manifestRange = manifest.skills[parsed.packageName];
+        if (!manifestRange) {
+            throw new Error(`Skill ${parsed.packageName} is not installed.`);
+        }
+        const index = await getFreshSkillIndex(parsed.scope, parsed.name, parsed.folderName);
+        const range = options.latest ? "latest" : manifestRange;
+        const nextVersion = (0, resolver_1.resolveVersion)(range, Object.keys(index.versions));
+        const lockedVersion = lockfile.skills[parsed.packageName]?.version ?? "none";
+        const shouldInstall = lockedVersion === "none" ||
+            !semver_1.default.valid(lockedVersion) ||
+            semver_1.default.gt(nextVersion, lockedVersion);
+        if (shouldInstall) {
+            const result = await (0, add_1.installRegistrySkill)(projectRoot, parsed, range, false);
+            lockfile.skills[parsed.packageName] = {
+                version: result.version,
+                integrity: result.integrity,
+                resolved: result.resolved
+            };
+            changed = true;
+        }
+        rows.push({
+            skill: parsed.packageName,
+            oldVersion: lockedVersion,
+            newVersion: shouldInstall ? nextVersion : lockedVersion,
+            changed: shouldInstall
+        });
+    }
+    if (changed) {
+        await (0, manifest_1.writeLockfile)(projectRoot, lockfile);
+        await (0, compile_1.compileCommand)();
+    }
+    printRows(rows);
+}
+async function getFreshSkillIndex(scope, name, cacheKey) {
+    const cached = await (0, cache_1.getCachedIndex)(cacheKey, INDEX_TTL_MS);
+    if (cached) {
+        return cached;
+    }
+    const index = await (0, client_1.fetchSkillIndex)(scope, name);
+    await (0, cache_1.putCachedIndex)(cacheKey, index);
+    return index;
+}
+function printRows(rows) {
+    const skillWidth = Math.max("Skill".length, ...rows.map((row) => row.skill.length));
+    const oldWidth = Math.max("Old".length, ...rows.map((row) => row.oldVersion.length));
+    console.log(`${"Skill".padEnd(skillWidth)}  ${"Old".padEnd(oldWidth)}  New`);
+    console.log(`${"-".repeat(skillWidth)}  ${"-".repeat(oldWidth)}  ---`);
+    for (const row of rows) {
+        const marker = row.changed ? picocolors_1.default.green(row.newVersion) : row.newVersion;
+        console.log(`${row.skill.padEnd(skillWidth)}  ${row.oldVersion.padEnd(oldWidth)}  ${marker}`);
+    }
+}