ronds_ai 0.1.6 → 0.1.7

package/bin/ronds_ai.js

@@ -3,6 +3,7 @@
 const { runCodeRecord, saveCliError } = require('../lib/code_record');
 const { runDoctor } = require('../lib/doctor');
 const { deployHooks } = require('../lib/hooks_deploy');
+const { runSkillsInstall } = require('../lib/skills_install');
 
 const SUPPORTED_SOURCES = new Set(['claude', 'cursor']);
 
@@ -12,10 +13,12 @@ function printUsage() {
     '  ronds_ai record <tool>',
     '  ronds_ai doctor <tool>',
     '  ronds_ai hooks deploy',
+    '  ronds_ai skills install <name> [--tool claude,codex,cursor] [--scope project|global] [--project-dir <path>] [--force]',
     '',
     'Supported tools:',
     '  claude',
     '  cursor',
+    '  codex',
     '',
     'Examples:',
     '  npx ronds_ai@latest record claude',
@@ -23,6 +26,9 @@ function printUsage() {
     '  npx ronds_ai@latest doctor claude',
     '  npx ronds_ai@latest doctor cursor',
     '  npx ronds_ai@latest hooks deploy',
+    '  npx ronds_ai@latest skills install demo-skill',
+    '  npx ronds_ai@latest skills install demo-skill --tool claude --scope global',
+    '  npx ronds_ai@latest skills install demo-skill --tool codex,cursor --scope project',
   ].join('\n'));
   process.stderr.write('\n');
 }
@@ -38,6 +44,86 @@ async function runHooksCommand(args) {
   process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 }
 
