@slats/claude-assets-sync 0.0.1

package/dist/core/github.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+class RateLimitError extends Error {
+    constructor() {
+        super('GitHub API rate limit exceeded. Set GITHUB_TOKEN environment variable to increase the limit.');
+        this.name = 'RateLimitError';
+    }
+}
+class NotFoundError extends Error {
+    constructor(resource) {
+        super(`GitHub resource not found: ${resource}`);
+        this.name = 'NotFoundError';
+    }
+}
+const getHeaders = () => {
+    const headers = {
+        Accept: 'application/vnd.github.v3+json',
+        'User-Agent': 'claude-assets-sync',
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+};
+const fetchDirectoryContents = async (repoInfo, path, tag) => {
+    const url = `https://api.github.com/repos/${repoInfo.owner}/${repoInfo.repo}/contents/${path}?ref=${encodeURIComponent(tag)}`;
+    const response = await fetch(url, {
+        headers: getHeaders(),
+    });
+    if (response.status === 403) {
+        const remaining = response.headers.get('x-ratelimit-remaining');
+        if (remaining === '0')
+            throw new RateLimitError();
+    }
+    if (response.status === 404)
+        return null;
+    if (!response.ok)
+        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    const data = await response.json();
+    return data.filter((entry) => entry.type === 'file' && entry.name.endsWith('.md'));
+};
+const fetchAssetFiles = async (repoInfo, assetPath, tag) => {
+    const basePath = repoInfo.directory
+        ? `${repoInfo.directory}/${assetPath}`
+        : assetPath;
+    const commandsPath = `${basePath}/commands`;
+    const skillsPath = `${basePath}/skills`;
+    const [commandsEntries, skillsEntries] = await Promise.all([
+        fetchDirectoryContents(repoInfo, commandsPath, tag),
+        fetchDirectoryContents(repoInfo, skillsPath, tag),
+    ]);
+    return {
+        commands: commandsEntries || [],
+        skills: skillsEntries || [],
+    };
+};
+const downloadFile = async (repoInfo, filePath, tag) => {
+    const url = `https://raw.githubusercontent.com/${repoInfo.owner}/${repoInfo.repo}/${encodeURIComponent(tag)}/${filePath}`;
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'claude-assets-sync',
+        },
+    });
+    if (response.status === 404) {
+        throw new NotFoundError(filePath);
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+};
+const downloadAssetFiles = async (repoInfo, assetPath, assetType, entries, tag) => {
+    const basePath = repoInfo.directory
+        ? `${repoInfo.directory}/${assetPath}/${assetType}`
+        : `${assetPath}/${assetType}`;
+    const results = new Map();
+    for (const entry of entries) {
+        const filePath = `${basePath}/${entry.name}`;
+        const content = await downloadFile(repoInfo, filePath, tag);
+        results.set(entry.name, content);
+    }
+    return results;
+};
+
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.downloadAssetFiles = downloadAssetFiles;
+exports.downloadFile = downloadFile;
+exports.fetchAssetFiles = fetchAssetFiles;
+exports.fetchDirectoryContents = fetchDirectoryContents;

package/dist/core/github.d.ts

@@ -0,0 +1,50 @@
+import type { AssetType, GitHubEntry, GitHubRepoInfo } from '../utils/types';
+/**
+ * Error thrown when GitHub API rate limit is exceeded
+ */
+export declare class RateLimitError extends Error {
+    constructor();
+}
+/**
+ * Error thrown when GitHub resource is not found
+ */
+export declare class NotFoundError extends Error {
+    constructor(resource: string);
+}
+/**
+ * Fetch directory contents from GitHub API
+ * @param repoInfo - GitHub repository information
+ * @param path - Path to the directory
+ * @param tag - Git tag or ref to fetch from
+ * @returns Array of GitHubEntry or null if directory doesn't exist
+ */
+export declare const fetchDirectoryContents: (repoInfo: GitHubRepoInfo, path: string, tag: string) => Promise<GitHubEntry[] | null>;
+/**
+ * Fetch asset files (commands and skills) from GitHub
+ * @param repoInfo - GitHub repository information
+ * @param assetPath - Base path to Claude assets (e.g., "docs/claude")
+ * @param tag - Git tag or ref to fetch from
+ * @returns Object with commands and skills file lists
+ */
+export declare const fetchAssetFiles: (repoInfo: GitHubRepoInfo, assetPath: string, tag: string) => Promise<{
+    commands: GitHubEntry[];
+    skills: GitHubEntry[];
+}>;
+/**
+ * Download file content from raw.githubusercontent.com
+ * @param repoInfo - GitHub repository information
+ * @param filePath - Full path to the file
+ * @param tag - Git tag or ref
+ * @returns File content as string
+ */
+export declare const downloadFile: (repoInfo: GitHubRepoInfo, filePath: string, tag: string) => Promise<string>;
+/**
+ * Download multiple files from a specific asset type
+ * @param repoInfo - GitHub repository information
+ * @param assetPath - Base path to Claude assets
+ * @param assetType - Type of asset (commands or skills)
+ * @param entries - Array of GitHubEntry to download
+ * @param tag - Git tag or ref
+ * @returns Map of filename to content
+ */
+export declare const downloadAssetFiles: (repoInfo: GitHubRepoInfo, assetPath: string, assetType: AssetType, entries: GitHubEntry[], tag: string) => Promise<Map<string, string>>;

