@slats/claude-assets-sync 0.1.4 → 0.3.0

package/dist/core/syncMeta.d.ts

@@ -1,75 +0,0 @@
-import type { PackageSyncInfo, SkillUnit, UnifiedSyncMeta } from '../utils/types.js';
-/**
- * Schema version for the unified metadata format
- */
-export declare const SCHEMA_VERSION: "0.1.4";
-/**
- * Read unified sync metadata from .claude/.sync-meta.json
- *
- * @param cwd - Project root directory
- * @returns Unified metadata object or null if file doesn't exist
- */
-export declare function readUnifiedSyncMeta(cwd: string): UnifiedSyncMeta | null;
-/**
- * Write unified sync metadata to .claude/.sync-meta.json
- *
- * @param cwd - Project root directory
- * @param meta - Unified metadata to write
- */
-export declare function writeUnifiedSyncMeta(cwd: string, meta: UnifiedSyncMeta): void;
-/**
- * Update or add package information in unified metadata
- *
- * @param meta - Current unified metadata
- * @param prefix - Package prefix (e.g., 'canard-schema-form')
- * @param info - Package sync information to store
- * @returns Updated metadata object
- */
-export declare function updatePackageInMeta(meta: UnifiedSyncMeta, prefix: string, info: PackageSyncInfo): UnifiedSyncMeta;
-/**
- * Remove package from unified metadata
- *
- * @param meta - Current unified metadata
- * @param prefix - Package prefix to remove
- * @returns Updated metadata object
- */
-export declare function removePackageFromMeta(meta: UnifiedSyncMeta, prefix: string): UnifiedSyncMeta;
-/**
- * Check if package needs sync based on version comparison
- *
- * @param meta - Current unified metadata (null if no metadata exists)
- * @param prefix - Package prefix to check
- * @param version - Current package version
- * @returns true if sync is needed (no metadata, no package entry, or version mismatch)
- */
-export declare function needsSyncUnified(meta: UnifiedSyncMeta | null, prefix: string, version: string): boolean;
-/**
- * Create empty unified metadata structure
- *
- * @returns New empty unified metadata object
- */
-export declare function createEmptyUnifiedMeta(): UnifiedSyncMeta;
-/**
- * Add a skill unit to a package's asset type in unified metadata
- */
-export declare function addSkillUnitToPackage(meta: UnifiedSyncMeta, prefix: string, assetType: string, unit: SkillUnit): UnifiedSyncMeta;
-/**
- * Remove a skill unit from a package's asset type in unified metadata
- */
-export declare function removeSkillUnitFromPackage(meta: UnifiedSyncMeta, prefix: string, assetType: string, skillName: string): UnifiedSyncMeta;
-/**
- * Update package version in unified metadata
- */
-export declare function updatePackageVersion(meta: UnifiedSyncMeta, prefix: string, newVersion: string): UnifiedSyncMeta;
-/**
- * Update filesystem metadata for a package's asset type
- */
-export declare function updatePackageFilesystemMeta(meta: UnifiedSyncMeta, prefix: string, assetType: string, updatedUnits: SkillUnit[]): UnifiedSyncMeta;
-/**
- * Check if unified metadata needs migration to SkillUnit format
- */
-export declare function needsSkillUnitMigration(meta: UnifiedSyncMeta): boolean;
-/**
- * Migrate unified metadata from old format to SkillUnit format (in-memory only)
- */
-export declare function migrateToSkillUnitSchema(meta: UnifiedSyncMeta): UnifiedSyncMeta;

package/dist/core/syncMeta.mjs

