skill-check 0.1.1 → 1.1.0

package/dist/core/remote-target.d.ts

@@ -0,0 +1,51 @@
+export interface ParsedGitHubTarget {
+    originalUrl: string;
+    owner: string;
+    repo: string;
+    cloneUrl: string;
+    ref?: string;
+    subpath?: string;
+}
+export interface MaterializedRemoteTarget {
+    path: string;
+    cleanup: () => void;
+    metadata: ParsedGitHubTarget & {
+        tempDir: string;
+        checkoutPath: string;
+    };
+}
+export type RemoteTargetProgressEvent = {
+    type: 'clone_start';
+    cloneUrl: string;
+    ref?: string;
+} | {
+    type: 'clone_done';
+    checkoutPath: string;
+} | {
+    type: 'subpath_start';
+    subpath: string;
+} | {
+    type: 'ready';
+    targetPath: string;
+} | {
+    type: 'failed';
+    message: string;
+};
+interface CommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: NodeJS.ErrnoException;
+}
+type CommandRunner = (command: string, args: string[], cwd?: string) => CommandResult;
+interface MaterializeDeps {
+    runCommand?: CommandRunner;
+    mkdtempSync?: (prefix: string) => string;
+    removeDir?: (target: string) => void;
+    pathExists?: (target: string) => boolean;
+    onProgress?: (event: RemoteTargetProgressEvent) => void;
+}
+export declare function isGitHubRepoUrl(input: string): boolean;
+export declare function parseGitHubTarget(input: string): ParsedGitHubTarget;
+export declare function materializeRemoteTarget(input: string, deps?: MaterializeDeps): MaterializedRemoteTarget;
+export {};

package/dist/core/remote-target.js