package/dist/core/github.mjs

@@ -0,0 +1,83 @@
+class RateLimitError extends Error {
+    constructor() {
+        super('GitHub API rate limit exceeded. Set GITHUB_TOKEN environment variable to increase the limit.');
+        this.name = 'RateLimitError';
+    }
+}
+class NotFoundError extends Error {
+    constructor(resource) {
+        super(`GitHub resource not found: ${resource}`);
+        this.name = 'NotFoundError';
+    }
+}
+const getHeaders = () => {
+    const headers = {
+        Accept: 'application/vnd.github.v3+json',
+        'User-Agent': 'claude-assets-sync',
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+};
+const fetchDirectoryContents = async (repoInfo, path, tag) => {
+    const url = `https://api.github.com/repos/${repoInfo.owner}/${repoInfo.repo}/contents/${path}?ref=${encodeURIComponent(tag)}`;
+    const response = await fetch(url, {
+        headers: getHeaders(),
+    });
+    if (response.status === 403) {
+        const remaining = response.headers.get('x-ratelimit-remaining');
+        if (remaining === '0')
+            throw new RateLimitError();
+    }
+    if (response.status === 404)
+        return null;
+    if (!response.ok)
+        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    const data = await response.json();
+    return data.filter((entry) => entry.type === 'file' && entry.name.endsWith('.md'));
+};
+const fetchAssetFiles = async (repoInfo, assetPath, tag) => {
+    const basePath = repoInfo.directory
+        ? `${repoInfo.directory}/${assetPath}`
+        : assetPath;
+    const commandsPath = `${basePath}/commands`;
+    const skillsPath = `${basePath}/skills`;
+    const [commandsEntries, skillsEntries] = await Promise.all([
+        fetchDirectoryContents(repoInfo, commandsPath, tag),
+        fetchDirectoryContents(repoInfo, skillsPath, tag),
+    ]);
+    return {
+        commands: commandsEntries || [],
+        skills: skillsEntries || [],
+    };
+};
+const downloadFile = async (repoInfo, filePath, tag) => {
+    const url = `https://raw.githubusercontent.com/${repoInfo.owner}/${repoInfo.repo}/${encodeURIComponent(tag)}/${filePath}`;
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'claude-assets-sync',
+        },
+    });
+    if (response.status === 404) {
+        throw new NotFoundError(filePath);
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+};
+const downloadAssetFiles = async (repoInfo, assetPath, assetType, entries, tag) => {
+    const basePath = repoInfo.directory
+        ? `${repoInfo.directory}/${assetPath}/${assetType}`
+        : `${assetPath}/${assetType}`;
+    const results = new Map();
+    for (const entry of entries) {
+        const filePath = `${basePath}/${entry.name}`;
+        const content = await downloadFile(repoInfo, filePath, tag);
+        results.set(entry.name, content);
+    }
+    return results;
+};
+
+export { NotFoundError, RateLimitError, downloadAssetFiles, downloadFile, fetchAssetFiles, fetchDirectoryContents };

