craftdesk 0.2.0 → 0.4.0

package/src/services/installer.ts

@@ -1,314 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import axios from 'axios';
-import { logger } from '../utils/logger';
-import { configManager } from './config-manager';
-import { CraftDeskLock, LockEntry } from '../types/craftdesk-lock';
-import { ensureDir } from '../utils/file-system';
-
-/**
- * Handles installation of crafts from various sources
- *
- * Supports installing from:
- * - Registry packages (via download URLs)
- * - Git repositories (with monorepo support)
- * - Local archives
- *
- * Organizes installations by craft type in the .claude directory.
- *
- * @example
- * ```typescript
- * const installer = new Installer();
- *
- * // Install from lockfile
- * const lockfile = await readLockfile();
- * await installer.installFromLockfile(lockfile);
- *
- * // Install single craft
- * await installer.installCraft('ruby-on-rails', lockEntry);
- * ```
- */
-export class Installer {
-  private installPath: string;
-
-  constructor() {
-    this.installPath = configManager.getInstallPath();
-  }
-
-  /**
-   * Installs all crafts defined in a lockfile
-   *
-   * Processes each craft sequentially, updating progress as it goes.
-   * Fails fast if any installation errors occur.
-   *
-   * @param lockfile - The craftdesk.lock content with all dependencies
-   * @throws Error if any craft fails to install
-   *
-   * @example
-   * ```typescript
-   * const lockfile = {
-   *   version: '1.0.0',
-   *   lockfileVersion: 1,
-   *   crafts: {
-   *     'ruby-on-rails': { version: '7.1.0', ... },
-   *     'postgres-expert': { version: '1.2.0', ... }
-   *   }
-   * };
-   *
-   * await installer.installFromLockfile(lockfile);
-   * ```
-   */
-  async installFromLockfile(lockfile: CraftDeskLock): Promise<void> {
-    const installDir = path.join(process.cwd(), this.installPath);
-    await ensureDir(installDir);
-
-    const crafts = Object.entries(lockfile.crafts);
-    let installed = 0;
-
-    for (const [name, entry] of crafts) {
-      try {
-        logger.updateSpinner(`Installing ${name}@${entry.version} (${installed + 1}/${crafts.length})`);
-        await this.installCraft(name, entry);
-        installed++;
-      } catch (error: any) {
-        logger.failSpinner(`Failed to install ${name}: ${error.message}`);
-        throw error;
-      }
-    }
-
-    logger.succeedSpinner(`Installed ${installed} crafts`);
-  }
-
-  /**
-   * Installs a single craft from registry or git source
-   *
-   * Installation process:
-   * 1. Determines installation directory based on craft type
-   * 2. For git dependencies: clones and extracts subdirectory
-   * 3. For registry: downloads archive, verifies, and extracts
-   * 4. Creates metadata file for tracking installation
-   *
-   * @param name - The name of the craft to install
-   * @param entry - Lockfile entry containing installation details
-   * @throws Error if download or extraction fails
-   *
-   * @example
-   * ```typescript
-   * // Install from registry
-   * await installer.installCraft('ruby-on-rails', {
-   *   version: '7.1.0',
-   *   resolved: 'https://craftdesk.ai/download/...',
-   *   type: 'skill',
-   *   dependencies: {}
-   * });
-   *
-   * // Install from git
-   * await installer.installCraft('custom-auth', {
-   *   version: '1.0.0',
-   *   git: 'https://github.com/company/auth.git',
-   *   branch: 'main',
-   *   type: 'agent',
-   *   dependencies: {}
-   * });
-   * ```
-   */
-  async installCraft(name: string, entry: LockEntry): Promise<void> {
-    const installDir = path.join(process.cwd(), this.installPath);
-
-    // Determine install subdirectory based on type
-    const typeDir = this.getTypeDirectory(entry.type);
-    const craftDir = path.join(installDir, typeDir, name);
-
-    // Create directory
-    await ensureDir(craftDir);
-
-    // Check if this is a git dependency
-    if (entry.git) {
-      await this.installFromGit(craftDir, entry);
-    } else {
-      // Download craft archive
-      const archivePath = path.join(craftDir, 'archive.tar.gz');
-      await this.downloadFile(entry.resolved, archivePath);
-
-      // Verify integrity (TODO: implement SHA-256 check)
-      // await this.verifyIntegrity(archivePath, entry.integrity);
-
-      // Extract archive
-      await this.extractArchive(archivePath, craftDir);
-
-      // Clean up archive
-      await fs.remove(archivePath);
-    }
-
-    // Create metadata file
-    await this.createMetadata(craftDir, name, entry);
-  }
-
-  private async installFromGit(craftDir: string, entry: LockEntry): Promise<void> {
-    const tempDir = path.join(craftDir, '.tmp-git');
-
-    try {
-      // Clone the repository
-      const { execSync } = require('child_process');
-
-      // Build clone command with appropriate ref
-      let cloneCmd = `git clone --depth 1`;
-
-      if (entry.branch) {
-        cloneCmd += ` -b ${entry.branch}`;
-      } else if (entry.tag) {
-        cloneCmd += ` -b ${entry.tag}`;
-      }
-
-      cloneCmd += ` ${entry.git} ${tempDir}`;
-
-      logger.debug(`Cloning git repository: ${cloneCmd}`);
-      execSync(cloneCmd, { stdio: 'pipe' });
-
-      // If specific commit, checkout that commit
-      if (entry.commit) {
-        execSync(`cd ${tempDir} && git fetch --unshallow && git checkout ${entry.commit}`, { stdio: 'pipe' });
-      }
-
-      // Handle direct file reference
-      if (entry.file) {
-        const sourceFile = path.join(tempDir, entry.file);
-        const destFile = path.join(craftDir, path.basename(entry.file));
-
-        if (await fs.pathExists(sourceFile)) {
-          await fs.copy(sourceFile, destFile, { overwrite: true });
-        } else {
-          throw new Error(`File not found: ${entry.file} in ${entry.git}`);
-        }
-      } else {
-        // Copy from subdirectory if specified, otherwise copy entire repo
-        const sourcePath = entry.path ? path.join(tempDir, entry.path) : tempDir;
-
-        // Copy contents to craft directory
-        const files = await fs.readdir(sourcePath);
-        for (const file of files) {
-          if (file !== '.tmp-git' && file !== '.git') {
-            await fs.copy(
-              path.join(sourcePath, file),
-              path.join(craftDir, file),
-              { overwrite: true }
-            );
-          }
-        }
-      }
-
-    } finally {
-      // Clean up temp directory
-      await fs.remove(tempDir);
-    }
-  }
-
-  private getTypeDirectory(type: string): string {
-    switch (type) {
-      case 'skill':
-        return 'skills';
-      case 'agent':
-        return 'agents';
-      case 'command':
-        return 'commands';
-      case 'hook':
-        return 'hooks';
-      default:
-        return 'crafts';
-    }
-  }
-
-  private async downloadFile(url: string, outputPath: string): Promise<void> {
-    const response = await axios({
-      method: 'GET',
-      url: url,
-      responseType: 'stream'
-    });
-
-    const writer = fs.createWriteStream(outputPath);
-    response.data.pipe(writer);
-
-    return new Promise((resolve, reject) => {
-      writer.on('finish', resolve);
-      writer.on('error', reject);
-    });
-  }
-
-  private async extractArchive(archivePath: string, outputDir: string): Promise<void> {
-    // For now, just copy some placeholder files
-    // In production, this would extract a tar.gz or zip archive
-
-    const type = path.basename(outputDir).includes('skill') ? 'SKILL' : 'AGENT';
-    const mainFile = `${type}.md`;
-
-    await fs.writeFile(
-      path.join(outputDir, mainFile),
-      `# ${path.basename(outputDir)}\n\nThis is a placeholder for the ${type.toLowerCase()} content.\n`,
-      'utf-8'
-    );
-  }
-
-  private async createMetadata(craftDir: string, name: string, entry: LockEntry): Promise<void> {
-    const metadata = {
-      name,
-      version: entry.version,
-      type: entry.type,
-      author: entry.author,
-      installedAt: new Date().toISOString(),
-      registry: entry.registry,
-      dependencies: entry.dependencies
-    };
-
-    await fs.writeFile(
-      path.join(craftDir, '.craftdesk-metadata.json'),
-      JSON.stringify(metadata, null, 2),
-      'utf-8'
-    );
-  }
-
-  async removeCraft(name: string, type: string): Promise<void> {
-    const installDir = path.join(process.cwd(), this.installPath);
-    const typeDir = this.getTypeDirectory(type);
-    const craftDir = path.join(installDir, typeDir, name);
-
-    if (await fs.pathExists(craftDir)) {
-      await fs.remove(craftDir);
-      logger.success(`Removed ${name}`);
-    } else {
-      logger.warn(`${name} is not installed`);
-    }
-  }
-
-  async listInstalled(): Promise<Array<{ name: string; version: string; type: string }>> {
-    const installDir = path.join(process.cwd(), this.installPath);
-    const installed: Array<{ name: string; version: string; type: string }> = [];
-
-    if (!await fs.pathExists(installDir)) {
-      return installed;
-    }
-
-    const typeDirs = ['skills', 'agents', 'commands', 'hooks'];
-
-    for (const typeDir of typeDirs) {
-      const dir = path.join(installDir, typeDir);
-      if (!await fs.pathExists(dir)) continue;
-
-      const crafts = await fs.readdir(dir);
-      for (const craftName of crafts) {
-        const metadataPath = path.join(dir, craftName, '.craftdesk-metadata.json');
-        if (await fs.pathExists(metadataPath)) {
-          const metadata = await fs.readJson(metadataPath);
-          installed.push({
-            name: craftName,
-            version: metadata.version,
-            type: metadata.type
-          });
-        }
-      }
-    }
-
-    return installed;
-  }
-}
-
-export const installer = new Installer();

