@maccesar/aiskills 1.7.0

package/lib/commands/status.js

@@ -0,0 +1,94 @@
+/**
+ * Status command
+ * Shows a quick overview of what's installed (read-only)
+ */
+
+import chalk from 'chalk';
+import { existsSync, lstatSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import {
+  SKILLS,
+  PACKAGE_VERSION,
+  getAgentsSkillsDir,
+  getConfigDir,
+  getPlatforms,
+} from '../config.js';
+import { hasHook } from '../hooks.js';
+import { readLastCheck } from '../cache.js';
+
+const CHECK = chalk.green('✓');
+const CROSS = chalk.red('✗');
+
+function countInstalledSkills(skillsDir) {
+  let count = 0;
+  for (const skill of SKILLS) {
+    if (existsSync(join(skillsDir, skill))) {
+      count++;
+    }
+  }
+  return count;
+}
+
+function countLinkedSkills(platformSkillsDir) {
+  let count = 0;
+  for (const skill of SKILLS) {
+    const linkPath = join(platformSkillsDir, skill);
+    try {
+      lstatSync(linkPath);
+      count++;
+    } catch {
+      // not found
+    }
+  }
+  return count;
+}
+
+function formatLastCheck(data) {
+  if (!data) return chalk.gray('never');
+  const date = new Date(data.lastCheck);
+  const formatted = date.toISOString().replace('T', ' ').slice(0, 16);
+  return `${formatted} (v${data.latestVersion})`;
+}
+
+export async function statusCommand() {
+  const homeDir = os.homedir();
+  const skillsDir = getAgentsSkillsDir(homeDir);
+  const claudeDir = join(homeDir, '.claude');
+  const cacheDir = getConfigDir();
+
+  // Skills count
+  const installedCount = countInstalledSkills(skillsDir);
+  const totalCount = SKILLS.length;
+
+  // Hook check
+  const hookExists = hasHook(claudeDir);
+
+  // Cache
+  const lastCheck = readLastCheck(cacheDir);
+
+  console.log('');
+  console.log(chalk.bold('AI Skills Status'));
+  console.log('');
+  console.log(`  Version:    v${PACKAGE_VERSION}`);
+  console.log(`  Skills:     ${installedCount}/${totalCount} installed`);
+  console.log(`  Hook:       Claude Code SessionStart ${hookExists ? CHECK : CROSS}`);
+  console.log(`  Last check: ${formatLastCheck(lastCheck)}`);
+
+  // Platforms
+  console.log('');
+  console.log('  Platforms:');
+  const platforms = getPlatforms(homeDir);
+  for (const platform of platforms) {
+    const linked = countLinkedSkills(platform.skillsDir);
+    if (linked > 0) {
+      console.log(`    ${platform.displayName.padEnd(13)} ${CHECK} ${linked} skills linked`);
+    } else {
+      console.log(`    ${platform.displayName.padEnd(13)} ${CROSS} ${chalk.gray('not linked')}`);
+    }
+  }
+
+  console.log('');
+}
+
+export default { statusCommand };

package/lib/commands/uninstall.js

@@ -0,0 +1,182 @@
+/**
+ * Uninstall command
+ * Removes installed skills and symlinks
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import os from 'os';
+import { SKILLS, getConfigDir } from '../config.js';
+import {
+  detectPlatforms,
+} from '../platform.js';
+import {
+  removeSkillSymlinks,
+  removeSkills,
+} from '../cleanup.js';
+import { removeHook } from '../hooks.js';
+import checkbox, { Separator } from '../prompts/checkboxCancel.js';
+import { existsSync } from 'fs';
+import { rm } from 'fs/promises';
+import { join, resolve } from 'path';
+import { getAgentsSkillsDir } from '../config.js';
+import { getSkillList } from '../cleanup.js';
+
+/**
+ * Uninstall command handler
+ */
+export async function uninstallCommand(options) {
+  console.log('');
+  console.log(chalk.bold.blue('AI Skills Uninstaller'));
+  console.log('');
+
+  const projectDir = resolve(process.cwd());
+  const baseDir = options.local ? projectDir : undefined;
+  if (options.local) {
+    console.log(chalk.cyan('Mode: Local uninstallation (current project)'));
+    console.log('');
+  }
+
+  const detectedPlatforms = detectPlatforms(baseDir);
+
+  const skillList = getSkillList();
+  const homeSkillsDir = getAgentsSkillsDir();
+  const projectSkillsDir = getAgentsSkillsDir(projectDir);
+
+  const hasAnyInDir = (dir, names) =>
+    !!dir && existsSync(dir) && names.some((name) => existsSync(join(dir, name)));
+
+  const hasHomeSkills = hasAnyInDir(homeSkillsDir, skillList);
+  const hasProjectSkills = options.local && hasAnyInDir(projectSkillsDir, skillList);
+
+  const hasHomeSymlinks = detectedPlatforms.some((platform) =>
+    hasAnyInDir(platform.skillsDir, skillList)
+  );
+  const hasProjectSymlinks = options.local && detectPlatforms(projectDir).some((platform) =>
+    hasAnyInDir(platform.skillsDir, skillList)
+  );
+
+  const choices = [];
+  if (hasHomeSkills) {
+    choices.push({ name: 'Skills from the `home` directory', value: 'skills-home', checked: false });
+  }
+  if (hasProjectSkills) {
+    choices.push({ name: 'Skills from the `project` directory', value: 'skills-project', checked: false });
+  }
+  if (hasHomeSymlinks) {
+    choices.push({ name: 'Skill symlinks from `home` directory', value: 'symlinks-home', checked: true });
+  }
+  if (hasProjectSymlinks) {
+    choices.push({ name: 'Skill symlinks from `project` directory', value: 'symlinks-project', checked: false });
+  }
+
+  if (choices.length === 0) {
+    console.log(chalk.yellow('No skills or symlinks found.'));
+    console.log('');
+    return;
+  }
+
+  let targets = [];
+  try {
+    targets = await checkbox({
+      message: 'What do you want to uninstall:',
+      choices: [
+        ...choices,
+        new Separator(' '),
+      ],
+      shortcuts: { invert: null },
+      theme: {
+        style: {
+          renderSelectedChoices: () => '',
+        },
+      },
+    });
+  } catch (error) {
+    console.log('\nCancelled.');
+    process.exit(0);
+  }
+
+  if (targets.includes('cancel')) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  if (targets.length === 0) {
+    console.log(chalk.yellow('Nothing to uninstall. Cancelled.'));
+    return;
+  }
+
+  const spinner = ora();
+  let actionTaken = false;
+
+  if (targets.includes('symlinks-home')) {
+    for (const platform of detectedPlatforms) {
+      spinner.start(`Removing ${platform.displayName} symlinks...`);
+      const symlinkResult = removeSkillSymlinks(platform.skillsDir);
+      if (symlinkResult.removed.length > 0) {
+        spinner.succeed(`${platform.displayName}: Skills unlinked`);
+        actionTaken = true;
+      } else {
+        spinner.info(`${platform.displayName}: No symlinks found`);
+      }
+    }
+  }
+
+  if (targets.includes('symlinks-project')) {
+    const projectPlatforms = detectPlatforms(projectDir);
+    for (const platform of projectPlatforms) {
+      spinner.start(`Removing ${platform.displayName} symlinks...`);
+      const symlinkResult = removeSkillSymlinks(platform.skillsDir);
+      if (symlinkResult.removed.length > 0) {
+        spinner.succeed(`${platform.displayName}: Skills unlinked`);
+        actionTaken = true;
+      } else {
+        spinner.info(`${platform.displayName}: No symlinks found`);
+      }
+    }
+  }
+
+  if (targets.includes('skills-home')) {
+    spinner.start('Removing skills...');
+    const skillsResult = removeSkills(undefined);
+    if (skillsResult.removed.length > 0) {
+      spinner.succeed(`${SKILLS.length} skills removed`);
+      actionTaken = true;
+    } else {
+      spinner.info('No skills to remove');
+    }
+  }
+
+  if (targets.includes('skills-project')) {
+    spinner.start('Removing skills...');
+    const skillsResult = removeSkills(projectDir);
+    if (skillsResult.removed.length > 0) {
+      spinner.succeed(`${SKILLS.length} skills removed`);
+      actionTaken = true;
+    } else {
+      spinner.info('No skills to remove');
+    }
+  }
+
+  // Remove Claude Code SessionStart hook
+  const claudeDir = join(os.homedir(), '.claude');
+  removeHook(claudeDir);
+
+  // Clean up cache directory
+  const cacheDir = getConfigDir();
+  if (existsSync(cacheDir)) {
+    await rm(cacheDir, { recursive: true, force: true });
+  }
+
+  if (actionTaken) {
+    console.log('');
+    console.log(chalk.green('✓ Uninstallation complete!'));
+    console.log('');
+  } else {
+    console.log('');
+    console.log(chalk.yellow('No changes were necessary.'));
+    console.log('');
+  }
+}
+
+export default uninstallCommand;

package/lib/commands/update.js

@@ -0,0 +1,149 @@
+/**
+ * Update command
+ * Checks for a newer CLI version, then syncs skills from the installed package
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  PACKAGE_VERSION,
+  REPO_URL,
+  SKILLS,
+} from '../config.js';
+import {
+  detectPlatforms,
+} from '../platform.js';
+import { cleanupLegacyArtifacts, getSkillList } from '../cleanup.js';
+import {
+  installSkills,
+  getLocalRepoDir,
+} from '../installer.js';
+import {
+  checkForUpdate,
+  fetchLatestNpmVersion,
+} from '../downloader.js';
+import { createSkillSymlinks } from '../symlink.js';
+import { getAgentsSkillsDir } from '../config.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Check if a platform has any skill symlinks installed
+ */
+function hasAnySkillSymlink(platformSkillsDir) {
+  if (!platformSkillsDir || !existsSync(platformSkillsDir)) return false;
+  const skillList = getSkillList();
+  return skillList.some((skill) => existsSync(join(platformSkillsDir, skill)));
+}
+
+/**
+ * Perform the actual update for a specific scope
+ */
+async function performUpdate(baseDir, repoDir, spinner) {
+  const detectedPlatforms = detectPlatforms(baseDir);
+  const platformsWithSymlinks = detectedPlatforms.filter((p) =>
+    hasAnySkillSymlink(p.skillsDir)
+  );
+
+  spinner.start('Syncing skills...');
+  const skillsResult = await installSkills(repoDir, baseDir);
+  spinner.succeed(`${skillsResult.installed.length} skills updated`);
+
+  cleanupLegacyArtifacts(baseDir);
+
+  for (const platform of platformsWithSymlinks) {
+    await createSkillSymlinks(
+      platform.skillsDir,
+      SKILLS,
+      baseDir
+    );
+  }
+}
+
+/**
+ * Update command handler
+ */
+export async function updateCommand(options) {
+  console.log('');
+  console.log(chalk.bold.blue('AI Skills Updater'));
+  console.log('');
+
+  const spinner = ora();
+
+  const baseDir = options.local ? process.cwd() : undefined;
+
+  if (baseDir) {
+    console.log(chalk.cyan('Mode: Local update (current project)'));
+  } else {
+    console.log(chalk.cyan('Mode: Global update (user home)'));
+  }
+  console.log('');
+
+  // Verify skills are installed
+  const skillsDir = getAgentsSkillsDir(baseDir);
+  const hasSkillsInstalled = skillsDir && SKILLS.some((skill) => existsSync(join(skillsDir, skill)));
+  if (!hasSkillsInstalled) {
+    console.log(chalk.yellow('No skills installed at this location.'));
+    console.log('Install them first with:');
+    console.log('  aiskills install');
+    console.log('');
+    return;
+  }
+
+  // Check for updates
+  spinner.start('Checking for updates...');
+
+  try {
+    const hasUpdate = await checkForUpdate(PACKAGE_VERSION);
+
+    if (hasUpdate) {
+      let latestVersion = '(newer)';
+      try {
+        latestVersion = await fetchLatestNpmVersion();
+      } catch {
+        // Ignore
+      }
+
+      spinner.warn('New version available');
+      console.log('');
+      console.log(chalk.yellow('A newer version of aiskills is available on npm:'));
+      console.log(`  Current: ${chalk.gray('v' + PACKAGE_VERSION)}`);
+      console.log(`  Latest:  ${chalk.green(latestVersion)}`);
+      console.log('');
+      console.log('Update the CLI with:');
+      console.log(`  ${chalk.cyan('npm update -g @maccesar/aiskills')}`);
+      console.log('');
+      console.log('After updating, run this command again:');
+      console.log(`  ${chalk.cyan('aiskills update')}`);
+      console.log('');
+      return;
+    }
+
+    spinner.succeed(`CLI is up to date (v${PACKAGE_VERSION})`);
+
+    const repoDir = getLocalRepoDir();
+    if (!repoDir) {
+      console.log('');
+      console.log(chalk.red('Error: Could not locate skills source directory.'));
+      console.log('Try reinstalling with:');
+      console.log(`  ${chalk.cyan('npm install -g @maccesar/aiskills')}`);
+      return;
+    }
+
+    await performUpdate(baseDir, repoDir, spinner);
+
+    console.log('');
+    console.log(chalk.green('✓ Update complete!'));
+    console.log('');
+
+  } catch (error) {
+    spinner.fail('Update failed');
+    console.error(chalk.red(error.message));
+    console.log('');
+    console.log('You can try manually installing from:');
+    console.log(chalk.cyan(REPO_URL));
+    process.exit(1);
+  }
+}
+
+export default updateCommand;

package/lib/config.js

@@ -0,0 +1,90 @@
+/**
+ * Configuration constants for AI Skills
+ * Single source of truth for version management
+ */
+
+import path from 'path';
+import os from 'os';
+import { readFileSync } from 'fs';
+
+// Read package.json version dynamically
+let packageVersion = '1.0.0';
+try {
+  const packagePath = new URL('../package.json', import.meta.url);
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  packageVersion = pkg.version;
+} catch {
+  // Use default version if package.json not found
+}
+
+// Version management
+export const PACKAGE_VERSION = packageVersion;
+
+// Repository configuration
+export const REPO_URL = 'https://github.com/macCesar/aiskills';
+export const REPO_RAW_URL = 'https://raw.githubusercontent.com/macCesar/aiskills/main';
+export const REPO_API_URL = 'https://api.github.com/repos/macCesar/aiskills';
+
+// Skills to install
+export const SKILLS = [
+  'humaniza',
+  'refactoring-ui',
+  'stitch-showcase',
+  'vscode-extension-dev',
+];
+
+// Legacy skills to remove during updates/uninstall
+export const LEGACY_SKILLS = [];
+
+// Cache/config directory
+export const getConfigDir = () => path.join(os.homedir(), '.aiskills');
+
+// Directory paths
+export const getAgentsSkillsDir = (baseDir = os.homedir()) => path.join(baseDir, '.agents', 'skills');
+export const getClaudeSkillsDir = (baseDir = os.homedir()) => path.join(baseDir, '.claude', 'skills');
+export const getGeminiSkillsDir = (baseDir = os.homedir()) => path.join(baseDir, '.gemini', 'skills');
+export const getCodexSkillsDir = (baseDir = os.homedir()) => path.join(baseDir, '.codex', 'skills');
+
+// AI platform detection
+export const getPlatforms = (baseDir = os.homedir()) => [
+  {
+    name: 'claude',
+    displayName: 'Claude Code',
+    skillsDir: getClaudeSkillsDir(baseDir),
+    configDir: path.join(baseDir, '.claude'),
+  },
+  {
+    name: 'gemini',
+    displayName: 'Gemini CLI',
+    skillsDir: getGeminiSkillsDir(baseDir),
+    configDir: path.join(baseDir, '.gemini'),
+  },
+  {
+    name: 'codex',
+    displayName: 'Codex CLI',
+    skillsDir: getCodexSkillsDir(baseDir),
+    configDir: path.join(baseDir, '.codex'),
+  },
+];
+
+// API configuration
+export const GITHUB_API_HEADERS = {
+  Accept: 'application/vnd.github.v3+json',
+  'User-Agent': 'aiskills',
+};
+
+export default {
+  PACKAGE_VERSION,
+  REPO_URL,
+  REPO_RAW_URL,
+  REPO_API_URL,
+  SKILLS,
+  LEGACY_SKILLS,
+  getConfigDir,
+  getAgentsSkillsDir,
+  getClaudeSkillsDir,
+  getGeminiSkillsDir,
+  getCodexSkillsDir,
+  getPlatforms,
+  GITHUB_API_HEADERS,
+};

package/lib/downloader.js

@@ -0,0 +1,110 @@
+/**
+ * GitHub download utilities
+ * Fetches releases and archives from GitHub
+ */
+
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+import { pipeline } from 'stream/promises';
+import { unlink } from 'fs/promises';
+import { extract } from 'tar';
+import { REPO_API_URL, REPO_RAW_URL, GITHUB_API_HEADERS } from './config.js';
+
+/**
+ * Download a file from URL to local path
+ * @param {string} url - URL to download
+ * @param {string} destPath - Destination path
+ * @returns {Promise<void>}
+ */
+export async function downloadFile(url, destPath) {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+
+  const dir = dirname(destPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  await pipeline(response.body, createWriteStream(destPath));
+}
+
+/**
+ * Download and extract GitHub repository archive
+ * @param {string} destDir - Destination directory
+ * @param {string} ref - Git ref (branch, tag, commit)
+ * @returns {Promise<string>} Path to extracted directory
+ */
+export async function downloadRepoArchive(destDir, ref = 'main') {
+  const archiveUrl = `${REPO_API_URL}/tarball/${ref}`;
+  const tempFile = join(tmpdir(), `aiskills-${Date.now()}.tar.gz`);
+
+  try {
+    await downloadFile(archiveUrl, tempFile);
+
+    await extract({
+      file: tempFile,
+      cwd: destDir,
+      strip: 1,
+    });
+
+    return destDir;
+  } finally {
+    if (existsSync(tempFile)) {
+      await unlink(tempFile);
+    }
+  }
+}
+
+/**
+ * Fetch latest version from npm registry
+ * @returns {Promise<string>} Latest version number
+ */
+export async function fetchLatestNpmVersion() {
+  const response = await fetch('https://registry.npmjs.org/@maccesar/aiskills');
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch npm info: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  return data['dist-tags'].latest;
+}
+
+/**
+ * Check if an update is available (checks npm)
+ * @param {string} currentVersion - Current version
+ * @returns {Promise<boolean>} True if update available
+ */
+export async function checkForUpdate(currentVersion) {
+  try {
+    const latestVersion = await fetchLatestNpmVersion();
+    const latest = latestVersion.replace(/^v/, '');
+    const current = currentVersion.replace(/^v/, '');
+
+    const latestParts = latest.split('.').map((v) => parseInt(v, 10));
+    const currentParts = current.split('.').map((v) => parseInt(v, 10));
+
+    for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+      const l = latestParts[i] || 0;
+      const c = currentParts[i] || 0;
+
+      if (l > c) return true;
+      if (l < c) return false;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export default {
+  downloadFile,
+  downloadRepoArchive,
+  fetchLatestNpmVersion,
+  checkForUpdate,
+};

package/lib/hooks.js

@@ -0,0 +1,74 @@
+/**
+ * Claude Code hook management
+ * Installs/removes the SessionStart hook for auto-update
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const HOOK_COMMAND = 'aiskills auto-update --silent';
+const SETTINGS_FILE = 'settings.json';
+
+function readSettings(claudeDir) {
+  const settingsPath = join(claudeDir, SETTINGS_FILE);
+  if (!existsSync(settingsPath)) return {};
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(claudeDir, settings) {
+  writeFileSync(
+    join(claudeDir, SETTINGS_FILE),
+    JSON.stringify(settings, null, 2) + '\n',
+    'utf8'
+  );
+}
+
+/**
+ * Find the hook entry that contains our command
+ * Claude Code hook format: { hooks: [{ type: "command", command: "..." }] }
+ */
+function findHookEntry(sessionStartHooks) {
+  if (!Array.isArray(sessionStartHooks)) return -1;
+  return sessionStartHooks.findIndex((entry) =>
+    Array.isArray(entry.hooks) &&
+    entry.hooks.some((h) => h.type === 'command' && h.command === HOOK_COMMAND)
+  );
+}
+
+export function hasHook(claudeDir) {
+  const settings = readSettings(claudeDir);
+  const hooks = settings.hooks?.SessionStart;
+  return findHookEntry(hooks) !== -1;
+}
+
+export function installHook(claudeDir) {
+  if (hasHook(claudeDir)) return;
+  const settings = readSettings(claudeDir);
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
+  settings.hooks.SessionStart.push({
+    hooks: [
+      {
+        type: 'command',
+        command: HOOK_COMMAND,
+      },
+    ],
+  });
+  writeSettings(claudeDir, settings);
+}
+
+export function removeHook(claudeDir) {
+  if (!hasHook(claudeDir)) return;
+  const settings = readSettings(claudeDir);
+  const idx = findHookEntry(settings.hooks.SessionStart);
+  if (idx !== -1) {
+    settings.hooks.SessionStart.splice(idx, 1);
+  }
+  writeSettings(claudeDir, settings);
+}
+
+export default { installHook, removeHook, hasHook };