package/dist/core/sync.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var logger = require('../utils/logger.cjs');
+var _package = require('../utils/package.cjs');
+var filesystem = require('./filesystem.cjs');
+var github = require('./github.cjs');
+
+const syncPackage = async (packageName, options, cwd = process.cwd(), outputDir) => {
+    logger.logger.packageStart(packageName);
+    try {
+        const destDir = outputDir ?? _package.findGitRoot(cwd) ?? cwd;
+        const packageInfo = options.local
+            ? _package.readLocalPackageJson(packageName, cwd)
+            : _package.readPackageJson(packageName, cwd);
+        if (!packageInfo) {
+            const location = options.local ? 'workspace' : 'node_modules';
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: `Package not found in ${location}`,
+            };
+        }
+        if (!packageInfo.claude?.assetPath)
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'Package does not have claude.assetPath in package.json',
+            };
+        const repoInfo = _package.parseGitHubRepo(packageInfo.repository);
+        if (!repoInfo) {
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'Unable to parse GitHub repository URL',
+            };
+        }
+        if (!options.force &&
+            !filesystem.needsSync(destDir, packageName, packageInfo.version)) {
+            return {
+                packageName,
+                success: true,
+                skipped: true,
+                reason: `Already synced at version ${packageInfo.version}`,
+            };
+        }
+        const tag = options.ref ?? _package.buildVersionTag(packageName, packageInfo.version);
+        const assetPath = _package.buildAssetPath(packageInfo.claude.assetPath);
+        logger.logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
+        const { commands, skills } = await github.fetchAssetFiles(repoInfo, assetPath, tag);
+        if (commands.length === 0 && skills.length === 0)
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'No commands or skills found in package',
+            };
+        logger.logger.step('Found', `${commands.length} commands, ${skills.length} skills`);
+        if (options.dryRun) {
+            if (commands.length > 0) {
+                logger.logger.step('Would sync commands to', filesystem.getDestinationDir(destDir, packageName, 'commands'));
+                commands.forEach((entry) => logger.logger.file('create', entry.name));
+            }
+            if (skills.length > 0) {
+                logger.logger.step('Would sync skills to', filesystem.getDestinationDir(destDir, packageName, 'skills'));
+                skills.forEach((entry) => logger.logger.file('create', entry.name));
+            }
+            return {
+                packageName,
+                success: true,
+                skipped: false,
+                syncedFiles: {
+                    commands: commands.map((e) => e.name),
+                    skills: skills.map((e) => e.name),
+                },
+            };
+        }
+        const syncedFiles = {
+            commands: [],
+            skills: [],
+        };
+        if (commands.length > 0) {
+            logger.logger.step('Downloading', 'commands');
+            const commandFiles = await github.downloadAssetFiles(repoInfo, assetPath, 'commands', commands, tag);
+            filesystem.cleanAssetDir(destDir, packageName, 'commands');
+            for (const [fileName, content] of commandFiles) {
+                filesystem.writeAssetFile(destDir, packageName, 'commands', fileName, content);
+                logger.logger.file('create', fileName);
+                syncedFiles.commands.push(fileName);
+            }
+            filesystem.writeSyncMeta(destDir, packageName, 'commands', filesystem.createSyncMeta(packageInfo.version, syncedFiles.commands));
+        }
+        if (skills.length > 0) {
+            logger.logger.step('Downloading', 'skills');
+            const skillFiles = await github.downloadAssetFiles(repoInfo, assetPath, 'skills', skills, tag);
+            filesystem.cleanAssetDir(destDir, packageName, 'skills');
+            for (const [fileName, content] of skillFiles) {
+                filesystem.writeAssetFile(destDir, packageName, 'skills', fileName, content);
+                logger.logger.file('create', fileName);
+                syncedFiles.skills.push(fileName);
+            }
+            filesystem.writeSyncMeta(destDir, packageName, 'skills', filesystem.createSyncMeta(packageInfo.version, syncedFiles.skills));
+        }
+        return {
+            packageName,
+            success: true,
+            skipped: false,
+            syncedFiles,
+        };
+    }
+    catch (error) {
+        if (error instanceof github.RateLimitError)
+            return {
+                packageName,
+                success: false,
+                skipped: false,
+                reason: error.message,
+            };
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        return {
+            packageName,
+            success: false,
+            skipped: false,
+            reason: message,
+        };
+    }
+};
+const syncPackages = async (packages, options, cwd = process.cwd()) => {
+    const results = [];
+    const gitRoot = _package.findGitRoot(cwd);
+    if (gitRoot)
+        logger.logger.info(`[Output] ${gitRoot}/.claude\n`);
+    for (const packageName of packages) {
+        const result = await syncPackage(packageName, options, cwd, gitRoot ?? undefined);
+        logger.logger.packageEnd(packageName, result);
+        results.push(result);
+    }
+    const summary = {
+        success: results.filter((r) => r.success && !r.skipped).length,
+        skipped: results.filter((r) => r.skipped).length,
+        failed: results.filter((r) => !r.success && !r.skipped).length,
+    };
+    logger.logger.summary(summary);
+    return results;
+};
+
+exports.syncPackage = syncPackage;
+exports.syncPackages = syncPackages;