@@ -1,229 +0,0 @@
-import { join } from 'node:path';
-import { needsVersionSync } from '../utils/version.mjs';
-import { META_FILES, SCHEMA_VERSIONS } from './constants.mjs';
-import { readJsonFile, writeJsonFile } from './io.mjs';
-
-const UNIFIED_META_PATH = META_FILES.UNIFIED_SYNC_META;
-const SCHEMA_VERSION = SCHEMA_VERSIONS.UNIFIED_SYNC_META;
-function readUnifiedSyncMeta(cwd) {
-    const metaPath = join(cwd, UNIFIED_META_PATH);
-    const meta = readJsonFile(metaPath);
-    if (meta && needsSkillUnitMigration(meta)) {
-        return migrateToSkillUnitSchema(meta);
-    }
-    return meta;
-}
-function writeUnifiedSyncMeta(cwd, meta) {
-    const metaPath = join(cwd, UNIFIED_META_PATH);
-    try {
-        writeJsonFile(metaPath, meta);
-    }
-    catch (error) {
-        console.error(`Failed to write unified sync meta to ${metaPath}:`, error);
-        throw error;
-    }
-}
-function updatePackageInMeta(meta, prefix, info) {
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: info,
-        },
-    };
-}
-function removePackageFromMeta(meta, prefix) {
-    const { [prefix]: removed, ...remainingPackages } = meta.packages;
-    return {
-        ...meta,
-        packages: remainingPackages,
-    };
-}
-function needsSyncUnified(meta, prefix, version) {
-    if (!meta) {
-        return true;
-    }
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        return true;
-    }
-    return needsVersionSync(version, pkgInfo.version);
-}
-function createEmptyUnifiedMeta() {
-    return {
-        schemaVersion: SCHEMA_VERSION,
-        syncedAt: new Date().toISOString(),
-        packages: {},
-    };
-}
-function removeSkillUnitFromPackage(meta, prefix, assetType, skillName) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    const existingUnits = (pkgInfo.files[assetType] || []);
-    const updatedUnits = existingUnits.filter((u) => u.name !== skillName);
-    if (existingUnits.length === updatedUnits.length) {
-        return meta;
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                files: {
-                    ...pkgInfo.files,
-                    [assetType]: updatedUnits,
-                },
-            },
-        },
-    };
-}
-function updatePackageVersion(meta, prefix, newVersion) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                version: newVersion,
-            },
-        },
-    };
-}
-function updatePackageFilesystemMeta(meta, prefix, assetType, updatedUnits) {
-    const pkgInfo = meta.packages[prefix];
-    if (!pkgInfo) {
-        throw new Error(`Package ${prefix} not found in metadata`);
-    }
-    return {
-        ...meta,
-        syncedAt: new Date().toISOString(),
-        skillUnitFormat: SCHEMA_VERSIONS.SKILL_UNIT_FORMAT,
-        packages: {
-            ...meta.packages,
-            [prefix]: {
-                ...pkgInfo,
-                files: {
-                    ...pkgInfo.files,
-                    [assetType]: updatedUnits,
-                },
-            },
-        },
-    };
-}
-function needsSkillUnitMigration(meta) {
-    if (meta.skillUnitFormat === SCHEMA_VERSIONS.SKILL_UNIT_FORMAT) {
-        return false;
-    }
-    for (const pkgInfo of Object.values(meta.packages)) {
-        for (const rawFiles of Object.values(pkgInfo.files)) {
-            const files = rawFiles;
-            if (!Array.isArray(files) || files.length === 0) {
-                continue;
-            }
-            const first = files[0];
-            if (typeof first === 'string') {
-                return true;
-            }
-            if (typeof first === 'object' &&
-                first !== null &&
-                'original' in first &&
-                'transformed' in first &&
-                !('isDirectory' in first)) {
-                return true;
-            }
-            if (typeof first === 'object' &&
-                first !== null &&
-                'isDirectory' in first) {
-                return false;
-            }
-        }
-    }
-    return false;
-}
-function migrateToSkillUnitSchema(meta) {
-    const migratedPackages = {};
-    for (const [prefix, pkgInfo] of Object.entries(meta.packages)) {
-        const migratedFiles = {};
-        for (const [assetType, rawFiles] of Object.entries(pkgInfo.files)) {
-            const files = rawFiles;
-            if (!Array.isArray(files) || files.length === 0) {
-                migratedFiles[assetType] = [];
-                continue;
-            }
-            const first = files[0];
-            if (typeof first === 'string') {
-                migratedFiles[assetType] = files.map((name) => ({
-                    name,
-                    isDirectory: false,
-                }));
-            }
-            else if (typeof first === 'object' &&
-                first !== null &&
-                'original' in first &&
-                !('isDirectory' in first)) {
-                const fileMappings = files;
-                const groupedByDir = new Map();
-                const singleFiles = [];
-                for (const mapping of fileMappings) {
-                    const slashIndex = mapping.original.indexOf('/');
-                    if (slashIndex === -1) {
-                        singleFiles.push({
-                            name: mapping.original,
-                            isDirectory: false,
-                            transformed: mapping.transformed,
-                        });
-                    }
-                    else {
-                        const dirName = mapping.original.substring(0, slashIndex);
-                        const internalFile = mapping.original.substring(slashIndex + 1);
-                        const transformedSlashIndex = mapping.transformed.indexOf('/');
-                        const transformedDir = transformedSlashIndex !== -1
-                            ? mapping.transformed.substring(0, transformedSlashIndex)
-                            : mapping.transformed;
-                        if (!groupedByDir.has(dirName)) {
-                            groupedByDir.set(dirName, {
-                                transformed: transformedDir,
-                                internalFiles: [],
-                            });
-                        }
-                        groupedByDir.get(dirName).internalFiles.push(internalFile);
-                    }
-                }
-                const dirSkillUnits = [];
-                for (const [dirName, data] of groupedByDir.entries()) {
-                    dirSkillUnits.push({
-                        name: dirName,
-                        isDirectory: true,
-                        transformed: data.transformed,
-                        internalFiles: data.internalFiles,
-                    });
-                }
-                migratedFiles[assetType] = [...singleFiles, ...dirSkillUnits];
-            }
-            else {
-                migratedFiles[assetType] = files;
-            }
-        }
-        migratedPackages[prefix] = {
-            ...pkgInfo,
-            files: migratedFiles,
-        };
-    }
-    return {
-        ...meta,
-        skillUnitFormat: SCHEMA_VERSIONS.SKILL_UNIT_FORMAT,
-        packages: migratedPackages,
-    };
-}
-
-export { SCHEMA_VERSION, createEmptyUnifiedMeta, migrateToSkillUnitSchema, needsSkillUnitMigration, needsSyncUnified, readUnifiedSyncMeta, removePackageFromMeta, removeSkillUnitFromPackage, updatePackageFilesystemMeta, updatePackageInMeta, updatePackageVersion, writeUnifiedSyncMeta };

