claudekit-cli 1.4.0 → 1.5.0

package/src/lib/github.ts

@@ -1,230 +0,0 @@
-import { Octokit } from "@octokit/rest";
-import { GitHubError, type GitHubRelease, GitHubReleaseSchema, type KitConfig } from "../types.js";
-import { logger } from "../utils/logger.js";
-import { AuthManager } from "./auth.js";
-
-export class GitHubClient {
-	private octokit: Octokit | null = null;
-
-	/**
-	 * Initialize Octokit client with authentication
-	 */
-	private async getClient(): Promise<Octokit> {
-		if (this.octokit) {
-			return this.octokit;
-		}
-
-		const { token } = await AuthManager.getToken();
-
-		this.octokit = new Octokit({
-			auth: token,
-			userAgent: "claudekit-cli",
-			request: {
-				timeout: 30000, // 30 seconds
-			},
-		});
-
-		return this.octokit;
-	}
-
-	/**
-	 * Get latest release for a kit
-	 */
-	async getLatestRelease(kit: KitConfig): Promise<GitHubRelease> {
-		try {
-			const client = await this.getClient();
-
-			logger.debug(`Fetching latest release for ${kit.owner}/${kit.repo}`);
-
-			const { data } = await client.repos.getLatestRelease({
-				owner: kit.owner,
-				repo: kit.repo,
-			});
-
-			return GitHubReleaseSchema.parse(data);
-		} catch (error: any) {
-			if (error?.status === 404) {
-				throw new GitHubError(`No releases found for ${kit.name}`, 404);
-			}
-			if (error?.status === 401) {
-				throw new GitHubError("Authentication failed. Please check your GitHub token.", 401);
-			}
-			if (error?.status === 403) {
-				throw new GitHubError(
-					"Access denied. Make sure your token has access to private repositories.",
-					403,
-				);
-			}
-			throw new GitHubError(
-				`Failed to fetch release: ${error?.message || "Unknown error"}`,
-				error?.status,
-			);
-		}
-	}
-
-	/**
-	 * Get specific release by version tag
-	 */
-	async getReleaseByTag(kit: KitConfig, tag: string): Promise<GitHubRelease> {
-		try {
-			const client = await this.getClient();
-
-			logger.debug(`Fetching release ${tag} for ${kit.owner}/${kit.repo}`);
-
-			const { data } = await client.repos.getReleaseByTag({
-				owner: kit.owner,
-				repo: kit.repo,
-				tag,
-			});
-
-			return GitHubReleaseSchema.parse(data);
-		} catch (error: any) {
-			if (error?.status === 404) {
-				throw new GitHubError(`Release ${tag} not found for ${kit.name}`, 404);
-			}
-			if (error?.status === 401) {
-				throw new GitHubError("Authentication failed. Please check your GitHub token.", 401);
-			}
-			if (error?.status === 403) {
-				throw new GitHubError(
-					"Access denied. Make sure your token has access to private repositories.",
-					403,
-				);
-			}
-			throw new GitHubError(
-				`Failed to fetch release: ${error?.message || "Unknown error"}`,
-				error?.status,
-			);
-		}
-	}
-
-	/**
-	 * List all releases for a kit
-	 */
-	async listReleases(kit: KitConfig, limit = 10): Promise<GitHubRelease[]> {
-		try {
-			const client = await this.getClient();
-
-			logger.debug(`Listing releases for ${kit.owner}/${kit.repo}`);
-
-			const { data } = await client.repos.listReleases({
-				owner: kit.owner,
-				repo: kit.repo,
-				per_page: limit,
-			});
-
-			return data.map((release) => GitHubReleaseSchema.parse(release));
-		} catch (error: any) {
-			if (error?.status === 401) {
-				throw new GitHubError("Authentication failed. Please check your GitHub token.", 401);
-			}
-			if (error?.status === 403) {
-				throw new GitHubError(
-					"Access denied. Make sure your token has access to private repositories.",
-					403,
-				);
-			}
-			throw new GitHubError(
-				`Failed to list releases: ${error?.message || "Unknown error"}`,
-				error?.status,
-			);
-		}
-	}
-
-	/**
-	 * Check if user has access to repository
-	 */
-	async checkAccess(kit: KitConfig): Promise<boolean> {
-		try {
-			const client = await this.getClient();
-
-			await client.repos.get({
-				owner: kit.owner,
-				repo: kit.repo,
-			});
-
-			return true;
-		} catch (error: any) {
-			if (error?.status === 404 || error?.status === 403) {
-				return false;
-			}
-			throw new GitHubError(
-				`Failed to check repository access: ${error?.message || "Unknown error"}`,
-				error?.status,
-			);
-		}
-	}
-
-	/**
-	 * Get downloadable asset or source code URL from release
-	 * Priority:
-	 * 1. "ClaudeKit Engineer Package" or "ClaudeKit Marketing Package" zip file
-	 * 2. Other custom uploaded assets (.tar.gz, .tgz, .zip) excluding "Source code" archives
-	 * 3. GitHub's automatic tarball URL
-	 */
-	static getDownloadableAsset(release: GitHubRelease): {
-		type: "asset" | "tarball" | "zipball";
-		url: string;
-		name: string;
-		size?: number;
-	} {
-		// Log all available assets for debugging
-		logger.debug(`Available assets for ${release.tag_name}:`);
-		if (release.assets.length === 0) {
-			logger.debug("  No custom assets found");
-		} else {
-			release.assets.forEach((asset, index) => {
-				logger.debug(`  ${index + 1}. ${asset.name} (${(asset.size / 1024 / 1024).toFixed(2)} MB)`);
-			});
-		}
-
-		// First priority: Look for official ClaudeKit package assets
-		const packageAsset = release.assets.find((a) => {
-			const nameLower = a.name.toLowerCase();
-			return (
-				nameLower.includes("claudekit") &&
-				nameLower.includes("package") &&
-				nameLower.endsWith(".zip")
-			);
-		});
-
-		if (packageAsset) {
-			logger.debug(`✓ Selected ClaudeKit package asset: ${packageAsset.name}`);
-			return {
-				type: "asset",
-				url: packageAsset.url, // Use API endpoint for authenticated downloads
-				name: packageAsset.name,
-				size: packageAsset.size,
-			};
-		}
-
-		logger.debug("⚠ No ClaudeKit package asset found, checking for other custom assets...");
-
-		// Second priority: Look for any custom uploaded assets (excluding GitHub's automatic source code archives)
-		const customAsset = release.assets.find(
-			(a) =>
-				(a.name.endsWith(".tar.gz") || a.name.endsWith(".tgz") || a.name.endsWith(".zip")) &&
-				!a.name.toLowerCase().startsWith("source") &&
-				!a.name.toLowerCase().includes("source code"),
-		);
-
-		if (customAsset) {
-			logger.debug(`✓ Selected custom asset: ${customAsset.name}`);
-			return {
-				type: "asset",
-				url: customAsset.url, // Use API endpoint for authenticated downloads
-				name: customAsset.name,
-				size: customAsset.size,
-			};
-		}
-
-		// Fall back to GitHub's automatic tarball
-		logger.debug("⚠ No custom assets found, falling back to GitHub automatic tarball");
-		return {
-			type: "tarball",
-			url: release.tarball_url,
-			name: `${release.tag_name}.tar.gz`,
-			size: undefined, // Size unknown for automatic tarballs
-		};
-	}
-}

