@lovinka/vitrinka 1.7.0 → 1.8.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 `vitrinka update` prints the sections newer than your previous version after
 updating — keep entries short and user-facing.
 
+## 1.8.0 — 2026-07-11
+
+### Changed
+- Skills now distribute EXCLUSIVELY as the vitrinka plugin — for Claude Code
+  (`claude plugin install vitrinka@lovinka`) AND Codex (`codex plugin add
+  vitrinka`), both from the `LEFTEQ/vitrinka` marketplace. `vitrinka install`,
+  `doctor --fix` and `update` install/refresh the plugin in every runtime CLI
+  they find; the npm package no longer bundles the skills.
+- Skills layout flattened: `listen` is a first-class skill
+  (`/vitrinka:listen` in Claude Code, `$listen` in Codex).
+
+### Removed
+- `vitrinka install-skills` — superseded by the plugin. `vitrinka uninstall`
+  still clears legacy `~/.claude/skills` copies from pre-plugin machines.
+
 ## 1.6.0 — 2026-07-08
 
 ### Added

package/dist/cli.js

@@ -10,7 +10,7 @@
 // skills/screenshot/gallery.mjs (offline marker, COPYFILE_DISABLE, control-file excludes,
 // `--key`, repeatable `--chip`). gallery.mjs is now a passthrough shim to this file.
 // Design: vitrinka/docs/plans/2026-07-03-hand-in-hand-tooling-design.md
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, copyFileSync, mkdtempSync, chmodSync, appendFileSync, statSync, cpSync, openSync, readSync, closeSync, realpathSync, } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, copyFileSync, mkdtempSync, chmodSync, appendFileSync, statSync, openSync, readSync, closeSync, realpathSync, } from 'node:fs';
 import { join, resolve, basename, dirname, extname, relative, sep } from 'node:path';
 import { tmpdir, hostname } from 'node:os';
 import { spawnSync, spawn } from 'node:child_process';
