shortcutxl 0.2.0

package/dist/utils/changelog.js

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from 'fs';
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export function parseChangelog(changelogPath) {
+    if (!existsSync(changelogPath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(changelogPath, 'utf-8');
+        const lines = content.split('\n');
+        const entries = [];
+        let currentLines = [];
+        let currentVersion = null;
+        for (const line of lines) {
+            // Check if this is a version header (## [x.y.z] ...)
+            if (line.startsWith('## ')) {
+                // Save previous entry if exists
+                if (currentVersion && currentLines.length > 0) {
+                    entries.push({
+                        ...currentVersion,
+                        content: currentLines.join('\n').trim()
+                    });
+                }
+                // Try to parse version from this line
+                const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
+                if (versionMatch) {
+                    currentVersion = {
+                        major: Number.parseInt(versionMatch[1], 10),
+                        minor: Number.parseInt(versionMatch[2], 10),
+                        patch: Number.parseInt(versionMatch[3], 10)
+                    };
+                    currentLines = [line];
+                }
+                else {
+                    // Reset if we can't parse version
+                    currentVersion = null;
+                    currentLines = [];
+                }
+            }
+            else if (currentVersion) {
+                // Collect lines for current version
+                currentLines.push(line);
+            }
+        }
+        // Save last entry
+        if (currentVersion && currentLines.length > 0) {
+            entries.push({
+                ...currentVersion,
+                content: currentLines.join('\n').trim()
+            });
+        }
+        return entries;
+    }
+    catch (error) {
+        console.error(`Warning: Could not parse changelog: ${error}`);
+        return [];
+    }
+}
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+    if (v1.major !== v2.major)
+        return v1.major - v2.major;
+    if (v1.minor !== v2.minor)
+        return v1.minor - v2.minor;
+    return v1.patch - v2.patch;
+}
+/**
+ * Get entries newer than lastVersion
+ */
+export function getNewEntries(entries, lastVersion) {
+    // Parse lastVersion
+    const parts = lastVersion.split('.').map(Number);
+    const last = {
+        major: parts[0] || 0,
+        minor: parts[1] || 0,
+        patch: parts[2] || 0,
+        content: ''
+    };
+    return entries.filter((entry) => compareVersions(entry, last) > 0);
+}
+// Re-export getChangelogPath from paths.ts for convenience
+export { getChangelogPath } from '../config.js';
+//# sourceMappingURL=changelog.js.map

package/dist/utils/clipboard-image.js