@@ -0,0 +1,191 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { CliError } from './errors.js';
+function decodePathPart(value, label) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        throw new CliError(`Invalid GitHub URL: unable to decode ${label}.`, 2);
+    }
+}
+function parseAsUrl(input) {
+    try {
+        return new URL(input);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultRunCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf8',
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        error: result.error,
+    };
+}
+function ensureWithinCheckout(baseDir, candidatePath) {
+    const relative = path.relative(baseDir, candidatePath);
+    if (relative.startsWith('..') ||
+        path.isAbsolute(relative) ||
+        relative === '') {
+        throw new CliError('Invalid GitHub tree subpath: resolved path escapes repository root.', 2);
+    }
+}
+function trimErrorText(text) {
+    return text.trim().split('\n').slice(0, 3).join(' ').trim();
+}
+export function isGitHubRepoUrl(input) {
+    const url = parseAsUrl(input);
+    if (!url)
+        return false;
+    if (url.hostname.toLowerCase() !== 'github.com')
+        return false;
+    const segments = url.pathname.split('/').filter(Boolean);
+    return segments.length >= 2;
+}
+export function parseGitHubTarget(input) {
+    const url = parseAsUrl(input);
+    if (!url) {
+        throw new CliError(`Invalid GitHub URL: "${input}".`, 2);
+    }
+    const host = url.hostname.toLowerCase();
+    if (host !== 'github.com') {
+        throw new CliError(`Unsupported URL host "${url.hostname}". Only github.com is supported.`, 2);
+    }
+    if (url.search || url.hash) {
+        throw new CliError('GitHub URL targets must not include query params or hash fragments.', 2);
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    if (segments.length < 2) {
+        throw new CliError('Invalid GitHub URL: expected https://github.com/<owner>/<repo>.', 2);
+    }
+    const owner = decodePathPart(segments[0], 'owner');
+    const repoRaw = decodePathPart(segments[1], 'repo');
+    const repo = repoRaw.endsWith('.git') ? repoRaw.slice(0, -4) : repoRaw;
+    if (!owner || !repo) {
+        throw new CliError('Invalid GitHub URL: owner and repo must be non-empty.', 2);
+    }
+    let ref;
+    let subpath;
+    if (segments.length > 2) {
+        if (segments[2] !== 'tree') {
+            throw new CliError('Unsupported GitHub URL path. Use repo root or /tree/<ref>/<subpath>.', 2);
+        }
+        if (segments.length < 4) {
+            throw new CliError('Invalid GitHub tree URL: missing <ref> segment after /tree/.', 2);
+        }
+        ref = decodePathPart(segments[3], 'ref');
+        if (!ref) {
+            throw new CliError('Invalid GitHub tree URL: <ref> cannot be empty.', 2);
+        }
+        if (segments.length > 4) {
+            subpath = segments
+                .slice(4)
+                .map((segment, index) => decodePathPart(segment, `tree subpath segment ${index + 1}`))
+                .join('/');
+        }
+    }
+    return {
+        originalUrl: input,
+        owner,
+        repo,
+        cloneUrl: `https://github.com/${owner}/${repo}.git`,
+        ref,
+        subpath,
+    };
+}
+export function materializeRemoteTarget(input, deps = {}) {
+    const onProgress = deps.onProgress;
+    let parsed;
+    try {
+        parsed = parseGitHubTarget(input);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onProgress?.({ type: 'failed', message });
+        throw error;
+    }
+    const mkdtempSync = deps.mkdtempSync ?? ((prefix) => fs.mkdtempSync(prefix));
+    const removeDir = deps.removeDir ??
+        ((target) => fs.rmSync(target, { recursive: true, force: true }));
+    const pathExists = deps.pathExists ?? ((target) => fs.existsSync(target));
+    const runCommand = deps.runCommand ?? defaultRunCommand;
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), 'skill-check-remote-'));
+    const checkoutPath = path.join(tempDir, 'repo');
+    const cleanup = () => {
+        removeDir(tempDir);
+    };
+    try {
+        const cloneArgs = ['clone', '--depth', '1'];
+        if (parsed.ref) {
+            cloneArgs.push('--branch', parsed.ref, '--single-branch');
+        }
+        cloneArgs.push(parsed.cloneUrl, checkoutPath);
+        onProgress?.({
+            type: 'clone_start',
+            cloneUrl: parsed.cloneUrl,
+            ref: parsed.ref,
+        });
+        const result = runCommand('git', cloneArgs);
+        if (result.error?.code === 'ENOENT') {
+            throw new CliError('git is required to scan GitHub URL targets but was not found in PATH.', 2);
+        }
+        if (result.error) {
+            throw new CliError(`Failed to clone GitHub URL target: ${result.error.message}`, 2);
+        }
+        if (result.status !== 0) {
+            const details = trimErrorText(result.stderr || result.stdout);
+            throw new CliError(`git clone failed for ${parsed.cloneUrl}${details ? `: ${details}` : ''}`, 2);
+        }
+        onProgress?.({
+            type: 'clone_done',
+            checkoutPath,
+        });
+        if (!pathExists(checkoutPath)) {
+            throw new CliError('Remote checkout did not produce a repository directory.', 2);
+        }
+        let targetPath = checkoutPath;
+        if (parsed.subpath) {
+            onProgress?.({
+                type: 'subpath_start',
+                subpath: parsed.subpath,
+            });
+            const resolvedSubpath = path.resolve(checkoutPath, parsed.subpath);
+            ensureWithinCheckout(checkoutPath, resolvedSubpath);
+            if (!pathExists(resolvedSubpath)) {
+                throw new CliError(`GitHub tree subpath not found in checkout: ${parsed.subpath}`, 2);
+            }
+            targetPath = resolvedSubpath;
+        }
+        onProgress?.({
+            type: 'ready',
+            targetPath,
+        });
+        return {
+            path: targetPath,
+            cleanup,
+            metadata: {
+                ...parsed,
+                tempDir,
+                checkoutPath,
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onProgress?.({
+            type: 'failed',
+            message,
+        });
+        cleanup();
+        throw error;
+    }
+}

package/dist/core/share-image.d.ts

@@ -0,0 +1,2 @@
+export declare function renderShareImageSvg(cardText: string): string;
+export declare function writeShareImage(cardText: string, outputPath: string): string;

package/dist/core/share-image.js

@@ -0,0 +1,144 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Resvg } from '@resvg/resvg-js';
+const ANSI_RE = new RegExp(`${String.fromCharCode(0x1b)}\\[[0-9;]*m`, 'g');
+const BASE_FONT_SIZE = 18;
+const LINE_HEIGHT = 28;
+const CHAR_WIDTH = 10;
+const PADDING_X = 32;
+const PADDING_Y = 32;
+const SUPPORTED_OUTPUT_FORMATS = new Set(['png', 'svg']);
+const DEFAULT_FILL = '#eaf2ff';
+const DIM_FILL = '#94a3b8';
+const RED_FILL = '#ef4444';
+const GREEN_FILL = '#22c55e';
+const YELLOW_FILL = '#eab308';
+const CYAN_FILL = '#06b6d4';
+function ansiToFill(code) {
+    if (code === '\x1b[0m' || code === '\x1b[39m')
+        return DEFAULT_FILL;
+    if (code === '\x1b[22m')
+        return DEFAULT_FILL;
+    if (code === '\x1b[2m')
+        return DIM_FILL;
+    if (code.includes('31'))
+        return RED_FILL;
+    if (code.includes('32'))
+        return GREEN_FILL;
+    if (code.includes('33'))
+        return YELLOW_FILL;
+    if (code.includes('36'))
+        return CYAN_FILL;
+    return null;
+}
+function parseAnsiLine(line) {
+    const raw = [];
+    let fill = DEFAULT_FILL;
+    let lastIndex = 0;
+    ANSI_RE.lastIndex = 0;
+    let match = ANSI_RE.exec(line);
+    while (match !== null) {
+        const text = line.slice(lastIndex, match.index);
+        if (text.length > 0) {
+            raw.push({ text, fill });
+        }
+        const nextFill = ansiToFill(match[0]);
+        if (nextFill !== null)
+            fill = nextFill;
+        lastIndex = match.index + match[0].length;
+        match = ANSI_RE.exec(line);
+    }
+    const tail = line.slice(lastIndex);
+    if (tail.length > 0) {
+        raw.push({ text: tail, fill });
+    }
+    // resvg drops whitespace-only tspan elements, so merge them into the
+    // preceding segment to keep spaces visible.
+    const segments = [];
+    for (const seg of raw) {
+        if (seg.text.trim() === '' && segments.length > 0) {
+            const prev = segments[segments.length - 1];
+            segments[segments.length - 1] = {
+                text: prev.text + seg.text,
+                fill: prev.fill,
+            };
+        }
+        else {
+            segments.push(seg);
+        }
+    }
+    return segments;
+}
+function escapeXml(input) {
+    return input
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+export function renderShareImageSvg(cardText) {
+    const trimmed = cardText.trimEnd();
+    const lines = trimmed.split('\n');
+    const maxChars = Math.max(1, ...lines.map((line) => line.replace(ANSI_RE, '').length));
+    const textBlockWidth = Math.ceil(maxChars * CHAR_WIDTH);
+    const textBlockHeight = Math.max(1, lines.length) * LINE_HEIGHT;
+    const canvasWidth = textBlockWidth + PADDING_X * 2;
+    const canvasHeight = textBlockHeight + PADDING_Y * 2;
+    const textX = PADDING_X;
+    const textStartY = PADDING_Y + BASE_FONT_SIZE;
+    const fontFamily = "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace";
+    const lineElements = lines
+        .map((line, index) => {
+        const y = textStartY + index * LINE_HEIGHT;
+        const segments = parseAnsiLine(line);
+        if (segments.length === 0) {
+            return `  <text x="${textX}" y="${y}" fill="${DEFAULT_FILL}" font-family="${fontFamily}" font-size="${BASE_FONT_SIZE}"></text>`;
+        }
+        const tspans = segments
+            .map((seg) => {
+            const escaped = escapeXml(seg.text);
+            return `<tspan fill="${seg.fill}">${escaped}</tspan>`;
+        })
+            .join('');
+        return `  <text x="${textX}" y="${y}" font-family="${fontFamily}" font-size="${BASE_FONT_SIZE}" xml:space="preserve">${tspans}</text>`;
+    })
+        .join('\n');
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${canvasWidth}" height="${canvasHeight}" viewBox="0 0 ${canvasWidth} ${canvasHeight}" role="img" aria-label="skill-check share card">`,
+        '  <rect width="100%" height="100%" fill="#0d1117"/>',
+        lineElements,
+        '</svg>',
+        '',
+    ].join('\n');
+}
+function resolveOutputTarget(outputPath) {
+    const resolved = path.resolve(outputPath);
+    const ext = path.extname(resolved).toLowerCase().replace('.', '');
+    const parsed = path.parse(resolved);
+    const format = SUPPORTED_OUTPUT_FORMATS.has(ext) ? ext : 'png';
+    const finalPath = format === ext
+        ? resolved
+        : path.join(parsed.dir, `${parsed.name}.${format}`);
+    return { path: finalPath, format: format };
+}
+export function writeShareImage(cardText, outputPath) {
+    const target = resolveOutputTarget(outputPath);
+    const parent = path.dirname(target.path);
+    fs.mkdirSync(parent, { recursive: true });
+    try {
+        fs.unlinkSync(target.path);
+    }
+    catch {
+        // ignore if file does not exist
+    }
+    const svg = renderShareImageSvg(cardText);
+    if (target.format === 'svg') {
+        fs.writeFileSync(target.path, svg, 'utf8');
+        return target.path;
+    }
+    const resvg = new Resvg(svg);
+    const pngData = resvg.render().asPng();
+    fs.writeFileSync(target.path, pngData);
+    return target.path;
+}