package/src/lib/merge.ts

@@ -1,116 +0,0 @@
-import { join, relative } from "node:path";
-import * as clack from "@clack/prompts";
-import { copy, pathExists, readdir, stat } from "fs-extra";
-import ignore from "ignore";
-import { PROTECTED_PATTERNS } from "../types.js";
-import { logger } from "../utils/logger.js";
-
-export class FileMerger {
-	private ig = ignore().add(PROTECTED_PATTERNS);
-
-	/**
-	 * Merge files from source to destination with conflict detection
-	 */
-	async merge(sourceDir: string, destDir: string, skipConfirmation = false): Promise<void> {
-		// Get list of files that will be affected
-		const conflicts = await this.detectConflicts(sourceDir, destDir);
-
-		if (conflicts.length > 0 && !skipConfirmation) {
-			logger.warning(`Found ${conflicts.length} file(s) that will be overwritten:`);
-			conflicts.slice(0, 10).forEach((file) => logger.info(`  - ${file}`));
-			if (conflicts.length > 10) {
-				logger.info(`  ... and ${conflicts.length - 10} more`);
-			}
-
-			const confirm = await clack.confirm({
-				message: "Do you want to continue?",
-			});
-
-			if (clack.isCancel(confirm) || !confirm) {
-				throw new Error("Merge cancelled by user");
-			}
-		}
-
-		// Copy files
-		await this.copyFiles(sourceDir, destDir);
-	}
-
-	/**
-	 * Detect files that will be overwritten
-	 */
-	private async detectConflicts(sourceDir: string, destDir: string): Promise<string[]> {
-		const conflicts: string[] = [];
-		const files = await this.getFiles(sourceDir);
-
-		for (const file of files) {
-			const relativePath = relative(sourceDir, file);
-
-			// Skip protected files
-			if (this.ig.ignores(relativePath)) {
-				continue;
-			}
-
-			const destPath = join(destDir, relativePath);
-			if (await pathExists(destPath)) {
-				conflicts.push(relativePath);
-			}
-		}
-
-		return conflicts;
-	}
-
-	/**
-	 * Copy files from source to destination, skipping protected patterns
-	 */
-	private async copyFiles(sourceDir: string, destDir: string): Promise<void> {
-		const files = await this.getFiles(sourceDir);
-		let copiedCount = 0;
-		let skippedCount = 0;
-
-		for (const file of files) {
-			const relativePath = relative(sourceDir, file);
-
-			// Skip protected files
-			if (this.ig.ignores(relativePath)) {
-				logger.debug(`Skipping protected file: ${relativePath}`);
-				skippedCount++;
-				continue;
-			}
-
-			const destPath = join(destDir, relativePath);
-			await copy(file, destPath, { overwrite: true });
-			copiedCount++;
-		}
-
-		logger.success(`Copied ${copiedCount} file(s), skipped ${skippedCount} protected file(s)`);
-	}
-
-	/**
-	 * Recursively get all files in a directory
-	 */
-	private async getFiles(dir: string): Promise<string[]> {
-		const files: string[] = [];
-		const entries = await readdir(dir);
-
-		for (const entry of entries) {
-			const fullPath = join(dir, entry);
-			const stats = await stat(fullPath);
-
-			if (stats.isDirectory()) {
-				const subFiles = await this.getFiles(fullPath);
-				files.push(...subFiles);
-			} else {
-				files.push(fullPath);
-			}
-		}
-
-		return files;
-	}
-
-	/**
-	 * Add custom patterns to ignore
-	 */
-	addIgnorePatterns(patterns: string[]): void {
-		this.ig.add(patterns);
-	}
-}