package/src/services/registry-client.ts

@@ -1,163 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import { configManager } from './config-manager';
-import { logger } from '../utils/logger';
-import { LockEntry } from '../types/craftdesk-lock';
-
-export interface CraftInfo {
-  name: string;
-  author: string;
-  version: string;
-  type: 'skill' | 'agent' | 'command' | 'hook';
-  description?: string;
-  dependencies?: Record<string, string>;
-  download_url?: string;
-  integrity?: string;
-}
-
-export interface ResolveResponse {
-  resolved: Record<string, any>;
-  lockfile: any;
-}
-
-export class RegistryClient {
-  private axiosInstance: AxiosInstance | null = null;
-
-  private async getClient(registryUrl: string): Promise<AxiosInstance> {
-    const token = await configManager.getAuthToken(registryUrl);
-
-    return axios.create({
-      baseURL: registryUrl,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(token ? { 'Authorization': `Bearer ${token}` } : {})
-      },
-      timeout: 30000
-    });
-  }
-
-  async getCraftInfo(craftName: string, version?: string, registryOverride?: string): Promise<CraftInfo | null> {
-    // Get registry URL - can be overridden by dependency-specific registry
-    const registryUrl = registryOverride
-      ? await this.resolveRegistry(registryOverride)
-      : await configManager.getRegistryForCraft(craftName);
-
-    const client = await this.getClient(registryUrl);
-
-    // Parse craft name (could be @scope/name or just name)
-    const [author, name] = this.parseCraftName(craftName);
-
-    try {
-      const endpoint = version
-        ? `/api/v1/crafts/${author}/${name}/versions/${version}`
-        : `/api/v1/crafts/${author}/${name}`;
-
-      logger.debug(`Fetching craft info from ${registryUrl}${endpoint}`);
-
-      const response = await client.get(endpoint);
-      return response.data.craft || response.data;
-    } catch (error: any) {
-      if (error.response?.status === 404) {
-        logger.error(`Craft '${craftName}' not found in registry`);
-      } else {
-        logger.error(`Failed to fetch craft info: ${error.message}`);
-      }
-      return null;
-    }
-  }
-
-  private async resolveRegistry(registry: string): Promise<string> {
-    // If it's a URL, use it directly
-    if (registry.startsWith('http://') || registry.startsWith('https://')) {
-      return registry;
-    }
-
-    // Look it up in the craftdesk.json registries section
-    const craftDeskJson = await configManager.getCraftDeskJson();
-    if (craftDeskJson?.registries?.[registry]) {
-      return craftDeskJson.registries[registry].url;
-    }
-
-    // If not found, assume it's a URL without protocol
-    return `https://${registry}`;
-  }
-
-  async listVersions(craftName: string): Promise<string[]> {
-    const registryUrl = await configManager.getRegistryForCraft(craftName);
-    const client = await this.getClient(registryUrl);
-
-    const [author, name] = this.parseCraftName(craftName);
-
-    try {
-      const response = await client.get(`/api/v1/crafts/${author}/${name}/versions`);
-      return response.data.versions || [];
-    } catch (error: any) {
-      logger.error(`Failed to fetch versions: ${error.message}`);
-      return [];
-    }
-  }
-
-  async resolveDependencies(dependencies: Record<string, string>): Promise<ResolveResponse | null> {
-    // Get the default registry from craftdesk.json or use fallback
-    const craftDesk = await configManager.getCraftDeskJson();
-    const registryUrl = craftDesk?.registries?.default?.url || 'https://craftdesk.ai';
-
-    const client = await this.getClient(registryUrl);
-
-    try {
-      logger.debug('Resolving dependencies via API...');
-      const response = await client.post('/api/v1/resolve', { dependencies });
-      return response.data;
-    } catch (error: any) {
-      logger.error(`Failed to resolve dependencies: ${error.message}`);
-      return null;
-    }
-  }
-
-  async downloadCraft(downloadUrl: string, outputPath: string): Promise<void> {
-    try {
-      const response = await axios.get(downloadUrl, {
-        responseType: 'stream'
-      });
-
-      // TODO: Save to file and extract
-      logger.debug(`Downloaded craft from ${downloadUrl}`);
-    } catch (error: any) {
-      throw new Error(`Failed to download craft: ${error.message}`);
-    }
-  }
-
-  async searchCrafts(query: string, type?: string): Promise<CraftInfo[]> {
-    // Get the default registry from craftdesk.json or use fallback
-    const craftDesk = await configManager.getCraftDeskJson();
-    const registryUrl = craftDesk?.registries?.default?.url || 'https://craftdesk.ai';
-
-    const client = await this.getClient(registryUrl);
-
-    try {
-      const params: any = { q: query };
-      if (type) params.type = type;
-
-      const response = await client.get('/api/v1/crafts', { params });
-      return response.data.crafts || [];
-    } catch (error: any) {
-      logger.error(`Failed to search crafts: ${error.message}`);
-      return [];
-    }
-  }
-
-  private parseCraftName(craftName: string): [string, string] {
-    if (craftName.startsWith('@')) {
-      // Scoped craft: @acme/skill-name
-      const parts = craftName.substring(1).split('/');
-      if (parts.length === 2) {
-        return [`@${parts[0]}`, parts[1]];
-      }
-    }
-
-    // Assume author is 'anthropic' for unscoped crafts (default)
-    // This should be configurable or determined by registry
-    return ['anthropic', craftName];
-  }
-}
-
-export const registryClient = new RegistryClient();

