@slats/claude-assets-sync 0.1.4 → 0.2.0

package/dist/core/github.mjs

@@ -1,107 +0,0 @@
-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')) ||
-        entry.type === 'dir');
-};
-const expandDirectoryEntries = async (repoInfo, parentPath, entries, tag, prefix = '') => {
-    const result = [];
-    for (const entry of entries) {
-        const entryPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.type === 'file') {
-            result.push({
-                ...entry,
-                name: prefix ? entryPrefix : entry.name,
-            });
-        }
-        else if (entry.type === 'dir') {
-            const subEntries = await fetchDirectoryContents(repoInfo, `${parentPath}/${entry.name}`, tag);
-            if (subEntries) {
-                const expanded = await expandDirectoryEntries(repoInfo, `${parentPath}/${entry.name}`, subEntries, tag, entryPrefix);
-                result.push(...expanded);
-            }
-        }
-    }
-    return result;
-};
-const fetchAssetFiles = async (repoInfo, assetPath, tag, assetTypes) => {
-    const basePath = repoInfo.directory
-        ? `${repoInfo.directory}/${assetPath}`
-        : assetPath;
-    const fetchPromises = assetTypes.map((assetType) => fetchDirectoryContents(repoInfo, `${basePath}/${assetType}`, tag));
-    const rawResults = await Promise.all(fetchPromises);
-    const expandedResults = await Promise.all(rawResults.map((entries, index) => {
-        if (!entries)
-            return Promise.resolve([]);
-        const assetDirPath = `${basePath}/${assetTypes[index]}`;
-        return expandDirectoryEntries(repoInfo, assetDirPath, entries, tag);
-    }));
-    const assetFiles = {};
-    assetTypes.forEach((assetType, index) => {
-        assetFiles[assetType] = expandedResults[index] || [];
-    });
-    return assetFiles;
-};
-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, expandDirectoryEntries, fetchAssetFiles, fetchDirectoryContents };

package/dist/core/io.cjs

