@maccesar/aiskills 1.7.0

package/lib/installer.js

@@ -0,0 +1,114 @@
+/**
+ * File installation utilities
+ * Installs skills to their respective directories
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+} from 'fs';
+import { join } from 'path';
+import { remove, copy } from 'fs-extra';
+import os from 'os';
+import {
+  SKILLS,
+  getAgentsSkillsDir,
+} from './config.js';
+import { removeSkills } from './cleanup.js';
+
+/**
+ * Recursively copy a directory
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @returns {Promise<void>}
+ */
+export async function copyDirectory(src, dest) {
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+  await copy(src, dest, { overwrite: true });
+}
+
+/**
+ * Install a single skill to the agents skills directory
+ * @param {string} repoDir - Repository directory
+ * @param {string} skillName - Name of the skill
+ * @param {string} baseDir - Base directory for installation
+ * @returns {Promise<boolean>} True if installed successfully
+ */
+export async function installSkill(repoDir, skillName, baseDir = os.homedir()) {
+  const skillsDir = getAgentsSkillsDir(baseDir);
+  const skillSrc = join(repoDir, 'skills', skillName);
+  const skillDest = join(skillsDir, skillName);
+
+  if (!existsSync(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+
+  if (!existsSync(skillSrc)) {
+    return false;
+  }
+
+  if (existsSync(skillDest)) {
+    await remove(skillDest);
+  }
+
+  await copyDirectory(skillSrc, skillDest);
+  return true;
+}
+
+/**
+ * Install all skills to the agents skills directory
+ * @param {string} repoDir - Repository directory
+ * @param {string} baseDir - Base directory for installation
+ * @returns {Promise<Object>} Results object with success/failure counts
+ */
+export async function installSkills(repoDir, baseDir = os.homedir()) {
+  const results = {
+    installed: [],
+    failed: [],
+    removed: [],
+  };
+
+  const legacyLocal = removeSkills(baseDir, { legacyOnly: true });
+  results.removed.push(...legacyLocal.removed);
+  results.failed.push(...legacyLocal.failed);
+
+  if (baseDir && baseDir !== os.homedir()) {
+    const legacyGlobal = removeSkills(undefined, { legacyOnly: true });
+    results.removed.push(...legacyGlobal.removed);
+    results.failed.push(...legacyGlobal.failed);
+  }
+
+  for (const skill of SKILLS) {
+    if (await installSkill(repoDir, skill, baseDir)) {
+      results.installed.push(skill);
+    } else {
+      results.failed.push(skill);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get the local repository directory if running from source
+ * @returns {string|null} Local repo directory or null
+ */
+export function getLocalRepoDir() {
+  const scriptDir = new URL('..', import.meta.url).pathname;
+  const skillsDir = join(scriptDir, 'skills');
+
+  if (existsSync(skillsDir)) {
+    return scriptDir;
+  }
+
+  return null;
+}
+
+export default {
+  copyDirectory,
+  installSkill,
+  installSkills,
+  getLocalRepoDir,
+};

package/lib/platform.js

@@ -0,0 +1,112 @@
+/**
+ * Platform detection utilities
+ * Detects AI coding assistants and operating system
+ */
+
+import { existsSync } from 'fs';
+import { getPlatforms } from './config.js';
+
+/**
+ * Detect installed AI coding assistant platforms
+ * @param {string} baseDir - Optional base directory to check
+ * @returns {Array} Detected platforms
+ */
+export function detectPlatforms(baseDir) {
+  const detected = [];
+  const platforms = getPlatforms(baseDir);
+
+  for (const platform of platforms) {
+    if (existsSync(platform.configDir)) {
+      detected.push(platform);
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Get platform by name
+ * @param {string} name - Platform name (claude, gemini, codex)
+ * @param {string} baseDir - Optional base directory
+ * @returns {Object|null} Platform object or null
+ */
+export function getPlatformByName(name, baseDir) {
+  const platforms = getPlatforms(baseDir);
+  return platforms.find((p) => p.name === name) || null;
+}
+
+/**
+ * Detect operating system
+ * @returns {string} OS type: 'macos', 'linux', 'windows'
+ */
+export function detectOS() {
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    return 'macos';
+  }
+  if (platform === 'win32') {
+    return 'windows';
+  }
+  return 'linux';
+}
+
+/**
+ * Check if running on Windows
+ * @returns {boolean}
+ */
+export function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Check if running on macOS
+ * @returns {boolean}
+ */
+export function isMacOS() {
+  return process.platform === 'darwin';
+}
+
+/**
+ * Check if running on Linux
+ * @returns {boolean}
+ */
+export function isLinux() {
+  return process.platform === 'linux';
+}
+
+/**
+ * Get bin directory path for the current platform
+ * @returns {string} Path to bin directory
+ */
+export function getBinDir() {
+  if (isWindows()) {
+    return `${process.env.HOME || process.env.USERPROFILE}\\bin`;
+  }
+  return '/usr/local/bin';
+}
+
+/**
+ * Check if we have sudo/admin permissions
+ * @returns {boolean}
+ */
+export function hasSudo() {
+  if (isWindows()) {
+    // Windows: check if running as administrator
+    return process.env.USERDOMAIN === process.env.COMPUTERNAME;
+  }
+  // Unix-like: check if we can write to /usr/local/bin
+  const binDir = getBinDir();
+  return existsSync(binDir) && process.getuid && process.getuid() === 0;
+}
+
+export default {
+  detectPlatforms,
+  getPlatformByName,
+  detectOS,
+  isWindows,
+  isMacOS,
+  isLinux,
+  getBinDir,
+  hasSudo,
+};

package/lib/prompts/checkboxCancel.js

@@ -0,0 +1,264 @@
+import {
+  Separator,
+  ValidationError,
+  createPrompt,
+  isDownKey,
+  isEnterKey,
+  isNumberKey,
+  isSpaceKey,
+  isUpKey,
+  makeTheme,
+  useKeypress,
+  useMemo,
+  usePagination,
+  usePrefix,
+  useState,
+} from '@inquirer/core';
+import { cursorHide } from '@inquirer/ansi';
+import { styleText } from 'node:util';
+import figures from '@inquirer/figures';
+
+const checkboxTheme = {
+  icon: {
+    checked: styleText('green', figures.circleFilled),
+    unchecked: figures.circle,
+    cursor: figures.pointer,
+  },
+  style: {
+    disabledChoice: (text) => styleText('dim', `- ${text}`),
+    renderSelectedChoices: (selectedChoices) =>
+      selectedChoices.map((choice) => choice.short).join(', '),
+    description: (text) => styleText('cyan', text),
+    keysHelpTip: (keys) =>
+      keys
+        .map(([key, action]) => `${styleText('bold', key)} ${styleText('dim', action)}`)
+        .join(styleText('dim', ' • ')),
+  },
+  keybindings: [],
+};
+
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+
+function isChecked(item) {
+  return isSelectable(item) && item.checked;
+}
+
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+
+function check(checked) {
+  return function (item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice)) return choice;
+    if (typeof choice === 'string') {
+      return {
+        value: choice,
+        name: choice,
+        short: choice,
+        checkedName: choice,
+        disabled: false,
+        checked: false,
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false,
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+
+const checkboxCancel = createPrompt((config, done) => {
+  const {
+    pageSize = 7,
+    loop = true,
+    required,
+    validate = () => true,
+    cancelValue = 'cancel',
+  } = config;
+  
+  // Shortcuts handling - allow disabling by setting to false or null
+  const shortcuts = { 
+    all: config.shortcuts?.all === undefined ? 'a' : config.shortcuts.all,
+    invert: config.shortcuts?.invert === undefined ? 'i' : config.shortcuts.invert
+  };
+  
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState('idle');
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(normalizeChoices(config.choices));
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isSelectable);
+    const last = items.findLastIndex(isSelectable);
+    if (first === -1) {
+      throw new ValidationError('[checkbox prompt] No selectable choices. All choices are disabled.');
+    }
+    return { first, last };
+  }, [items]);
+  const [active, setActive] = useState(bounds.first);
+  const [errorMsg, setError] = useState();
+  const [cancelled, setCancelled] = useState(false);
+
+  useKeypress(async (key) => {
+    if (key.name?.toLowerCase() === 'q') {
+      setCancelled(true);
+      setStatus('done');
+      done([cancelValue]);
+      return;
+    }
+    if (isEnterKey(key)) {
+      const activeItem = items[active];
+      
+      // If the active item IS the cancel option, cancel immediately
+      if (isSelectable(activeItem) && activeItem.value === cancelValue) {
+        setCancelled(true);
+        setStatus('done');
+        done([cancelValue]);
+        return;
+      }
+
+      // If ANY checked item is the cancel option, cancel immediately
+      const anyCancelChecked = items.some(
+        (item) => isSelectable(item) && item.value === cancelValue && item.checked
+      );
+      if (anyCancelChecked) {
+        setCancelled(true);
+        setStatus('done');
+        done([cancelValue]);
+        return;
+      }
+
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      if (required && selection.length === 0) {
+        setError('At least one choice must be selected');
+      } else if (isValid === true) {
+        setStatus('done');
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || 'You must select a valid value');
+      }
+    } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      if (
+        loop ||
+        (isUpKey(key, keybindings) && active !== bounds.first) ||
+        (isDownKey(key, keybindings) && active !== bounds.last)
+      ) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isSelectable(items[next]));
+        setActive(next);
+      }
+    } else if (isSpaceKey(key)) {
+      setError(undefined);
+      setItems(items.map((choice, i) => (i === active ? toggle(choice) : choice)));
+    } else if (shortcuts.all && key.name === shortcuts.all) {
+      const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked && choice.value !== cancelValue);
+      setItems(items.map((item) => {
+        if (isSelectable(item) && item.value !== cancelValue) {
+          return { ...item, checked: selectAll };
+        }
+        return item;
+      }));
+    } else if (shortcuts.invert && key.name === shortcuts.invert) {
+      setItems(items.map((item) => {
+        if (isSelectable(item) && item.value !== cancelValue) {
+          return toggle(item);
+        }
+        return item;
+      }));
+    } else if (isNumberKey(key)) {
+      const selectedIndex = Number(key.name) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item)) return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const selectedItem = items[position];
+      if (selectedItem && isSelectable(selectedItem)) {
+        setActive(position);
+        setItems(items.map((choice, i) => (i === position ? toggle(choice) : choice)));
+      }
+    }
+  });
+
+  const message = theme.style.message(config.message, status);
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) {
+        return ` ${item.separator}`;
+      }
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === 'string' ? item.disabled : '(disabled)';
+        return theme.style.disabledChoice(`${item.name} ${disabledLabel}`);
+      }
+      if (isActive) {
+        description = item.description;
+      }
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const name = item.checked ? item.checkedName : item.name;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      const cursor = isActive ? theme.icon.cursor : ' ';
+      return color(`${cursor}${checkbox} ${name}`);
+    },
+    pageSize,
+    loop,
+  });
+
+  if (status === 'done') {
+    if (cancelled) {
+      return [prefix, message].filter(Boolean).join(' ');
+    }
+    const selection = items.filter(item => isChecked(item) && item.value !== cancelValue);
+    const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+    return [prefix, message, answer].filter(Boolean).join(' ');
+  }
+
+  const keys = [
+    ['↑↓', 'navigate'],
+    ['space', 'select'],
+  ];
+  if (shortcuts.all) keys.push([shortcuts.all, 'all']);
+  if (shortcuts.invert) keys.push([shortcuts.invert, 'invert']);
+  keys.push(['⏎', 'submit']);
+  keys.push(['q', 'quit']);
+  const helpLine = theme.style.keysHelpTip(keys);
+  const lines = [
+    [prefix, message].filter(Boolean).join(' '),
+    page,
+    ' ',
+    description ? theme.style.description(description) : '',
+    errorMsg ? theme.style.error(errorMsg) : '',
+    helpLine,
+  ]
+    .filter(Boolean)
+    .join('\n')
+    .trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
+export { Separator };
+export default checkboxCancel;

