viepilot 2.23.0 → 2.41.0

package/lib/skill-installer.cjs

@@ -0,0 +1,274 @@
+/**
+ * ViePilot Skill Installer — multi-channel skill installation (FEAT-020 Phase 91).
+ *
+ * Channels supported:
+ *   npm     — "npm:@scope/pkg" or bare "@scope/pkg" / "pkg"
+ *   github  — "github:org/repo"
+ *   local   — "./path" or "/absolute/path"
+ *
+ * After any install/uninstall/update: calls scanSkills() to refresh registry.
+ * Records skill-meta.json in skill dir for updateSkill() re-install support.
+ */
+
+'use strict';
+
+const fs             = require('fs');
+const path           = require('path');
+const os             = require('os');
+const { execSync }   = require('child_process');
+const https          = require('https');
+const http           = require('http');
+
+const { scanSkills }   = require('./skill-registry.cjs');
+const { listAdapters } = require('./adapters/index.cjs');
+
+// ---------------------------------------------------------------------------
+// Channel detection
+// ---------------------------------------------------------------------------
+
+function detectChannel(source) {
+  if (source.startsWith('github:')) return 'github';
+  if (source.startsWith('./') || source.startsWith('/') || source.startsWith('../')) return 'local';
+  return 'npm';
+}
+
+// ---------------------------------------------------------------------------
+// Adapter skill dirs
+// ---------------------------------------------------------------------------
+
+function getAdapterSkillDirs(homeDir) {
+  const adapters = listAdapters(homeDir);
+  return adapters
+    .map(a => (typeof a.skillsDir === 'function' ? a.skillsDir(homeDir) : null))
+    .filter(Boolean);
+}
+
+// ---------------------------------------------------------------------------
+// npm channel
+// ---------------------------------------------------------------------------
+
+function installFromNpm(pkgName, skillId, skillDirs, tempBase) {
+  const tempDir = fs.mkdtempSync(path.join(tempBase, 'vp-npm-'));
+  try {
+    // Pack the package into tempDir
+    execSync(`npm pack ${pkgName} --pack-destination "${tempDir}"`, {
+      stdio: 'pipe',
+      timeout: 60000,
+    });
+
+    const tarballs = fs.readdirSync(tempDir).filter(f => f.endsWith('.tgz'));
+    if (tarballs.length === 0) throw new Error(`npm pack produced no tarball for ${pkgName}`);
+
+    const tarball = path.join(tempDir, tarballs[0]);
+    const extractDir = path.join(tempDir, 'extracted');
+    fs.mkdirSync(extractDir, { recursive: true });
+
+    // Extract synchronously
+    execSync(`tar -xzf "${tarball}" -C "${extractDir}"`, { stdio: 'pipe' });
+
+    // npm pack wraps in package/
+    const packageDir = path.join(extractDir, 'package');
+    const skillMdPath = path.join(packageDir, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+      throw new Error(`SKILL.md not found in npm package ${pkgName}`);
+    }
+
+    const installedPaths = [];
+    for (const skillsDir of skillDirs) {
+      const targetDir = path.join(skillsDir, skillId);
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.cpSync(packageDir, targetDir, { recursive: true });
+      installedPaths.push(targetDir);
+    }
+    return installedPaths;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// github channel
+// ---------------------------------------------------------------------------
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const proto = url.startsWith('https:') ? https : http;
+    const file = fs.createWriteStream(destPath);
+    proto.get(url, res => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        file.close();
+        fs.unlinkSync(destPath);
+        return downloadFile(res.headers.location, destPath).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        return;
+      }
+      res.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    }).on('error', reject);
+  });
+}
+
+async function installFromGithub(orgRepo, skillId, skillDirs, tempBase) {
+  const [org, repo] = orgRepo.split('/');
+  if (!org || !repo) throw new Error(`Invalid github source "github:${orgRepo}" — expected "github:org/repo"`);
+
+  const tarballUrl = `https://github.com/${org}/${repo}/archive/refs/heads/main.tar.gz`;
+  const tempDir = fs.mkdtempSync(path.join(tempBase, 'vp-gh-'));
+  try {
+    const tarball = path.join(tempDir, 'repo.tar.gz');
+    await downloadFile(tarballUrl, tarball);
+
+    const extractDir = path.join(tempDir, 'extracted');
+    fs.mkdirSync(extractDir, { recursive: true });
+    execSync(`tar -xzf "${tarball}" -C "${extractDir}"`, { stdio: 'pipe' });
+
+    // GitHub archives create org-repo-main/ directory
+    const entries = fs.readdirSync(extractDir);
+    const repoDir = path.join(extractDir, entries[0]);
+
+    const skillMdPath = path.join(repoDir, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+      throw new Error(`SKILL.md not found in GitHub repo ${org}/${repo}`);
+    }
+
+    const installedPaths = [];
+    for (const skillsDir of skillDirs) {
+      const targetDir = path.join(skillsDir, skillId);
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.cpSync(repoDir, targetDir, { recursive: true });
+      installedPaths.push(targetDir);
+    }
+    return installedPaths;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// local channel
+// ---------------------------------------------------------------------------
+
+function installFromLocal(srcPath, skillId, skillDirs) {
+  const resolved = path.resolve(srcPath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Local path not found: ${resolved}`);
+  }
+  const skillMdPath = path.join(resolved, 'SKILL.md');
+  if (!fs.existsSync(skillMdPath)) {
+    throw new Error(`SKILL.md not found at ${resolved}`);
+  }
+
+  const installedPaths = [];
+  for (const skillsDir of skillDirs) {
+    const targetDir = path.join(skillsDir, skillId);
+    fs.mkdirSync(targetDir, { recursive: true });
+    fs.cpSync(resolved, targetDir, { recursive: true });
+    installedPaths.push(targetDir);
+  }
+  return installedPaths;
+}
+
+// ---------------------------------------------------------------------------
+// skill-meta.json
+// ---------------------------------------------------------------------------
+
+function writeSkillMeta(installedPaths, id, source) {
+  const meta = { id, source, installed_at: new Date().toISOString() };
+  for (const p of installedPaths) {
+    fs.writeFileSync(path.join(p, 'skill-meta.json'), JSON.stringify(meta, null, 2));
+  }
+}
+
+function readSkillMeta(skillId, homeDir) {
+  const skillDirs = getAdapterSkillDirs(homeDir);
+  for (const skillsDir of skillDirs) {
+    const metaPath = path.join(skillsDir, skillId, 'skill-meta.json');
+    if (fs.existsSync(metaPath)) {
+      try { return JSON.parse(fs.readFileSync(metaPath, 'utf8')); } catch { /* skip */ }
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Install a skill from source.
+ * Returns { ok: true, id, installedPaths[] } or { ok: false, error }
+ */
+async function installSkill(source, home = os.homedir()) {
+  try {
+    const channel = detectChannel(source);
+    const skillDirs = getAdapterSkillDirs(home);
+    if (skillDirs.length === 0) {
+      return { ok: false, error: 'No adapter skill directories found' };
+    }
+
+    const tempBase = os.tmpdir();
+    let skillId;
+    let installedPaths;
+
+    if (channel === 'npm') {
+      const pkgName = source.replace(/^npm:/, '');
+      skillId = pkgName.split('/').pop().replace(/^vp-skills-/, '');
+      installedPaths = installFromNpm(pkgName, skillId, skillDirs, tempBase);
+    } else if (channel === 'github') {
+      const orgRepo = source.replace('github:', '');
+      skillId = orgRepo.split('/').pop();
+      installedPaths = await installFromGithub(orgRepo, skillId, skillDirs, tempBase);
+    } else {
+      // local
+      skillId = path.basename(source.replace(/[/\\]+$/, ''));
+      installedPaths = installFromLocal(source, skillId, skillDirs);
+    }
+
+    writeSkillMeta(installedPaths, skillId, source);
+    scanSkills(home);
+
+    return { ok: true, id: skillId, installedPaths };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Uninstall a skill by id from all adapter dirs.
+ * Returns { ok: true, removedPaths[] } or { ok: false, error }
+ */
+function uninstallSkill(id, home = os.homedir()) {
+  try {
+    const skillDirs = getAdapterSkillDirs(home);
+    const removedPaths = [];
+
+    for (const skillsDir of skillDirs) {
+      const targetDir = path.join(skillsDir, id);
+      if (fs.existsSync(targetDir)) {
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        removedPaths.push(targetDir);
+      }
+    }
+
+    scanSkills(home);
+    return { ok: true, removedPaths };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Update a skill by re-installing from its recorded source.
+ * Returns installSkill result, or { ok: false, error } if source not found.
+ */
+async function updateSkill(id, home = os.homedir()) {
+  const meta = readSkillMeta(id, home);
+  if (!meta || !meta.source) {
+    return { ok: false, error: `No skill-meta.json found for skill "${id}" — cannot update` };
+  }
+  return installSkill(meta.source, home);
+}
+
+module.exports = { installSkill, uninstallSkill, updateSkill, detectChannel };

package/lib/skill-registry.cjs

@@ -0,0 +1,212 @@
+/**
+ * ViePilot Skill Registry — scanner + registry builder (FEAT-020 Phase 1).
+ *
+ * Registry file: ~/.viepilot/skill-registry.json
+ * Schema:
+ *   version        — "1.0"
+ *   last_scan      — ISO datetime
+ *   scan_paths     — adapter skillsDir paths scanned
+ *   skills[]       — indexed skill entries (deduplicated by id)
+ *
+ * Extended SKILL.md format (optional sections):
+ *   ## Capabilities   — one capability per line (- prefix)
+ *   ## Tags           — comma-separated or one per line
+ *   ## Best Practices — one practice per line (- prefix)
+ *
+ * Legacy SKILL.md (no extended sections) → fields default to []
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const REGISTRY_REL = path.join('.viepilot', 'skill-registry.json');
+const REGISTRY_VERSION = '1.0';
+
+// ---------------------------------------------------------------------------
+// Section parsers
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a SKILL.md string and extract extended metadata.
+ * Falls back gracefully when sections are absent.
+ * @param {string} content
+ * @returns {{ description: string, capabilities: string[], tags: string[], best_practices: string[] }}
+ */
+function parseSkillMd(content) {
+  const lines = content.split('\n');
+
+  // Extract first non-empty non-heading paragraph as description
+  let description = '';
+  for (const line of lines) {
+    const t = line.trim();
+    if (t && !t.startsWith('#')) { description = t; break; }
+  }
+
+  return {
+    description,
+    capabilities:   extractListSection(content, 'Capabilities'),
+    tags:           extractTagsSection(content, 'Tags'),
+    best_practices: extractListSection(content, 'Best Practices'),
+  };
+}
+
+/**
+ * Extract a `- item` list under `## {sectionName}`.
+ * @param {string} content
+ * @param {string} sectionName
+ * @returns {string[]}
+ */
+function extractListSection(content, sectionName) {
+  const re = new RegExp(`^##\\s+${sectionName}\\s*$`, 'im');
+  const match = re.exec(content);
+  if (!match) return [];
+
+  const afterHeader = content.slice(match.index + match[0].length);
+  const items = [];
+  for (const line of afterHeader.split('\n')) {
+    const t = line.trim();
+    if (t.startsWith('## ')) break;          // next section — stop
+    const itemMatch = t.match(/^-\s+(.+)/);
+    if (itemMatch) items.push(itemMatch[1].trim());
+  }
+  return items;
+}
+
+/**
+ * Extract comma-separated or line-per-item tags under `## Tags`.
+ * @param {string} content
+ * @param {string} sectionName
+ * @returns {string[]}
+ */
+function extractTagsSection(content, sectionName) {
+  const re = new RegExp(`^##\\s+${sectionName}\\s*$`, 'im');
+  const match = re.exec(content);
+  if (!match) return [];
+
+  const afterHeader = content.slice(match.index + match[0].length);
+  const raw = [];
+  for (const line of afterHeader.split('\n')) {
+    const t = line.trim();
+    if (t.startsWith('## ')) break;
+    if (t.startsWith('- ')) { raw.push(t.slice(2).trim()); continue; }
+    if (t) {
+      // Comma-separated on one line
+      raw.push(...t.split(',').map(s => s.trim()).filter(Boolean));
+    }
+  }
+  return raw.filter(Boolean);
+}
+
+// ---------------------------------------------------------------------------
+// Scanner
+// ---------------------------------------------------------------------------
+
+/**
+ * Scan all adapter skillsDirs, parse SKILL.md files, build registry.
+ * Writes ~/.viepilot/skill-registry.json and returns the registry object.
+ *
+ * @param {string} [home] Override home directory (defaults to os.homedir())
+ * @returns {{ version: string, last_scan: string, scan_paths: string[], skills: object[] }}
+ */
+function scanSkills(home) {
+  const homeDir = home || os.homedir();
+  const { listAdapters } = require('./adapters/index.cjs');
+  const adapters = listAdapters();
+
+  /** @type {Map<string, object>} */
+  const skillMap = new Map();
+  const scanPaths = [];
+
+  for (const adapter of adapters) {
+    const skillsDir = adapter.skillsDir(homeDir);
+    scanPaths.push(skillsDir);
+
+    if (!fs.existsSync(skillsDir)) continue;
+
+    let entries;
+    try { entries = fs.readdirSync(skillsDir, { withFileTypes: true }); }
+    catch (_) { continue; }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillDir  = path.join(skillsDir, entry.name);
+      const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+      if (!fs.existsSync(skillMdPath)) continue;
+
+      let mdContent = '';
+      try { mdContent = fs.readFileSync(skillMdPath, 'utf8'); }
+      catch (_) { /* skip unreadable */ }
+
+      const parsed  = parseSkillMd(mdContent);
+      const skillId = entry.name;
+
+      if (skillMap.has(skillId)) {
+        // Merge — same skill found in multiple adapter dirs
+        const existing = skillMap.get(skillId);
+        if (!existing.adapters.includes(adapter.id)) {
+          existing.adapters.push(adapter.id);
+        }
+        existing.installed_paths[adapter.id] = skillDir;
+      } else {
+        skillMap.set(skillId, {
+          id:              skillId,
+          name:            skillId,      // display name = dir name by default
+          source:          null,
+          version:         null,
+          description:     parsed.description,
+          capabilities:    parsed.capabilities,
+          tags:            parsed.tags,
+          best_practices:  parsed.best_practices,
+          adapters:        [adapter.id],
+          installed_paths: { [adapter.id]: skillDir },
+        });
+      }
+    }
+  }
+
+  const registry = {
+    version:    REGISTRY_VERSION,
+    last_scan:  new Date().toISOString(),
+    scan_paths: scanPaths,
+    skills:     [...skillMap.values()],
+  };
+
+  // Write registry to ~/.viepilot/skill-registry.json
+  const registryDir = path.join(homeDir, '.viepilot');
+  if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(registryDir, 'skill-registry.json'),
+    JSON.stringify(registry, null, 2),
+    'utf8'
+  );
+
+  return registry;
+}
+
+// ---------------------------------------------------------------------------
+// Registry reader
+// ---------------------------------------------------------------------------
+
+/**
+ * Load the current skill registry from disk.
+ * Returns null if the registry has not been written yet.
+ *
+ * @param {string} [home] Override home directory (defaults to os.homedir())
+ * @returns {object|null}
+ */
+function loadRegistry(home) {
+  const homeDir = home || os.homedir();
+  const registryPath = path.join(homeDir, '.viepilot', 'skill-registry.json');
+  if (!fs.existsSync(registryPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+module.exports = { scanSkills, loadRegistry, parseSkillMd };

package/lib/viepilot-update.cjs

@@ -1,8 +1,12 @@
 /**
  * Plan and run `npm` upgrade for the viepilot package (FEAT-008 / vp-tools update).
+ * ENH-072: checkLatestVersion() — non-blocking npm registry check with 24h cache.
  */
 
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const https = require('https');
 const { spawnSync, execFileSync } = require('child_process');
 const viepilotInfo = require('./viepilot-info.cjs');
 
@@ -147,10 +151,119 @@ function runNpmUpdate(plan) {
   return { ok: false, code: r.status == null ? 1 : r.status };
 }
 
+/**
+ * ENH-072: Check npm registry for a newer ViePilot version, with 24h cache.
+ *
+ * Silent on all errors — never throws, never crashes a skill invocation.
+ *
+ * @param {{ force?: boolean, cacheFile?: string, _fetchFn?: function }} opts
+ * @returns {Promise<{ upToDate: boolean, installed: string, latest: string }>}
+ */
+async function checkLatestVersion(opts = {}) {
+  const SILENT_RESULT = { upToDate: true, installed: '', latest: '' };
+  const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+  try {
+    const cacheFile =
+      opts.cacheFile || path.join(os.homedir(), '.viepilot', 'update-cache.json');
+
+    // Read installed version from package.json at viepilot package root
+    const pkgRoot = viepilotInfo.resolveViepilotPackageRoot(path.join(__dirname, '..'));
+    const installed = pkgRoot ? viepilotInfo.readInstalledVersion(pkgRoot) : null;
+    if (!installed) return SILENT_RESULT;
+
+    // Check cache unless force
+    if (!opts.force) {
+      try {
+        const raw = fs.readFileSync(cacheFile, 'utf8');
+        const cache = JSON.parse(raw);
+        if (
+          cache &&
+          typeof cache.checked_at === 'string' &&
+          typeof cache.latest === 'string' &&
+          Date.now() - new Date(cache.checked_at).getTime() < TTL_MS
+        ) {
+          const upToDate = compareSemver(installed, cache.latest) >= 0;
+          return { upToDate, installed, latest: cache.latest };
+        }
+      } catch (_e) {
+        // cache missing or unreadable — proceed to network
+      }
+    }
+
+    // Fetch latest version from npm registry with 3s timeout
+    const fetchFn = opts._fetchFn || _fetchNpmLatest;
+    let latest;
+    try {
+      latest = await fetchFn('viepilot');
+    } catch (_e) {
+      return { upToDate: true, installed, latest: installed };
+    }
+    if (!latest || typeof latest !== 'string') {
+      return { upToDate: true, installed, latest: installed };
+    }
+
+    // Write cache
+    try {
+      const cacheDir = path.dirname(cacheFile);
+      fs.mkdirSync(cacheDir, { recursive: true });
+      const has_update = compareSemver(installed, latest) < 0;
+      fs.writeFileSync(
+        cacheFile,
+        JSON.stringify({ checked_at: new Date().toISOString(), installed, latest, has_update }),
+        'utf8'
+      );
+    } catch (_e) {
+      // cache write failure is non-fatal
+    }
+
+    const upToDate = compareSemver(installed, latest) >= 0;
+    return { upToDate, installed, latest };
+  } catch (_e) {
+    return SILENT_RESULT;
+  }
+}
+
+/**
+ * Fetch latest version of a package from npm registry using https (3s timeout).
+ * @param {string} pkgName
+ * @returns {Promise<string>}
+ */
+function _fetchNpmLatest(pkgName) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${pkgName}/latest`,
+      { headers: { 'Accept': 'application/json' } },
+      (res) => {
+        let body = '';
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => {
+          try {
+            const data = JSON.parse(body);
+            if (data && typeof data.version === 'string') {
+              resolve(data.version);
+            } else {
+              reject(new Error('no version in response'));
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.setTimeout(3000, () => {
+      req.destroy(new Error('timeout'));
+    });
+  });
+}
+
 module.exports = {
   tryGetNpmGlobalViepilotPath,
   classifyInstall,
   compareSemver,
   buildUpdatePlan,
   runNpmUpdate,
+  checkLatestVersion,
+  _fetchNpmLatest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viepilot",
-  "version": "2.23.0",
+  "version": "2.41.0",
   "description": "**Autonomous Vibe Coding Framework / Bộ khung phát triển tự động có kiểm soát**",
   "main": "index.js",
   "bin": {