@@ -1,46 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-
-function readJsonFile(path) {
-    if (!fs.existsSync(path)) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(path, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-function writeJsonFile(path$1, data) {
-    ensureDirectory(path.dirname(path$1));
-    fs.writeFileSync(path$1, JSON.stringify(data, null, 2), 'utf-8');
-}
-function ensureDirectory(path) {
-    if (!fs.existsSync(path)) {
-        fs.mkdirSync(path, { recursive: true });
-    }
-}
-function fileExists(path) {
-    return fs.existsSync(path);
-}
-function listDirectory(path) {
-    if (!fs.existsSync(path)) {
-        return [];
-    }
-    return fs.readdirSync(path);
-}
-function writeTextFile(path$1, content) {
-    ensureDirectory(path.dirname(path$1));
-    fs.writeFileSync(path$1, content, 'utf-8');
-}
-
-exports.ensureDirectory = ensureDirectory;
-exports.fileExists = fileExists;
-exports.listDirectory = listDirectory;
-exports.readJsonFile = readJsonFile;
-exports.writeJsonFile = writeJsonFile;
-exports.writeTextFile = writeTextFile;

package/dist/core/io.d.ts

@@ -1,40 +0,0 @@
-/**
- * Read and parse JSON file
- * @param path - File path
- * @returns Parsed JSON or null if file doesn't exist or parsing fails
- */
-export declare function readJsonFile<T>(path: string): T | null;
-/**
- * Write JSON file with pretty formatting
- * @param path - File path
- * @param data - Data to serialize
- */
-export declare function writeJsonFile<T>(path: string, data: T): void;
-/**
- * Ensure directory exists (creates recursively if needed)
- * @param path - Directory path
- */
-export declare function ensureDirectory(path: string): void;
-/**
- * Check if file or directory exists
- * @param path - File or directory path
- * @returns true if exists
- */
-export declare function fileExists(path: string): boolean;
-/**
- * Remove directory recursively
- * @param path - Directory path
- */
-export declare function removeDirectory(path: string): void;
-/**
- * List files in directory
- * @param path - Directory path
- * @returns Array of file names
- */
-export declare function listDirectory(path: string): string[];
-/**
- * Write text file with directory creation
- * @param path - File path
- * @param content - File content
- */
-export declare function writeTextFile(path: string, content: string): void;

package/dist/core/io.mjs

@@ -1,39 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-function readJsonFile(path) {
-    if (!existsSync(path)) {
-        return null;
-    }
-    try {
-        const content = readFileSync(path, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-function writeJsonFile(path, data) {
-    ensureDirectory(dirname(path));
-    writeFileSync(path, JSON.stringify(data, null, 2), 'utf-8');
-}
-function ensureDirectory(path) {
-    if (!existsSync(path)) {
-        mkdirSync(path, { recursive: true });
-    }
-}
-function fileExists(path) {
-    return existsSync(path);
-}
-function listDirectory(path) {
-    if (!existsSync(path)) {
-        return [];
-    }
-    return readdirSync(path);
-}
-function writeTextFile(path, content) {
-    ensureDirectory(dirname(path));
-    writeFileSync(path, content, 'utf-8');
-}
-
-export { ensureDirectory, fileExists, listDirectory, readJsonFile, writeJsonFile, writeTextFile };

package/dist/core/listOperations.cjs

@@ -1,228 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var sync = require('./sync.cjs');
-var syncMeta = require('./syncMeta.cjs');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-
-function computeFileOperations(meta, packageFiles, selectedTrees, cwd) {
-    const newPackageFiles = { ...packageFiles };
-    for (const packageTree of selectedTrees) {
-        const prefix = packageTree.id;
-        if (!newPackageFiles[prefix])
-            continue;
-        const selectedPaths = new Set();
-        if (packageTree.children) {
-            for (const assetTypeNode of packageTree.children) {
-                if (assetTypeNode.children) {
-                    for (const fileNode of assetTypeNode.children) {
-                        if (fileNode.disabled)
-                            continue;
-                        if (fileNode.selected) {
-                            selectedPaths.add(fileNode.path);
-                        }
-                    }
-                }
-            }
-        }
-        newPackageFiles[prefix] = {
-            ...newPackageFiles[prefix],
-            selected: selectedPaths,
-        };
-    }
-    const fileOperations = [];
-    const filesToDelete = [];
-    const packagesToSync = [];
-    for (const [prefix] of Object.entries(meta.packages)) {
-        const packageTree = selectedTrees.find((t) => t.id === prefix);
-        const packageInfo = meta.packages[prefix];
-        const packageData = newPackageFiles[prefix];
-        if (!packageTree || !packageTree.selected || !packageData) {
-            for (const [assetType, files] of Object.entries(packageInfo.files)) {
-                if (!Array.isArray(files))
-                    continue;
-                const units = files;
-                for (const unit of units) {
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                }
-                const firstUnit = units[0];
-                if (firstUnit?.transformed) {
-                    for (const unit of units) {
-                        const targetPath = path__namespace.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                }
-                else {
-                    const dirPath = path__namespace.join(cwd, '.claude', assetType, packageInfo.originalName);
-                    filesToDelete.push(dirPath);
-                }
-            }
-            continue;
-        }
-        let hasChanges = false;
-        const selectedByAssetType = {};
-        for (const filePath of packageData.selected) {
-            const [assetType, fileName] = filePath.split('/');
-            if (!selectedByAssetType[assetType]) {
-                selectedByAssetType[assetType] = new Set();
-            }
-            selectedByAssetType[assetType].add(fileName);
-        }
-        for (const [assetType, originalFiles] of Object.entries(packageInfo.files)) {
-            const selectedFiles = selectedByAssetType[assetType];
-            const units = Array.isArray(originalFiles)
-                ? originalFiles
-                : [];
-            const firstUnit = units[0];
-            const isFlat = !!firstUnit?.transformed;
-            if (!selectedFiles || selectedFiles.size === 0) {
-                hasChanges = true;
-                for (const unit of units) {
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                }
-                if (isFlat) {
-                    for (const unit of units) {
-                        const targetPath = path__namespace.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                }
-                else {
-                    const dirPath = path__namespace.join(cwd, '.claude', assetType, packageInfo.originalName);
-                    filesToDelete.push(dirPath);
-                }
-                continue;
-            }
-            const originalNames = new Set(units.map((u) => u.name));
-            for (const unit of units) {
-                if (!selectedFiles.has(unit.name)) {
-                    hasChanges = true;
-                    fileOperations.push({
-                        type: 'remove',
-                        prefix,
-                        assetType,
-                        skillName: unit.name,
-                    });
-                    if (unit.transformed) {
-                        const targetPath = path__namespace.join(cwd, '.claude', assetType, unit.transformed);
-                        filesToDelete.push(targetPath);
-                    }
-                    else {
-                        const filePath = path__namespace.join(cwd, '.claude', assetType, packageInfo.originalName, unit.name);
-                        filesToDelete.push(filePath);
-                    }
-                }
-            }
-            for (const skillName of selectedFiles) {
-                if (!originalNames.has(skillName)) {
-                    hasChanges = true;
-                    fileOperations.push({
-                        type: 'add',
-                        prefix,
-                        assetType,
-                        skillName,
-                    });
-                }
-            }
-        }
-        if (hasChanges) {
-            packagesToSync.push({
-                prefix,
-                name: packageInfo.originalName,
-                local: packageInfo.local,
-            });
-        }
-    }
-    return { filesToDelete, fileOperations, packagesToSync };
-}
-async function applyChangesAndSync(changesSummary, meta, cwd, callbacks) {
-    const syncErrors = [];
-    for (const filePath of changesSummary.filesToDelete) {
-        try {
-            const stat = fs__namespace.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs__namespace.rmSync(filePath, { recursive: true, force: true });
-            }
-            else {
-                fs__namespace.unlinkSync(filePath);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                console.error(`Failed to remove ${filePath}: ${error}`);
-            }
-        }
-    }
-    let updatedMeta = { ...meta };
-    const hasAddOperations = changesSummary.fileOperations.some((op) => op.type === 'add');
-    for (const op of changesSummary.fileOperations) {
-        if (op.type === 'remove') {
-            updatedMeta = syncMeta.removeSkillUnitFromPackage(updatedMeta, op.prefix, op.assetType, op.skillName);
-        }
-    }
-    for (const prefix of Object.keys(updatedMeta.packages)) {
-        const pkg = updatedMeta.packages[prefix];
-        if (!pkg.files || Object.keys(pkg.files).length === 0) {
-            updatedMeta = syncMeta.removePackageFromMeta(updatedMeta, prefix);
-        }
-    }
-    syncMeta.writeUnifiedSyncMeta(cwd, updatedMeta);
-    if (hasAddOperations && changesSummary.packagesToSync.length > 0) {
-        callbacks?.onSyncStart?.();
-        for (const { prefix, name, local } of changesSummary.packagesToSync) {
-            try {
-                const removedFiles = changesSummary.fileOperations
-                    .filter((op) => op.type === 'remove' && op.prefix === prefix)
-                    .map((op) => `${op.assetType}/${op.skillName}`);
-                const exclusions = removedFiles.length > 0
-                    ? { directories: [], files: removedFiles }
-                    : undefined;
-                await sync.syncPackage(name, {
-                    force: true,
-                    dryRun: false,
-                    local: local ?? false,
-                    ref: undefined,
-                    flat: undefined,
-                }, cwd, exclusions);
-            }
-            catch (error) {
-                const msg = `Failed to sync ${name}: ${error}`;
-                console.error(msg);
-                syncErrors.push(msg);
-            }
-        }
-    }
-    return { updatedMeta, syncErrors };
-}
-
-exports.applyChangesAndSync = applyChangesAndSync;
-exports.computeFileOperations = computeFileOperations;

package/dist/core/listOperations.d.ts

@@ -1,43 +0,0 @@
-import type { TreeNode, UnifiedSyncMeta } from '../utils/types.js';
-export type FileOperation = {
-    type: 'add';
-    prefix: string;
-    assetType: string;
-    skillName: string;
-} | {
-    type: 'remove';
-    prefix: string;
-    assetType: string;
-    skillName: string;
-};
-export interface ChangesSummary {
-    filesToDelete: string[];
-    fileOperations: FileOperation[];
-    packagesToSync: Array<{
-        prefix: string;
-        name: string;
-        local?: boolean;
-    }>;
-}
-export interface PackageFiles {
-    [prefix: string]: {
-        available: TreeNode[];
-        selected: Set<string>;
-    };
-}
-/**
- * Pure computation: given current meta, packageFiles, and selected trees,
- * compute what file operations need to happen.
- * No React state, no side effects.
- */
-export declare function computeFileOperations(meta: UnifiedSyncMeta, packageFiles: PackageFiles, selectedTrees: TreeNode[], cwd: string): ChangesSummary;
-/**
- * Apply file changes and sync packages.
- * Has side effects (filesystem writes, sync calls) but NO React/ink dependencies.
- */
-export declare function applyChangesAndSync(changesSummary: ChangesSummary, meta: UnifiedSyncMeta, cwd: string, callbacks?: {
-    onSyncStart?: () => void;
-}): Promise<{
-    updatedMeta: UnifiedSyncMeta;
-    syncErrors: string[];
-}>;