package/dist/utils/dependencies.cjs

@@ -1,57 +0,0 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-
-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 readProjectDependencies(cwd) {
-    const pkgPath = path__namespace.join(cwd, 'package.json');
-    if (!fs__namespace.existsSync(pkgPath)) {
-        throw new Error(`package.json not found at: ${pkgPath}`);
-    }
-    let pkg;
-    try {
-        pkg = JSON.parse(fs__namespace.readFileSync(pkgPath, 'utf-8'));
-    }
-    catch (error) {
-        throw new Error(`Failed to parse package.json at ${pkgPath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return {
-        ...pkg.dependencies,
-        ...pkg.devDependencies,
-        ...pkg.peerDependencies,
-        ...pkg.optionalDependencies,
-    };
-}
-function filterByPattern(deps, pattern) {
-    let regex;
-    try {
-        regex = new RegExp(pattern);
-    }
-    catch (error) {
-        throw new Error(`Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return Object.keys(deps).filter(name => regex.test(name));
-}
-
-exports.filterByPattern = filterByPattern;
-exports.readProjectDependencies = readProjectDependencies;

package/dist/utils/dependencies.d.ts

@@ -1,10 +0,0 @@
-/**
- * Reads all dependencies from the project's package.json
- * (dependencies, devDependencies, peerDependencies, optionalDependencies)
- */
-export declare function readProjectDependencies(cwd: string): Record<string, string>;
-/**
- * Filters dependency names by regex pattern.
- * Wraps RegExp construction in try/catch for invalid patterns.
- */
-export declare function filterByPattern(deps: Record<string, string>, pattern: string): string[];

package/dist/utils/dependencies.mjs

@@ -1,34 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-function readProjectDependencies(cwd) {
-    const pkgPath = path.join(cwd, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-        throw new Error(`package.json not found at: ${pkgPath}`);
-    }
-    let pkg;
-    try {
-        pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    }
-    catch (error) {
-        throw new Error(`Failed to parse package.json at ${pkgPath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return {
-        ...pkg.dependencies,
-        ...pkg.devDependencies,
-        ...pkg.peerDependencies,
-        ...pkg.optionalDependencies,
-    };
-}
-function filterByPattern(deps, pattern) {
-    let regex;
-    try {
-        regex = new RegExp(pattern);
-    }
-    catch (error) {
-        throw new Error(`Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return Object.keys(deps).filter(name => regex.test(name));
-}
-
-export { filterByPattern, readProjectDependencies };

package/dist/utils/nameTransform.cjs

@@ -1,13 +0,0 @@
-'use strict';
-
-function toFlatFileName(prefix, fileName) {
-    const slashIndex = fileName.indexOf('/');
-    if (slashIndex === -1) {
-        return `${prefix}_${fileName}`;
-    }
-    const dirName = fileName.substring(0, slashIndex);
-    const rest = fileName.substring(slashIndex);
-    return `${prefix}_${dirName}${rest}`;
-}
-
-exports.toFlatFileName = toFlatFileName;

package/dist/utils/nameTransform.d.ts

@@ -1,65 +0,0 @@
-/**
- * Converts kebab-case string to camelCase
- * All hyphens are removed and the following character is capitalized
- *
- * @param str - Input string in kebab-case format
- * @returns String in camelCase format
- *
- * @example
- * ```ts
- * kebabToCamel('schema-form') // 'schemaForm'
- * kebabToCamel('schema-form-plugin') // 'schemaFormPlugin'
- * kebabToCamel('my-long-name') // 'myLongName'
- * ```
- */
-export declare function kebabToCamel(str: string): string;
-/**
- * Creates a flat file name by combining prefix and original file name.
- * For single files (no path separator), creates prefix_filename.
- * For directory-based entries (with path separator), applies prefix only
- * to the top-level directory name, preserving internal path structure.
- *
- * @param prefix - Package prefix (e.g., 'canard-schemaForm')
- * @param fileName - Original file name (e.g., 'guide.md' or 'expert/SKILL.md')
- * @returns Flat file name with prefix
- *
- * @example
- * ```ts
- * toFlatFileName('canard-schemaForm', 'guide.md')
- * // 'canard-schemaForm_guide.md'
- *
- * toFlatFileName('canard-schemaForm', 'expert/SKILL.md')
- * // 'canard-schemaForm_expert/SKILL.md'
- *
- * toFlatFileName('canard-schemaForm', 'expert/knowledge/api.md')
- * // 'canard-schemaForm_expert/knowledge/api.md'
- * ```
- */
-export declare function toFlatFileName(prefix: string, fileName: string): string;
-/**
- * Parses a flat file name back into prefix and original file name.
- * Reverses the transformation done by toFlatFileName.
- * Returns null if the file name doesn't match the expected pattern.
- *
- * @param flatName - Flat file name (e.g., 'canard-schemaForm_guide.md' or 'canard-schemaForm_expert/SKILL.md')
- * @returns Object with prefix and original name, or null if invalid
- *
- * @example
- * ```ts
- * parseFlatFileName('canard-schemaForm_guide.md')
- * // { prefix: 'canard-schemaForm', original: 'guide.md' }
- *
- * parseFlatFileName('canard-schemaForm_expert/SKILL.md')
- * // { prefix: 'canard-schemaForm', original: 'expert/SKILL.md' }
- *
- * parseFlatFileName('canard-schemaForm_expert/knowledge/api.md')
- * // { prefix: 'canard-schemaForm', original: 'expert/knowledge/api.md' }
- *
- * parseFlatFileName('invalid-name.md')
- * // null (no underscore separator)
- * ```
- */
-export declare function parseFlatFileName(flatName: string): {
-    prefix: string;
-    original: string;
-} | null;

package/dist/utils/nameTransform.mjs

@@ -1,11 +0,0 @@
-function toFlatFileName(prefix, fileName) {
-    const slashIndex = fileName.indexOf('/');
-    if (slashIndex === -1) {
-        return `${prefix}_${fileName}`;
-    }
-    const dirName = fileName.substring(0, slashIndex);
-    const rest = fileName.substring(slashIndex);
-    return `${prefix}_${dirName}${rest}`;
-}
-
-export { toFlatFileName };

package/dist/utils/package.cjs

@@ -1,170 +0,0 @@
-'use strict';
-
-var node_child_process = require('node:child_process');
-var fs = require('node:fs');
-var path = require('node:path');
-var constants = require('../core/constants.cjs');
-
-const resolvePackagePath = (packageName, cwd) => {
-    let dir = cwd;
-    while (true) {
-        const candidate = path.join(dir, 'node_modules', packageName);
-        if (fs.existsSync(path.join(candidate, 'package.json'))) {
-            return candidate;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-};
-const readPackageJson = (packageName, cwd = process.cwd()) => {
-    try {
-        const packagePath = resolvePackagePath(packageName, cwd);
-        if (!packagePath)
-            return null;
-        const content = fs.readFileSync(path.join(packagePath, 'package.json'), 'utf-8');
-        const json = JSON.parse(content);
-        if (!json.name || !json.version || !json.repository)
-            return null;
-        return {
-            name: json.name,
-            version: json.version,
-            repository: json.repository,
-            claude: json.claude,
-        };
-    }
-    catch {
-        return null;
-    }
-};
-const parseGitHubRepo = (repository) => {
-    if (!repository || typeof repository.url !== 'string')
-        return null;
-    const url = repository.url;
-    const httpsMatch = url.match(constants.FS_PATTERNS.GITHUB_HTTPS_URL);
-    if (httpsMatch)
-        return {
-            owner: httpsMatch[1],
-            repo: httpsMatch[2],
-            directory: repository.directory,
-        };
-    const sshMatch = url.match(constants.FS_PATTERNS.GITHUB_SSH_URL);
-    if (sshMatch)
-        return {
-            owner: sshMatch[1],
-            repo: sshMatch[2],
-            directory: repository.directory,
-        };
-    const shorthandMatch = url.match(constants.FS_PATTERNS.GITHUB_SHORTHAND);
-    if (shorthandMatch)
-        return {
-            owner: shorthandMatch[1],
-            repo: shorthandMatch[2],
-            directory: repository.directory,
-        };
-    return null;
-};
-const buildVersionTag = (packageName, version) => `${packageName}@${version}`;
-const buildAssetPath = (assetPath, directory) => (assetPath);
-const findGitRoot = (cwd = process.cwd()) => {
-    try {
-        const gitRoot = node_child_process.execSync('git rev-parse --show-toplevel', {
-            cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        return gitRoot;
-    }
-    catch {
-        return null;
-    }
-};
-const findWorkspaceRoot = (startDir = process.cwd()) => {
-    let currentDir = startDir;
-    while (currentDir !== '/') {
-        const packageJsonPath = path.join(currentDir, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const content = fs.readFileSync(packageJsonPath, 'utf-8');
-                const json = JSON.parse(content);
-                if (json.workspaces)
-                    return currentDir;
-            }
-            catch {
-            }
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    return null;
-};
-const getWorkspaceList = (workspaceRoot) => {
-    try {
-        const output = node_child_process.execSync('yarn workspaces list --json', {
-            cwd: workspaceRoot,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return output
-            .trim()
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
-    }
-    catch {
-        return [];
-    }
-};
-const findWorkspaceLocation = (packageName, workspaceRoot) => {
-    const workspaces = getWorkspaceList(workspaceRoot);
-    const workspace = workspaces.find((ws) => ws.name === packageName);
-    return workspace ? path.join(workspaceRoot, workspace.location) : null;
-};
-const readLocalPackageJson = (packageName, cwd = process.cwd()) => {
-    try {
-        const workspaceRoot = findWorkspaceRoot(cwd);
-        if (!workspaceRoot)
-            return null;
-        const packageLocation = findWorkspaceLocation(packageName, workspaceRoot);
-        if (!packageLocation)
-            return null;
-        const packageJsonPath = path.join(packageLocation, 'package.json');
-        const content = fs.readFileSync(packageJsonPath, 'utf-8');
-        const json = JSON.parse(content);
-        if (!json.name || !json.version || !json.repository)
-            return null;
-        return {
-            name: json.name,
-            version: json.version,
-            repository: json.repository,
-            claude: json.claude,
-        };
-    }
-    catch {
-        return null;
-    }
-};
-function getAssetTypes(config) {
-    if (!config.assets) {
-        return Array.from(constants.DEFAULT_ASSET_TYPES);
-    }
-    return Object.keys(config.assets);
-}
-const resolveClaudeConfig = (claude) => ({
-    assetPath: claude?.assetPath ?? constants.DEFAULT_ASSET_PATH,
-    ...(claude?.assets ? { assets: claude.assets } : {}),
-});
-
-exports.buildAssetPath = buildAssetPath;
-exports.buildVersionTag = buildVersionTag;
-exports.findGitRoot = findGitRoot;
-exports.findWorkspaceLocation = findWorkspaceLocation;
-exports.findWorkspaceRoot = findWorkspaceRoot;
-exports.getAssetTypes = getAssetTypes;
-exports.getWorkspaceList = getWorkspaceList;
-exports.parseGitHubRepo = parseGitHubRepo;
-exports.readLocalPackageJson = readLocalPackageJson;
-exports.readPackageJson = readPackageJson;
-exports.resolveClaudeConfig = resolveClaudeConfig;
-exports.resolvePackagePath = resolvePackagePath;