package/src/lib/prompts.ts

@@ -1,114 +0,0 @@
-import * as clack from "@clack/prompts";
-import { AVAILABLE_KITS, type KitType } from "../types.js";
-import { intro, note, outro } from "../utils/safe-prompts.js";
-
-export class PromptsManager {
-	/**
-	 * Prompt user to select a kit
-	 */
-	async selectKit(defaultKit?: KitType): Promise<KitType> {
-		const kit = await clack.select({
-			message: "Select a ClaudeKit:",
-			options: Object.entries(AVAILABLE_KITS).map(([key, config]) => ({
-				value: key as KitType,
-				label: config.name,
-				hint: config.description,
-			})),
-			initialValue: defaultKit,
-		});
-
-		if (clack.isCancel(kit)) {
-			throw new Error("Kit selection cancelled");
-		}
-
-		return kit as KitType;
-	}
-
-	/**
-	 * Prompt user to select a version
-	 */
-	async selectVersion(versions: string[], defaultVersion?: string): Promise<string> {
-		if (versions.length === 0) {
-			throw new Error("No versions available");
-		}
-
-		// If only one version or default is latest, return first version
-		if (versions.length === 1 || !defaultVersion) {
-			return versions[0];
-		}
-
-		const version = await clack.select({
-			message: "Select a version:",
-			options: versions.map((v) => ({
-				value: v,
-				label: v,
-			})),
-			initialValue: defaultVersion,
-		});
-
-		if (clack.isCancel(version)) {
-			throw new Error("Version selection cancelled");
-		}
-
-		return version as string;
-	}
-
-	/**
-	 * Prompt user for target directory
-	 */
-	async getDirectory(defaultDir = "."): Promise<string> {
-		const dir = await clack.text({
-			message: "Enter target directory:",
-			placeholder: defaultDir,
-			defaultValue: defaultDir,
-			validate: (value) => {
-				if (!value || value.trim().length === 0) {
-					return "Directory path is required";
-				}
-				return;
-			},
-		});
-
-		if (clack.isCancel(dir)) {
-			throw new Error("Directory input cancelled");
-		}
-
-		return dir.trim();
-	}
-
-	/**
-	 * Confirm action
-	 */
-	async confirm(message: string): Promise<boolean> {
-		const result = await clack.confirm({
-			message,
-		});
-
-		if (clack.isCancel(result)) {
-			return false;
-		}
-
-		return result;
-	}
-
-	/**
-	 * Show intro message
-	 */
-	intro(message: string): void {
-		intro(message);
-	}
-
-	/**
-	 * Show outro message
-	 */
-	outro(message: string): void {
-		outro(message);
-	}
-
-	/**
-	 * Show note
-	 */
-	note(message: string, title?: string): void {
-		note(message, title);
-	}
-}