package/dist/core/sync.d.ts

@@ -0,0 +1,17 @@
+import type { CliOptions, SyncResult } from '../utils/types';
+/**
+ * Sync Claude assets for a single package
+ * @param packageName - Package name to sync
+ * @param options - CLI options
+ * @param cwd - Current working directory
+ * @returns Sync result
+ */
+export declare const syncPackage: (packageName: string, options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref">, cwd?: string, outputDir?: string) => Promise<SyncResult>;
+/**
+ * Sync Claude assets for multiple packages
+ * @param packages - List of package names to sync
+ * @param options - CLI options
+ * @param cwd - Current working directory
+ * @returns Array of sync results
+ */
+export declare const syncPackages: (packages: string[], options: Pick<CliOptions, "force" | "dryRun" | "local" | "ref">, cwd?: string) => Promise<SyncResult[]>;

package/dist/core/sync.mjs

@@ -0,0 +1,147 @@
+import { logger } from '../utils/logger.mjs';
+import { findGitRoot, readLocalPackageJson, readPackageJson, parseGitHubRepo, buildVersionTag, buildAssetPath } from '../utils/package.mjs';
+import { needsSync, getDestinationDir, cleanAssetDir, writeAssetFile, writeSyncMeta, createSyncMeta } from './filesystem.mjs';
+import { fetchAssetFiles, downloadAssetFiles, RateLimitError } from './github.mjs';
+
+const syncPackage = async (packageName, options, cwd = process.cwd(), outputDir) => {
+    logger.packageStart(packageName);
+    try {
+        const destDir = outputDir ?? findGitRoot(cwd) ?? cwd;
+        const packageInfo = options.local
+            ? readLocalPackageJson(packageName, cwd)
+            : readPackageJson(packageName, cwd);
+        if (!packageInfo) {
+            const location = options.local ? 'workspace' : 'node_modules';
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: `Package not found in ${location}`,
+            };
+        }
+        if (!packageInfo.claude?.assetPath)
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'Package does not have claude.assetPath in package.json',
+            };
+        const repoInfo = parseGitHubRepo(packageInfo.repository);
+        if (!repoInfo) {
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'Unable to parse GitHub repository URL',
+            };
+        }
+        if (!options.force &&
+            !needsSync(destDir, packageName, packageInfo.version)) {
+            return {
+                packageName,
+                success: true,
+                skipped: true,
+                reason: `Already synced at version ${packageInfo.version}`,
+            };
+        }
+        const tag = options.ref ?? buildVersionTag(packageName, packageInfo.version);
+        const assetPath = buildAssetPath(packageInfo.claude.assetPath);
+        logger.step('Fetching', `asset list from GitHub (ref: ${tag})`);
+        const { commands, skills } = await fetchAssetFiles(repoInfo, assetPath, tag);
+        if (commands.length === 0 && skills.length === 0)
+            return {
+                packageName,
+                success: false,
+                skipped: true,
+                reason: 'No commands or skills found in package',
+            };
+        logger.step('Found', `${commands.length} commands, ${skills.length} skills`);
+        if (options.dryRun) {
+            if (commands.length > 0) {
+                logger.step('Would sync commands to', getDestinationDir(destDir, packageName, 'commands'));
+                commands.forEach((entry) => logger.file('create', entry.name));
+            }
+            if (skills.length > 0) {
+                logger.step('Would sync skills to', getDestinationDir(destDir, packageName, 'skills'));
+                skills.forEach((entry) => logger.file('create', entry.name));
+            }
+            return {
+                packageName,
+                success: true,
+                skipped: false,
+                syncedFiles: {
+                    commands: commands.map((e) => e.name),
+                    skills: skills.map((e) => e.name),
+                },
+            };
+        }
+        const syncedFiles = {
+            commands: [],
+            skills: [],
+        };
+        if (commands.length > 0) {
+            logger.step('Downloading', 'commands');
+            const commandFiles = await downloadAssetFiles(repoInfo, assetPath, 'commands', commands, tag);
+            cleanAssetDir(destDir, packageName, 'commands');
+            for (const [fileName, content] of commandFiles) {
+                writeAssetFile(destDir, packageName, 'commands', fileName, content);
+                logger.file('create', fileName);
+                syncedFiles.commands.push(fileName);
+            }
+            writeSyncMeta(destDir, packageName, 'commands', createSyncMeta(packageInfo.version, syncedFiles.commands));
+        }
+        if (skills.length > 0) {
+            logger.step('Downloading', 'skills');
+            const skillFiles = await downloadAssetFiles(repoInfo, assetPath, 'skills', skills, tag);
+            cleanAssetDir(destDir, packageName, 'skills');
+            for (const [fileName, content] of skillFiles) {
+                writeAssetFile(destDir, packageName, 'skills', fileName, content);
+                logger.file('create', fileName);
+                syncedFiles.skills.push(fileName);
+            }
+            writeSyncMeta(destDir, packageName, 'skills', createSyncMeta(packageInfo.version, syncedFiles.skills));
+        }
+        return {
+            packageName,
+            success: true,
+            skipped: false,
+            syncedFiles,
+        };
+    }
+    catch (error) {
+        if (error instanceof RateLimitError)
+            return {
+                packageName,
+                success: false,
+                skipped: false,
+                reason: error.message,
+            };
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        return {
+            packageName,
+            success: false,
+            skipped: false,
+            reason: message,
+        };
+    }
+};
+const syncPackages = async (packages, options, cwd = process.cwd()) => {
+    const results = [];
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot)
+        logger.info(`[Output] ${gitRoot}/.claude\n`);
+    for (const packageName of packages) {
+        const result = await syncPackage(packageName, options, cwd, gitRoot ?? undefined);
+        logger.packageEnd(packageName, result);
+        results.push(result);
+    }
+    const summary = {
+        success: results.filter((r) => r.success && !r.skipped).length,
+        skipped: results.filter((r) => r.skipped).length,
+        failed: results.filter((r) => !r.success && !r.skipped).length,
+    };
+    logger.summary(summary);
+    return results;
+};
+
+export { syncPackage, syncPackages };