package/src/types/craftdesk-json.ts

@@ -1,53 +0,0 @@
-export interface CraftDeskJson {
-  name: string;
-  version: string;
-  type?: 'skill' | 'agent' | 'command' | 'hook';
-  description?: string;
-  author?: string;
-  license?: string;
-  homepage?: string;
-  repository?: {
-    type: string;
-    url: string;
-  };
-  keywords?: string[];
-
-  // Dependencies - type-agnostic (skills, agents, commands, hooks can all depend on each other)
-  // Can be simple string versions or objects with version and registry
-  dependencies?: Record<string, string | DependencyConfig>;
-  devDependencies?: Record<string, string | DependencyConfig>;
-  peerDependencies?: Record<string, string | DependencyConfig>;
-  optionalDependencies?: Record<string, string | DependencyConfig>;
-
-  // Registry configuration (optional, in-file configuration)
-  registries?: Record<string, RegistryConfig>;
-
-  // Commands and hooks
-  commands?: Record<string, string | CommandConfig>;
-  hooks?: Record<string, string[]>;
-
-  // Index signature to allow dynamic property access
-  [key: string]: any;
-}
-
-export interface DependencyConfig {
-  version?: string;  // Optional for git dependencies
-  registry?: string;  // Can be a registry name (from registries section) or direct URL
-  git?: string;       // Git repository URL
-  branch?: string;    // Git branch (default: main/master)
-  tag?: string;       // Git tag
-  commit?: string;    // Git commit hash
-  path?: string;      // Subdirectory path within the repository
-  file?: string;      // Direct file path within the repository
-}
-
-export interface RegistryConfig {
-  url: string;
-  scope?: string;  // Optional scope like "@company"
-  auth?: string;   // Optional auth token (though better in ~/.craftrc for security)
-}
-
-export interface CommandConfig {
-  version: string;
-  config?: Record<string, any>;
-}

