craftdesk 0.1.0 → 0.2.0

package/examples/simple-craftdesk.json

@@ -0,0 +1,10 @@
+{
+  "name": "my-project",
+  "version": "1.0.0",
+  "type": "skill",
+  "description": "A simple project with default registry",
+  "dependencies": {
+    "ruby-on-rails": "^7.0.0",
+    "postgres-expert": "^1.2.0"
+  }
+}

package/package.json

@@ -1,38 +1,45 @@
 {
   "name": "craftdesk",
-  "version": "0.1.0",
-  "description": "Package management for Claude Skills and AI Agents - npm-style versioning, dependency resolution, and company-wide skill distribution",
-  "main": "index.js",
+  "version": "0.2.0",
+  "description": "Package manager for Claude Code skills and agents",
+  "main": "dist/index.js",
+  "bin": {
+    "craftdesk": "./bin/craftdesk.js"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest watch",
+    "prepare": "npm run build"
   },
   "keywords": [
-    "claude",
+    "craftdesk",
     "ai",
-    "skills",
-    "agents",
+    "cli",
     "package-manager",
-    "claude-skills",
-    "ai-agents",
-    "skill-management",
-    "craftdesk"
+    "skills",
+    "agents"
   ],
-  "author": "CraftDesk Team",
+  "author": "CraftDesk",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/craftdesk/craftdesk.git"
+  "dependencies": {
+    "axios": "^1.6.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0"
   },
-  "bugs": {
-    "url": "https://github.com/craftdesk/craftdesk/issues"
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "@types/fs-extra": "^11.0.4",
+    "typescript": "^5.3.3",
+    "vitest": "^1.0.4",
+    "@vitest/ui": "^1.0.4",
+    "@vitest/coverage-v8": "^1.0.4"
   },
-  "homepage": "https://craftdesk.dev",
   "engines": {
     "node": ">=18.0.0"
-  },
-  "files": [
-    "index.js",
-    "README.md",
-    "LICENSE"
-  ]
-}
+  }
+}

package/src/commands/add.ts

