@slats/claude-assets-sync 0.0.1

package/dist/utils/logger.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Logger utility with colored output
+ */
+export declare const logger: {
+    /**
+     * Log info message
+     */
+    info(message: string): void;
+    /**
+     * Log success message
+     */
+    success(message: string): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string): void;
+    /**
+     * Log error message
+     */
+    error(message: string): void;
+    /**
+     * Log debug message (only in verbose mode)
+     */
+    debug(message: string): void;
+    /**
+     * Log a step in the sync process
+     */
+    step(step: string, detail?: string): void;
+    /**
+     * Log file operation
+     */
+    file(operation: "create" | "update" | "skip", path: string): void;
+    /**
+     * Log package sync start
+     */
+    packageStart(packageName: string): void;
+    /**
+     * Log package sync result
+     */
+    packageEnd(_packageName: string, result: {
+        success: boolean;
+        skipped: boolean;
+        reason?: string;
+    }): void;
+    /**
+     * Log summary at the end
+     */
+    summary(results: {
+        success: number;
+        skipped: number;
+        failed: number;
+    }): void;
+    /**
+     * Log dry-run notice
+     */
+    dryRunNotice(): void;
+};

package/dist/utils/logger.mjs

@@ -0,0 +1,65 @@
+import pc from '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();
+    },
+};
+
+export { logger };

package/dist/utils/package.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+var node_child_process = require('node:child_process');
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+
+const GITHUB_HTTPS_URL_PATTERN = /https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/;
+const GITHUB_SSH_URL_PATTERN = /git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/;
+const GITHUB_SHORTHAND_PATTERN = /^github:([^/]+)\/([^/]+)$/;
+const readPackageJson = (packageName, cwd = process.cwd()) => {
+    try {
+        const packageJsonPath = node_path.join(cwd, 'node_modules', packageName, 'package.json');
+        const content = node_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;
+    }
+};
+const parseGitHubRepo = (repository) => {
+    if (!repository || typeof repository.url !== 'string')
+        return null;
+    const url = repository.url;
+    const httpsMatch = url.match(GITHUB_HTTPS_URL_PATTERN);
+    if (httpsMatch)
+        return {
+            owner: httpsMatch[1],
+            repo: httpsMatch[2],
+            directory: repository.directory,
+        };
+    const sshMatch = url.match(GITHUB_SSH_URL_PATTERN);
+    if (sshMatch)
+        return {
+            owner: sshMatch[1],
+            repo: sshMatch[2],
+            directory: repository.directory,
+        };
+    const shorthandMatch = url.match(GITHUB_SHORTHAND_PATTERN);
+    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 = node_path.join(currentDir, 'package.json');
+        if (node_fs.existsSync(packageJsonPath)) {
+            try {
+                const content = node_fs.readFileSync(packageJsonPath, 'utf-8');
+                const json = JSON.parse(content);
+                if (json.workspaces)
+                    return currentDir;
+            }
+            catch {
+            }
+        }
+        currentDir = node_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 ? node_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 = node_path.join(packageLocation, 'package.json');
+        const content = node_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;
+    }
+};
+
+exports.buildAssetPath = buildAssetPath;
+exports.buildVersionTag = buildVersionTag;
+exports.findGitRoot = findGitRoot;
+exports.findWorkspaceLocation = findWorkspaceLocation;
+exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.getWorkspaceList = getWorkspaceList;
+exports.parseGitHubRepo = parseGitHubRepo;
+exports.readLocalPackageJson = readLocalPackageJson;
+exports.readPackageJson = readPackageJson;

package/dist/utils/package.d.ts

@@ -0,0 +1,66 @@
+import type { GitHubRepoInfo, PackageInfo, WorkspaceInfo } from './types';
+/**
+ * Read package.json from node_modules
+ * @param packageName - Package name (e.g., "@canard/schema-form")
+ * @param cwd - Current working directory
+ * @returns PackageInfo or null if not found
+ */
+export declare const readPackageJson: (packageName: string, cwd?: string) => PackageInfo | null;
+/**
+ * Parse GitHub repository URL to extract owner and repo
+ * Supports formats:
+ * - https://github.com/owner/repo.git
+ * - https://github.com/owner/repo
+ * - git@github.com:owner/repo.git
+ * - github:owner/repo
+ *
+ * @param repository - Repository info from package.json
+ * @returns GitHubRepoInfo or null if parsing failed
+ */
+export declare const parseGitHubRepo: (repository: PackageInfo["repository"]) => GitHubRepoInfo | null;
+/**
+ * Build version tag for GitHub
+ * @param packageName - Package name (e.g., "@canard/schema-form")
+ * @param version - Package version (e.g., "0.10.0")
+ * @returns Version tag (e.g., "@canard/schema-form@0.10.0")
+ */
+export declare const buildVersionTag: (packageName: string, version: string) => string;
+/**
+ * Build asset path for a package
+ * @param assetPath - Base asset path (e.g., "docs/claude")
+ * @param directory - Repository directory (optional)
+ * @returns Full asset path
+ */
+export declare const buildAssetPath: (assetPath: string, directory?: string) => string;
+/**
+ * Find git repository root directory
+ * @param cwd - Current working directory
+ * @returns Git root path or null if not in a git repository
+ */
+export declare const findGitRoot: (cwd?: string) => string | null;
+/**
+ * Find the workspace root directory by looking for package.json with workspaces
+ * @param startDir - Directory to start searching from
+ * @returns Workspace root path or null if not found
+ */
+export declare const findWorkspaceRoot: (startDir?: string) => string | null;
+/**
+ * Get list of workspaces using yarn workspaces list
+ * @param workspaceRoot - Workspace root directory
+ * @returns Array of WorkspaceInfo
+ */
+export declare const getWorkspaceList: (workspaceRoot: string) => WorkspaceInfo[];
+/**
+ * Find workspace location by package name
+ * @param packageName - Package name to find
+ * @param workspaceRoot - Workspace root directory
+ * @returns Workspace location path or null if not found
+ */
+export declare const findWorkspaceLocation: (packageName: string, workspaceRoot: string) => string | null;
+/**
+ * Read package.json from local workspace
+ * @param packageName - Package name (e.g., "@canard/schema-form")
+ * @param cwd - Current working directory
+ * @returns PackageInfo or null if not found
+ */
+export declare const readLocalPackageJson: (packageName: string, cwd?: string) => PackageInfo | null;

