myskillshub 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myskillshub",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI tool for SkillHub skill management",
   "main": "src/index.js",
   "bin": {
@@ -9,7 +9,8 @@
   "scripts": {
     "test": "jest",
     "lint": "eslint src/**/*.js",
-    "start": "node src/index.js"
+    "start": "node src/index.js",
+    "prepublishOnly": "node scripts/auto-bump-version.js"
   },
   "keywords": [
     "cli",

package/scripts/auto-bump-version.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_JSON_PATH = path.join(__dirname, '..', 'package.json');
+const PACKAGE_LOCK_PATH = path.join(__dirname, '..', 'package-lock.json');
+
+function parseSemver(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(String(version || '').trim());
+  if (!match) {
+    throw new Error(`Invalid semver version: ${version}`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+
+function compareSemver(left, right) {
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  return left.patch - right.patch;
+}
+
+function bumpPatch(version) {
+  const parsed = parseSemver(version);
+  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function fetchPublishedVersion(packageName) {
+  const cacheDir = path.join(os.tmpdir(), 'myskillshub-npm-cache');
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const result = spawnSync(
+    'npm',
+    ['view', packageName, 'version', '--json'],
+    {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        npm_config_cache: cacheDir,
+      },
+    }
+  );
+
+  if (result.status === 0) {
+    const stdout = String(result.stdout || '').trim();
+    if (!stdout) {
+      return null;
+    }
+    const parsed = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed[parsed.length - 1] : String(parsed);
+  }
+
+  const stderr = String(result.stderr || '');
+  if (stderr.includes('E404') || stderr.includes('Not Found')) {
+    return null;
+  }
+
+  throw new Error(`Failed to query published version: ${stderr || result.stdout}`);
+}
+
+function main() {
+  const pkg = readJson(PACKAGE_JSON_PATH);
+  const packageName = pkg.name;
+  const currentVersion = pkg.version;
+
+  if (!packageName) {
+    throw new Error('package.json name is required');
+  }
+  if (!currentVersion) {
+    throw new Error('package.json version is required');
+  }
+
+  const publishedVersion = fetchPublishedVersion(packageName);
+  if (!publishedVersion) {
+    console.log(`[auto-bump] ${packageName} has no published version yet, keep ${currentVersion}`);
+    return;
+  }
+
+  const currentParsed = parseSemver(currentVersion);
+  const publishedParsed = parseSemver(publishedVersion);
+  const shouldBump = compareSemver(currentParsed, publishedParsed) <= 0;
+
+  if (!shouldBump) {
+    console.log(`[auto-bump] local version ${currentVersion} is newer than published ${publishedVersion}, keep current`);
+    return;
+  }
+
+  const nextVersion = bumpPatch(publishedVersion);
+  pkg.version = nextVersion;
+  writeJson(PACKAGE_JSON_PATH, pkg);
+
+  if (fs.existsSync(PACKAGE_LOCK_PATH)) {
+    const lock = readJson(PACKAGE_LOCK_PATH);
+    lock.version = nextVersion;
+    if (lock.packages && lock.packages['']) {
+      lock.packages[''].version = nextVersion;
+    }
+    writeJson(PACKAGE_LOCK_PATH, lock);
+  }
+
+  console.log(`[auto-bump] bumped ${packageName} version: ${currentVersion} -> ${nextVersion}`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[auto-bump] ${error.message}`);
+  process.exit(1);
+}

package/src/commands/publish.js

@@ -14,23 +14,24 @@ const program = new Command();
 program
   .name('publish')
   .description('Publish a skill from local directory')
-  .argument('<directory>', 'Directory containing skill to publish')
+  .argument('[directory]', 'Directory containing skill to publish (default: current directory)')
   .option('--verbose', 'Verbose output')
   .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
   .action(async (directory, options) => {
+    const targetDirectory = directory || '.';
     const spinner = ora('Starting publish process...').start();
 
     try {
       // Validate directory exists
-      if (!fs.existsSync(directory)) {
-        spinner.fail(chalk.red(`Directory not found: ${directory}`));
+      if (!fs.existsSync(targetDirectory)) {
+        spinner.fail(chalk.red(`Directory not found: ${targetDirectory}`));
         process.exit(1);
       }
 
       // Find skill.md file
-      const skillMdPath = path.join(directory, 'skill.md');
-      if (!fs.existsSync(skillMdPath)) {
-        spinner.fail(chalk.red('skill.md not found in the directory'));
+      const skillMdPath = resolveSkillFilePath(targetDirectory);
+      if (!skillMdPath) {
+        spinner.fail(chalk.red('SKILL.md or skill.md not found in the directory'));
         process.exit(1);
       }
 
@@ -43,7 +44,7 @@ program
 
       // Create ZIP package
       spinner.text = 'Creating ZIP package...';
-      const zipPath = await createZipPackage(directory);
+      const zipPath = await createZipPackage(targetDirectory);
       spinner.succeed(chalk.green(`ZIP package created: ${zipPath}`));
 
       // Upload to SkillHub API
@@ -63,6 +64,17 @@ program
     }
   });
 
+function resolveSkillFilePath(directory) {
+  const candidates = ['SKILL.md', 'skill.md'];
+  for (const fileName of candidates) {
+    const fullPath = path.join(directory, fileName);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
 function parseSkillMd(content) {
   const lines = content.split('\n');
   const skillData = {
@@ -106,7 +118,8 @@ function parseSkillMd(content) {
 
 function createZipPackage(directory) {
   return new Promise((resolve, reject) => {
-    const zipPath = path.join(process.cwd(), `${path.basename(directory)}-package.zip`);
+    const baseName = path.basename(path.resolve(directory));
+    const zipPath = path.join(process.cwd(), `${baseName}-package-${Date.now()}.zip`);
     const output = createWriteStream(zipPath);
     const archive = archiver('zip', {
       zlib: { level: 9 }
@@ -119,14 +132,21 @@ function createZipPackage(directory) {
     output.on('error', (err) => {
       reject(err);
     });
+    archive.on('error', (err) => {
+      reject(err);
+    });
 
     archive.pipe(output);
 
-    // Add all files except node_modules and .git
-    archive.directory(directory, false, (data) => {
-      return data.stats.isDirectory() &&
-             !data.name.includes('node_modules') &&
-             !data.name.includes('.git');
+    // Add all files recursively, excluding typical VCS/dependency artifacts.
+    archive.glob('**/*', {
+      cwd: directory,
+      dot: true,
+      ignore: [
+        '**/node_modules/**',
+        '**/.git/**',
+        '**/.DS_Store'
+      ]
     });
 
     archive.finalize();