+function parseSkillsInstallArgs(args) {
+  const options = {
+    tool: '',
+    scope: '',
+    projectDir: '',
+    force: false,
+  };
+  const positional = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+
+    if (value === '--force') {
+      options.force = true;
+      continue;
+    }
+
+    if (value === '--tool') {
+      index += 1;
+      options.tool = args[index] || '';
+      continue;
+    }
+
+    if (value.startsWith('--tool=')) {
+      options.tool = value.slice('--tool='.length);
+      continue;
+    }
+
+    if (value === '--scope') {
+      index += 1;
+      options.scope = args[index] || '';
+      continue;
+    }
+
+    if (value.startsWith('--scope=')) {
+      options.scope = value.slice('--scope='.length);
+      continue;
+    }
+
+    if (value === '--project-dir') {
+      index += 1;
+      options.projectDir = args[index] || '';
+      continue;
+    }
+
+    if (value.startsWith('--project-dir=')) {
+      options.projectDir = value.slice('--project-dir='.length);
+      continue;
+    }
+
+    if (value.startsWith('--')) {
+      throw new Error(`Unsupported option: ${value}`);
+    }
+
+    positional.push(value);
+  }
+
+  const [name] = positional;
+  if (!name) {
+    throw new Error('Missing skill name');
+  }
+
+  return {
+    name,
+    options,
+  };
+}
+
+async function runSkillsCommand(args) {
+  const [action, ...rest] = args;
+
+  if (action !== 'install') {
+    throw new Error('Unsupported skills command');
+  }
+
+  const { name, options } = parseSkillsInstallArgs(rest);
+  const result = await runSkillsInstall(name, options);
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
 async function run() {
   const [, , command, ...args] = process.argv;
 
@@ -71,6 +157,11 @@ async function run() {
     return;
   }
 
+  if (command === 'skills') {
+    await runSkillsCommand(args);
+    return;
+  }
+
   throw new Error(`Unsupported command: ${command || ''}`);
 }
 

package/lib/skills_install.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const { execFileSync } = require('child_process');
+const { buildInstallTargets, normalizeScope, normalizeTools } = require('./skills_targets');
+const { promptForScope, promptForTools } = require('./skills_prompt');
+
+const SKILL_DOWNLOAD_BASE_URL = 'https://aihub.ronds.com/api/api/v1/skills/download';
+const MAX_REDIRECTS = 5;
+
+function streamToFile(url, destinationPath, redirectCount = 0) {
+  return new Promise((resolve, reject) => {
+    const transport = String(url).startsWith('http://') ? http : https;
+    const request = transport.get(url, (response) => {
+      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        response.resume();
+        if (redirectCount >= MAX_REDIRECTS) {
+          reject(new Error('Too many redirects while downloading skill archive'));
+          return;
+        }
+
+        const nextUrl = new URL(response.headers.location, url).toString();
+        streamToFile(nextUrl, destinationPath, redirectCount + 1).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`Skill download failed with status ${response.statusCode || 0}`));
+        return;
+      }
+
+      const fileStream = fs.createWriteStream(destinationPath);
+      response.pipe(fileStream);
+
+      fileStream.on('finish', () => {
+        fileStream.close(() => resolve(destinationPath));
+      });
+
+      fileStream.on('error', (error) => {
+        fileStream.close(() => reject(error));
+      });
+    });
+
+    request.on('error', reject);
+  });
+}
+
+async function downloadSkillArchive(name, workingDir) {
+  const archivePath = path.join(workingDir, `${name}.zip`);
+  const url = `${SKILL_DOWNLOAD_BASE_URL}/${encodeURIComponent(name)}`;
+  await streamToFile(url, archivePath);
+  return {
+    url,
+    archivePath,
+  };
+}
+
+function extractArchive(archivePath, outputDir) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  execFileSync('unzip', ['-q', archivePath, '-d', outputDir], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function findSkillRoot(extractDir) {
+  const directSkillMd = path.join(extractDir, 'SKILL.md');
+  if (fs.existsSync(directSkillMd)) {
+    return extractDir;
+  }
+
+  const entries = fs.readdirSync(extractDir, { withFileTypes: true });
+  const candidateDirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(extractDir, entry.name))
+    .filter((entryPath) => fs.existsSync(path.join(entryPath, 'SKILL.md')));
+
+  if (candidateDirs.length === 1) {
+    return candidateDirs[0];
+  }
+
+  if (candidateDirs.length > 1) {
+    throw new Error('Downloaded archive contains multiple skill roots');
+  }
+
+  throw new Error('Downloaded archive does not contain SKILL.md');
+}
+
+function copySkill(sourceDir, destinationDir, force) {
+  if (fs.existsSync(destinationDir)) {
+    if (!force) {
+      throw new Error(`Skill already exists at ${destinationDir}. Use --force to overwrite.`);
+    }
+
+    fs.rmSync(destinationDir, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(path.dirname(destinationDir), { recursive: true });
+  fs.cpSync(sourceDir, destinationDir, { recursive: true });
+}
+
+async function resolveInstallOptions(options) {
+  let tools = normalizeTools(options.tool);
+  if (tools.length === 0) {
+    tools = normalizeTools(await promptForTools());
+  }
+
+  if (tools.length === 0) {
+    throw new Error('No skills tool selected');
+  }
+
+  let scope = normalizeScope(options.scope);
+  if (!scope) {
+    scope = normalizeScope(await promptForScope());
+  }
+
+  if (!scope) {
+    throw new Error('No skills scope selected');
+  }
+
+  return {
+    tools,
+    scope,
+    projectDir: options.projectDir ? path.resolve(options.projectDir) : process.cwd(),
+    force: Boolean(options.force),
+  };
+}
+
+async function runSkillsInstall(name, rawOptions = {}) {
+  const skillName = String(name || '').trim();
+  if (!skillName) {
+    throw new Error('Missing skill name');
+  }
+
+  const options = await resolveInstallOptions(rawOptions);
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ronds-ai-skill-'));
+
+  try {
+    const download = await downloadSkillArchive(skillName, tempRoot);
+    const extractDir = path.join(tempRoot, 'extracted');
+    extractArchive(download.archivePath, extractDir);
+    const skillRoot = findSkillRoot(extractDir);
+    const targets = buildInstallTargets(options.tools, options.scope, options.projectDir, skillName);
+
+    for (const target of targets) {
+      copySkill(skillRoot, target.destination, options.force);
+    }
+
+    return {
+      name: skillName,
+      scope: options.scope,
+      projectDir: options.scope === 'project' ? options.projectDir : '',
+      archiveUrl: download.url,
+      installedTargets: targets.map((target) => ({
+        tools: target.tools,
+        destination: target.destination,
+      })),
+    };
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  runSkillsInstall,
+};

package/lib/skills_prompt.js

@@ -0,0 +1,87 @@
+const readline = require('readline/promises');
+
+const TOOL_CHOICES = ['claude', 'codex', 'cursor'];
+const SCOPE_CHOICES = ['project', 'global'];
+
+function normalizeCsvInput(raw) {
+  return String(raw || '')
+    .split(',')
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function normalizeChoiceInput(raw) {
+  const values = normalizeCsvInput(raw);
+  if (values.length === 0) {
+    return [];
+  }
+
+  return values.flatMap((value) => {
+    if (/^\d+$/.test(value)) {
+      const index = Number(value) - 1;
+      return TOOL_CHOICES[index] ? [TOOL_CHOICES[index]] : [];
+    }
+
+    return [value];
+  });
+}
+
+async function promptForTools() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    process.stderr.write([
+      'Select tools to install:',
+      '  1. claude',
+      '  2. codex',
+      '  3. cursor',
+      'Enter comma-separated names or numbers:',
+    ].join('\n'));
+    process.stderr.write('\n');
+
+    const answer = await rl.question('> ');
+    return normalizeChoiceInput(answer);
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptForScope() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    process.stderr.write([
+      'Select install scope:',
+      '  1. project',
+      '  2. global',
+      'Enter project or global:',
+    ].join('\n'));
+    process.stderr.write('\n');
+
+    const answer = String(await rl.question('> ')).trim().toLowerCase();
+    if (answer === '1') {
+      return 'project';
+    }
+    if (answer === '2') {
+      return 'global';
+    }
+    return answer;
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = {
+  SCOPE_CHOICES,
+  TOOL_CHOICES,
+  normalizeChoiceInput,
+  normalizeCsvInput,
+  promptForScope,
+  promptForTools,
+};

package/lib/skills_targets.js

@@ -0,0 +1,81 @@
+const os = require('os');
+const path = require('path');
+const { SCOPE_CHOICES, TOOL_CHOICES, normalizeCsvInput } = require('./skills_prompt');
+
+function normalizeTools(rawTools) {
+  const values = Array.isArray(rawTools)
+    ? rawTools.flatMap((item) => normalizeCsvInput(item))
+    : normalizeCsvInput(rawTools);
+  const unique = [];
+
+  for (const tool of values) {
+    if (!TOOL_CHOICES.includes(tool)) {
+      throw new Error(`Unsupported skills tool: ${tool}`);
+    }
+
+    if (!unique.includes(tool)) {
+      unique.push(tool);
+    }
+  }
+
+  return unique;
+}
+
+function normalizeScope(rawScope) {
+  const scope = String(rawScope || '').trim().toLowerCase();
+  if (!scope) {
+    return '';
+  }
+
+  if (!SCOPE_CHOICES.includes(scope)) {
+    throw new Error(`Unsupported skills scope: ${rawScope}`);
+  }
+
+  return scope;
+}
+
+function resolveToolBaseDir(tool, scope, projectDir) {
+  const baseDir = scope === 'global' ? os.homedir() : path.resolve(projectDir || process.cwd());
+
+  if (tool === 'claude') {
+    return path.join(baseDir, '.claude', 'skills');
+  }
+
+  if (tool === 'codex' || tool === 'cursor') {
+    return path.join(baseDir, '.agents', 'skills');
+  }
+
+  throw new Error(`Unsupported skills tool: ${tool}`);
+}
+
+function buildInstallTargets(tools, scope, projectDir, skillName) {
+  const deduped = new Map();
+
+  for (const tool of tools) {
+    const baseDir = resolveToolBaseDir(tool, scope, projectDir);
+    const destination = path.join(baseDir, skillName);
+    const existing = deduped.get(destination);
+
+    if (existing) {
+      existing.tools.push(tool);
+      continue;
+    }
+
+    deduped.set(destination, {
+      tool,
+      tools: [tool],
+      scope,
+      baseDir,
+      destination,
+    });
+  }
+
+  return Array.from(deduped.values());
+}
+
+module.exports = {
+  buildInstallTargets,
+  normalizeScope,
+  normalizeTools,
+  resolveToolBaseDir,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ronds_ai",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "CLI for reporting AI code edit events.",
   "bin": {
     "ronds_ai": "bin/ronds_ai.js"