package/src/types.ts

@@ -1,171 +0,0 @@
-import { z } from "zod";
-
-// Kit types
-export const KitType = z.enum(["engineer", "marketing"]);
-export type KitType = z.infer<typeof KitType>;
-
-// Exclude pattern validation schema
-export const ExcludePatternSchema = z
-	.string()
-	.trim()
-	.min(1, "Exclude pattern cannot be empty")
-	.max(500, "Exclude pattern too long")
-	.refine((val) => !val.startsWith("/"), "Absolute paths not allowed in exclude patterns")
-	.refine((val) => !val.includes(".."), "Path traversal not allowed in exclude patterns");
-
-// Command options schemas
-export const NewCommandOptionsSchema = z.object({
-	dir: z.string().default("."),
-	kit: KitType.optional(),
-	version: z.string().optional(),
-	force: z.boolean().default(false),
-	exclude: z.array(ExcludePatternSchema).optional().default([]),
-});
-export type NewCommandOptions = z.infer<typeof NewCommandOptionsSchema>;
-
-export const UpdateCommandOptionsSchema = z.object({
-	dir: z.string().default("."),
-	kit: KitType.optional(),
-	version: z.string().optional(),
-	exclude: z.array(ExcludePatternSchema).optional().default([]),
-});
-export type UpdateCommandOptions = z.infer<typeof UpdateCommandOptionsSchema>;
-
-export const VersionCommandOptionsSchema = z.object({
-	kit: KitType.optional(),
-	limit: z.number().optional(),
-	all: z.boolean().optional(),
-});
-export type VersionCommandOptions = z.infer<typeof VersionCommandOptionsSchema>;
-
-// Config schemas
-export const ConfigSchema = z.object({
-	github: z
-		.object({
-			token: z.string().optional(),
-		})
-		.optional(),
-	defaults: z
-		.object({
-			kit: KitType.optional(),
-			dir: z.string().optional(),
-		})
-		.optional(),
-});
-export type Config = z.infer<typeof ConfigSchema>;
-
-// GitHub schemas
-export const GitHubReleaseAssetSchema = z.object({
-	id: z.number(),
-	name: z.string(),
-	url: z.string().url(), // API endpoint for authenticated downloads
-	browser_download_url: z.string().url(), // Direct download URL (public only)
-	size: z.number(),
-	content_type: z.string(),
-});
-export type GitHubReleaseAsset = z.infer<typeof GitHubReleaseAssetSchema>;
-
-export const GitHubReleaseSchema = z.object({
-	id: z.number(),
-	tag_name: z.string(),
-	name: z.string(),
-	draft: z.boolean(),
-	prerelease: z.boolean(),
-	assets: z.array(GitHubReleaseAssetSchema),
-	published_at: z.string().optional(),
-	tarball_url: z.string().url(),
-	zipball_url: z.string().url(),
-});
-export type GitHubRelease = z.infer<typeof GitHubReleaseSchema>;
-
-// Kit configuration
-export const KitConfigSchema = z.object({
-	name: z.string(),
-	repo: z.string(),
-	owner: z.string(),
-	description: z.string(),
-});
-export type KitConfig = z.infer<typeof KitConfigSchema>;
-
-// Available kits
-export const AVAILABLE_KITS: Record<KitType, KitConfig> = {
-	engineer: {
-		name: "ClaudeKit Engineer",
-		repo: "claudekit-engineer",
-		owner: "claudekit",
-		description: "Engineering toolkit for building with Claude",
-	},
-	marketing: {
-		name: "ClaudeKit Marketing",
-		repo: "claudekit-marketing",
-		owner: "claudekit",
-		description: "[Coming Soon] Marketing toolkit",
-	},
-};
-
-// Protected file patterns (files to skip during update)
-export const PROTECTED_PATTERNS = [
-	".env",
-	".env.local",
-	".env.*.local",
-	"*.key",
-	"*.pem",
-	"*.p12",
-	"node_modules/**",
-	".git/**",
-	"dist/**",
-	"build/**",
-];
-
-// Archive types
-export type ArchiveType = "tar.gz" | "zip";
-
-// Download progress
-export interface DownloadProgress {
-	total: number;
-	current: number;
-	percentage: number;
-}
-
-// Authentication method
-export type AuthMethod = "gh-cli" | "env-var" | "keychain" | "prompt";
-
-// Error types
-export class ClaudeKitError extends Error {
-	constructor(
-		message: string,
-		public code?: string,
-		public statusCode?: number,
-	) {
-		super(message);
-		this.name = "ClaudeKitError";
-	}
-}
-
-export class AuthenticationError extends ClaudeKitError {
-	constructor(message: string) {
-		super(message, "AUTH_ERROR", 401);
-		this.name = "AuthenticationError";
-	}
-}
-
-export class GitHubError extends ClaudeKitError {
-	constructor(message: string, statusCode?: number) {
-		super(message, "GITHUB_ERROR", statusCode);
-		this.name = "GitHubError";
-	}
-}
-
-export class DownloadError extends ClaudeKitError {
-	constructor(message: string) {
-		super(message, "DOWNLOAD_ERROR");
-		this.name = "DownloadError";
-	}
-}
-
-export class ExtractionError extends ClaudeKitError {
-	constructor(message: string) {
-		super(message, "EXTRACTION_ERROR");
-		this.name = "ExtractionError";
-	}
-}