@@ -1218,20 +1218,20 @@ async function doctorCmd(args) {
         console.log(`✓ operator   ${op}`);
     else
         console.log('✗ operator   unset — board writes stay anonymous (fix: vitrinka operator <name>)');
-    // Setup surfaces (skills / shim / MCP / Claude UI) — informational rows, and
+    // Setup surfaces (plugin / shim / MCP / Claude UI) — informational rows, and
     // `--fix` repairs everything repairable in place. Token/operator stay manual
     // (they're credentials/identity, not installation).
     const fix = args.fix === true;
     const home = process.env.HOME || '';
-    const bundle = bundledSkillsDir(CLI_PATH);
-    if (bundle && home) {
-        const st = skillsStateOf(bundle, join(home, '.claude', 'skills'));
-        if (st === 'current')
-            console.log('✓ skills     current');
-        else if (fix)
-            installSkillsCmd(args);
+    for (const rt of pluginRuntimes()) {
+        if (!rt.present)
+            continue; // no runtime, nothing to wire
+        if (rt.installed)
+            console.log(`✓ plugin     ${rt.name}: vitrinka installed`);
+        else if (fix && installPluginInto(rt))
+            console.log(`✓ plugin     ${rt.name}: vitrinka installed`);
         else
-            console.log(`✗ skills     ${st} — repair: vitrinka doctor --fix`);
+            console.log(`✗ plugin     ${rt.name}: not installed — repair: vitrinka doctor --fix`);
     }
     if (home) {
         const shimP = shimPathOf(home);
@@ -1269,94 +1269,65 @@ async function doctorCmd(args) {
         process.exit(1);
 }
 // ---------- install: PATH shim ----------
-// bundledSkillsDir locates the skills bundle shipped inside the npm package
-// (dist/cli.js → ../skills) or, when running from a repo checkout
-// (pkg/src/cli.ts), the repo-root skills/ directory.
-export function bundledSkillsDir(cliPath) {
-    for (const cand of [join(dirname(cliPath), '..', 'skills'), join(dirname(cliPath), '..', '..', 'skills')]) {
-        if (existsSync(join(cand, 'vitrinka')))
-            return cand;
-    }
-    return '';
-}
-// installSkillsCmd copies the packaged skills bundle (vitrinka + listen,
-// screenshot, artifact, brainstorming) into the Claude skills directory —
-// ~/.claude/skills by default, ./.claude/skills with --local. `npm i -g
-// @lovinka/vitrinka && vitrinka install-skills` fully equips a machine
-// without a repo checkout.
-function installSkillsCmd(args) {
-    const bundle = bundledSkillsDir(CLI_PATH);
-    if (!bundle)
-        fail('install-skills: bundled skills not found next to the CLI — reinstall the package');
-    const home = process.env.HOME;
-    const local = args.local === true;
-    if (!local && !home)
-        fail('install-skills: $HOME is not set (or pass --local)');
-    const target = local ? resolve('.claude', 'skills') : join(home, '.claude', 'skills');
-    mkdirSync(target, { recursive: true });
-    // Whole directories: a skill may nest its SKILL.md (the vitrinka skill
-    // keeps it under listen/ next to its CLI + tests).
-    const names = readdirSync(bundle).filter((n) => !n.startsWith('.') && statSync(join(bundle, n)).isDirectory());
-    if (!names.length)
-        fail(`install-skills: no skills found in ${bundle}`);
-    for (const n of names) {
-        rmSync(join(target, n), { recursive: true, force: true });
-        cpSync(join(bundle, n), join(target, n), { recursive: true });
-        // Local installs live at ./.claude/skills — keep referenced CLI paths copy-pasteable.
-        if (local) {
-            for (const doc of [join(target, n, 'SKILL.md'), join(target, n, 'listen', 'SKILL.md')]) {
-                if (!existsSync(doc))
-                    continue;
-                writeFileSync(doc, readFileSync(doc, 'utf8')
-                    .replaceAll('~/.claude/skills/vitrinka/cli.ts', '.claude/skills/vitrinka/cli.ts'));
-            }
+// ---------- plugin distribution (skills ship via the runtimes' plugin systems) ----------
+// The skills bundle used to be copied into ~/.claude/skills (install-skills,
+// REMOVED 2026-07-11). Skills now distribute exclusively as the `vitrinka`
+// plugin from the `lovinka` marketplace (this repo), installable into BOTH
+// Claude Code and Codex — one distribution per machine per runtime.
+const MARKETPLACE_REPO = 'LEFTEQ/vitrinka';
+// pluginRuntimes probes which agent CLIs exist and whether the vitrinka
+// plugin is installed in each. Claude records installs in
+// ~/.claude/plugins/installed_plugins.json; Codex is asked directly
+// (`codex plugin list` is fast and authoritative across its versions).
+function pluginRuntimes() {
+    const home = process.env.HOME || '';
+    const out = [];
+    const claudePresent = claudeCliPresent();
+    let claudeInstalled = false;
+    if (claudePresent && home) {
+        try {
+            claudeInstalled = readFileSync(join(home, '.claude', 'plugins', 'installed_plugins.json'), 'utf8')
+                .includes('vitrinka@lovinka');
+        }
+        catch {
+            claudeInstalled = false; // no plugins file yet — nothing installed
         }
-        console.log(`✓ ${n} → ${join(target, n)}`);
     }
-    // /vitrinka:listen command stub — nested SKILL.md files (skills/vitrinka/listen/)
-    // never register as invocable skills; only a stub under commands/vitrinka/ makes
-    // the slash command callable.
-    const stub = join(bundle, 'vitrinka', 'commands', 'listen.md');
-    if (existsSync(stub)) {
-        const commandsDir = local ? resolve('.claude', 'commands', 'vitrinka') : join(home, '.claude', 'commands', 'vitrinka');
-        mkdirSync(commandsDir, { recursive: true });
-        let content = readFileSync(stub, 'utf8');
-        if (local)
-            content = content.replaceAll('~/.claude/skills/vitrinka/listen/SKILL.md', '.claude/skills/vitrinka/listen/SKILL.md');
-        writeFileSync(join(commandsDir, 'listen.md'), content);
-        console.log(`✓ /vitrinka:listen command → ${join(commandsDir, 'listen.md')}`);
+    out.push({ name: 'claude', present: claudePresent, installed: claudeInstalled });
+    const codexPresent = !spawnSync('codex', ['--version'], { stdio: 'ignore' }).error;
+    let codexInstalled = false;
+    if (codexPresent) {
+        const r = spawnSync('codex', ['plugin', 'list'], { encoding: 'utf8' });
+        codexInstalled = r.status === 0 && /\bvitrinka\b/.test(r.stdout || '');
     }
-    console.log(`${names.length} skill${names.length === 1 ? '' : 's'} installed (${names.sort().join(', ')})`);
+    out.push({ name: 'codex', present: codexPresent, installed: codexInstalled });
+    return out;
 }
-// ---------- setup state probing (shared by install / doctor / uninstall) ----------
-// dirsEqual — recursive byte comparison, the node twin of install.sh's `diff -rq`.
-function dirsEqual(a, b) {
-    const names = new Set([...readdirSync(a), ...readdirSync(b)]);
-    for (const n of names) {
-        const pa = join(a, n), pb = join(b, n);
-        if (!existsSync(pa) || !existsSync(pb))
+// installPluginInto registers the lovinka marketplace and installs the
+// vitrinka plugin for one runtime. Both runtimes' commands are idempotent
+// enough for our purposes (marketplace add on an existing source errors —
+// tolerated; install/add on an installed plugin re-snapshots).
+function installPluginInto(rt) {
+    const cmds = rt.name === 'claude'
+        ? [['claude', 'plugin', 'marketplace', 'add', MARKETPLACE_REPO], ['claude', 'plugin', 'install', 'vitrinka@lovinka']]
+        : [['codex', 'plugin', 'marketplace', 'add', MARKETPLACE_REPO], ['codex', 'plugin', 'add', 'vitrinka@lovinka']];
+    for (const [bin, ...rest] of cmds) {
+        const r = spawnSync(bin, rest, { encoding: 'utf8' });
+        if (r.status !== 0 && !/already|exists/i.test((r.stderr || '') + (r.stdout || ''))) {
+            console.error(`⚠ ${rt.name}: \`${[bin, ...rest].join(' ')}\` failed${r.stderr ? ` — ${r.stderr.trim().split('\n').pop()}` : ''}`);
             return false;
-        const da = statSync(pa).isDirectory(), db = statSync(pb).isDirectory();
-        if (da !== db)
-            return false;
-        if (da) {
-            if (!dirsEqual(pa, pb))
-                return false;
         }
-        else if (!readFileSync(pa).equals(readFileSync(pb)))
-            return false;
     }
     return true;
 }
-// skillsStateOf — the bundled skills' freshness at a target skills dir. Local
-// installs rewrite CLI paths after copy, so a fresh local copy reads "outdated"
-// against the bundle — harmless (refresh is idempotent), same as install.sh.
-function skillsStateOf(bundle, target) {
-    const names = readdirSync(bundle).filter((n) => !n.startsWith('.') && statSync(join(bundle, n)).isDirectory());
-    if (names.some((n) => !existsSync(join(target, n))))
-        return 'missing';
-    return names.every((n) => dirsEqual(join(bundle, n), join(target, n))) ? 'current' : 'outdated';
+// updatePluginIn refreshes an installed plugin to the marketplace's latest.
+function updatePluginIn(rt) {
+    const cmd = rt.name === 'claude'
+        ? ['claude', 'plugin', 'update', 'vitrinka@lovinka']
+        : ['codex', 'plugin', 'marketplace', 'upgrade'];
+    return spawnSync(cmd[0], cmd.slice(1), { stdio: 'inherit' }).status === 0;
 }
+// ---------- setup state probing (shared by install / doctor / uninstall) ----------
 const SHIM_CONTENT = `#!/bin/sh\nexec node "${CLI_PATH}" "$@"\n`;
 function shimPathOf(home) { return join(home, '.local', 'bin', 'vitrinka'); }
 function rcPathOf(home) {
@@ -1431,9 +1402,7 @@ async function installCmd(args) {
     const base = resolveBaseUrl(strArg(args.base));
     const mcpScope = local ? 'project' : 'user';
     // ---- probe (before touching anything) ----
-    const bundle = bundledSkillsDir(CLI_PATH);
-    const skillsTarget = local ? resolve('.claude', 'skills') : join(home, '.claude', 'skills');
-    const skills = bundle ? skillsStateOf(bundle, skillsTarget) : 'no-bundle';
+    const runtimes = pluginRuntimes();
     const shimP = shimPathOf(home);
     const shimOk = existsSync(shimP) && readFileSync(shimP, 'utf8') === SHIM_CONTENT;
     const rc = rcPathOf(home);
@@ -1448,8 +1417,9 @@ async function installCmd(args) {
         console.log(`  ${ok ? '✓' : '✗'} ${label.padEnd(11)}${detail}`);
     };
     console.log(`vitrinka setup — ${base}${local ? '  (local scope)' : ''}`);
-    row(skills === 'current', 'skills', skills === 'no-bundle' ? 'bundle not found next to the CLI (reinstall the package)'
-        : skills === 'current' ? `current → ${skillsTarget}` : `${skills} → will refresh`);
+    for (const rt of runtimes) {
+        row(rt.installed, `plugin·${rt.name}`, rt.installed ? 'vitrinka installed' : rt.present ? 'will install (skills ship as the plugin)' : `${rt.name} CLI not found`);
+    }
     if (!local)
         row(shimOk, 'shim', shimOk ? shimP : 'will install');
     if (!local)
@@ -1459,9 +1429,11 @@ async function installCmd(args) {
     row(!!op, 'operator', op || 'unset — board writes stay anonymous');
     row(uiOk, 'claude ui', uiOk ? 'statusline + footer wired' : 'not wired');
     console.log('');
-    // ---- silent steps: skills, shim, PATH, completion (reversible, own dirs) ----
-    if (bundle && skills !== 'current')
-        installSkillsCmd(args);
+    // ---- silent steps: plugins, shim, PATH, completion (reversible, own dirs) ----
+    for (const rt of runtimes) {
+        if (rt.present && !rt.installed && installPluginInto(rt))
+            console.log(`✓ plugin (${rt.name}) → vitrinka@lovinka`);
+    }
     if (!local) {
         if (!shimOk) {
             mkdirSync(dirname(shimP), { recursive: true });
@@ -1587,9 +1559,9 @@ export function stripMarkerBlock(content, marker) {
     }
     return out.join('\n');
 }
-// The bundled skill names — used by uninstall when the bundle isn't next to the
-// CLI anymore (e.g. the package was removed first).
-const BUNDLED_SKILLS = ['artifact', 'brainstorming', 'screenshot', 'vitrinka'];
+// Legacy ~/.claude/skills copy names — removed by uninstall on machines set
+// up before the plugin distribution (install-skills, removed 2026-07-11).
+const LEGACY_SKILLS = ['artifact', 'brainstorming', 'screenshot', 'vitrinka', 'listen'];
 // uninstallCmd removes everything install put on the machine — the exact
 // inverse: bundled skills + the /vitrinka:listen stub, shim, rc marker blocks,
 // statusline wrapper (restoring the original statusLine command), the /boards/
@@ -1600,21 +1572,31 @@ function uninstallCmd(args) {
     if (!home)
         fail('uninstall: $HOME is not set');
     const local = args.local === true;
-    if (args.yes !== true && !promptYesNo(`Remove vitrinka from this machine (skills, shim, completion, Claude wiring, MCP${args.purge === true ? ', token+operator' : ''})? [Y/n] `)) {
+    if (args.yes !== true && !promptYesNo(`Remove vitrinka from this machine (plugins, legacy skill copies, shim, completion, Claude wiring, MCP${args.purge === true ? ', token+operator' : ''})? [Y/n] `)) {
         fail('uninstall: aborted (non-interactive runs need --yes)', 2);
     }
-    // Skills + the /vitrinka:listen command stub.
-    const bundle = bundledSkillsDir(CLI_PATH);
-    const names = bundle
-        ? readdirSync(bundle).filter((n) => !n.startsWith('.') && statSync(join(bundle, n)).isDirectory())
-        : BUNDLED_SKILLS;
+    // Plugins (the current distribution) + legacy ~/.claude/skills copies +
+    // the old /vitrinka:listen command stub, from machines set up pre-plugin.
+    for (const rt of pluginRuntimes()) {
+        if (!rt.installed)
+            continue;
+        const cmd = rt.name === 'claude'
+            ? ['claude', 'plugin', 'uninstall', 'vitrinka@lovinka']
+            : ['codex', 'plugin', 'remove', 'vitrinka@lovinka'];
+        if (spawnSync(cmd[0], cmd.slice(1), { stdio: 'inherit' }).status === 0) {
+            console.log(`✓ removed ${rt.name} plugin`);
+        }
+        else {
+            console.error(`⚠ ${rt.name} plugin removal failed — run: ${cmd.join(' ')}`);
+        }
+    }
     const skillsDir = local ? resolve('.claude', 'skills') : join(home, '.claude', 'skills');
     const commandsDir = local ? resolve('.claude', 'commands', 'vitrinka') : join(home, '.claude', 'commands', 'vitrinka');
-    for (const n of names) {
+    for (const n of LEGACY_SKILLS) {
         if (!existsSync(join(skillsDir, n)))
             continue;
         rmSync(join(skillsDir, n), { recursive: true, force: true });
-        console.log(`✓ removed skill ${n}`);
+        console.log(`✓ removed legacy skill copy ${n}`);
     }
     if (existsSync(join(commandsDir, 'listen.md'))) {
         rmSync(join(commandsDir, 'listen.md'));
@@ -1977,7 +1959,7 @@ export function cmpSemver(a, b) {
     return 0;
 }
 // Commands that must never carry the notifier/hint noise (setup and meta paths).
-const HINT_SKIP = new Set(['install', 'install-claude', 'install-skills', 'update', 'uninstall',
+const HINT_SKIP = new Set(['install', 'install-claude', 'update', 'uninstall',
     'doctor', 'help', 'completion', '__complete', 'ai']);
 function updateCheckPath() {
     return join(process.env.HOME || '', '.config', 'vitrinka', 'update-check');
@@ -2070,7 +2052,7 @@ function pkgVersion() {
 // before, the Claude Code UI wiring. It never asks new consent questions —
 // that stays `vitrinka install`'s job. The refresh steps re-exec the (possibly
 // just replaced) CLI file so they run the NEW code, not this stale process.
-async function updateCmd(args) {
+async function updateCmd(_args) {
     const repoTop = git(['rev-parse', '--show-toplevel'], dirname(CLI_PATH));
     if (repoTop) {
         // Repo checkout — the shim/MCP run the source directly, so a pull IS the update.
@@ -2124,11 +2106,13 @@ async function updateCmd(args) {
             }
         }
     }
-    // Refresh installed surfaces from the NEW code — skills always (an install
-    // implies them), Claude wiring only if the wrapper shows prior consent.
+    // Refresh installed surfaces from the NEW code — plugins where installed,
+    // Claude wiring only if the wrapper shows prior consent.
     const rerun = (sub) => spawnSync(process.execPath, [CLI_PATH, ...sub], { stdio: 'inherit' }).status === 0;
-    if (!rerun(['install-skills', ...(args.local === true ? ['--local'] : [])])) {
-        fail('update: skills refresh failed — re-run: vitrinka install-skills');
+    for (const rt of pluginRuntimes()) {
+        if (rt.installed && !updatePluginIn(rt)) {
+            console.error(`⚠ update: ${rt.name} plugin refresh failed — re-run its plugin update manually`);
+        }
     }
     const wrapper = join(process.env.HOME || '', '.claude', 'vitrinka-statusline.sh');
     if (existsSync(wrapper)) {
@@ -2854,12 +2838,7 @@ export const COMMANDS = [
         examples: ['vitrinka install-claude'],
     },
     {
-        name: 'install-skills', summary: 'Install the bundled Claude skills (vitrinka, screenshot, artifact, brainstorming)',
-        usage: '[--local]', flags: [{ f: '--local', d: 'install into ./.claude/skills of the current project instead of ~/.claude/skills' }],
-        examples: ['vitrinka install-skills'],
-    },
-    {
-        name: 'update', summary: 'Update the CLI (git pull / npm -g), show what\'s new, refresh the installed skills + Claude wiring',
+        name: 'update', summary: 'Update the CLI (git pull / npm -g), show what\'s new, refresh the installed plugins + Claude wiring',
         usage: '[--local]',
         flags: [{ f: '--local', d: 'refresh skills into ./.claude/skills of the current project instead of ~/.claude/skills' }],
         examples: ['vitrinka update'],
@@ -3741,8 +3720,6 @@ async function runSub(argv) {
         await installCmd(args);
     else if (cmd === 'install-claude')
         installClaudeCmd(args);
-    else if (cmd === 'install-skills')
-        installSkillsCmd(args);
     else if (cmd === 'uninstall')
         uninstallCmd(args);
     else if (cmd === 'update')