oh-skillhub 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-skillhub",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "OpenHarmony Skills installer for Codex, Claude Code, and OpenCode.",
   "type": "commonjs",
   "bin": {

package/src/cli.js

@@ -6,7 +6,7 @@ const readlinePromises = require("node:readline/promises");
 
 const { resolveAgentTargets } = require("./agents");
 const { applyCleanPlan, planClean, scanInstalledSkills } = require("./cleaner");
-const { loadLocalManifest, loadProfiles, selectSkills } = require("./manifest");
+const { loadLocalManifest, loadProfiles, loadRuntimeManifest, selectSkills } = require("./manifest");
 const { applyInstallPlan, planInstall } = require("./planner");
 const { ensureSkillSourceRoot, ensureSkillSourceRootAsync } = require("./source");
 const { buildTelemetryEvent, enqueueTelemetryEvent, telemetryStatus } = require("./telemetry");
@@ -368,7 +368,7 @@ async function runInteractiveInstaller(input = process.stdin, output = process.s
     return;
   }
 
-  const manifest = loadLocalManifest();
+  const manifest = await loadInteractiveManifest(input, output);
   const choices = buildRepositoryChoices(manifest);
   const agent = await runRawAgentSelection(input, output);
   const selectedIndexes = await runRawTuiSelection(input, output, choices, agent);
@@ -376,7 +376,7 @@ async function runInteractiveInstaller(input = process.stdin, output = process.s
 }
 
 async function runInteractiveInstallerFromAnswers(answers, output = process.stdout) {
-  const manifest = loadLocalManifest();
+  const manifest = await loadRuntimeManifest({ env: process.env });
   const choices = buildRepositoryChoices(manifest);
   const [agentAnswer, groupAnswer] = answers.length > 1 ? [answers[0], answers.slice(1).join(" ")] : ["", answers[0] || ""];
   output.write(renderAgentMenu());
@@ -388,6 +388,13 @@ async function runInteractiveInstallerFromAnswers(answers, output = process.stdo
   await installInteractiveSelection(manifest, choices, agent, selectedIndexes, output);
 }
 
+async function loadInteractiveManifest(_input, output) {
+  if (output.isTTY) {
+    return withSpinner(output, "Refreshing skill catalog", () => loadRuntimeManifest({ env: process.env }));
+  }
+  return loadRuntimeManifest({ env: process.env });
+}
+
 async function installInteractiveSelection(manifest, choices, agent, selectedIndexes, output) {
   const selectedChoices = selectedIndexes.map((index) => choices[index]);
   const skills = selectSkillsForChoices(manifest, selectedChoices);

package/src/manifest.js

@@ -1,13 +1,242 @@
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 
 function loadLocalManifest() {
   return require(path.join(__dirname, "data", "manifest.json"));
 }
 
+async function loadRuntimeManifest(options = {}) {
+  const env = options.env || process.env;
+  const bundled = loadLocalManifest();
+  if (options.offline || env.OH_SKILLHUB_OFFLINE === "1") {
+    return loadCachedManifest(env) || bundled;
+  }
+
+  try {
+    const manifest = env.OH_SKILLHUB_SOURCE_DIR
+      ? buildManifestFromSourceTree(env.OH_SKILLHUB_SOURCE_DIR, bundled)
+      : await buildManifestFromGit(bundled, { env });
+    writeCachedManifest(manifest, env);
+    return manifest;
+  } catch (error) {
+    if (env.OH_SKILLHUB_SOURCE_DIR) {
+      throw error;
+    }
+    return loadCachedManifest(env) || bundled;
+  }
+}
+
 function loadProfiles() {
   return require(path.join(__dirname, "data", "profiles.json"));
 }
 
+function buildManifestFromSourceTree(sourceRoot, baseManifest = loadLocalManifest()) {
+  const root = path.resolve(sourceRoot);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    throw new Error(`OH_SKILLHUB_SOURCE_DIR is not a directory: ${root}`);
+  }
+  const skillFiles = findSkillFiles(path.join(root, "skills"));
+  if (!skillFiles.length) {
+    throw new Error(`No SKILL.md files found in source tree: ${root}`);
+  }
+  return buildManifestFromSkillFiles(root, skillFiles, baseManifest);
+}
+
+async function buildManifestFromGit(baseManifest, options = {}) {
+  const source = baseManifest.source;
+  const ref = baseManifest.ref || "release";
+  const env = options.env || process.env;
+  const cacheRoot = env.OH_SKILLHUB_CACHE_DIR || path.join(os.homedir(), ".oh-skillhub", "cache");
+  fs.mkdirSync(cacheRoot, { recursive: true });
+  const tempCheckout = path.join(cacheRoot, `.manifest-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  try {
+    const clone = await runGitAsync([
+      "-c",
+      "core.longpaths=true",
+      "clone",
+      "--depth",
+      "1",
+      "--branch",
+      ref,
+      "--no-checkout",
+      source,
+      tempCheckout,
+    ]);
+    if (clone.status !== 0) {
+      throw new Error(gitDetail(clone) || `Failed to clone ${source}#${ref}`);
+    }
+    const tree = await runGitAsync(["-C", tempCheckout, "ls-tree", "-r", "--name-only", "HEAD", "skills"]);
+    if (tree.status !== 0) {
+      throw new Error(gitDetail(tree) || "Failed to list remote skills tree.");
+    }
+    const skillFiles = tree.stdout
+      .split(/\r?\n/)
+      .filter((item) => item.endsWith("/SKILL.md"))
+      .sort();
+    if (!skillFiles.length) {
+      throw new Error("Remote skills tree does not contain SKILL.md files.");
+    }
+    const loadedFiles = [];
+    for (const relativePath of skillFiles) {
+      const show = await runGitAsync(["-C", tempCheckout, "show", `HEAD:${relativePath}`]);
+      if (show.status === 0) {
+        loadedFiles.push({ relativePath, contents: show.stdout });
+      }
+    }
+    if (!loadedFiles.length) {
+      throw new Error("Remote skills tree could not load SKILL.md files.");
+    }
+    return buildManifestFromSkillFiles(null, loadedFiles, baseManifest);
+  } finally {
+    fs.rmSync(tempCheckout, { recursive: true, force: true });
+  }
+}
+
+function buildManifestFromSkillFiles(root, skillFiles, baseManifest) {
+  const byPath = new Map((baseManifest.skills || []).map((skill) => [skill.path, skill]));
+  const byName = new Map((baseManifest.skills || []).map((skill) => [skill.name, skill]));
+  const skills = [];
+  for (const item of skillFiles) {
+    const relativePath = typeof item === "string" ? toPosixPath(path.relative(root, item)) : item.relativePath;
+    const contents = typeof item === "string" ? fs.readFileSync(item, "utf8") : item.contents;
+    const skillPath = relativePath.replace(/\/SKILL\.md$/, "");
+    const parsed = parseSkillFile(contents);
+    const inferred = inferSkillFromPath(skillPath, parsed);
+    const base = byPath.get(skillPath) || byName.get(inferred.name) || {};
+    skills.push({
+      name: parsed.name || base.name || inferred.name,
+      scope: inferred.scope || base.scope || "domain",
+      domain: parsed.domain || base.domain || inferred.domain || "unknown",
+      stage: parsed.stage || base.stage || inferred.stage || "unknown",
+      path: skillPath,
+      description: parsed.description || base.description || `Use ${parsed.name || inferred.name}.`,
+      version: parsed.version || base.version || "0.1.0",
+      status: parsed.status || base.status || "stable",
+      tags: parsed.tags || base.tags || [],
+    });
+  }
+  return {
+    source: baseManifest.source,
+    ref: baseManifest.ref || "release",
+    generatedAt: new Date().toISOString(),
+    skills: skills.sort((left, right) => left.path.localeCompare(right.path)),
+  };
+}
+
+function findSkillFiles(root) {
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+  const found = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      found.push(...findSkillFiles(fullPath));
+    } else if (entry.isFile() && entry.name === "SKILL.md") {
+      found.push(fullPath);
+    }
+  }
+  return found.sort();
+}
+
+function parseSkillFile(contents) {
+  const frontmatter = contents.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatter) {
+    return {};
+  }
+  const parsed = {};
+  let inMetadata = false;
+  for (const line of frontmatter[1].split(/\r?\n/)) {
+    if (/^\s*metadata\s*:\s*$/.test(line)) {
+      inMetadata = true;
+      continue;
+    }
+    const nested = line.match(/^\s+([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (inMetadata && nested) {
+      parsed[nested[1]] = cleanYamlValue(nested[2]);
+      continue;
+    }
+    if (/^\S/.test(line)) {
+      inMetadata = false;
+    }
+    const topLevel = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (topLevel) {
+      parsed[topLevel[1]] = cleanYamlValue(topLevel[2]);
+    }
+  }
+  return parsed;
+}
+
+function cleanYamlValue(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+
+function inferSkillFromPath(skillPath, parsed = {}) {
+  const parts = skillPath.split("/");
+  const name = parsed.name || parts[parts.length - 1];
+  if (parts[1] === "common") {
+    return { name, scope: "common", stage: parts[2] || parsed.stage || "unknown", domain: parsed.domain || "unknown" };
+  }
+  if (parts[1] === "domain") {
+    return { name, scope: "domain", domain: parts[2] || parsed.domain || "unknown", stage: parsed.stage || parts[3] || "unknown" };
+  }
+  return { name, scope: parsed.scope || "domain", domain: parsed.domain || "unknown", stage: parsed.stage || "unknown" };
+}
+
+function runtimeManifestCachePath(env = process.env) {
+  return env.OH_SKILLHUB_MANIFEST_CACHE || path.join(env.OH_SKILLHUB_CACHE_DIR || path.join(os.homedir(), ".oh-skillhub", "cache"), "manifest-release.json");
+}
+
+function loadCachedManifest(env = process.env) {
+  const file = runtimeManifestCachePath(env);
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCachedManifest(manifest, env = process.env) {
+  const file = runtimeManifestCachePath(env);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function runGitAsync(args) {
+  return new Promise((resolve) => {
+    const child = spawn("git", args, { shell: false });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      resolve({ status: 1, stdout, stderr: `${stderr}${error.message}` });
+    });
+    child.on("close", (status) => {
+      resolve({ status, stdout, stderr });
+    });
+  });
+}
+
+function gitDetail(result) {
+  return (result.stderr || result.stdout || "").trim();
+}
+
 function selectSkills(manifest, profiles, options = {}) {
   const selected = new Map();
   const unknownNames = [];
@@ -88,7 +317,9 @@ function selectSkills(manifest, profiles, options = {}) {
 }
 
 module.exports = {
+  buildManifestFromSourceTree,
   loadLocalManifest,
   loadProfiles,
+  loadRuntimeManifest,
   selectSkills,
 };