package/dist/index.cjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+'use strict';
+
+var index = require('./cli/index.cjs');
+var sync = require('./core/sync.cjs');
+
+index.run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+});
+
+exports.createProgram = index.createProgram;
+exports.run = index.run;
+exports.syncPackage = sync.syncPackage;
+exports.syncPackages = sync.syncPackages;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { syncPackage, syncPackages } from './core/sync';
+export { createProgram, run } from './cli';
+export type { AssetType, CliOptions, ClaudeConfig, GitHubRepoInfo, PackageInfo, SyncMeta, SyncResult, } from './utils/types';

package/dist/index.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { run } from './cli/index.mjs';
+export { createProgram } from './cli/index.mjs';
+export { syncPackage, syncPackages } from './core/sync.mjs';
+
+run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+});
+
+export { run };

package/dist/utils/logger.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var pc = require('picocolors');
+
+const logger = {
+    info(message) {
+        console.log(pc.blue('info'), message);
+    },
+    success(message) {
+        console.log(pc.green('success'), message);
+    },
+    warn(message) {
+        console.log(pc.yellow('warn'), message);
+    },
+    error(message) {
+        console.log(pc.red('error'), message);
+    },
+    debug(message) {
+        if (process.env.VERBOSE) {
+            console.log(pc.gray('debug'), message);
+        }
+    },
+    step(step, detail) {
+        const stepText = pc.cyan(`[${step}]`);
+        console.log(stepText, detail || '');
+    },
+    file(operation, path) {
+        const colors = {
+            create: pc.green,
+            update: pc.yellow,
+            skip: pc.gray,
+        };
+        const symbols = {
+            create: '+',
+            update: '~',
+            skip: '-',
+        };
+        console.log(`  ${colors[operation](symbols[operation])} ${path}`);
+    },
+    packageStart(packageName) {
+        console.log();
+        console.log(pc.bold(pc.cyan(`Syncing ${packageName}...`)));
+    },
+    packageEnd(_packageName, result) {
+        if (result.skipped)
+            console.log(pc.gray(`  Skipped: ${result.reason || 'Unknown reason'}`));
+        else if (result.success)
+            console.log(pc.green(`  Completed successfully`));
+        else
+            console.log(pc.red(`  Failed: ${result.reason || 'Unknown error'}`));
+    },
+    summary(results) {
+        console.log();
+        console.log(pc.bold('Summary:'));
+        console.log(`  ${pc.green('Success:')} ${results.success}`);
+        console.log(`  ${pc.gray('Skipped:')} ${results.skipped}`);
+        if (results.failed > 0)
+            console.log(`  ${pc.red('Failed:')} ${results.failed}`);
+    },
+    dryRunNotice() {
+        console.log();
+        console.log(pc.yellow(pc.bold('[DRY RUN] No files will be created or modified.')));
+        console.log();
+    },
+};
+
+exports.logger = logger;