package/dist/rules/core/body.js

@@ -14,7 +14,9 @@ export const bodyRules = [
             return [
                 {
                     message: `body lines ${lines} exceeds max ${max}`,
-                    suggestion: `Reduce body to ${max} lines or fewer.`,
+                    suggestion: `Run "npx skill-check split-body <skill-dir-or-file>" to preview section-based extraction into references/*.md, then re-run with "--write". ` +
+                        `For editorial cleanup, use docs/skills/split-into-references/SKILL.md ` +
+                        `(https://github.com/thedaviddias/skill-check/blob/main/docs/skills/split-into-references/SKILL.md).`,
                 },
             ];
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-check",
-  "version": "0.1.1",
+  "version": "1.1.0",
   "description": "Linter for agent skill files",
   "type": "module",
   "private": false,
@@ -52,8 +52,13 @@
     "url": "git+https://github.com/thedaviddias/skill-check.git"
   },
   "license": "MIT",
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
+    "@resvg/resvg-js": "^2.6.2",
     "boxen": "^8.0.1",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
@@ -69,6 +74,7 @@
     "@commitlint/config-conventional": "^20.4.2",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^13.1.4",
     "@types/node": "^25.3.0",
     "@vitest/coverage-v8": "^4.0.18",
     "commitlint": "^20.4.2",