agent-skillboard 0.1.0

package/src/advisor.mjs

@@ -0,0 +1,134 @@
+import {
+  auditSources,
+  listWorkflows
+} from "./control.mjs";
+import { doctorProject } from "./doctor.mjs";
+import { buildActionCards, buildInitActions } from "./advisor/actions.mjs";
+import {
+  buildBrief,
+  buildCleanup,
+  emptySkillGroups,
+  emptyWorkflowState,
+  healthFromDoctor,
+  resolveProjectPaths
+} from "./advisor/schema.mjs";
+import {
+  buildReviewQueue,
+  emptySources,
+  sourcesFromDoctor,
+  summarizeSources
+} from "./advisor/sources.mjs";
+import { skillsForWorkflow, skillsWithoutWorkflow } from "./advisor/skills.mjs";
+import { resolveWorkflow } from "./advisor/workflow.mjs";
+import { loadWorkspace } from "./workspace.mjs";
+
+export async function buildSkillBrief(options = {}) {
+  const paths = resolveProjectPaths(options);
+  const cleanup = await buildCleanup(paths.root);
+  const configDoctor = await doctorProject({
+    root: paths.root,
+    configPath: paths.configPath,
+    skillsRoot: paths.skillsRoot
+  });
+
+  if (!configDoctor.config.exists || !configDoctor.initialized) {
+    return buildBrief({
+      ok: false,
+      error: {
+        code: "not-initialized",
+        message: configDoctor.config.error ?? "skillboard.config.yaml was not found"
+      },
+      health: healthFromDoctor(configDoctor, paths),
+      workflow: emptyWorkflowState(),
+      skills: emptySkillGroups(),
+      sources: emptySources(),
+      reviewQueue: [],
+      cleanup,
+      actions: requestedActions(options) ? buildInitActions(paths) : undefined
+    });
+  }
+
+  if (!configDoctor.config.valid) {
+    return buildExpectedConfigError(configDoctor, paths, cleanup, {
+      code: "invalid-config",
+      message: configDoctor.config.error ?? "skillboard.config.yaml is invalid"
+    });
+  }
+
+  let workspace;
+  try {
+    workspace = await loadWorkspace({ configPath: paths.configPath, skillsRoot: paths.skillsRoot });
+  } catch (error) {
+    return buildExpectedConfigError(configDoctor, paths, cleanup, {
+      code: "invalid-config",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+
+  const doctor = await doctorProject({
+    root: paths.root,
+    configPath: paths.configPath,
+    skillsRoot: paths.skillsRoot,
+    workspace,
+    verifySources: options.verifySources
+  });
+  const sourceAudit = auditSources(workspace);
+  const workflow = resolveWorkflow(listWorkflows(workspace), options.workflow);
+  const reviewQueue = buildReviewQueue(workspace, sourceAudit);
+
+  if (workflow.unknown) {
+    const skills = skillsWithoutWorkflow(workspace);
+    const actionData = actionsForBrief({ options, paths, workflow, skills, reviewQueue, cleanup, workspace });
+    return buildBrief({
+      ok: false,
+      error: {
+        code: "unknown-workflow",
+        message: `Unknown workflow: ${workflow.selected}`
+      },
+      health: healthFromDoctor(doctor, paths),
+      workflow,
+      skills,
+      sources: summarizeSources(sourceAudit),
+      reviewQueue: actionData.reviewQueue,
+      cleanup,
+      actions: actionData.actions
+    });
+  }
+
+  const skills = skillsForWorkflow(workspace, workflow.selected, sourceAudit);
+  const actionData = actionsForBrief({ options, paths, workflow, skills, reviewQueue, cleanup, workspace });
+  return buildBrief({
+    ok: doctor.ok,
+    health: healthFromDoctor(doctor, paths),
+    workflow,
+    skills,
+    sources: summarizeSources(sourceAudit),
+    reviewQueue: actionData.reviewQueue,
+    cleanup,
+    actions: actionData.actions
+  });
+}
+
+function buildExpectedConfigError(doctor, paths, cleanup, error) {
+  return buildBrief({
+    ok: false,
+    error,
+    health: healthFromDoctor(doctor, paths),
+    workflow: emptyWorkflowState(),
+    skills: emptySkillGroups(),
+    sources: sourcesFromDoctor(doctor),
+    reviewQueue: [],
+    cleanup
+  });
+}
+
+function actionsForBrief(context) {
+  if (!requestedActions(context.options)) {
+    return { reviewQueue: context.reviewQueue, actions: undefined };
+  }
+  return buildActionCards(context);
+}
+
+function requestedActions(options) {
+  return options.includeActions === true;
+}

package/src/agent-inventory-platforms.mjs

@@ -0,0 +1,100 @@
+import { readdir } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+export async function defaultScanRoots(home, env) {
+  const codexHome = env.CODEX_HOME ?? join(home, ".codex");
+  const hermesHome = env.HERMES_HOME ?? join(home, ".hermes");
+  return [
+    join(codexHome, "skills", ".system"),
+    join(codexHome, "skills"),
+    join(codexHome, "plugins", "cache"),
+    join(home, ".claude", "skills"),
+    join(hermesHome, "skills"),
+    ...(await hermesProfileSkillRoots(hermesHome))
+  ];
+}
+
+export function systemCodexUnit(path, home) {
+  return {
+    id: "codex.system-skills",
+    kind: "agent",
+    sourceClass: "runtime-extension",
+    priority: 55,
+    trustLevel: "reviewed",
+    source: displayPath(path, home),
+    scope: "user-global",
+    manifestPath: "",
+    cachePath: displayPath(path, home),
+    category: "agent-runtime"
+  };
+}
+
+export function userCodexUnit(path, home) {
+  return userSkillUnit("codex.user-skills", path, home);
+}
+
+export function userClaudeUnit(path, home) {
+  return userSkillUnit("claude.user-skills", path, home);
+}
+
+export function userHermesUnit(path, home) {
+  return userSkillUnit("hermes.user-skills", path, home);
+}
+
+export function hermesProfileUnit(path, home) {
+  const profile = safeSegment(basename(dirname(path))).replaceAll(".", "-");
+  return userSkillUnit(`hermes.profile.${profile}.skills`, path, home);
+}
+
+export function customUserUnit(path, home) {
+  return {
+    ...userSkillUnit(`custom.${safeSegment(basename(path))}.skills`, path, home),
+    scope: "local"
+  };
+}
+
+export function isHermesProfileSkillsPath(path) {
+  const normalized = path.replaceAll("\\", "/");
+  return /\/\.hermes\/profiles\/[^/]+\/skills$/u.test(normalized);
+}
+
+export function safeSegment(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return normalized.length === 0 ? "skill" : normalized;
+}
+
+export function displayPath(path, home) {
+  const resolvedHome = resolve(home);
+  const resolvedPath = resolve(path);
+  const rel = relative(resolvedHome, resolvedPath);
+  if (rel === "") {
+    return "~";
+  }
+  if (!rel.startsWith("..") && !isAbsolute(rel)) {
+    return `~/${rel.replaceAll("\\", "/")}`;
+  }
+  return resolvedPath;
+}
+
+async function hermesProfileSkillRoots(hermesHome) {
+  const profilesRoot = join(hermesHome, "profiles");
+  const entries = await readdir(profilesRoot, { withFileTypes: true }).catch(() => []);
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => join(profilesRoot, entry.name, "skills"));
+}
+
+function userSkillUnit(id, path, home) {
+  return {
+    id,
+    kind: "skill",
+    sourceClass: undefined,
+    priority: 100,
+    trustLevel: "trusted",
+    source: displayPath(path, home),
+    scope: "user-global",
+    manifestPath: "",
+    cachePath: displayPath(path, home),
+    category: "user"
+  };
+}