package/src/utils/config.ts

@@ -1,87 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { type Config, ConfigSchema } from "../types.js";
-import { logger } from "./logger.js";
-
-const CONFIG_DIR = join(homedir(), ".claudekit");
-const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-
-export class ConfigManager {
-	private static config: Config | null = null;
-
-	static async load(): Promise<Config> {
-		if (ConfigManager.config) {
-			return ConfigManager.config;
-		}
-
-		try {
-			if (existsSync(CONFIG_FILE)) {
-				const content = await readFile(CONFIG_FILE, "utf-8");
-				const data = JSON.parse(content);
-				ConfigManager.config = ConfigSchema.parse(data);
-				logger.debug(`Config loaded from ${CONFIG_FILE}`);
-				return ConfigManager.config;
-			}
-		} catch (error) {
-			logger.warning(
-				`Failed to load config: ${error instanceof Error ? error.message : "Unknown error"}`,
-			);
-		}
-
-		// Return default config
-		ConfigManager.config = { github: {}, defaults: {} };
-		return ConfigManager.config;
-	}
-
-	static async save(config: Config): Promise<void> {
-		try {
-			// Validate config
-			const validConfig = ConfigSchema.parse(config);
-
-			// Ensure config directory exists
-			if (!existsSync(CONFIG_DIR)) {
-				await mkdir(CONFIG_DIR, { recursive: true });
-			}
-
-			// Write config file
-			await writeFile(CONFIG_FILE, JSON.stringify(validConfig, null, 2), "utf-8");
-			ConfigManager.config = validConfig;
-			logger.debug(`Config saved to ${CONFIG_FILE}`);
-		} catch (error) {
-			throw new Error(
-				`Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`,
-			);
-		}
-	}
-
-	static async get(): Promise<Config> {
-		return ConfigManager.load();
-	}
-
-	static async set(key: string, value: unknown): Promise<void> {
-		const config = await ConfigManager.load();
-		const keys = key.split(".");
-		let current: any = config;
-
-		for (let i = 0; i < keys.length - 1; i++) {
-			if (!(keys[i] in current)) {
-				current[keys[i]] = {};
-			}
-			current = current[keys[i]];
-		}
-
-		current[keys[keys.length - 1]] = value;
-		await ConfigManager.save(config);
-	}
-
-	static async getToken(): Promise<string | undefined> {
-		const config = await ConfigManager.load();
-		return config.github?.token;
-	}
-
-	static async setToken(token: string): Promise<void> {
-		await ConfigManager.set("github.token", token);
-	}
-}