@areca-cms/skills 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { cancel, confirm, groupMultiselect, intro, isCancel, log, multiselect, note, outro, select, text, } from '@clack/prompts';
+import { AGENTS, findAgent, GROUP_LABELS, mcpServerName, validateConnectorUrl, } from './agents.js';
+import { exportZips, installSkills, removeSkills, resolveTargets } from './install.js';
+import { configureMcp } from './mcp-config.js';
+import { loadSkills } from './skills.js';
+const USAGE = `Usage: npx @areca-cms/skills [command] [options]
+
+Commands:
+  add (default)   Install the Areca skills into your agents
+  mcp             Add the Areca MCP server to your agents' project config
+  remove          Remove the Areca skills
+  export          Write one .zip per skill (Claude app, ChatGPT uploads)
+  list            Show supported agents and bundled skills
+
+Options:
+  -a, --agent <id>    Agent id, repeatable or comma separated (see list)
+  -s, --skill <name>  Only this skill (areca-sdk, areca-mcp); default all
+  -g, --global        Install into user-level folders instead of the project
+      --mcp-url <url> Connector URL (<cms>/api/mcp/<site-slug>) to register
+      --out <dir>     Zip folder for chat apps and export (default: areca-skills)
+  -y, --yes           No prompts; requires --agent for add/mcp/remove
+  -h, --help          Show this help`;
+class Cancelled extends Error {
+}
+export async function run(argv, cwd = process.cwd()) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                agent: { type: 'string', short: 'a', multiple: true },
+                skill: { type: 'string', short: 's', multiple: true },
+                global: { type: 'boolean', short: 'g' },
+                'mcp-url': { type: 'string' },
+                url: { type: 'string' },
+                out: { type: 'string' },
+                yes: { type: 'boolean', short: 'y' },
+                help: { type: 'boolean', short: 'h' },
+            },
+        });
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        console.error(USAGE);
+        return 1;
+    }
+    const { values, positionals } = parsed;
+    const command = positionals[0] ?? 'add';
+    if (values.help || command === 'help') {
+        console.log(USAGE);
+        return 0;
+    }
+    const options = {
+        agents: splitList(values.agent),
+        skills: splitList(values.skill),
+        global: values.global === true,
+        mcpUrl: values['mcp-url'] ?? values.url,
+        out: values.out ?? 'areca-skills',
+        yes: values.yes === true || !process.stdin.isTTY,
+    };
+    try {
+        const unknown = options.agents.filter((id) => !findAgent(id));
+        if (unknown.length)
+            throw new Error(`Unknown agent: ${unknown.join(', ')}. Run "list" to see ids.`);
+        if (options.mcpUrl) {
+            const problem = validateConnectorUrl(options.mcpUrl);
+            if (problem)
+                throw new Error(problem);
+        }
+        switch (command) {
+            case 'add':
+                return await add(options, cwd);
+            case 'mcp':
+                return await mcp(options, cwd);
+            case 'remove':
+                return await remove(options, cwd);
+            case 'export':
+                return exportCommand(options, cwd);
+            case 'list':
+                return list();
+            default:
+                console.error(`Unknown command: ${command}\n\n${USAGE}`);
+                return 1;
+        }
+    }
+    catch (error) {
+        if (error instanceof Cancelled) {
+            cancel('Cancelled.');
+            return 0;
+        }
+        console.error(error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+async function add(options, cwd) {
+    const interactive = !options.yes;
+    if (interactive)
+        intro('Areca agent skills');
+    const agents = await chooseAgents(options, cwd, 'Which agents should get the Areca skills?');
+    const skills = await chooseSkills(options);
+    const coding = agents.filter((agent) => agent.group !== 'chat');
+    const chat = agents.filter((agent) => agent.group === 'chat');
+    let scope = options.global ? 'global' : 'project';
+    if (interactive && coding.length && !options.global) {
+        scope = unwrap(await select({
+            message: 'Install for',
+            options: [
+                { value: 'project', label: 'This project', hint: 'commit them so the whole team gets them' },
+                { value: 'global', label: 'Me, in every project', hint: 'user-level folders' },
+            ],
+        }));
+    }
+    const targets = resolveTargets(coding, scope, cwd);
+    const written = installSkills(skills, targets);
+    for (const target of targets) {
+        log.success(`${target.label}  (${target.agents.join(', ')})`);
+    }
+    if (chat.length) {
+        const files = exportZips(skills, resolve(cwd, options.out));
+        log.success(`Zips: ${files.map((file) => relative(cwd, file)).join(', ')}`);
+    }
+    let mcpResults = [];
+    if (coding.length) {
+        const url = await chooseMcpUrl(options, cwd, interactive);
+        if (url)
+            mcpResults = registerMcp(coding, url, scope, cwd);
+    }
+    const after = [...new Set(agents.map((agent) => agent.after).filter(Boolean))];
+    const name = mcpResults.length ? mcpServerName(options.mcpUrl ?? '') : '<name>';
+    const steps = [
+        `Installed ${skills.map((skill) => skill.name).join(' + ')} (${written.length} folder${written.length === 1 ? '' : 's'}).`,
+        ...after.map((line) => line.replaceAll('<name>', name)),
+    ];
+    if (interactive)
+        outro(steps.join('\n'));
+    else
+        console.log(steps.join('\n'));
+    return 0;
+}
+async function mcp(options, cwd) {
+    const interactive = !options.yes;
+    if (interactive)
+        intro('Areca MCP server');
+    const agents = (await chooseAgents(options, cwd, 'Add the Areca MCP server to which agents?')).filter((agent) => agent.group !== 'chat');
+    const url = await chooseMcpUrl({ ...options, yes: options.yes }, cwd, interactive, true);
+    if (!url)
+        throw new Error('Pass --url <cms>/api/mcp/<site-slug>');
+    registerMcp(agents, url, 'project', cwd);
+    const after = [...new Set(agents.map((agent) => agent.after).filter(Boolean))].map((line) => line.replaceAll('<name>', mcpServerName(url)));
+    const done = ['Each agent opens a browser to sign in to Areca on first use.', ...after].join('\n');
+    if (interactive)
+        outro(done);
+    else
+        console.log(done);
+    return 0;
+}
+async function remove(options, cwd) {
+    const interactive = !options.yes;
+    if (interactive)
+        intro('Remove Areca agent skills');
+    const agents = await chooseAgents(options, cwd, 'Remove the Areca skills from which agents?');
+    const names = (options.skills.length ? options.skills : loadSkills().map((skill) => skill.name));
+    const scope = options.global ? 'global' : 'project';
+    const removed = removeSkills(names, resolveTargets(agents, scope, cwd));
+    const message = removed.length ? `Removed ${removed.join(', ')}` : 'Nothing to remove.';
+    if (interactive)
+        outro(message);
+    else
+        console.log(message);
+    return 0;
+}
+function exportCommand(options, cwd) {
+    const files = exportZips(selectSkills(options.skills), resolve(cwd, options.out));
+    console.log(`Wrote ${files.map((file) => relative(cwd, file)).join(', ')}`);
+    for (const id of ['claude-app', 'chatgpt'])
+        console.log(findAgent(id).after);
+    return 0;
+}
+function list() {
+    const skills = loadSkills();
+    console.log('Skills:');
+    for (const skill of skills)
+        console.log(`  ${skill.name.padEnd(12)} ${skill.description.slice(0, 90)}…`);
+    for (const group of Object.keys(GROUP_LABELS)) {
+        console.log(`\n${GROUP_LABELS[group]}:`);
+        for (const agent of AGENTS.filter((item) => item.group === group)) {
+            const where = agent.projectDir ? `${agent.projectDir}  ~/${agent.globalDir}` : 'zip upload';
+            console.log(`  ${agent.id.padEnd(15)} ${agent.label.padEnd(40)} ${where}`);
+        }
+    }
+    return 0;
+}
+async function chooseAgents(options, cwd, message) {
+    if (options.agents.length)
+        return options.agents.map((id) => findAgent(id));
+    if (options.yes)
+        throw new Error('Pass --agent <id> (repeatable). Run "list" to see ids.');
+    const detected = AGENTS.filter((agent) => agent.detect.some((path) => existsSync(join(cwd, path))));
+    const groups = {};
+    for (const agent of AGENTS) {
+        const group = GROUP_LABELS[agent.group];
+        (groups[group] ??= []).push({
+            value: agent.id,
+            label: agent.label,
+            hint: agent.projectDir ?? 'zip',
+        });
+    }
+    const ids = unwrap(await groupMultiselect({
+        message: `${message} (space to toggle, enter to confirm)`,
+        options: groups,
+        initialValues: detected.map((agent) => agent.id),
+        required: true,
+    }));
+    return ids.map((id) => findAgent(id));
+}
+async function chooseSkills(options) {
+    if (options.skills.length || options.yes)
+        return selectSkills(options.skills);
+    const all = loadSkills();
+    const names = unwrap(await multiselect({
+        message: 'Which skills?',
+        options: all.map((skill) => ({ value: skill.name, label: skill.name, hint: hintFor(skill.name) })),
+        initialValues: all.map((skill) => skill.name),
+        required: true,
+    }));
+    return all.filter((skill) => names.includes(skill.name));
+}
+function selectSkills(names) {
+    const all = loadSkills();
+    if (!names.length)
+        return all;
+    const missing = names.filter((name) => !all.some((skill) => skill.name === name));
+    if (missing.length)
+        throw new Error(`Unknown skill: ${missing.join(', ')}. Available: ${all.map((s) => s.name).join(', ')}`);
+    return all.filter((skill) => names.includes(skill.name));
+}
+function hintFor(name) {
+    if (name === 'areca-sdk')
+        return 'website code: setup, config, CLI, content, preview, deploy';
+    if (name === 'areca-mcp')
+        return 'AI content editing: connect, tools, workflow';
+    return '';
+}
+async function chooseMcpUrl(options, cwd, interactive, required = false) {
+    if (options.mcpUrl)
+        return options.mcpUrl;
+    if (!interactive)
+        return undefined;
+    if (!required) {
+        const wanted = unwrap(await confirm({
+            message: 'Also add the Areca MCP server to these agents? (URL only, sign-in happens in the browser)',
+            initialValue: false,
+        }));
+        if (!wanted)
+            return undefined;
+    }
+    const url = unwrap(await text({
+        message: 'Connector URL (CMS > your site > Connect AI)',
+        placeholder: 'https://cms.example.com/api/mcp/acme-site',
+        initialValue: guessConnectorUrl(cwd),
+        validate: (value) => validateConnectorUrl(value ?? ''),
+    }));
+    options.mcpUrl = url;
+    return url;
+}
+function registerMcp(agents, url, scope, cwd) {
+    const name = mcpServerName(url);
+    // Global installs never write outside the repo: show what to add instead.
+    const results = configureMcp(agents, url, name, cwd, scope === 'project');
+    for (const result of results) {
+        if (result.status === 'manual') {
+            note(result.snippet, `Add to ${result.where}${result.reason ? ` (${result.reason})` : ''}`);
+        }
+        else {
+            log.success(`${result.file} ${result.status === 'written' ? 'updated' : 'already set'} (${name})`);
+        }
+    }
+    return results;
+}
+/** `${ARECA_CMS_URL}/api/mcp/${siteKey}` from the site project, if both are present. */
+export function guessConnectorUrl(cwd) {
+    const env = ['.env.local', '.env']
+        .map((file) => join(cwd, file))
+        .filter((file) => existsSync(file))
+        .map((file) => readFileSync(file, 'utf8'))
+        .join('\n');
+    const cmsUrl = process.env.ARECA_CMS_URL ?? /^\s*ARECA_CMS_URL\s*=\s*["']?([^"'\s#]+)/m.exec(env)?.[1];
+    const config = ['areca.config.ts', 'areca.config.mts', 'areca.config.js', 'areca.config.mjs']
+        .map((file) => join(cwd, file))
+        .find((file) => existsSync(file));
+    const siteKey = config ? /siteKey\s*:\s*["'`]([a-z0-9-]+)["'`]/.exec(readFileSync(config, 'utf8'))?.[1] : undefined;
+    if (!cmsUrl || !siteKey)
+        return undefined;
+    return `${cmsUrl.replace(/\/+$/, '')}/api/mcp/${siteKey}`;
+}
+function splitList(values) {
+    return (values ?? []).flatMap((value) => value.split(',')).map((value) => value.trim()).filter(Boolean);
+}
+function unwrap(value) {
+    if (isCancel(value))
+        throw new Cancelled();
+    return value;
+}
+function isMainModule() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        return realpathSync(fileURLToPath(import.meta.url)).toLowerCase() === realpathSync(entry).toLowerCase();
+    }
+    catch {
+        return resolve(fileURLToPath(import.meta.url)).toLowerCase() === resolve(entry).toLowerCase();
+    }
+}
+if (isMainModule()) {
+    void run(process.argv.slice(2)).then((code) => {
+        if (code !== 0)
+            process.exit(code);
+    });
+}

package/dist/install.d.ts

@@ -0,0 +1,18 @@
+import type { Agent } from './agents.js';
+import { type Skill } from './skills.js';
+export type Scope = 'project' | 'global';
+export type InstallTarget = {
+    /** Absolute skills directory, e.g. `<repo>/.agents/skills`. */
+    dir: string;
+    /** Display path, e.g. `.agents/skills` or `~/.claude/skills`. */
+    label: string;
+    agents: string[];
+};
+/** One target per unique skills directory, so shared folders get one copy. */
+export declare function resolveTargets(agents: Agent[], scope: Scope, cwd: string, home?: string): InstallTarget[];
+/** Replace each skill folder in each target with a fresh copy. */
+export declare function installSkills(skills: Skill[], targets: InstallTarget[]): string[];
+/** Remove only the named skill folders; other skills in the folder stay. */
+export declare function removeSkills(names: string[], targets: InstallTarget[]): string[];
+/** One `<name>.zip` per skill with the folder at the zip root (Claude app / ChatGPT upload format). */
+export declare function exportZips(skills: Skill[], outDir: string): string[];

package/dist/install.js

@@ -0,0 +1,58 @@
+import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { skillFiles } from './skills.js';
+import { createZip } from './zip.js';
+/** One target per unique skills directory, so shared folders get one copy. */
+export function resolveTargets(agents, scope, cwd, home = homedir()) {
+    const byDir = new Map();
+    for (const agent of agents) {
+        const rel = scope === 'project' ? agent.projectDir : agent.globalDir;
+        if (!rel)
+            continue;
+        const dir = scope === 'project' ? join(cwd, rel) : join(home, rel);
+        const label = scope === 'project' ? rel : `~/${rel}`;
+        const target = byDir.get(dir) ?? { dir, label, agents: [] };
+        target.agents.push(agent.label);
+        byDir.set(dir, target);
+    }
+    return [...byDir.values()];
+}
+/** Replace each skill folder in each target with a fresh copy. */
+export function installSkills(skills, targets) {
+    const written = [];
+    for (const target of targets) {
+        for (const skill of skills) {
+            const dest = join(target.dir, skill.name);
+            rmSync(dest, { recursive: true, force: true });
+            mkdirSync(target.dir, { recursive: true });
+            cpSync(skill.dir, dest, { recursive: true });
+            written.push(`${target.label}/${skill.name}`);
+        }
+    }
+    return written;
+}
+/** Remove only the named skill folders; other skills in the folder stay. */
+export function removeSkills(names, targets) {
+    const removed = [];
+    for (const target of targets) {
+        for (const name of names) {
+            const dest = join(target.dir, name);
+            if (!existsSync(dest))
+                continue;
+            rmSync(dest, { recursive: true, force: true });
+            removed.push(`${target.label}/${name}`);
+        }
+    }
+    return removed;
+}
+/** One `<name>.zip` per skill with the folder at the zip root (Claude app / ChatGPT upload format). */
+export function exportZips(skills, outDir) {
+    mkdirSync(outDir, { recursive: true });
+    return skills.map((skill) => {
+        const entries = skillFiles(skill.dir).map(([path, data]) => ({ path: `${skill.name}/${path}`, data }));
+        const file = join(outDir, `${skill.name}.zip`);
+        writeFileSync(file, createZip(entries));
+        return file;
+    });
+}

package/dist/mcp-config.d.ts

@@ -0,0 +1,20 @@
+import type { Agent, McpTarget } from './agents.js';
+export type McpResult = {
+    status: 'written' | 'unchanged';
+    file: string;
+}
+/** Could not edit safely (or no project config exists): show this to the user. */
+ | {
+    status: 'manual';
+    where: string;
+    snippet: string;
+    reason?: string;
+};
+/**
+ * Register the connector URL (OAuth only, no secrets) for each agent. Files
+ * shared by several agents are written once. Existing servers and keys are kept.
+ */
+export declare function configureMcp(agents: Agent[], url: string, name: string, cwd: string, write?: boolean): McpResult[];
+/** The snippet for a target without touching disk (used for global installs). */
+export declare function describeTarget(target: McpTarget, url: string, name: string): McpResult;
+export declare function applyTarget(target: McpTarget, url: string, name: string, cwd: string): McpResult;

package/dist/mcp-config.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/**
+ * Register the connector URL (OAuth only, no secrets) for each agent. Files
+ * shared by several agents are written once. Existing servers and keys are kept.
+ */
+export function configureMcp(agents, url, name, cwd, write = true) {
+    const results = [];
+    const seen = new Set();
+    for (const agent of agents) {
+        for (const target of agent.mcp) {
+            const key = target.kind === 'manual' ? `manual:${target.where}` : targetPath(target, name);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            results.push(write ? applyTarget(target, url, name, cwd) : describeTarget(target, url, name));
+        }
+    }
+    return results;
+}
+function targetPath(target, name) {
+    return target.kind === 'yaml' ? `${target.dir}/${name}.yaml` : target.file;
+}
+/** The snippet for a target without touching disk (used for global installs). */
+export function describeTarget(target, url, name) {
+    if (target.kind === 'manual')
+        return { status: 'manual', where: target.where, snippet: target.snippet(name, url) };
+    if (target.kind === 'json') {
+        return { status: 'manual', where: target.file, snippet: JSON.stringify({ [target.key]: { [name]: target.entry(url) } }, null, 2) };
+    }
+    if (target.kind === 'toml') {
+        return { status: 'manual', where: target.file, snippet: `[mcp_servers.${name}]\nurl = ${JSON.stringify(url)}` };
+    }
+    return { status: 'manual', where: `${target.dir}/${name}.yaml`, snippet: yamlServer(name, url) };
+}
+export function applyTarget(target, url, name, cwd) {
+    switch (target.kind) {
+        case 'manual':
+            return { status: 'manual', where: target.where, snippet: target.snippet(name, url) };
+        case 'json':
+            return mergeJson(target.file, target.key, name, target.entry(url), cwd);
+        case 'toml':
+            return appendToml(target.file, name, url, cwd);
+        case 'yaml': {
+            const file = `${target.dir}/${name}.yaml`;
+            return writeIfChanged(join(cwd, file), file, yamlServer(name, url));
+        }
+    }
+}
+function mergeJson(file, key, name, entry, cwd) {
+    const path = join(cwd, file);
+    const snippet = JSON.stringify({ [key]: { [name]: entry } }, null, 2);
+    let config = {};
+    if (existsSync(path)) {
+        const source = readFileSync(path, 'utf8');
+        try {
+            config = source.trim() ? JSON.parse(source) : {};
+        }
+        catch {
+            // JSONC with comments: rewriting it would drop them, so let the user paste.
+            return { status: 'manual', where: file, snippet, reason: 'has comments or invalid JSON' };
+        }
+        if (!isObject(config))
+            return { status: 'manual', where: file, snippet, reason: 'is not a JSON object' };
+    }
+    const servers = config[key] ?? {};
+    if (!isObject(servers))
+        return { status: 'manual', where: file, snippet, reason: `"${key}" is not an object` };
+    const next = { ...config, [key]: { ...servers, [name]: entry } };
+    return writeIfChanged(path, file, `${JSON.stringify(next, null, 2)}\n`);
+}
+function appendToml(file, name, url, cwd) {
+    const path = join(cwd, file);
+    const section = `[mcp_servers.${name}]\nurl = ${JSON.stringify(url)}\n`;
+    const source = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const header = new RegExp(`^\\[mcp_servers\\.(?:${name}|"${name}")\\]`, 'm');
+    if (header.test(source)) {
+        if (source.includes(`url = ${JSON.stringify(url)}`))
+            return { status: 'unchanged', file };
+        return { status: 'manual', where: file, snippet: section, reason: `already has [mcp_servers.${name}]` };
+    }
+    const prefix = source && !source.endsWith('\n') ? `${source}\n` : source;
+    return writeIfChanged(path, file, `${prefix}${prefix ? '\n' : ''}${section}`);
+}
+function writeIfChanged(path, file, body) {
+    if (existsSync(path) && readFileSync(path, 'utf8') === body)
+        return { status: 'unchanged', file };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, body);
+    return { status: 'written', file };
+}
+function yamlServer(name, url) {
+    return `name: ${name}\nversion: 0.0.1\nschema: v1\nmcpServers:\n  - name: ${name}\n    type: streamable-http\n    url: ${url}\n`;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/skills.d.ts

@@ -0,0 +1,16 @@
+export type Skill = {
+    name: string;
+    description: string;
+    /** Absolute path of the skill folder. */
+    dir: string;
+};
+/**
+ * Skills ship in the package's `skills/` folder (copied from the repo root at
+ * build). From source inside the monorepo, fall back to the repo root copy.
+ */
+export declare function skillsRoot(): string;
+export declare function loadSkills(root?: string): Skill[];
+/** Top-level `key: value` pairs of a SKILL.md frontmatter block. */
+export declare function parseFrontmatter(source: string): Record<string, string>;
+/** Every file in a skill folder as [path relative to the folder, contents]. */
+export declare function skillFiles(dir: string): [string, Buffer][];

package/dist/skills.js

@@ -0,0 +1,55 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Skills ship in the package's `skills/` folder (copied from the repo root at
+ * build). From source inside the monorepo, fall back to the repo root copy.
+ */
+export function skillsRoot() {
+    const candidates = [
+        fileURLToPath(new URL('../skills', import.meta.url)),
+        fileURLToPath(new URL('../../../skills', import.meta.url)),
+    ];
+    const found = candidates.find((dir) => existsSync(join(dir, 'areca-sdk', 'SKILL.md')));
+    if (!found)
+        throw new Error(`Bundled skills not found (looked in ${candidates.join(', ')})`);
+    return found;
+}
+export function loadSkills(root = skillsRoot()) {
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, 'SKILL.md')))
+        .map((entry) => {
+        const dir = join(root, entry.name);
+        const meta = parseFrontmatter(readFileSync(join(dir, 'SKILL.md'), 'utf8'));
+        return { name: meta.name ?? entry.name, description: meta.description ?? '', dir };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Top-level `key: value` pairs of a SKILL.md frontmatter block. */
+export function parseFrontmatter(source) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(source);
+    if (!match)
+        return {};
+    const out = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const pair = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+        if (pair && pair[2])
+            out[pair[1]] = pair[2].replace(/^["']|["']$/g, '');
+    }
+    return out;
+}
+/** Every file in a skill folder as [path relative to the folder, contents]. */
+export function skillFiles(dir) {
+    const out = [];
+    const walk = (current) => {
+        for (const name of readdirSync(current).sort()) {
+            const path = join(current, name);
+            if (statSync(path).isDirectory())
+                walk(path);
+            else
+                out.push([relative(dir, path).split('\\').join('/'), readFileSync(path)]);
+        }
+    };
+    walk(dir);
+    return out;
+}

package/dist/zip.d.ts

@@ -0,0 +1,6 @@
+export type ZipEntry = {
+    path: string;
+    data: Buffer;
+};
+/** Minimal deflate ZIP writer, enough for skill uploads. No external deps. */
+export declare function createZip(entries: ZipEntry[]): Buffer;

package/dist/zip.js

@@ -0,0 +1,51 @@
+import { crc32, deflateRawSync } from 'node:zlib';
+/** Minimal deflate ZIP writer, enough for skill uploads. No external deps. */
+export function createZip(entries) {
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    // 1980-01-01 00:00, so the same skills always give the same bytes.
+    const dosTime = 0;
+    const dosDate = (0 << 9) | (1 << 5) | 1;
+    for (const { path, data } of entries) {
+        const name = Buffer.from(path, 'utf8');
+        const compressed = deflateRawSync(data);
+        const crc = crc32(data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0x0800, 6); // UTF-8 names
+        local.writeUInt16LE(8, 8); // deflate
+        local.writeUInt16LE(dosTime, 10);
+        local.writeUInt16LE(dosDate, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4); // version made by
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(8, 10);
+        central.writeUInt16LE(dosTime, 12);
+        central.writeUInt16LE(dosDate, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt32LE(offset, 42);
+        locals.push(local, name, compressed);
+        centrals.push(central, name);
+        offset += local.length + name.length + compressed.length;
+    }
+    const centralSize = centrals.reduce((sum, part) => sum + part.length, 0);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralSize, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...locals, ...centrals, end]);
+}