claude-dev-env 8.27.0 → 8.28.0

package/bin/export-pstack-skills.mjs

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+import { cpSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function inventory(directory, prefix = '') {
+    return readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))
+        .flatMap(entry => {
+            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const entryPath = join(directory, entry.name);
+            if (entry.isDirectory()) return inventory(entryPath, relativePath);
+            if (!entry.isFile()) throw new Error(`Unsupported source entry: ${relativePath}`);
+            return [[relativePath, createHash('sha256').update(readFileSync(entryPath)).digest('hex')]];
+        });
+}
+
+export function exportPstackSkills(pluginRoot, destination) {
+    const source = resolve(pluginRoot);
+    const target = resolve(destination);
+    const manifest = JSON.parse(readFileSync(join(source, '.codex-plugin', 'plugin.json'), 'utf8'));
+    if (manifest.name !== 'pstack' || manifest.skills !== './skills/' || !manifest.version || !manifest.repository) {
+        throw new Error('Expected a versioned pstack Codex plugin with a skills directory and repository.');
+    }
+    if (lstatSync(target, { throwIfNoEntry: false })) throw new Error(`Destination already exists: ${target}`);
+    const skillsRoot = join(source, 'skills');
+    const poteto = readFileSync(join(skillsRoot, 'poteto-mode', 'SKILL.md'), 'utf8');
+    if (!/^name: poteto-mode\r?$/m.test(poteto)) throw new Error('Missing upstream poteto-mode metadata.');
+    const files = Object.fromEntries(inventory(skillsRoot));
+    const license = readFileSync(join(skillsRoot, 'poteto-mode', 'references', 'licenses', 'LICENSE'));
+    const receipt = {
+        repository: manifest.repository,
+        version: manifest.version,
+        sourceManifestSha256: createHash('sha256').update(readFileSync(join(source, '.codex-plugin', 'plugin.json'))).digest('hex'),
+        licenseSha256: createHash('sha256').update(license).digest('hex'),
+        skillCount: Object.keys(files).filter(path => /^[^/]+\/SKILL\.md$/.test(path)).length,
+        expectedRepositorySkillName: 'poteto-mode',
+        cloudDiscovery: 'unverified',
+        cloudInvocation: 'unverified',
+        files,
+    };
+    mkdirSync(dirname(target), { recursive: true });
+    const staging = mkdtempSync(join(dirname(target), '.pstack-export-'));
+    try {
+        cpSync(skillsRoot, staging, { recursive: true });
+        writeFileSync(join(staging, 'PSTACK-LICENSE'), license);
+        writeFileSync(join(staging, 'pstack-export.json'), `${JSON.stringify(receipt, null, 2)}\n`);
+        if (lstatSync(target, { throwIfNoEntry: false })) throw new Error(`Destination appeared: ${target}`);
+        renameSync(staging, target);
+    } finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+    return receipt;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    const [pluginRoot, destination, ...extra] = process.argv.slice(2);
+    if (!pluginRoot || !destination || extra.length) {
+        console.error('Usage: node export-pstack-skills.mjs <plugin-root> <new-repository/.agents/skills>');
+        process.exitCode = 1;
+    } else {
+        try {
+            const receipt = exportPstackSkills(pluginRoot, destination);
+            console.log(JSON.stringify({ destination: resolve(destination), version: receipt.version, skillCount: receipt.skillCount,
+                expectedRepositorySkillName: receipt.expectedRepositorySkillName, cloudDiscovery: receipt.cloudDiscovery,
+                cloudInvocation: receipt.cloudInvocation }, null, 2));
+        } catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+    }
+}

package/bin/export-pstack-skills.test.mjs

@@ -0,0 +1,64 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { exportPstackSkills } from './export-pstack-skills.mjs';
+
+function fixture(context) {
+    const root = mkdtempSync(join(tmpdir(), 'pstack-export-test-'));
+    context.after(() => rmSync(root, { recursive: true, force: true }));
+    const plugin = join(root, 'plugin');
+    const target = join(root, 'repo', '.agents', 'skills');
+    mkdirSync(join(plugin, '.codex-plugin'), { recursive: true });
+    writeFileSync(join(plugin, '.codex-plugin', 'plugin.json'), JSON.stringify({
+        name: 'pstack', version: '0.9.53', repository: 'https://github.com/michael-denyer/pstack-claude', skills: './skills/',
+    }));
+    mkdirSync(join(plugin, 'skills', 'poteto-mode', 'references'), { recursive: true });
+    mkdirSync(join(plugin, 'skills', 'unslop'), { recursive: true });
+    writeFileSync(join(plugin, 'skills', 'poteto-mode', 'SKILL.md'), '---\nname: poteto-mode\n---\nUpstream body\n');
+    writeFileSync(join(plugin, 'skills', 'poteto-mode', 'references', 'codex-tools.md'), 'Tool mapping\n');
+    writeFileSync(join(plugin, 'skills', 'unslop', 'SKILL.md'), 'Sibling dependency\n');
+    mkdirSync(join(plugin, 'skills', 'poteto-mode', 'references', 'licenses'));
+    writeFileSync(join(plugin, 'skills', 'poteto-mode', 'references', 'licenses', 'LICENSE'), 'Upstream license\n');
+    return { root, plugin, target };
+}
+
+test('exports upstream bodies and dependencies unchanged with verifiable provenance', context => {
+    const { plugin, target } = fixture(context);
+    const receipt = exportPstackSkills(plugin, target);
+    assert.equal(receipt.skillCount, 2);
+    assert.equal(receipt.cloudInvocation, 'unverified');
+    assert.equal(receipt.expectedRepositorySkillName, 'poteto-mode');
+    for (const [path, hash] of Object.entries(receipt.files)) {
+        const exported = readFileSync(join(target, path));
+        assert.deepEqual(exported, readFileSync(join(plugin, 'skills', path)));
+        assert.equal(createHash('sha256').update(exported).digest('hex'), hash);
+    }
+    assert.deepEqual(JSON.parse(readFileSync(join(target, 'pstack-export.json'))), receipt);
+    assert.equal(readFileSync(join(target, 'PSTACK-LICENSE'), 'utf8'), 'Upstream license\n');
+});
+
+test('existing custom skills survive a rejected repeat export', context => {
+    const { plugin, target } = fixture(context);
+    exportPstackSkills(plugin, target);
+    const customPath = join(target, 'poteto-mode', 'SKILL.md');
+    writeFileSync(customPath, 'Custom instructions\n');
+    assert.throws(() => exportPstackSkills(plugin, target), /already exists/);
+    assert.equal(readFileSync(customPath, 'utf8'), 'Custom instructions\n');
+});
+
+test('a source symlink is rejected before creating the destination', context => {
+    const { plugin, target } = fixture(context);
+    symlinkSync(join(plugin, 'skills', 'poteto-mode', 'SKILL.md'), join(plugin, 'skills', 'linked-skill'));
+    assert.throws(() => exportPstackSkills(plugin, target), /Unsupported source entry/);
+    assert.equal(existsSync(target), false);
+});
+
+test('a plugin without the required poteto entry cannot produce a partial export', context => {
+    const { plugin, target } = fixture(context);
+    rmSync(join(plugin, 'skills', 'poteto-mode', 'SKILL.md'));
+    assert.throws(() => exportPstackSkills(plugin, target), /ENOENT/);
+    assert.equal(existsSync(target), false);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.27.0",
+    "version": "8.28.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {