@julioventura/opensquad 0.1.17

package/src/skills-cli.js

@@ -0,0 +1,157 @@
+import { createInterface } from 'node:readline';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listInstalled, installSkill, removeSkill, getSkillMeta, getLocalizedDescription } from './skills.js';
+import { loadLocale, t, getLocaleCode } from './i18n.js';
+import { loadSavedLocale } from './init.js';
+import { logEvent } from './logger.js';
+
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+export async function skillsCli(subcommand, args, targetDir) {
+  // Require initialized project
+  try {
+    await stat(join(targetDir, '_opensquad'));
+  } catch {
+    await loadLocale('English');
+    console.log(`\n  ${t('skillsNotInitialized')}\n`);
+    return { success: false };
+  }
+
+  await loadSavedLocale(targetDir);
+
+  try {
+    if (subcommand === 'list' || !subcommand) {
+      await runList(targetDir);
+    } else if (subcommand === 'install') {
+      const installed = await runInstall(args[0], targetDir);
+      if (installed === false) return { success: false };
+    } else if (subcommand === 'remove') {
+      const removed = await runRemove(args[0], targetDir);
+      if (removed === false) return { success: false };
+    } else if (subcommand === 'update') {
+      await runUpdate(targetDir);
+    } else if (subcommand === 'update-one') {
+      await runUpdateOne(args[0], targetDir);
+    } else {
+      console.log(`\n  ${t('skillsUnknownCommand', { cmd: subcommand })}\n`);
+      return { success: false };
+    }
+  } catch (err) {
+    console.log(`\n  ${t('skillsError', { message: err.message })}\n`);
+    return { success: false };
+  }
+
+  return { success: true };
+}
+
+async function runList(targetDir) {
+  console.log(`\n  Opensquad Skills\n`);
+
+  const installed = await listInstalled(targetDir);
+
+  if (installed.length > 0) {
+    console.log(`  ${t('skillsInstalledHeader')}`);
+    for (const id of installed) {
+      const meta = await getSkillMeta(id);
+      if (meta) {
+        const desc = getLocalizedDescription(meta, getLocaleCode());
+        const parts = [meta.name];
+        if (meta.type) parts.push(`(${meta.type})`);
+        parts.push(`- ${desc.split('.')[0]}`);
+        console.log(`    ${parts.join(' ')}`);
+      } else {
+        console.log(`    ${id}`);
+      }
+    }
+  } else {
+    console.log(`  ${t('skillsNoneInstalled')}`);
+  }
+
+  console.log(`\n  Browse available skills at: https://github.com/julioventura/opensquad/tree/main/skills\n`);
+}
+
+async function runInstall(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: opensquad install <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (installed.includes(id)) {
+    const answer = await confirm(`\n  ${t('skillsAlreadyInstalled', { id })}`);
+    // Accept 'y' (English) or 's' (Portuguese "sim") as affirmative answers
+    if (answer !== 'y' && answer !== 's') return false;
+    console.log(`  ${t('skillsInstalling', { id })}`);
+    await installSkill(id, targetDir);
+    console.log(`  ${t('skillsReinstalled', { id })}\n`);
+    await logEvent('skill:install', { name: id, reinstall: true }, targetDir);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsInstalling', { id })}`);
+  await installSkill(id, targetDir);
+  console.log(`  ${t('skillsInstalled', { id })}\n`);
+  await logEvent('skill:install', { name: id }, targetDir);
+}
+
+async function runRemove(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: opensquad uninstall <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('skillsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsRemoving', { id })}`);
+  await removeSkill(id, targetDir);
+  await logEvent('skill:remove', { name: id }, targetDir);
+  console.log(`  ${t('skillsRemoved', { id })}\n`);
+}
+
+async function runUpdate(targetDir) {
+  const installed = await listInstalled(targetDir);
+  if (installed.length === 0) {
+    console.log(`\n  ${t('skillsUpdateNone')}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsUpdating')}`);
+  for (const id of installed) {
+    console.log(`  ${t('skillsInstalling', { id })}`);
+    await installSkill(id, targetDir);
+    console.log(`  ${t('skillsInstalled', { id })}`);
+  }
+  await logEvent('skill:update', { count: installed.length }, targetDir);
+  console.log(`\n  ${t('skillsUpdateDone', { count: installed.length })}\n`);
+}
+
+async function runUpdateOne(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: opensquad update <name>\n');
+    return;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('skillsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsInstalling', { id })}`);
+  await installSkill(id, targetDir);
+  await logEvent('skill:update', { name: id }, targetDir);
+  console.log(`  ${t('skillsInstalled', { id })}\n`);
+}

package/src/skills.js

@@ -0,0 +1,146 @@
+import { cp, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_SKILLS_DIR = join(__dirname, '..', 'skills');
+
+const metaCache = new Map();
+
+export async function listInstalled(targetDir) {
+  try {
+    const skillsDir = join(targetDir, 'skills');
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isDirectory() && e.name !== 'opensquad-skill-creator')
+      .map((e) => e.name);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+export async function listAvailable() {
+  try {
+    const entries = await readdir(BUNDLED_SKILLS_DIR, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export async function getSkillMeta(id) {
+  if (metaCache.has(id)) return metaCache.get(id);
+  try {
+    const raw = await readFile(join(BUNDLED_SKILLS_DIR, id, 'SKILL.md'), 'utf-8');
+    const content = raw.replace(/\r\n/g, '\n');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return { name: id, description: '', descriptions: {}, type: '', env: [] };
+
+    const fm = fmMatch[1];
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() || id;
+    const type = fm.match(/^type:\s*(.+)$/m)?.[1]?.trim() || '';
+
+    // description may use YAML folded scalar (>)
+    let description = '';
+    const descBlock = fm.match(/^description:\s*>\s*\n((?:\s{2,}.+\n?)+)/m);
+    if (descBlock) {
+      description = descBlock[1].replace(/\n\s*/g, ' ').trim();
+    } else {
+      const descInline = fm.match(/^description:\s*(.+)$/m);
+      if (descInline) description = descInline[1].trim();
+    }
+
+    // localized descriptions: description_pt-BR, description_es, etc.
+    const descriptions = {};
+    for (const code of ['pt-BR', 'es']) {
+      const key = `description_${code}`;
+      // folded scalar
+      const blockMatch = fm.match(new RegExp(`^${key}:\\s*>\\s*\\n((?:\\s{2,}.+\\n?)+)`, 'm'));
+      if (blockMatch) {
+        descriptions[code] = blockMatch[1].replace(/\n\s*/g, ' ').trim();
+      } else {
+        // inline
+        const inlineMatch = fm.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+        if (inlineMatch) descriptions[code] = inlineMatch[1].trim();
+      }
+    }
+
+    // env is a YAML list: lines starting with "  - "
+    const env = [];
+    const envSection = fm.match(/^env:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (envSection) {
+      for (const line of envSection[1].split('\n')) {
+        const item = line.match(/^\s+-\s+(.+)/);
+        if (item) env.push(item[1].trim());
+      }
+    }
+
+    const result = { name, description, descriptions, type, env };
+    metaCache.set(id, result);
+    return result;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      metaCache.set(id, null);
+      return null;
+    }
+    throw err;
+  }
+}
+
+function validateSkillId(id) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
+    throw new Error(`Invalid skill id: '${id}'`);
+  }
+}
+
+export async function installSkill(id, targetDir) {
+  validateSkillId(id);
+  const srcDir = join(BUNDLED_SKILLS_DIR, id);
+  try {
+    await stat(srcDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error(`Skill '${id}' not found in registry`, { cause: err });
+    throw err;
+  }
+  const destDir = join(targetDir, 'skills', id);
+  const resolvedSrc = resolve(srcDir);
+  const resolvedDest = resolve(destDir);
+  if (resolvedSrc === resolvedDest || resolvedDest.startsWith(resolvedSrc + sep)) {
+    return;
+  }
+  await cp(srcDir, destDir, { recursive: true });
+  metaCache.delete(id);
+}
+
+export async function removeSkill(id, targetDir) {
+  validateSkillId(id);
+  const skillDir = join(targetDir, 'skills', id);
+  await rm(skillDir, { recursive: true, force: true });
+  metaCache.delete(id);
+}
+
+export function clearMetaCache() {
+  metaCache.clear();
+}
+
+export async function getSkillVersion(id, targetDir) {
+  try {
+    const skillPath = join(targetDir, 'skills', id, 'SKILL.md');
+    const content = await readFile(skillPath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+    const versionMatch = fmMatch[1].match(/^version:\s*(.+)$/m);
+    return versionMatch ? versionMatch[1].trim() : null;
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+export function getLocalizedDescription(meta, localeCode) {
+  if (localeCode && localeCode !== 'en' && meta.descriptions?.[localeCode]) {
+    return meta.descriptions[localeCode];
+  }
+  return meta.description;
+}