package/src/types/craftdesk-lock.ts

@@ -1,38 +0,0 @@
-export interface CraftDeskLock {
-  version: string;
-  lockfileVersion: number;
-  generatedAt: string;
-
-  crafts: Record<string, LockEntry>;
-  tree?: DependencyTree;
-  metadata?: {
-    totalCrafts: number;
-    totalSize: string;
-    installPath: string;
-  };
-}
-
-export interface LockEntry {
-  version: string;
-  resolved: string;  // Download URL or git URL
-  integrity: string; // SHA-256 hash (or commit hash for git)
-  type: 'skill' | 'agent' | 'command' | 'hook';
-  author?: string;
-  registry?: string;
-  scope?: string;
-  dependencies?: Record<string, string>;
-
-  // Git source fields
-  git?: string;       // Git repository URL
-  branch?: string;    // Git branch
-  tag?: string;       // Git tag
-  commit?: string;    // Git commit hash (resolved)
-  path?: string;      // Subdirectory path within repository
-  file?: string;      // Direct file path within repository
-}
-
-export interface DependencyTree {
-  [key: string]: {
-    dependencies?: DependencyTree;
-  } | string; // String for "(shared)" marker
-}

package/src/utils/file-system.ts

@@ -1,55 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { CraftDeskJson } from '../types/craftdesk-json';
-import { CraftDeskLock } from '../types/craftdesk-lock';
-
-export async function readCraftDeskJson(dir: string = process.cwd()): Promise<CraftDeskJson | null> {
-  const filePath = path.join(dir, 'craftdesk.json');
-
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-
-export async function writeCraftDeskJson(data: CraftDeskJson, dir: string = process.cwd()): Promise<void> {
-  const filePath = path.join(dir, 'craftdesk.json');
-  const content = JSON.stringify(data, null, 2);
-  await fs.writeFile(filePath, content, 'utf-8');
-}
-
-export async function readCraftDeskLock(dir: string = process.cwd()): Promise<CraftDeskLock | null> {
-  const filePath = path.join(dir, 'craftdesk.lock');
-
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-
-export async function writeCraftDeskLock(data: CraftDeskLock, dir: string = process.cwd()): Promise<void> {
-  const filePath = path.join(dir, 'craftdesk.lock');
-  const content = JSON.stringify(data, null, 2);
-  await fs.writeFile(filePath, content, 'utf-8');
-}
-
-export async function ensureDir(dirPath: string): Promise<void> {
-  await fs.ensureDir(dirPath);
-}
-
-export async function removeDir(dirPath: string): Promise<void> {
-  await fs.remove(dirPath);
-}
-
-export async function exists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/logger.ts

@@ -1,82 +0,0 @@
-// ANSI color codes
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-};
-
-export class Logger {
-  private spinnerText: string | null = null;
-
-  success(message: string): void {
-    console.log(`${colors.green}✓${colors.reset}`, message);
-  }
-
-  error(message: string): void {
-    console.error(`${colors.red}✗${colors.reset}`, message);
-  }
-
-  warn(message: string): void {
-    console.log(`${colors.yellow}!${colors.reset}`, message);
-  }
-
-  info(message: string): void {
-    console.log(`${colors.blue}→${colors.reset}`, message);
-  }
-
-  debug(message: string): void {
-    if (process.env.DEBUG) {
-      console.log(`${colors.gray}[DEBUG]${colors.reset}`, message);
-    }
-  }
-
-  startSpinner(text: string): void {
-    this.spinnerText = text;
-    console.log(`${colors.cyan}⋯${colors.reset}`, text);
-  }
-
-  updateSpinner(text: string): void {
-    if (this.spinnerText) {
-      this.spinnerText = text;
-      console.log('  ', text);
-    }
-  }
-
-  succeedSpinner(text?: string): void {
-    if (this.spinnerText) {
-      console.log(`${colors.green}✓${colors.reset}`, text || this.spinnerText);
-      this.spinnerText = null;
-    }
-  }
-
-  failSpinner(text?: string): void {
-    if (this.spinnerText) {
-      console.log(`${colors.red}✗${colors.reset}`, text || this.spinnerText);
-      this.spinnerText = null;
-    }
-  }
-
-  stopSpinner(): void {
-    this.spinnerText = null;
-  }
-
-  log(message: string): void {
-    console.log(message);
-  }
-
-  bold(text: string): string {
-    return `${colors.bold}${text}${colors.reset}`;
-  }
-
-  dim(text: string): string {
-    return `${colors.dim}${text}${colors.reset}`;
-  }
-}
-
-export const logger = new Logger();