@@ -0,0 +1,164 @@
+import { spawnSync } from 'child_process';
+import { clipboard } from './clipboard-native.js';
+import { loadPhoton } from './photon.js';
+const SUPPORTED_IMAGE_MIME_TYPES = ['image/png', 'image/jpeg', 'image/webp', 'image/gif'];
+const DEFAULT_LIST_TIMEOUT_MS = 1000;
+const DEFAULT_READ_TIMEOUT_MS = 3000;
+const DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+export function isWaylandSession(env = process.env) {
+    return Boolean(env.WAYLAND_DISPLAY) || env.XDG_SESSION_TYPE === 'wayland';
+}
+function baseMimeType(mimeType) {
+    return mimeType.split(';')[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+export function extensionForImageMimeType(mimeType) {
+    switch (baseMimeType(mimeType)) {
+        case 'image/png':
+            return 'png';
+        case 'image/jpeg':
+            return 'jpg';
+        case 'image/webp':
+            return 'webp';
+        case 'image/gif':
+            return 'gif';
+        default:
+            return null;
+    }
+}
+function selectPreferredImageMimeType(mimeTypes) {
+    const normalized = mimeTypes
+        .map((t) => t.trim())
+        .filter(Boolean)
+        .map((t) => ({ raw: t, base: baseMimeType(t) }));
+    for (const preferred of SUPPORTED_IMAGE_MIME_TYPES) {
+        const match = normalized.find((t) => t.base === preferred);
+        if (match) {
+            return match.raw;
+        }
+    }
+    const anyImage = normalized.find((t) => t.base.startsWith('image/'));
+    return anyImage?.raw ?? null;
+}
+function isSupportedImageMimeType(mimeType) {
+    const base = baseMimeType(mimeType);
+    return SUPPORTED_IMAGE_MIME_TYPES.some((t) => t === base);
+}
+/**
+ * Convert unsupported image formats to PNG using Photon.
+ * Returns null if conversion is unavailable or fails.
+ */
+async function convertToPng(bytes) {
+    const photon = await loadPhoton();
+    if (!photon) {
+        return null;
+    }
+    try {
+        const image = photon.PhotonImage.new_from_byteslice(bytes);
+        try {
+            return image.get_bytes();
+        }
+        finally {
+            image.free();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function runCommand(command, args, options) {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_READ_TIMEOUT_MS;
+    const maxBufferBytes = options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
+    const result = spawnSync(command, args, {
+        timeout: timeoutMs,
+        maxBuffer: maxBufferBytes
+    });
+    if (result.error) {
+        return { ok: false, stdout: Buffer.alloc(0) };
+    }
+    if (result.status !== 0) {
+        return { ok: false, stdout: Buffer.alloc(0) };
+    }
+    const stdout = Buffer.isBuffer(result.stdout)
+        ? result.stdout
+        : Buffer.from(result.stdout ?? '', typeof result.stdout === 'string' ? 'utf-8' : undefined);
+    return { ok: true, stdout };
+}
+function readClipboardImageViaWlPaste() {
+    const list = runCommand('wl-paste', ['--list-types'], { timeoutMs: DEFAULT_LIST_TIMEOUT_MS });
+    if (!list.ok) {
+        return null;
+    }
+    const types = list.stdout
+        .toString('utf-8')
+        .split(/\r?\n/)
+        .map((t) => t.trim())
+        .filter(Boolean);
+    const selectedType = selectPreferredImageMimeType(types);
+    if (!selectedType) {
+        return null;
+    }
+    const data = runCommand('wl-paste', ['--type', selectedType, '--no-newline']);
+    if (!data.ok || data.stdout.length === 0) {
+        return null;
+    }
+    return { bytes: data.stdout, mimeType: baseMimeType(selectedType) };
+}
+function readClipboardImageViaXclip() {
+    const targets = runCommand('xclip', ['-selection', 'clipboard', '-t', 'TARGETS', '-o'], {
+        timeoutMs: DEFAULT_LIST_TIMEOUT_MS
+    });
+    let candidateTypes = [];
+    if (targets.ok) {
+        candidateTypes = targets.stdout
+            .toString('utf-8')
+            .split(/\r?\n/)
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    const preferred = candidateTypes.length > 0 ? selectPreferredImageMimeType(candidateTypes) : null;
+    const tryTypes = preferred
+        ? [preferred, ...SUPPORTED_IMAGE_MIME_TYPES]
+        : [...SUPPORTED_IMAGE_MIME_TYPES];
+    for (const mimeType of tryTypes) {
+        const data = runCommand('xclip', ['-selection', 'clipboard', '-t', mimeType, '-o']);
+        if (data.ok && data.stdout.length > 0) {
+            return { bytes: data.stdout, mimeType: baseMimeType(mimeType) };
+        }
+    }
+    return null;
+}
+export async function readClipboardImage(options) {
+    const env = options?.env ?? process.env;
+    const platform = options?.platform ?? process.platform;
+    if (env.TERMUX_VERSION) {
+        return null;
+    }
+    let image = null;
+    if (platform === 'linux' && isWaylandSession(env)) {
+        image = readClipboardImageViaWlPaste() ?? readClipboardImageViaXclip();
+    }
+    else {
+        if (!clipboard || !clipboard.hasImage()) {
+            return null;
+        }
+        const imageData = await clipboard.getImageBinary();
+        if (!imageData || imageData.length === 0) {
+            return null;
+        }
+        const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
+        image = { bytes, mimeType: 'image/png' };
+    }
+    if (!image) {
+        return null;
+    }
+    // Convert unsupported formats (e.g., BMP from WSLg) to PNG
+    if (!isSupportedImageMimeType(image.mimeType)) {
+        const pngBytes = await convertToPng(image.bytes);
+        if (!pngBytes) {
+            return null;
+        }
+        return { bytes: pngBytes, mimeType: 'image/png' };
+    }
+    return image;
+}
+//# sourceMappingURL=clipboard-image.js.map

package/dist/utils/clipboard-native.js

@@ -0,0 +1,14 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+let clipboard = null;
+const hasDisplay = process.platform !== 'linux' || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+if (!process.env.TERMUX_VERSION && hasDisplay) {
+    try {
+        clipboard = require('@mariozechner/clipboard');
+    }
+    catch {
+        clipboard = null;
+    }
+}
+export { clipboard };
+//# sourceMappingURL=clipboard-native.js.map

package/dist/utils/clipboard.js

@@ -0,0 +1,67 @@
+import { execSync, spawn } from 'child_process';
+import { platform } from 'os';
+import { isWaylandSession } from './clipboard-image.js';
+export function copyToClipboard(text) {
+    // Always emit OSC 52 - works over SSH/mosh, harmless locally
+    const encoded = Buffer.from(text).toString('base64');
+    process.stdout.write(`\x1b]52;c;${encoded}\x07`);
+    // Also try native tools (best effort for local sessions)
+    const p = platform();
+    const options = { input: text, timeout: 5000 };
+    try {
+        if (p === 'darwin') {
+            execSync('pbcopy', options);
+        }
+        else if (p === 'win32') {
+            execSync('clip', options);
+        }
+        else {
+            // Linux. Try Termux, Wayland, or X11 clipboard tools.
+            if (process.env.TERMUX_VERSION) {
+                try {
+                    execSync('termux-clipboard-set', options);
+                    return;
+                }
+                catch {
+                    // Fall back to Wayland or X11 tools.
+                }
+            }
+            const isWayland = isWaylandSession();
+            if (isWayland) {
+                try {
+                    // Verify wl-copy exists (spawn errors are async and won't be caught)
+                    execSync('which wl-copy', { stdio: 'ignore' });
+                    // wl-copy with execSync hangs due to fork behavior; use spawn instead
+                    const proc = spawn('wl-copy', [], { stdio: ['pipe', 'ignore', 'ignore'] });
+                    proc.stdin.on('error', () => {
+                        // Ignore EPIPE errors if wl-copy exits early
+                    });
+                    proc.stdin.write(text);
+                    proc.stdin.end();
+                    proc.unref();
+                }
+                catch {
+                    // Fall back to xclip/xsel (works on XWayland)
+                    try {
+                        execSync('xclip -selection clipboard', options);
+                    }
+                    catch {
+                        execSync('xsel --clipboard --input', options);
+                    }
+                }
+            }
+            else {
+                try {
+                    execSync('xclip -selection clipboard', options);
+                }
+                catch {
+                    execSync('xsel --clipboard --input', options);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore - OSC 52 already emitted as fallback
+    }
+}
+//# sourceMappingURL=clipboard.js.map

package/dist/utils/frontmatter.js

@@ -0,0 +1,26 @@
+import { parse } from 'yaml';
+const normalizeNewlines = (value) => value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+const extractFrontmatter = (content) => {
+    const normalized = normalizeNewlines(content);
+    if (!normalized.startsWith('---')) {
+        return { yamlString: null, body: normalized };
+    }
+    const endIndex = normalized.indexOf('\n---', 3);
+    if (endIndex === -1) {
+        return { yamlString: null, body: normalized };
+    }
+    return {
+        yamlString: normalized.slice(4, endIndex),
+        body: normalized.slice(endIndex + 4).trim()
+    };
+};
+export const parseFrontmatter = (content) => {
+    const { yamlString, body } = extractFrontmatter(content);
+    if (!yamlString) {
+        return { frontmatter: {}, body };
+    }
+    const parsed = parse(yamlString);
+    return { frontmatter: (parsed ?? {}), body };
+};
+export const stripFrontmatter = (content) => parseFrontmatter(content).body;
+//# sourceMappingURL=frontmatter.js.map

package/dist/utils/git.js

@@ -0,0 +1,166 @@
+import hostedGitInfo from 'hosted-git-info';
+function splitRef(url) {
+    const scpLikeMatch = url.match(/^git@([^:]+):(.+)$/);
+    if (scpLikeMatch) {
+        const pathWithMaybeRef = scpLikeMatch[2] ?? '';
+        const refSeparator = pathWithMaybeRef.indexOf('@');
+        if (refSeparator < 0)
+            return { repo: url };
+        const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+        const ref = pathWithMaybeRef.slice(refSeparator + 1);
+        if (!repoPath || !ref)
+            return { repo: url };
+        return {
+            repo: `git@${scpLikeMatch[1] ?? ''}:${repoPath}`,
+            ref
+        };
+    }
+    if (url.includes('://')) {
+        try {
+            const parsed = new URL(url);
+            const pathWithMaybeRef = parsed.pathname.replace(/^\/+/, '');
+            const refSeparator = pathWithMaybeRef.indexOf('@');
+            if (refSeparator < 0)
+                return { repo: url };
+            const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+            const ref = pathWithMaybeRef.slice(refSeparator + 1);
+            if (!repoPath || !ref)
+                return { repo: url };
+            parsed.pathname = `/${repoPath}`;
+            return {
+                repo: parsed.toString().replace(/\/$/, ''),
+                ref
+            };
+        }
+        catch {
+            return { repo: url };
+        }
+    }
+    const slashIndex = url.indexOf('/');
+    if (slashIndex < 0) {
+        return { repo: url };
+    }
+    const host = url.slice(0, slashIndex);
+    const pathWithMaybeRef = url.slice(slashIndex + 1);
+    const refSeparator = pathWithMaybeRef.indexOf('@');
+    if (refSeparator < 0) {
+        return { repo: url };
+    }
+    const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+    const ref = pathWithMaybeRef.slice(refSeparator + 1);
+    if (!repoPath || !ref) {
+        return { repo: url };
+    }
+    return {
+        repo: `${host}/${repoPath}`,
+        ref
+    };
+}
+function parseGenericGitUrl(url) {
+    const { repo: repoWithoutRef, ref } = splitRef(url);
+    let repo = repoWithoutRef;
+    let host = '';
+    let path = '';
+    const scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
+    if (scpLikeMatch) {
+        host = scpLikeMatch[1] ?? '';
+        path = scpLikeMatch[2] ?? '';
+    }
+    else if (repoWithoutRef.startsWith('https://') ||
+        repoWithoutRef.startsWith('http://') ||
+        repoWithoutRef.startsWith('ssh://') ||
+        repoWithoutRef.startsWith('git://')) {
+        try {
+            const parsed = new URL(repoWithoutRef);
+            host = parsed.hostname;
+            path = parsed.pathname.replace(/^\/+/, '');
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        const slashIndex = repoWithoutRef.indexOf('/');
+        if (slashIndex < 0) {
+            return null;
+        }
+        host = repoWithoutRef.slice(0, slashIndex);
+        path = repoWithoutRef.slice(slashIndex + 1);
+        if (!host.includes('.') && host !== 'localhost') {
+            return null;
+        }
+        repo = `https://${repoWithoutRef}`;
+    }
+    const normalizedPath = path.replace(/\.git$/, '').replace(/^\/+/, '');
+    if (!host || !normalizedPath || normalizedPath.split('/').length < 2) {
+        return null;
+    }
+    return {
+        type: 'git',
+        repo,
+        host,
+        path: normalizedPath,
+        ref,
+        pinned: Boolean(ref)
+    };
+}
+/**
+ * Parse git source into a GitSource.
+ *
+ * Rules:
+ * - With git: prefix, accept all historical shorthand forms.
+ * - Without git: prefix, only accept explicit protocol URLs.
+ */
+export function parseGitUrl(source) {
+    const trimmed = source.trim();
+    const hasGitPrefix = trimmed.startsWith('git:');
+    const url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
+    if (!hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(url)) {
+        return null;
+    }
+    const split = splitRef(url);
+    const hostedCandidates = [split.ref ? `${split.repo}#${split.ref}` : undefined, url].filter((value) => Boolean(value));
+    for (const candidate of hostedCandidates) {
+        const info = hostedGitInfo.fromUrl(candidate);
+        if (info) {
+            if (split.ref && info.project?.includes('@')) {
+                continue;
+            }
+            const useHttpsPrefix = !split.repo.startsWith('http://') &&
+                !split.repo.startsWith('https://') &&
+                !split.repo.startsWith('ssh://') &&
+                !split.repo.startsWith('git://') &&
+                !split.repo.startsWith('git@');
+            return {
+                type: 'git',
+                repo: useHttpsPrefix ? `https://${split.repo}` : split.repo,
+                host: info.domain || '',
+                path: `${info.user}/${info.project}`.replace(/\.git$/, ''),
+                ref: info.committish || split.ref || undefined,
+                pinned: Boolean(info.committish || split.ref)
+            };
+        }
+    }
+    const httpsCandidates = [
+        split.ref ? `https://${split.repo}#${split.ref}` : undefined,
+        `https://${url}`
+    ].filter((value) => Boolean(value));
+    for (const candidate of httpsCandidates) {
+        const info = hostedGitInfo.fromUrl(candidate);
+        if (info) {
+            if (split.ref && info.project?.includes('@')) {
+                continue;
+            }
+            return {
+                type: 'git',
+                repo: `https://${split.repo}`,
+                host: info.domain || '',
+                path: `${info.user}/${info.project}`.replace(/\.git$/, ''),
+                ref: info.committish || split.ref || undefined,
+                pinned: Boolean(info.committish || split.ref)
+            };
+        }
+    }
+    return parseGenericGitUrl(url);
+}
+//# sourceMappingURL=git.js.map

package/dist/utils/image-convert.js

@@ -0,0 +1,35 @@
+import { loadPhoton } from './photon.js';
+/**
+ * Convert image to PNG format for terminal display.
+ * Kitty graphics protocol requires PNG format (f=100).
+ */
+export async function convertToPng(base64Data, mimeType) {
+    // Already PNG, no conversion needed
+    if (mimeType === 'image/png') {
+        return { data: base64Data, mimeType };
+    }
+    const photon = await loadPhoton();
+    if (!photon) {
+        // Photon not available, can't convert
+        return null;
+    }
+    try {
+        const bytes = new Uint8Array(Buffer.from(base64Data, 'base64'));
+        const image = photon.PhotonImage.new_from_byteslice(bytes);
+        try {
+            const pngBuffer = image.get_bytes();
+            return {
+                data: Buffer.from(pngBuffer).toString('base64'),
+                mimeType: 'image/png'
+            };
+        }
+        finally {
+            image.free();
+        }
+    }
+    catch {
+        // Conversion failed
+        return null;
+    }
+}
+//# sourceMappingURL=image-convert.js.map