agent-skillboard 0.1.1 → 0.2.1

package/src/workspace.mjs

@@ -1,9 +1,12 @@
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import YAML from "yaml";
 import {
   readBoolean,
+  readOptionalRecord,
   readOptionalString,
+  readRequiredString,
   readString,
   readStringList,
   requireRecord
@@ -20,40 +23,106 @@ import { normalizeSkillPath } from "./skill-paths.mjs";
 export async function loadWorkspace(options) {
   const configText = await readFile(options.configPath, "utf8");
   const parsed = YAML.parse(configText);
-  const config = requireRecord(parsed, "config root");
-  const version = parseVersion(config.version);
-  const skills = parseSkills(config.skills);
-  return {
-    version,
-    defaults: parseDefaults(config.defaults),
-    installedSkills: await discoverInstalledSkills(options.skillsRoot, skills),
-    skills,
-    capabilities: parseCapabilities(config.capabilities),
-    harnesses: parseHarnesses(config.harnesses),
-    installUnits: parseInstallUnits(config.install_units),
-    workflows: parseWorkflows(config.workflows)
-  };
-}
-
-async function discoverInstalledSkills(skillsRoot, declaredSkills) {
-  if (skillsRoot === undefined) {
-    return [];
-  }
-  const skillFiles = await findSkillFiles(skillsRoot);
-  const installed = [];
-  for (const file of skillFiles) {
-    const frontmatter = parseSkillFrontmatter(await readFile(file, "utf8"));
-    const path = relative(skillsRoot, file).replaceAll("\\", "/").replace(/\/SKILL\.md$/, "");
-    const declared = declaredSkills.find((skill) => skill.path === path);
-    installed.push({
-      id: declared?.id ?? frontmatter.name ?? path,
-      name: frontmatter.name,
-      description: frontmatter.description,
-      path
-    });
-  }
-  return installed.sort((left, right) => left.path.localeCompare(right.path));
-}
+  const config = requireRecord(parsed, "config root");
+  const version = parseVersion(config.version);
+  const skills = parseSkills(config.skills);
+  const installUnits = parseInstallUnits(config.install_units);
+  return {
+    version,
+    defaults: parseDefaults(config.defaults),
+    installedSkills: await discoverInstalledSkills(options.skillsRoot, skills, {
+      configPath: options.configPath,
+      env: options.env ?? process.env,
+      home: options.home,
+      installUnits
+    }),
+    skills,
+    capabilities: parseCapabilities(config.capabilities),
+    harnesses: parseHarnesses(config.harnesses),
+    installUnits,
+    workflows: parseWorkflows(config.workflows)
+  };
+}
+
+async function discoverInstalledSkills(skillsRoot, declaredSkills, options = {}) {
+  const installed = [];
+  const installedKeys = new Set();
+  if (skillsRoot !== undefined) {
+    const skillFiles = await findSkillFiles(skillsRoot);
+    for (const file of skillFiles) {
+      const frontmatter = parseSkillFrontmatter(await readFile(file, "utf8"));
+      const path = relative(skillsRoot, file).replaceAll("\\", "/").replace(/\/SKILL\.md$/, "");
+      const declared = declaredSkills.find((skill) => skill.path === path);
+      appendInstalledSkill(installed, installedKeys, {
+        id: declared?.id ?? frontmatter.name ?? path,
+        name: frontmatter.name,
+        description: frontmatter.description,
+        path
+      });
+    }
+  }
+  await appendInstallUnitSkillMetadata(installed, installedKeys, declaredSkills, options);
+  return installed.sort((left, right) => left.path.localeCompare(right.path));
+}
+
+async function appendInstallUnitSkillMetadata(installed, installedKeys, declaredSkills, options) {
+  const units = new Map((options.installUnits ?? []).map((unit) => [unit.id, unit]));
+  for (const skill of declaredSkills) {
+    if (installedKeys.has(skill.id) || installedKeys.has(skill.path)) {
+      continue;
+    }
+    const unit = units.get(skill.ownerInstallUnit);
+    const root = resolveStoredPath(unit?.cachePath, options);
+    if (root === undefined) {
+      continue;
+    }
+    const frontmatter = await readOptionalSkillFrontmatter(join(root, skill.path, "SKILL.md"));
+    if (frontmatter === null) {
+      continue;
+    }
+    appendInstalledSkill(installed, installedKeys, {
+      id: skill.id,
+      name: frontmatter.name,
+      description: frontmatter.description,
+      path: skill.path
+    });
+  }
+}
+
+async function readOptionalSkillFrontmatter(file) {
+  const text = await readFile(file, "utf8").catch(() => null);
+  if (text === null) {
+    return null;
+  }
+  try {
+    return parseSkillFrontmatter(text);
+  } catch {
+    return null;
+  }
+}
+
+function appendInstalledSkill(installed, installedKeys, skill) {
+  installed.push(skill);
+  installedKeys.add(skill.id);
+  installedKeys.add(skill.path);
+}
+
+function resolveStoredPath(value, options) {
+  if (value === undefined || value.trim() === "") {
+    return undefined;
+  }
+  const home = options.home ?? options.env?.HOME ?? options.env?.USERPROFILE ?? homedir();
+  if (value === "~") {
+    return home;
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return join(home, value.slice(2));
+  }
+  if (isAbsolute(value)) {
+    return value;
+  }
+  return resolve(dirname(options.configPath ?? "."), value);
+}
 
 async function findSkillFiles(root, seen = new Set()) {
   const files = [];
@@ -144,14 +213,43 @@ function parseSkills(value) {
       invocation,
       exposure,
       category: readString(skill, "category", "uncategorized"),
-      canonicalFor: readStringList(skill, "canonical_for"),
-      conflictsWith: readStringList(skill, "conflicts_with"),
-      replacedBy: readOptionalString(skill, "replaced_by"),
-      ownerInstallUnit: readOptionalString(skill, "owner_install_unit")
-    };
-  });
-}
-
+      canonicalFor: readStringList(skill, "canonical_for"),
+      conflictsWith: readStringList(skill, "conflicts_with"),
+      replacedBy: readOptionalString(skill, "replaced_by"),
+      ownerInstallUnit: readOptionalString(skill, "owner_install_unit"),
+      variant: parseSkillVariant(skill, `skills.${id}.variant`)
+    };
+  });
+}
+
+function parseSkillVariant(skill, label) {
+  const raw = readOptionalRecord(skill, "variant", label);
+  if (raw === undefined) {
+    return null;
+  }
+  const approved = readOptionalRecord(raw, "approved", `${label}.approved`);
+  return {
+    of: readRequiredString(raw, "of", `${label}.of`),
+    adaptedFor: readOptionalString(raw, "adapted_for") ?? null,
+    capability: readRequiredString(raw, "capability", `${label}.capability`),
+    workflow: readRequiredString(raw, "workflow", `${label}.workflow`),
+    status: readRequiredString(raw, "status", `${label}.status`),
+    base: parseVariantCheckpoint(raw, "base", `${label}.base`),
+    ...(approved === undefined ? {} : { approved: parseVariantCheckpoint(raw, "approved", `${label}.approved`) })
+  };
+}
+
+function parseVariantCheckpoint(raw, key, label) {
+  const checkpoint = readOptionalRecord(raw, key, label);
+  if (checkpoint === undefined) {
+    throw new Error(`${label} must be a mapping`);
+  }
+  return {
+    contentDigest: readRequiredString(checkpoint, "content_digest", `${label}.content_digest`),
+    snapshot: readRequiredString(checkpoint, "snapshot", `${label}.snapshot`)
+  };
+}
+
 function parseCapabilities(value) {
   const raw = requireRecord(value ?? {}, "capabilities");
   return Object.entries(raw).map(([name, entry]) => {

package/tsconfig.lsp.json

@@ -11,5 +11,5 @@
     "strict": false,
     "noImplicitAny": false
   },
-  "include": ["bin/**/*.mjs", "src/**/*.mjs", "test/**/*.mjs"]
+  "include": ["bin/**/*.mjs", "src/**/*.mjs", "test/**/*.mjs", ".github/scripts/**/*.mjs"]
 }