package/lib/prompts/selectCancel.js

@@ -0,0 +1,204 @@
+import {
+  Separator,
+  ValidationError,
+  createPrompt,
+  isBackspaceKey,
+  isDownKey,
+  isEnterKey,
+  isNumberKey,
+  isUpKey,
+  makeTheme,
+  useEffect,
+  useKeypress,
+  useMemo,
+  usePagination,
+  usePrefix,
+  useRef,
+  useState,
+} from '@inquirer/core';
+import { cursorHide } from '@inquirer/ansi';
+import { styleText } from 'node:util';
+import figures from '@inquirer/figures';
+
+const selectTheme = {
+  icon: { cursor: figures.pointer },
+  style: {
+    disabled: (text) => styleText('dim', `- ${text}`),
+    description: (text) => styleText('cyan', text),
+    keysHelpTip: (keys) =>
+      keys
+        .map(([key, action]) => `${styleText('bold', key)} ${styleText('dim', action)}`)
+        .join(styleText('dim', ' • ')),
+  },
+  indexMode: 'hidden',
+  keybindings: [],
+};
+
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice)) return choice;
+    if (typeof choice !== 'object' || choice === null || !('value' in choice)) {
+      const name = String(choice);
+      return {
+        value: choice,
+        name,
+        short: name,
+        disabled: false,
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false,
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+
+const selectCancel = createPrompt((config, done) => {
+  const { loop = true, pageSize = 7, cancelValue = 'cancel' } = config;
+  const theme = makeTheme(selectTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState('idle');
+  const [cancelled, setCancelled] = useState(false);
+  const prefix = usePrefix({ status, theme });
+  const searchTimeoutRef = useRef();
+  const searchEnabled = !keybindings.includes('vim');
+  const items = useMemo(() => normalizeChoices(config.choices), [config.choices]);
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isSelectable);
+    const last = items.findLastIndex(isSelectable);
+    if (first === -1) {
+      throw new ValidationError('[select prompt] No selectable choices. All choices are disabled.');
+    }
+    return { first, last };
+  }, [items]);
+  const defaultItemIndex = useMemo(() => {
+    if (!('default' in config)) return -1;
+    return items.findIndex((item) => isSelectable(item) && item.value === config.default);
+  }, [config.default, items]);
+  const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+  const selectedChoice = items[active];
+
+  useKeypress((key, rl) => {
+    clearTimeout(searchTimeoutRef.current);
+    if (key.name?.toLowerCase() === 'q') {
+      setCancelled(true);
+      setStatus('done');
+      done(cancelValue);
+    } else if (isEnterKey(key)) {
+      setStatus('done');
+      done(selectedChoice.value);
+    }
+    else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      rl.clearLine(0);
+      if (
+        loop ||
+        (isUpKey(key, keybindings) && active !== bounds.first) ||
+        (isDownKey(key, keybindings) && active !== bounds.last)
+      ) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isSelectable(items[next]));
+        setActive(next);
+      }
+    } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+      const selectedIndex = Number(rl.line) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item)) return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const item = items[position];
+      if (item != null && isSelectable(item)) {
+        setActive(position);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    } else if (isBackspaceKey(key)) {
+      rl.clearLine(0);
+    } else if (searchEnabled) {
+      const searchTerm = rl.line.toLowerCase();
+      const matchIndex = items.findIndex((item) => {
+        if (Separator.isSeparator(item) || !isSelectable(item)) return false;
+        return item.name.toLowerCase().startsWith(searchTerm);
+      });
+      if (matchIndex !== -1) {
+        setActive(matchIndex);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    }
+  });
+
+  useEffect(() => () => {
+    clearTimeout(searchTimeoutRef.current);
+  }, []);
+
+  const message = theme.style.message(config.message, status);
+  const helpLine = theme.style.keysHelpTip([
+    ['↑↓', 'navigate'],
+    ['⏎', 'select'],
+    ['q', 'quit'],
+  ]);
+  let separatorCount = 0;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive, index }) {
+      if (Separator.isSeparator(item)) {
+        separatorCount++;
+        return ` ${item.separator}`;
+      }
+      const indexLabel = theme.indexMode === 'number' ? `${index + 1 - separatorCount}. ` : '';
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === 'string' ? item.disabled : '(disabled)';
+        return theme.style.disabled(`${indexLabel}${item.name} ${disabledLabel}`);
+      }
+      const color = isActive ? theme.style.highlight : (x) => x;
+      const cursor = isActive ? theme.icon.cursor : ` `;
+      return color(`${cursor} ${indexLabel}${item.name}`);
+    },
+    pageSize,
+    loop,
+  });
+
+  if (status === 'done') {
+    if (cancelled) {
+      return [prefix, message].filter(Boolean).join(' ');
+    }
+    return [prefix, message, theme.style.answer(selectedChoice.short)]
+      .filter(Boolean)
+      .join(' ');
+  }
+
+  const { description } = selectedChoice;
+  const lines = [
+    [prefix, message].filter(Boolean).join(' '),
+    page,
+    ' ',
+    description ? theme.style.description(description) : '',
+    helpLine,
+  ]
+    .filter(Boolean)
+    .join('\n')
+    .trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
+export { Separator };
+export default selectCancel;