package/dist/utils/package.mjs

@@ -0,0 +1,133 @@
+import { execSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+const GITHUB_HTTPS_URL_PATTERN = /https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/;
+const GITHUB_SSH_URL_PATTERN = /git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/;
+const GITHUB_SHORTHAND_PATTERN = /^github:([^/]+)\/([^/]+)$/;
+const readPackageJson = (packageName, cwd = process.cwd()) => {
+    try {
+        const packageJsonPath = join(cwd, 'node_modules', packageName, 'package.json');
+        const content = 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;
+    }
+};
+const parseGitHubRepo = (repository) => {
+    if (!repository || typeof repository.url !== 'string')
+        return null;
+    const url = repository.url;
+    const httpsMatch = url.match(GITHUB_HTTPS_URL_PATTERN);
+    if (httpsMatch)
+        return {
+            owner: httpsMatch[1],
+            repo: httpsMatch[2],
+            directory: repository.directory,
+        };
+    const sshMatch = url.match(GITHUB_SSH_URL_PATTERN);
+    if (sshMatch)
+        return {
+            owner: sshMatch[1],
+            repo: sshMatch[2],
+            directory: repository.directory,
+        };
+    const shorthandMatch = url.match(GITHUB_SHORTHAND_PATTERN);
+    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 = 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 = join(currentDir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            try {
+                const content = readFileSync(packageJsonPath, 'utf-8');
+                const json = JSON.parse(content);
+                if (json.workspaces)
+                    return currentDir;
+            }
+            catch {
+            }
+        }
+        currentDir = dirname(currentDir);
+    }
+    return null;
+};
+const getWorkspaceList = (workspaceRoot) => {
+    try {
+        const output = 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 ? 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 = join(packageLocation, 'package.json');
+        const content = 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;
+    }
+};
+
+export { buildAssetPath, buildVersionTag, findGitRoot, findWorkspaceLocation, findWorkspaceRoot, getWorkspaceList, parseGitHubRepo, readLocalPackageJson, readPackageJson };

package/dist/utils/types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Claude configuration in package.json
+ */
+export interface ClaudeConfig {
+    /** Path to Claude assets directory (e.g., "docs/claude") */
+    assetPath: string;
+}
+/**
+ * Repository information from package.json
+ */
+export interface RepositoryInfo {
+    type: string;
+    url: string;
+    directory?: string;
+}
+/**
+ * Parsed package information
+ */
+export interface PackageInfo {
+    name: string;
+    version: string;
+    repository: RepositoryInfo;
+    claude?: ClaudeConfig;
+}
+/**
+ * Parsed GitHub repository details
+ */
+export interface GitHubRepoInfo {
+    owner: string;
+    repo: string;
+    directory?: string;
+}
+/**
+ * GitHub API file/directory entry
+ */
+export interface GitHubEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'dir';
+    download_url: string | null;
+    sha: string;
+}
+/**
+ * Sync metadata stored in .sync-meta.json
+ */
+export interface SyncMeta {
+    /** Package version at sync time */
+    version: string;
+    /** ISO timestamp of last sync */
+    syncedAt: string;
+    /** List of synced file names */
+    files: string[];
+}
+/**
+ * Asset type (commands or skills)
+ */
+export type AssetType = 'commands' | 'skills';
+/**
+ * Sync result for a single package
+ */
+export interface SyncResult {
+    packageName: string;
+    success: boolean;
+    skipped: boolean;
+    reason?: string;
+    syncedFiles?: {
+        commands: string[];
+        skills: string[];
+    };
+}
+/**
+ * CLI options
+ */
+export interface CliOptions {
+    package: string[];
+    force: boolean;
+    dryRun: boolean;
+    local: boolean;
+    /** Custom git ref (branch, tag, or commit) to fetch from */
+    ref?: string;
+}
+/**
+ * Workspace info from yarn workspaces
+ */
+export interface WorkspaceInfo {
+    name: string;
+    location: string;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@slats/claude-assets-sync",
+  "version": "0.0.1",
+  "description": "CLI tool to sync Claude commands and skills from npm packages to your project's .claude directory",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "sync",
+    "commands",
+    "skills",
+    "assets"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vincent-kk/albatrion.git",
+    "directory": "packages/slats/claude-assets-sync"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Vincent K. Kelvin",
+    "email": "lunox273@gmail.com"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": "./dist/index.mjs",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c && yarn build:types",
+    "build:publish:npm": "yarn build && yarn publish:npm",
+    "build:types": "tsc -p ./tsconfig.declarations.json && tsc-alias -p ./tsconfig.declarations.json",
+    "dev": "tsx src/index.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint \"src/**/*.ts\"",
+    "publish:npm": "npm publish --access public",
+    "test": "vitest",
+    "version:major": "yarn version major",
+    "version:minor": "yarn version minor",
+    "version:patch": "yarn version patch"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "picocolors": "^1.1.1"
+  }
+}