@@ -0,0 +1,314 @@
+import { Command } from 'commander';
+import path from 'path';
+import { readCraftDeskJson, writeCraftDeskJson, readCraftDeskLock, writeCraftDeskLock } from '../utils/file-system';
+import { logger } from '../utils/logger';
+import { registryClient } from '../services/registry-client';
+import { installer } from '../services/installer';
+import { gitResolver } from '../services/git-resolver';
+
+export function createAddCommand(): Command {
+  return new Command('add')
+    .description('Add a new dependency and install it')
+    .argument('<craft>', 'Craft name (e.g., ruby-on-rails or @acme/patterns)')
+    .option('-D, --save-dev', 'Save as devDependency')
+    .option('-O, --save-optional', 'Save as optionalDependency')
+    .option('-E, --save-exact', 'Save exact version')
+    .option('-t, --type <type>', 'Specify craft type (skill, agent, command, hook)')
+    .action(async (craftArg: string, options) => {
+      await addCommand(craftArg, options);
+    });
+}
+
+async function addCommand(craftArg: string, options: any): Promise<void> {
+  try {
+    // Read craftdesk.json
+    const craftDeskJson = await readCraftDeskJson();
+    if (!craftDeskJson) {
+      logger.error('No craftdesk.json found in current directory');
+      logger.info('Run "craftdesk init" to create one');
+      process.exit(1);
+    }
+
+    // Parse craft name and version
+    let craftName: string;
+    let versionConstraint: string = '*';
+
+    if (craftArg.includes('@') && !craftArg.startsWith('@')) {
+      // Format: craft@version
+      const parts = craftArg.split('@');
+      craftName = parts[0];
+      versionConstraint = parts[1];
+    } else if (craftArg.startsWith('@')) {
+      // Scoped craft: @scope/craft or @scope/craft@version
+      const afterScope = craftArg.substring(craftArg.indexOf('/') + 1);
+      if (afterScope.includes('@')) {
+        const parts = craftArg.split('@');
+        craftName = `${parts[0]}@${parts[1]}`;
+        versionConstraint = parts[2];
+      } else {
+        craftName = craftArg;
+      }
+    } else {
+      craftName = craftArg;
+    }
+
+    logger.info(`Adding ${craftName}...`);
+
+    // Check if this is a git dependency
+    let depValue: string | any;
+    let lockEntry: any;
+    let displayInfo: string;
+
+    // Convert GitHub web URLs to git URLs automatically
+    const normalizedArg = normalizeGitHubUrl(craftArg);
+
+    if (normalizedArg.startsWith('git+') || normalizedArg.includes('.git')) {
+      // Handle git dependency
+      logger.startSpinner('Analyzing git dependency...');
+
+      const gitInfo = parseGitUrl(normalizedArg);
+
+      // Resolve the git dependency to get its craftdesk.json and dependencies
+      const resolvedGit = await gitResolver.resolveGitDependency({
+        url: gitInfo.url,
+        branch: gitInfo.branch,
+        tag: gitInfo.tag,
+        commit: gitInfo.commit,
+        path: gitInfo.path,
+        file: gitInfo.file
+      });
+
+      depValue = {
+        git: gitInfo.url,
+        ...(gitInfo.branch && { branch: gitInfo.branch }),
+        ...(gitInfo.tag && { tag: gitInfo.tag }),
+        ...(gitInfo.path && { path: gitInfo.path }),
+        ...(gitInfo.file && { file: gitInfo.file })
+      };
+
+      // Use resolved information for the lock entry
+      const craftJson = resolvedGit.craftDeskJson;
+
+      // Determine type: explicit option > craftdesk.json > inferred > default
+      const craftType = options.type || craftJson?.type || 'skill';
+
+      lockEntry = {
+        version: craftJson?.version || gitInfo.tag || gitInfo.branch || 'HEAD',
+        resolved: gitInfo.url,
+        integrity: resolvedGit.resolvedCommit || 'git',
+        type: craftType,
+        author: craftJson?.author || 'git',
+        git: gitInfo.url,
+        ...(gitInfo.branch && { branch: gitInfo.branch }),
+        ...(gitInfo.tag && { tag: gitInfo.tag }),
+        ...(resolvedGit.resolvedCommit && { commit: resolvedGit.resolvedCommit }),
+        ...(gitInfo.path && { path: gitInfo.path }),
+        ...(gitInfo.file && { file: gitInfo.file }),
+        dependencies: craftJson?.dependencies || {}
+      };
+
+      craftName = craftJson?.name || gitInfo.name || path.basename(gitInfo.url, '.git');
+      displayInfo = `${craftName}@${craftJson?.version || 'git'} from ${gitInfo.url}`;
+      logger.succeedSpinner(`Resolved git dependency: ${displayInfo}`);
+    } else {
+      // Regular registry dependency
+      logger.startSpinner('Fetching craft information...');
+
+      // Check if the dependency has custom registry info in craftdesk.json
+      let registryOverride: string | undefined;
+      const existingDep = craftDeskJson.dependencies?.[craftName];
+      if (existingDep && typeof existingDep === 'object' && 'registry' in existingDep) {
+        registryOverride = existingDep.registry;
+      }
+
+      // Get craft info from registry
+      const craftInfo = await registryClient.getCraftInfo(craftName, undefined, registryOverride);
+      if (!craftInfo) {
+        logger.failSpinner(`Craft '${craftName}' not found`);
+        process.exit(1);
+      }
+
+      logger.succeedSpinner(`Found ${craftInfo.name}@${craftInfo.version}`);
+
+      const version = options.saveExact ? craftInfo.version : versionConstraint;
+      depValue = version;
+
+      lockEntry = {
+        version: craftInfo.version,
+        resolved: craftInfo.download_url || `http://localhost:3000/api/v1/crafts/${craftInfo.author}/${craftInfo.name}/versions/${craftInfo.version}/download`,
+        integrity: craftInfo.integrity || 'sha256-placeholder',
+        type: craftInfo.type,
+        author: craftInfo.author,
+        dependencies: craftInfo.dependencies || {}
+      };
+
+      displayInfo = `${craftInfo.name}@${craftInfo.version}`;
+    }
+
+    // Determine which dependency field to use
+    let depField: string;
+    if (options.saveDev) {
+      depField = 'devDependencies';
+    } else if (options.saveOptional) {
+      depField = 'optionalDependencies';
+    } else {
+      depField = 'dependencies';
+    }
+
+    // Initialize field if it doesn't exist
+    if (!craftDeskJson[depField]) {
+      craftDeskJson[depField] = {};
+    }
+
+    // Add to craftdesk.json
+    craftDeskJson[depField][craftName] = depValue;
+
+    // Save craftdesk.json
+    await writeCraftDeskJson(craftDeskJson);
+
+    const displayVersion = typeof depValue === 'string' ? depValue : (depValue.tag || depValue.branch || 'git');
+    logger.success(`Added ${craftName}@${displayVersion} to ${depField}`);
+
+    // Install the craft
+    logger.startSpinner(`Installing ${craftName}...`);
+
+    await installer.installCraft(craftName, lockEntry);
+
+    logger.succeedSpinner(`Installed ${displayInfo}`);
+
+    // Update craftdesk.lock
+    let lockfile = await readCraftDeskLock();
+    if (!lockfile) {
+      lockfile = {
+        version: '1.0.0',
+        lockfileVersion: 1,
+        generatedAt: new Date().toISOString(),
+        crafts: {}
+      };
+    }
+
+    // Add or update the craft in the lockfile
+    lockfile.crafts[craftName] = lockEntry;
+    await writeCraftDeskLock(lockfile);
+
+    logger.success('Craft added successfully!');
+  } catch (error: any) {
+    logger.failSpinner();
+    logger.error(`Failed to add craft: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Converts GitHub web URLs to git URL format
+ *
+ * Supported GitHub URL formats:
+ * - https://github.com/user/repo/tree/branch/path/to/dir
+ * - https://github.com/user/repo/blob/branch/path/to/file.md
+ * - https://github.com/user/repo (assumes main branch)
+ *
+ * @param url - The GitHub URL (web or git format)
+ * @returns Normalized git URL with #branch#path: or #branch#file: syntax
+ * @private
+ */
+function normalizeGitHubUrl(url: string): string {
+  // Already in git+ format, return as-is
+  if (url.startsWith('git+')) {
+    return url;
+  }
+
+  // Already a .git URL, return as-is
+  if (url.endsWith('.git') || url.includes('.git#')) {
+    return url;
+  }
+
+  // Check if it's a GitHub web URL
+  const githubTreeMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+  const githubBlobMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
+  const githubRepoMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/);
+
+  if (githubTreeMatch) {
+    // Tree URL: directory reference
+    const [, owner, repo, branch, path] = githubTreeMatch;
+    return `git+https://github.com/${owner}/${repo}.git#${branch}#path:${path}`;
+  } else if (githubBlobMatch) {
+    // Blob URL: file reference
+    const [, owner, repo, branch, file] = githubBlobMatch;
+    return `git+https://github.com/${owner}/${repo}.git#${branch}#file:${file}`;
+  } else if (githubRepoMatch) {
+    // Repo URL without tree/blob: clone entire repo
+    const [, owner, repo] = githubRepoMatch;
+    return `git+https://github.com/${owner}/${repo}.git`;
+  }
+
+  // Not a recognized GitHub URL, return as-is
+  return url;
+}
+
+/**
+ * Parses a git URL with optional ref and subdirectory/file specifiers
+ *
+ * Supported formats:
+ * - git+https://github.com/user/repo.git#branch
+ * - git+https://github.com/user/repo.git#v1.0.0
+ * - git+https://github.com/user/repo.git#commit-hash
+ * - git+https://github.com/user/repo.git#path:subfolder/skill
+ * - git+https://github.com/user/repo.git#file:skill.md
+ * - git+https://github.com/user/repo.git#main#file:rspec-agent.md
+ * - https://github.com/user/repo.git
+ *
+ * @param urlString - The git URL to parse
+ * @returns Parsed git dependency information
+ * @private
+ */
+function parseGitUrl(urlString: string): any {
+  // Remove optional git+ prefix (npm-style format)
+  let url = urlString.replace(/^git\+/, '');
+
+  const result: any = {};
+
+  // Extract direct file path (e.g., #file:rspec-agent.md)
+  if (url.includes('#file:')) {
+    const [baseUrl, filePart] = url.split('#file:');
+    url = baseUrl;
+    result.file = filePart;
+  }
+
+  // Extract subdirectory path for monorepos (e.g., #path:crafts/auth)
+  if (url.includes('#path:')) {
+    const [baseUrl, pathPart] = url.split('#path:');
+    url = baseUrl;
+    result.path = pathPart;
+  }
+
+  // Extract git reference (branch/tag/commit)
+  // Must be parsed after path and file to avoid conflicts
+  if (url.includes('#') && !url.includes('#path:') && !url.includes('#file:')) {
+    const [baseUrl, ref] = url.split('#');
+    url = baseUrl;
+
+    // Heuristic to determine ref type:
+    // - Tags typically start with 'v' or match semver pattern (1.0.0)
+    if (ref.startsWith('v') || /^\d+\.\d+/.test(ref)) {
+      result.tag = ref;
+    }
+    // - Commit hashes are 40-character hex strings
+    else if (ref.length === 40 && /^[a-f0-9]+$/.test(ref)) {
+      result.commit = ref;
+    }
+    // - Otherwise, assume it's a branch name
+    else {
+      result.branch = ref;
+    }
+  }
+
+  result.url = url;
+
+  // Extract repository name from URL for display purposes
+  const match = url.match(/\/([^/]+?)(\.git)?$/);
+  if (match) {
+    result.name = match[1];
+  }
+
+  return result;
+}

package/src/commands/init.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import path from 'path';
+import { CraftDeskJson } from '../types/craftdesk-json';
+import { writeCraftDeskJson, exists } from '../utils/file-system';
+import { logger } from '../utils/logger';
+
+export function createInitCommand(): Command {
+  return new Command('init')
+    .description('Initialize a new craftdesk.json file')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .option('-n, --name <name>', 'Project name')
+    .option('--project-version <version>', 'Project version', '1.0.0')
+    .option('-t, --type <type>', 'Project type (skill, agent, command, hook)', 'skill')
+    .option('-d, --description <desc>', 'Project description')
+    .option('-a, --author <author>', 'Author name')
+    .option('-l, --license <license>', 'License', 'MIT')
+    .action(async (options) => {
+      await initCommand(options);
+    });
+}
+
+async function initCommand(options: any): Promise<void> {
+  try {
+    // Check if craftdesk.json already exists
+    if (await exists('craftdesk.json')) {
+      logger.error('craftdesk.json already exists in this directory');
+      process.exit(1);
+    }
+
+    const config: CraftDeskJson = {
+      name: options.name || path.basename(process.cwd()),
+      version: options.projectVersion,
+      type: options.type,
+      description: options.description || undefined,
+      author: options.author || undefined,
+      license: options.license || undefined,
+      dependencies: {},
+      registries: {
+        default: {
+          url: 'https://craftdesk.ai'
+        }
+      }
+    };
+
+    // Write craftdesk.json
+    await writeCraftDeskJson(config);
+
+    logger.success('Created craftdesk.json');
+    logger.info('Run "craftdesk install" to install dependencies');
+    logger.info('Run "craftdesk add <craft>" to add dependencies');
+  } catch (error: any) {
+    logger.error(`Failed to initialize: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/install.ts

@@ -0,0 +1,126 @@
+import { Command } from 'commander';
+import { readCraftDeskJson, readCraftDeskLock, writeCraftDeskLock } from '../utils/file-system';
+import { logger } from '../utils/logger';
+import { registryClient } from '../services/registry-client';
+import { gitResolver } from '../services/git-resolver';
+import { installer } from '../services/installer';
+import { CraftDeskLock } from '../types/craftdesk-lock';
+
+export function createInstallCommand(): Command {
+  return new Command('install')
+    .description('Install all dependencies from craftdesk.json')
+    .option('--no-lockfile', 'Ignore craftdesk.lock and re-resolve dependencies')
+    .option('--production', 'Skip devDependencies')
+    .action(async (options) => {
+      await installCommand(options);
+    });
+}
+
+async function installCommand(options: any): Promise<void> {
+  try {
+    // Read craftdesk.json
+    const craftDeskJson = await readCraftDeskJson();
+    if (!craftDeskJson) {
+      logger.error('No craftdesk.json found in current directory');
+      logger.info('Run "craftdesk init" to create one');
+      process.exit(1);
+    }
+
+    logger.info('Installing dependencies from craftdesk.json...');
+
+    let lockfile: CraftDeskLock | null = null;
+
+    // Check for existing lockfile
+    if (!options.noLockfile) {
+      lockfile = await readCraftDeskLock();
+    }
+
+    if (lockfile) {
+      // Install from lockfile
+      logger.info('Installing from craftdesk.lock...');
+      logger.startSpinner('Installing crafts...');
+
+      await installer.installFromLockfile(lockfile);
+
+      logger.success('Installation complete!');
+    } else {
+      // Resolve dependencies
+      logger.info('No lockfile found. Resolving dependencies...');
+      logger.startSpinner('Resolving dependencies...');
+
+      const rawDependencies = craftDeskJson.dependencies || {};
+
+      if (Object.keys(rawDependencies).length === 0) {
+        logger.stopSpinner();
+        logger.info('No dependencies to install');
+        return;
+      }
+
+      // Collect all dependencies (including devDependencies if not --production)
+      const allDependencies: Record<string, any> = { ...rawDependencies };
+
+      if (!options.production && craftDeskJson.devDependencies) {
+        Object.assign(allDependencies, craftDeskJson.devDependencies);
+      }
+
+      // Use git resolver which handles both git AND registry dependencies
+      const resolution = await gitResolver.resolveAllDependencies(allDependencies);
+
+      if (!resolution) {
+        logger.failSpinner('Failed to resolve dependencies');
+        process.exit(1);
+      }
+
+      logger.succeedSpinner('Dependencies resolved');
+
+      // For registry dependencies that need resolution, fetch their info
+      logger.startSpinner('Fetching registry crafts...');
+
+      for (const [name, entry] of Object.entries(resolution.resolved)) {
+        if (entry.needsResolution) {
+          const craftInfo = await registryClient.getCraftInfo(name, entry.version, entry.registry);
+          if (craftInfo) {
+            resolution.resolved[name] = {
+              version: craftInfo.version,
+              resolved: craftInfo.download_url || `http://localhost:3000/api/v1/crafts/${craftInfo.author}/${craftInfo.name}/versions/${craftInfo.version}/download`,
+              integrity: craftInfo.integrity || 'sha256-placeholder',
+              type: craftInfo.type,
+              author: craftInfo.author,
+              dependencies: craftInfo.dependencies || {}
+            };
+          } else {
+            logger.failSpinner(`Failed to resolve craft: ${name}`);
+            process.exit(1);
+          }
+        }
+      }
+
+      logger.succeedSpinner('Registry crafts fetched');
+
+      // Install resolved crafts
+      logger.startSpinner('Installing crafts...');
+
+      const newLockfile = resolution.lockfile;
+      await installer.installFromLockfile(newLockfile);
+
+      // Save lockfile
+      await writeCraftDeskLock(newLockfile);
+      logger.success('Created craftdesk.lock');
+
+      logger.success('Installation complete!');
+    }
+
+    // Show summary
+    const installedCrafts = await installer.listInstalled();
+    if (installedCrafts.length > 0) {
+      logger.log('\nInstalled crafts:');
+      for (const craft of installedCrafts) {
+        logger.log(`  • ${craft.name}@${craft.version} (${craft.type})`);
+      }
+    }
+  } catch (error: any) {
+    logger.failSpinner();
+    logger.error(`Installation failed: ${error.message}`);
+    process.exit(1);
+  }
+}